Execute a system command: Difference between revisions

{{Task|Programming environment operations}}

 

 

=={{header|Ada}}==

 

procedure Execute_System is

begin

Ret_Val := Sys(To_C("ls"));

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9 - "system" is not part of the standard's prelude.}}

 

Or the classic "!" shell escape can be implemented as an "!" operator:

 

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9 - "system" & "ANDF" are not part of the standard's prelude.}}

 

IF ! "touch test.tmp" ANDF ( ! "ls test.tmp" ANDF ! "rm test.tmp" ) THEN

print (("test.tmp now gone!", new line))

 

=={{header|AppleScript}}==

 

=={{header|AutoHotkey}}==

 

=={{header|AWK}}==

 

 

=={{header|BASIC}}==

 

 

=={{header|C}}==

ISO C & POSIX:

 

 

int main()

system("ls");

return 0;

 

=={{header|C sharp|C#}}==

Using Windows / .NET:

 

namespace Execute

}

}

 

{{works with|MCS|1.2.3.1}}

class Execute {

proc.Start();

}

 

=={{header|Common Lisp}}==

 

{{works with|LispWorks}}

 

 

{{libheader|trivial-shell}}

 

 

=={{header|D}}==

 

=={{header|dc}}==

 

=={{header|E}}==

ls("-l")

 

} catch problem {

print(`failed to execute ls: $problem`)

 

=={{header|Erlang}}==

 

=={{header|Factor}}==

 

=={{header|Forth}}==

{{works with|gforth|0.6.2}}

 

=={{header|Fortran}}==

{{works with|gfortran}}

The <tt>SYSTEM</tt> subroutine (and function) are a GNU extension.

call system("ls")

 

=={{header|gnuplot}}==

 

 

=={{header|Haskell}}==

{{works with|GHC|GHCi|6.6}}

 

 

 

=={{header|IDL}}==

 

Will execute "ls" with output to the screen.

 

 

will execute it and store the result in the string array "result".

 

 

will execute it asynchronously and direct any output from it into the LUN "unit" from whence it can be read at any (later) time.

 

=={{header|Io}}==

 

=={{header|J}}==

 

The system command interface in J is provided by the standard "task" script:

 

NB. Execute a command and wait for it to complete

NB. and capture its stdout

stdin =: 'blahblahblah'

 

=={{header|Java}}==

{{works with|Java|1.5+}}

import java.io.*;

 

}

}

 

{{works with|Java|1.4+}}

There are two ways to run system commands. The simple way, which will hang the JVM (I would be interested in some kind of reason). -- this happens because the the inputStream buffer fills up and blocks until it gets read. Moving your .waitFor after reading the InputStream would fix your issue (as long as your error stream doesn't fill up)

import java.io.InputStream;

 

 

And the right way, which uses threading to read the InputStream given by the process.

import java.io.InputStream;

 

}

}

 

=={{header|JavaScript}}==

 

{{works with|JScript}}

 

{{works with|Rhino}}

print("===");

var options = {

};

runCommand("cmd", options);

 

=={{header|Joy}}==

 

=={{header|Logo}}==

{{works with|UCB Logo}}

The lines of output of the SHELL command are returned as a list.

 

=={{header|Lua}}==

os.execute("ls")

 

-- to execute and capture the output, use io.popen

local f = io.popen("ls") -- store the output in a "file"

 

 

 

=={{header|Make}}==

in definition

 

 

in target

 

 

=={{header|Modula-3}}==

 

Also note the <code>EVAL</code> keyword, which ignores the return value of a function.

 

IMPORT Unix, M3toC;

EVAL Unix.system(command);

M3toC.FreeCopiedS(command);

 

=={{header|Objective-C}}==

{{works with|GCC}}<br>

NSTask runs an external process with explicit path and arguments.

