Execute a system command: Difference between revisions

 

=={{header|11l}}==

 

=={{header|ABAP}}==

ABAP report which checks if there is an external command called 'ls' for the os of the current application server. When running on Windows, it calls dir, for all other platforms ls. A new command is created if not existing and run.

 

*& Report ZEXEC_SYS_CMD

*&

ENDIF.

ENDIF.

 

=={{header|Ada}}==

Using the IEEE POSIX Ada standard, P1003.5c:

 

procedure Execute_A_System_Command is

POSIX.Append (Arguments, "ls");

POSIX.Unsafe_Process_Primitives.Exec_Search ("ls", Arguments);

 

Importing the C system() function:

 

procedure Execute_System is

begin

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

 

Using the GNAT run-time library:

with Ada.Text_IO; use Ada.Text_IO;

with System.OS_Lib; use System.OS_Lib;

end loop;

end Execute_Synchronously;

 

=={{header|Aikido}}==

The simplest way to do this is using the <code>system()</code> function. It returns a vector of strings (the output from the command).

var lines = system ("ls")

foreach line lines {

println (line)

}

If you don't want to process the output you can use the <code>exec</code> function. It writes the output to the standard output stream by default;

exec ("ls")

You also have the regular <code>fork</code> and <code>execv</code> calls available:

var pid = fork()

