Gambas Documentation - /lang/exec

# EXEC

[ Process = ] EXEC Command [ WAIT ] [ FOR { { READ | INPUT } | { WRITE | OUTPUT } } ] [ AS Name ]

EXEC Command TO Variable

Executes a command by running a child process.

An internal Process object is created to manage the command.

- Standard syntax

- Program Search

- Quick Syntax

- Environment

- Running Inside A Virtual Terminal

- Examples

### Standard syntax

The Command passed to EXEC must be specified as either a list of comma delimited string constants or as an array. The first element in the list/array is the name of the command, and the other elements are the commands parameters (if any).

- If `WAIT` is specified, then the interpreter waits for the command to complete, otherwise the command is run in background and your program will continue executing.

Don't forget the WAIT keyword if you want to chain commands, otherwise the second one will start before the first one is finished!

- If `FOR` is specified, then the command input-outputs are redirected so that your program intercepts them:

  - If `WRITE` is specified, data can be sent to the command standard input by using the Process object with common output instructions: PRINT, WRITE, ... Note that a reference to the Process object is required.

  - If `READ` is specified, then events will be generated each time the command sends data to its standard output stream: the Read event is raised when data are sent to the standard output stream, and the Error event is raised when data are sent to the standard error stream. Use the process object with Stream & Input/Output functions to read the process standard output.

  - If you use the `INPUT` and `OUTPUT` keywords instead of `READ` and `WRITE`, then the process is executed inside a virtual terminal. The process will think running inside a true terminal.

- `Name` is the event name used by the Process object. By default, it is `"Process"`.

In Gambas 3, there is no default event name anymore.

In other words, you must add `AS "Process"` to get the same behaviour as Gambas 2.

You can get a reference to the internal Process object created by using an assignment.

### Program Search

The command can be specified as an absolute path or as a program name.

If the command is specified as a program name, then that program is searched through the `PATH` environment variable. That feature is handy, but slows down the start-up time.

Since 3.6

You can use the System.Find method to search for a program through the `PATH` environment variable.

Then you can store the returned absolute path in a variable, and use it later with EXEC to start the program without having to repeat the search procedure.

### Quick Syntax

If you use the second form of the syntax,

EXEC Command TO Variable

the interpreter waits for the command to complete, and then places the complete command output in the specified string.

During execution of the command you have no control over the process being executed.

Only the standard output of the process is retrieved. The error output is not redirected.

### Environment

You can specify new environment variables for the running process by using the WITH keyword just after the command argument:

[ Process = ] EXEC Command WITH Environment ...

Environment is an array of strings, each string having the following form: `"NAME=VALUE"`. `NAME` is the name of the environment variable, `VALUE` is its value.

If you want to erase an environment variable, just use the string `"NAME="`.

### Running Inside A Virtual Terminal

If the process is run inside a virtual terminal, i.e. if you use the FOR INPUT / OUTPUT syntax, then you can send control characters to the process standard input to get the same effect as if you enter them inside a real terminal. `^C` stops the process, `^Z` suspends it, and so on.

A virtual terminal has only one output. Consequently, the standard error output of the running process is received through the `Read` event.

Some programs have a command-line interface that is accessible only if running inside a virtual terminal.

If you plan to control an application by sending commands to standard input then testing should be performed outside of the IDE (i.e. make an executable and launch it from the command line) as the console within the development environment is not a true virtual terminal and will cause unexpected results.

### Examples

    ' Get the contents of a directory
    EXEC [ "ls", "-la", "/tmp" ] WAIT

    ' Get the contents of a directory into a string
    DIM sOutput AS String
    EXEC [ "ls", "-la", "/tmp" ] TO sOutput

    ' How to give a value to an option: Print contents of /tmp directory, except gambas temporary
    ' directories, using the --hide option to ls.

    ' Either use = to separate the long option from the value and put both into one array member
    Exec ["ls", "-l", "--hide=*gambas*", "/tmp"] Wait

    ' Or use a new array member. This must be used with short options.
    Exec ["ls", "-l", "--hide", "*gambas*", "/tmp"] Wait

    ' Get the contents of a directory into a string, but in background
    DIM sOutput AS String

    ' A specific event name is used
    EXEC [ "ls", "-la", "/tmp" ] FOR READ AS "Contents"

    ...

    PUBLIC SUB Contents_Read()

      DIM sLine AS String

      READ #LAST, sLine, -256

      sOutput &= sLine

    END

    PUBLIC SUB Contents_Kill()

      PRINT sOutput

    END

If you want to know how many bytes you can read in a `Process_Read` event handler, use the Lof function.

As arguments are sent directly to the process, you do not have to quote them, as you must do in a shell.

### Examples

    ' perl -e 'print while <>;' becomes

    EXEC [ "perl", "-e", "print while <>;" ] FOR READ WRITE

### See also

- SHELL

- Process Management

- Process

- Lof

- Differences Between Shell And Exec

- System.Find