{

[[NSTask launchedTaskWithLaunchPath:@"/bin/ls"

If you need to run a system command, invoke the shell:

{

[[NSTask launchedTaskWithLaunchPath:@"/bin/sh"

waitUntilExit];

Complete usage example:

 

{{works with|Cocoa}}<br>

{{works with|GNUstep}}

 

void runSystemCommand(NSString *cmd)

{

[[NSTask launchedTaskWithLaunchPath:@"/bin/sh"

waitUntilExit];

}

int main(int argc, const char **argv)

{

 

return 0;

Or use the C method above.

 

Just run the command:

 

 

To capture the output of the command:

 

 

let syscall cmd =

(Buffer.contents buf)

 

 

=={{header|Octave}}==

 

=={{header|Oz}}==

 

A more sophisticated example can be found [http://www.mozart-oz.org/home/doc/op/node17.html here].

 

=={{header|Perl}}==

 

 

 

 

http://perldoc.perl.org/perlipc.html#Using-open()-for-IPC

http://perldoc.perl.org/IPC/Open3.html

 

=={{header|PHP}}==

The first line execute the command and the second line display the output:

'''Note:'''The '@' is here to prevent error messages to be displayed, 'nl2br' translate '\n' chars to 'br' in HTML.

 

Other:

 

See also: [http://us.php.net/manual/en/function.proc-open.php proc_open()]

 

=={{header|Pike}}==

// response is now a map containing 3 fields

// stderr, stdout, and exitcode. We want stdout.

write(response["stdout"] + "\n");

 

=={{header|Pop11}}==

The sysobey function runs commands using a shell:

 

 

=={{header|PowerShell}}==

Since PowerShell is a shell, running commands is the default operation.

ls

are all equivalent (the first two are aliases for the third) but they are PowerShell-native commands. If one really needs to execute <code>dir</code> (which is no program but rather a built-in command in <code>cmd.exe</code>) this can be achieved by

 

=={{header|Prolog}}==

 

{{works with|GNU Prolog}}

 

=={{header|Python}}==

 

or

 

{{works with|Python|2.4 (and above)}}

p = Popen('ls', stdout=PIPE, stderr=STDOUT)

 

'''Note:''' The latter is the preferred method for calling external processes, although cumbersome, it gives you finer control over the process.

 

{{works with|Python|2.2 (and above)}}

stat, out = commands.getstatusoutput('ls')

if not stat:

 

=={{header|R}}==

 

=={{header|Raven}}==

Back tick string is auto executed:

 

 

Or specifically on any string:

 

 

=={{header|REBOL}}==

 

x: "" call/output "dir" x

; The 'shell' refinement may be necessary to launch some programs.

 

 

=={{header|Ruby}}==

# runs command and returns its STDOUT as a string

string = %x{ls}

io = IO.popen('ls')

# ... later

 

=={{header|Slate}}==

Run a command normally through the shell:

 

Run a command (this way takes advantage of the 'does not understand' message for the shell object and calls the Platform run: command above with a specific command):

 

 

=={{header|Smalltalk}}==

 

 

=={{header|Standard ML}}==

Just run the command:

 

 

=={{header|Tcl}}==

 

 

This page uses "ls" as the primary example. For what it's worth, Tcl has built-in primitives for retrieving lists of files so one would rarely ever directly exec an ls command.

It is also possible to execute a system command by "open"ing it through a pipe from whence any output of the command can be read at any (later) time. For example:

 

 

 

or read the whole shebang in a fell swoop:

 

 

If the command is opened "rw", it is even possible to send it user input through the same handle, though care must be taken with buffering in that case.

 

=={{header|Toka}}==

 

=={{header|UNIX Shell}}==

UNIX shells are designed to run system commands as a default operation.

 

 

 

 

 

 

=={{header|Ursala}}==

Here is a self-contained command line application providing a limited replacement

for the ls command.

#import cli

 

#executable ('parameterized','')

 

The color option is needed to suppress terminal escape sequences.

 

=={{header|Visual Basic}}==

Shelling out a sub task in Visual Basic is rather a pain if you need to wait for the task to complete, which

is probably the usual case. But it is possible.

Option Explicit

 

Sub SpawnDir()

ShellAndWait("dir", 10)

 

{{omit from|TI-83 BASIC}} {{omit from|TI-89 BASIC}} <!-- Does not have an external OS/command processor. -->