if (pid == 0) {

waitpid (pid, status)

 

 

=={{header|Aime}}==

 

ss.argv.insert("ls");

 

o_(ss.link);

 

=={{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|Applesoft BASIC}}==

=={{header|AutoHotkey}}==

 

=={{header|AutoIt}}==

 

=={{header|AWK}}==

 

Using system() function:

system("ls") # Unix

#system("dir") # DOS/MS-Windows

 

Using getline command:

ls = sys2var("ls")

print ls

close(command)

return ship

 

=={{header|BASIC}}==

 

 

==={{header|BaCon}}===

 

=={{header|Batch File}}==

 

 

=={{header|BBC BASIC}}==

On Acorn computers the *CAT command catalogues the current directory, the equivalent of the Unix ls command or the DOS/Windows dir command. The BBC BASIC OSCLI command passes a string to the Command Line Interpreter to execute a system command, it is the equivalent of C's system() command.

 

With BBC BASIC for Windows you can execute the Windows dir command:

 

And if running BBC BASIC on a Unix host, you can execute the ls command:

 

=={{header|Bracmat}}==

 

=={{header|Brat}}==

 

 

=={{header|Brlcad}}==

 

exec ls

 

=={{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|Clojure}}==

 

 

user=> (use '[clojure.java.shell :only [sh]])

drwxr-xr-x 4 zkim staff 136 Jul 5 13:15 src

, :err }

 

user=> (use '[clojure.java.shell :only [sh]])

 

 

nil

 

=={{header|CMake}}==

{{works with|Unix}}

 

Because of a quirk in the implementation ([http://cmake.org/gitweb?p=cmake.git;a=blob;f=Source/cmExecuteProcessCommand.cxx;hb=HEAD cmExecuteProcessCommand.cxx] and [http://cmake.org/gitweb?p=cmake.git;a=blob;f=Source/kwsys/ProcessUNIX.c;hb=HEAD ProcessUNIX.c]), CMake diverts the standard output to a pipe. The effect is like running <code>ls | cat</code> in the shell. The ''ls'' process inherits the original standard input and standard error, but receives a new pipe for standard output. CMake then reads this pipe and copies all data to the original standard output.

''execute_process()'' can also chain commands in a pipeeline, and capture output.

 

execute_process(

COMMAND printf "scale = 45; 4 * a(1) + 5 / 10 ^ 41\\n"

COMMAND sed -e "s/.\\{5\\}$//"

OUTPUT_VARIABLE pi OUTPUT_STRIP_TRAILING_WHITESPACE)

 

<pre>-- pi is 3.1415926535897932384626433832795028841972</pre>

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

 

=={{header|CoffeeScript}}==

{{works with|Node.js}}

{ spawn } = require 'child_process'

 

 

ls.on 'close', -> console.log "'ls' has finished executing."

 

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

{{works with|CMUCL}}

 

{{works with|LispWorks}}

 

 

{{libheader|trivial-shell}}

 

 

=={{header|D}}==

import std.process, std.stdio;

//these two alternatives wait for the process to return, and capture the output

writeln((ls_array.status == 0) ? ls_array.output : "command failed");

//other alternatives exist to spawn processes in parallel and capture output via pipes

std.process.system() is deprecated.

 

=={{header|dc}}==

=={{header|DCL}}==

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

begin

ShellExecute(0, nil, 'cmd.exe', ' /c dir', nil, SW_HIDE);

 

=={{header|E}}==

ls("-l")

 

} catch problem {

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

 

=={{header|Emacs Lisp}}==

 

 

=={{header|Erlang}}==

 

=={{header|ERRE}}==

For example

 

 

lists the current directory and then returns to the program.

 

 

=={{header|Euphoria}}==

Euphoria has 2 systems command functions: '''system()''' and '''system_exec()'''.

-- the simplest way --

-- system spawns a new shell so I/O redirection is possible --

else

printf( STDERR, "command %s failed with code %d\n", ls_command, exit_code)

 

=={{header|F_Sharp|F#}}==

 

=={{header|Factor}}==

 

=={{header|Fantom}}==

The Process class handles creating and running external processes. in/out/err streams can be redirected, but default to the usual stdin/stdout/stderr. So following program prints result of 'ls' to the command line:

 

class Main

{

}

}

 

=={{header|Forth}}==

{{works with|gforth|0.6.2}}

 

=={{header|Fortran}}==

execute_command_line subroutine in Fortran 2008 and later runs a system command

program SystemTest

integer :: i

call execute_command_line ("ls", exitstat=i)

end program SystemTest

 

{{works with|gfortran}}

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

call system("ls")

 

=={{header|FreeBASIC}}==

 

Shell "dir"

 

=={{header|Frink}}==

 

=={{header|FunL}}==

 

 

=={{header|FutureBasic}}==

local fn DoUnixCommand( cmd as str255 )

 

open "Unix", 2, cmd

 

fn DoUnixCommand( "ls -A" )

 

Output:

usr

var

</pre>

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=9460b39a86794a7346a390aeb50fc5cf Click this link to run this code]'''

 

Shell "ls -aul"

 

Output:

<pre>

 

=={{header|Genie}}==

/*

Execute system command, in Genie

Process.spawn_command_line_async("ls")

except e : SpawnError

 

{{out}}

...

</pre>

 

=={{header|Go}}==

 

import (

log.Fatal(err)

}

 

=={{header|Groovy}}==

 

=={{header|GUISS}}==

 

 

=={{header|Haskell}}==

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

 

main = system "ls"

 

See also: the [http://www.haskell.org/ghc/docs/latest/html/libraries/process-1.2.0.0/System-Process.html System.Process] module

 

=={{header|HicEst}}==

 

=={{header|HolyC}}==

For example, to execute the <code>Dir</code> command:

 

 

=={{header|Icon}} and {{header|Unicon}}==

The code below selects the 'ls' or 'dir' command at runtime based on the UNIX feature.

 

 

write("Trying command ",cmd := if &features == "UNIX" then "ls" else "dir")

system(cmd)

 

 

Unicon extends system to allow specification of files and a wait/nowait parameter as in the examples below.

pid := system(command_string,&input,&output,&errout,"wait")

pid := system(command_string,&input,&output,&errout,"nowait")

=={{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'

 

Note that on unix systems, you can also use the [http://www.jsoftware.com/help/dictionary/dx002.htm 2!:x family] of foreign verbs to execute system commands.

=={{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|Julia}}==

The Julia manual has an excellent [http://docs.julialang.org/en/release-0.3/manual/running-external-programs/ section] on this topic, which is worth a read. The short answer on Linux is:

 

{{out}}

 

Execute "ls"

 

Execute "ls" and capture the output in the variable "r":

 

=={{header|Kotlin}}==

 

import java.util.Scanner

while (it.hasNextLine()) println(it.nextLine())

}

 

=={{header|Lang5}}==

For one-word commands:

For multi-word commands:

 

=={{header|Lasso}}==

path = file_forceroot,

ls = sys_process('/bin/ls', (:'-l', #path)),

'<pre>'

#ls -> read

<pre>total 16

drwxr-xr-x 8 _lasso staff 272 Nov 10 08:13 mydir

In the LFE REPL:

 

> (os:cmd "ls -alrt")

 

That will display output on a single line, with literal newlines.

For pretty output, compose with <code>io:format</code>:

 

> (io:format (os:cmd "ls -alrt"))

 

=={{header|Liberty BASIC}}==

drive1$ = left$(Drives$,1)

run "cmd.exe /";drive1$;" dir & pause"

 

=={{header|Limbo}}==

This version passes its argument list through to ls:

 

 

include "sys.m"; sys: Sys;

sys->fprint(sys->fildes(2), "runls: %s: %r", s);

raise "fail:errors";

 

It's not strictly necessary to pass the graphics context to ls, but it is generally a good idea to do so when calling another program.

 

=={{header|Locomotive Basic}}==

The Amstrad CPC464 uses a ROM based basic interpreter, so every statement within the program is a system command. If a command without a line number is typed, whilst the computer is in a ready state, the command gets executed immediately. There is no pause command, so in this example, we use the list command (which exhibits totally different behaviour to a pause command):

 

 

=={{header|Logo}}==

{{works with|UCB Logo}}

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

 

=={{header|Logtalk}}==

Using the standard library:

 

=={{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|M4}}==

 

=={{header|Make}}==

in definition

 

 

in target

 

 

=={{header|Maple}}==

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

=={{header|MATLAB}}==

 

Sample Usage:

 

Press any key to continue . . .

 

0

 

=={{header|Maxima}}==

 

=={{header|MAXScript}}==

 

=={{header|Mercury}}==

:- module execute_sys_cmd.

:- interface.

main(!IO) :-

io.call_system("ls", _Result, !IO).

 

=={{header|min}}==

{{works with|min|0.19.3}}

 

=={{header|Modula-2}}==

 

FROM SYSTEM IMPORT ADR;

InOut.WriteLn;

InOut.WriteBf

 

=={{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|MUMPS}}==

<p>ANSI MUMPS doesn't allow access to the operating system except possibly through the View command and $View function, both of which are implementation specific. Intersystems' Caché does allow you to create processes with the $ZF function, and if the permissions for the Caché process allow it you can perform operating system commands.</p>

<p>In Caché on OpenVMS in an FILES-11 filesystem ODS-5 mode this could work:

 

<p>In GT.M on OpenVMS, the following will work:

<p>GT.M on UNIX is the same:

<p>Note: $ZF in GT.M is Unicode version of $F[ind].</p>

 

=={{header|NetRexx}}==

{{Trans|Java}}

options replace format comments java crossref symbols binary

 

return

 

method runSample(arg) private static

parse arg command

end

return

 

=={{header|NewLISP}}==

 

=={{header|Nim}}==

 

let exitCode = execCmd "ls"

 

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

{{works with|GCC}}<br>

NSTask runs an external process with explicit path and arguments.

{

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

arguments:@[]] waitUntilExit];

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

{

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

arguments:@[@"-c", cmd]]

waitUntilExit];

Complete usage example:

 

{{works with|Cocoa}}<br>

{{works with|GNUstep}}

 

void runSystemCommand(NSString *cmd)

}

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)

 

 

 

a more complete version which also returns the contents from stderr, and checks the exit-status, and where the environment can be specified:

 

| Unix.WEXITED 0 -> ()

| Unix.WEXITED r -> Printf.eprintf "warning: the process terminated with exit code (%d)\n%!" r

check_exit_status exit_status;

(Buffer.contents buf1,

 

val syscall : ?env:string array -> string -> string * string

 

=={{header|Octave}}==

 

=={{header|Oforth}}==

 

 

=={{header|Oz}}==

 

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

 

=={{header|PARI/GP}}==

 

=={{header|Pascal}}==

{{works with|Free_Pascal}} {{libheader|SysUtils}}

 

uses

begin

ExecuteProcess('/bin/ls', '-alh');

 

=={{header|PDP-11 Assembly}}==

PDP-11 running Unix

;

; On entry, r1=>nul-terminated command string

EQUW 0

EQUW 0

So, call with, for example:

jsr pc,CLIsystem

...

 

=={{header|Phix}}==

system_exec allows you to specify whether you want a command shell or not, and whether to wait for a result. In the case of pause, the 4 signifies that we need a shell and we want to wait for it to complete.

 

=={{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:

# runs command and returns its STDOUT as a string

 

 

passthru("ls");

 

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

 

=={{header|PicoLisp}}==

 

=={{header|Pike}}==

// Process.run was added in Pike 7.8 as a wrapper to simplify the use of Process.create_process()

mapping response = Process.run("ls -l");

Process.create_process(({"ls", "-l"}), ([ "stdout" : stdout->pipe() ]) );

write(stdout->read() + "\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|PureBasic}}==

system(str.p-ascii)

EndImport

Input()

CloseConsole()

 

=={{header|Python}}==

exit_code = os.system('ls') # Just execute the command, return a success/fail code

or

 

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

# if the exit code was non-zero these commands raise a CalledProcessError

exit_code = subprocess.check_call(['ls', '-l']) # Python 2.5+

assert exit_code == 0

 

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|Racket}}==

#lang racket

 

;; avoid specifying the executable path

(system* (find-executable-path "/bin/ls") "-l")

 

=={{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|Red}}==

call/show %pause ;The /show refinement forces the display of system's shell window (Windows only).

call/show %dir

 

=={{header|REXX}}==

Since REXX is a shell scripting language, it's easy to execute commands:

 

=={{header|Ring}}==

system("dir")

 

=={{header|Ruby}}==

# runs command and returns its STDOUT as a string

string = %x{ls}

io = IO.popen('ls')

# ... later

 

=={{header|Run BASIC}}==

 

=={{header|Rust}}==

fn main() {

let output = Command::new("ls").output().unwrap_or_else(|e| {

println!("{}", String::from_utf8_lossy(&output.stdout));

}

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

{{works with|Guile}}

{{works with|Chicken Scheme}}

 

=={{header|Seed7}}==

Anyway, the task was to use a system command, so here is the example:

 

include "shell.s7i";

 

begin

cmd_sh("ls");

 

=={{header|SETL}}==

 

=={{header|Sidef}}==

%p(ls).open_r.each { |line|

print line;

 

Sys.system('ls'); # system: executes a command and prints the result

 

=={{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|SQL PL}}==

{{works with|Db2 LUW}}

In Linux or UNIX:

!ls

Output:

<pre>

</pre>

In Windows:

!dir

 

=={{header|Stata}}==

The command '''!''' (or equivalently '''shell'''), opens a Windows console to run the command, while '''winexec''' does not.

 

 

* print a message and wait

 

* load Windows Notepad

 

=={{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:

 

 

would execute "ls" and pipe the result into the channel whose name is put in the "io" variable. From there one could receive it either line by line like this:

 

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|TUSCRIPT}}==

$$ MODE TUSCRIPT

system=SYSTEM ()

EXECUTE "ls -l"

ENDIF

 

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

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

 

If one wishes to replace the shell process with some other command (chain into some command with no return) one can use the '''''exec''''' shell built-in command.

 

 

===Command substitution===

 

With [[Bourne Shell]]:

 

With [[Korn Shell]] or any modern shell:

 

* '''Note 1:''' in <code>`ls`</code>, these are "backticks" rather than quotes or apostrophes.

The '''`...`''' form is difficult to nest, but the '''$(...)''' form is very nestable.

 

 

Both forms, `backticks` and '''$(...)''', also work inside double-quoted strings. This prevents file name expansion and also prevents word splitting.

 

 

==={{header|C Shell}}===

C Shell also runs system commands, and has an '''exec''' built-in command, exactly like Bourne Shell.

 

 

`Backticks` are slightly different. When inside double quotes, as '''"`...`"''', C Shell splits words at newlines, like '''"line 1" "line 2" ...''', but preserves spaces and tabs.

 

echo "Line 1: $output[1]"

 

=={{header|Ursa}}==

decl string<> output

decl iodevice iod

for (decl int i) (< i (size output)) (inc i)

out output<i> endl console

 

=={{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|VBScript}}==

Set objShell = CreateObject("WScript.Shell")

objShell.Run "%comspec% /K dir",3,True

 

=={{header|Vedit macro language}}==

 

 

The above does not work on 64-bit Windows versions which do not have 16-bit DOS emulation.

In this case, you need to call cmd.exe explicitly:

 

 

=={{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)

 

=={{header|Visual Basic .NET}}==

{{works with|Visual Basic .NET|9.0+}}

 

Sub Main()

 

End Module

=={{header|Wart}}==

 

=={{header|zkl}}==

 

=={{header|ZX Spectrum Basic}}==

The ZX Spectrum uses a ROM based basic interpreter, so every statement within the program is a system command. If a command without a line number is typed, whilst the computer is in a ready state, the command gets executed immediately:

 

 

{{omit from|Retro}}

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