Execute a system command: Difference between revisions
m
→{{header|Wren}}: Minor tidy
No edit summary |
m (→{{header|Wren}}: Minor tidy) |
||
| (346 intermediate revisions by more than 100 users not shown) | |||
Line 1:
{{Task|Programming environment operations}}
;Task:
Run either the <tt>'''ls'''</tt> system command (<tt>'''dir'''</tt> on Windows), or the <tt>'''pause'''</tt> system command.
<br><br>
;Related task
* [[Get_system_command_output | Get system command output]]
<br><br>
==
<syntaxhighlight lang="11l">os:(‘pause’)</syntaxhighlight>
=={{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.
<syntaxhighlight lang="abap">*&---------------------------------------------------------------------*
*& Report ZEXEC_SYS_CMD
*&
*&---------------------------------------------------------------------*
*&
*&
*&---------------------------------------------------------------------*
REPORT zexec_sys_cmd.
DATA: lv_opsys TYPE syst-opsys,
lt_sxpgcotabe TYPE TABLE OF sxpgcotabe,
ls_sxpgcotabe LIKE LINE OF lt_sxpgcotabe,
ls_sxpgcolist TYPE sxpgcolist,
lv_name TYPE sxpgcotabe-name,
lv_opcommand TYPE sxpgcotabe-opcommand,
lv_index TYPE c,
lt_btcxpm TYPE TABLE OF btcxpm,
ls_btcxpm LIKE LINE OF lt_btcxpm
.
* Initialize
lv_opsys = sy-opsys.
CLEAR lt_sxpgcotabe[].
IF lv_opsys EQ 'Windows NT'.
lv_opcommand = 'dir'.
ELSE.
lv_opcommand = 'ls'.
ENDIF.
* Check commands
SELECT * FROM sxpgcotabe INTO TABLE lt_sxpgcotabe
WHERE opsystem EQ lv_opsys
AND opcommand EQ lv_opcommand.
IF lt_sxpgcotabe IS INITIAL.
CLEAR ls_sxpgcolist.
CLEAR lv_name.
WHILE lv_name IS INITIAL.
* Don't mess with other users' commands
lv_index = sy-index.
CONCATENATE 'ZLS' lv_index INTO lv_name.
SELECT * FROM sxpgcostab INTO ls_sxpgcotabe
WHERE name EQ lv_name.
ENDSELECT.
IF sy-subrc = 0.
CLEAR lv_name.
ENDIF.
ENDWHILE.
ls_sxpgcolist-name = lv_name.
ls_sxpgcolist-opsystem = lv_opsys.
ls_sxpgcolist-opcommand = lv_opcommand.
* Create own ls command when nothing is declared
CALL FUNCTION 'SXPG_COMMAND_INSERT'
EXPORTING
command = ls_sxpgcolist
public = 'X'
EXCEPTIONS
command_already_exists = 1
no_permission = 2
parameters_wrong = 3
foreign_lock = 4
system_failure = 5
OTHERS = 6.
IF sy-subrc <> 0.
* Implement suitable error handling here
ELSE.
* Hooray it worked! Let's try to call it
CALL FUNCTION 'SXPG_COMMAND_EXECUTE_LONG'
EXPORTING
commandname = lv_name
TABLES
exec_protocol = lt_btcxpm
EXCEPTIONS
no_permission = 1
command_not_found = 2
parameters_too_long = 3
security_risk = 4
wrong_check_call_interface = 5
program_start_error = 6
program_termination_error = 7
x_error = 8
parameter_expected = 9
too_many_parameters = 10
illegal_command = 11
wrong_asynchronous_parameters = 12
cant_enq_tbtco_entry = 13
jobcount_generation_error = 14
OTHERS = 15.
IF sy-subrc <> 0.
* Implement suitable error handling here
WRITE: 'Cant execute ls - '.
CASE sy-subrc.
WHEN 1.
WRITE: / ' no permission!'.
WHEN 2.
WRITE: / ' command could not be created!'.
WHEN 3.
WRITE: / ' parameter list too long!'.
WHEN 4.
WRITE: / ' security risk!'.
WHEN 5.
WRITE: / ' wrong call of SXPG_COMMAND_EXECUTE_LONG!'.
WHEN 6.
WRITE: / ' command cant be started!'.
WHEN 7.
WRITE: / ' program terminated!'.
WHEN 8.
WRITE: / ' x_error!'.
WHEN 9.
WRITE: / ' parameter missing!'.
WHEN 10.
WRITE: / ' too many parameters!'.
WHEN 11.
WRITE: / ' illegal command!'.
WHEN 12.
WRITE: / ' wrong asynchronous parameters!'.
WHEN 13.
WRITE: / ' cant enqueue job!'.
WHEN 14.
WRITE: / ' cant create job!'.
WHEN 15.
WRITE: / ' unknown error!'.
WHEN OTHERS.
WRITE: / ' unknown error!'.
ENDCASE.
ELSE.
LOOP AT lt_btcxpm INTO ls_btcxpm.
WRITE: / ls_btcxpm.
ENDLOOP.
ENDIF.
ENDIF.
ENDIF.</syntaxhighlight>
=={{header|Ada}}==
Using the IEEE POSIX Ada standard, P1003.5c:
<syntaxhighlight lang="ada">with POSIX.Unsafe_Process_Primitives;
procedure Execute_A_System_Command is
Arguments : POSIX.POSIX_String_List;
begin
POSIX.Append (Arguments, "ls");
POSIX.Unsafe_Process_Primitives.Exec_Search ("ls", Arguments);
end Execute_A_System_Command;</syntaxhighlight>
Importing the C system() function:
<syntaxhighlight lang="ada">with Interfaces.C; use Interfaces.C;
procedure Execute_System is
function Sys (Arg : Char_Array) return Integer;
pragma Import(C, Sys, "system");
Ret_Val : Integer;
Ret_Val := Sys(To_C("ls"));
Using the GNAT run-time library:
<syntaxhighlight lang="ada">
with Ada.Text_IO; use Ada.Text_IO;
with System.OS_Lib; use System.OS_Lib;
procedure Execute_Synchronously is
Result : Integer;
Arguments : Argument_List :=
( 1=> new String'("cmd.exe"),
2=> new String'("/C dir c:\temp\*.adb")
);
begin
Spawn
( Program_Name => "cmd.exe",
Args => Arguments,
Output_File_Descriptor => Standout,
Return_Code => Result
);
for Index in Arguments'Range loop
Free (Arguments (Index)); -- Free the argument list
end loop;
end Execute_Synchronously;
</syntaxhighlight>
=={{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).
<syntaxhighlight lang="aikido">
var lines = system ("ls")
foreach line lines {
println (line)
}
</syntaxhighlight>
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;
<syntaxhighlight lang="aikido">
exec ("ls")
</syntaxhighlight>
You also have the regular <code>fork</code> and <code>execv</code> calls available:
<syntaxhighlight lang="aikido">
var pid = fork()
if (pid == 0) {
var args = ["/bin/ls"]
execv ("/bin/ls", args)
exit(1)
}
var status = 0
waitpid (pid, status)
</syntaxhighlight>
==
<syntaxhighlight lang="aime">sshell ss;
ss.argv.insert("ls");
o_(ss.link);
</syntaxhighlight>
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9 - "system" is not part of the standard's prelude.}}
<syntaxhighlight lang="algol68">system("ls")</syntaxhighlight>
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.}}
<syntaxhighlight lang="algol68">OP ! = (STRING cmd)BOOL: system(cmd) = 0;
IF ! "touch test.tmp" ANDF ( ! "ls test.tmp" ANDF ! "rm test.tmp" ) THEN
print (("test.tmp now gone!", new line))
FI</syntaxhighlight>
=={{header|Amazing Hopper}}==
<syntaxhighlight lang="amazing hopper">
#!/usr/bin/hopper
#include <hopper.h>
main:
/* execute "ls -lstar" with no result return (only displayed) */
{"ls -lstar"},execv
/* this form does not allow composition of the line with variables.
Save result in the variable "s", and then display it */
s=`ls -l | awk '{if($2=="2")print $0;}'`
{"\n",s,"\n"}print
data="2"
{""}tok sep
// the same as above, only I can compose the line:
{"ls -l | awk '{if($2==\"",data,"\")print $0;}'"}join(s),{s}exec,print
{"\n\n"}print
// this does the same as above, with an "execute" macro inside a "let" macro:
t=0,let (t := execute( {"ls -l | awk '{if($2==\""},{data},{"\")print $0;}'"} ))
{t,"\n"}print
{0}return
</syntaxhighlight>
=={{header|APL}}==
<syntaxhighlight lang="apl">
∇ system s;handle
⍝⍝ NOTE: one MUST give the full absolute path to the program (eg. /bin/ls)
⍝⍝ Exercise: Can you improve this by parsing the value of
⍝⍝ ⎕ENV 'PATH' ?
⍝⍝
handle ← ⎕fio['fork_daemon'] s
⎕fio['fclose'] handle
∇
system '/bin/ls /var'
backups games lib lock mail run tmp
cache gemini local log opt spool
</syntaxhighlight>
=={{header|AppleScript}}==
<syntaxhighlight lang="applescript">do shell script "ls" without altering line endings</syntaxhighlight>
=={{header|Applesoft BASIC}}==
<syntaxhighlight lang="applesoftbasic">? CHR$(4)"CATALOG"</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">print execute "ls"</syntaxhighlight>
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">Run, %comspec% /k dir & pause</syntaxhighlight>
=={{header|AutoIt}}==
<syntaxhighlight lang="autoit">Run(@ComSpec & " /c " & 'pause', "", @SW_HIDE)</syntaxhighlight>
=={{header|AWK}}==
Using system() function:
<syntaxhighlight lang="awk">BEGIN {
system("ls") # Unix
#system("dir") # DOS/MS-Windows
}</syntaxhighlight>
Using getline command:
<syntaxhighlight lang="awk">BEGIN {
ls = sys2var("ls")
print ls
}
function sys2var(command ,fish, scale, ship) {
command = command " 2>/dev/null"
while ( (command | getline fish) > 0 ) {
if ( ++scale == 1 )
ship = fish
else
ship = ship "\n" fish
}
close(command)
return ship
}</syntaxhighlight>
=={{header|BASIC}}==
<syntaxhighlight lang="qbasic">SHELL "dir"</syntaxhighlight>
==={{header|BaCon}}===
<syntaxhighlight lang="freebasic">' Execute a system command
SYSTEM "ls"</syntaxhighlight>
=={{header|BASIC256}}==
<syntaxhighlight lang="basic256">system "dir"</syntaxhighlight>
=={{header|Batch File}}==
<syntaxhighlight lang="batch">dir</syntaxhighlight>
=={{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.
<syntaxhighlight lang="bbcbasic">OSCLI "CAT"</syntaxhighlight>
With BBC BASIC for Windows you can execute the Windows dir command:
<syntaxhighlight lang="bbcbasic">OSCLI "*dir":REM *dir to bypass BB4W's built-in dir command</syntaxhighlight>
And if running BBC BASIC on a Unix host, you can execute the ls command:
<syntaxhighlight lang="bbcbasic">OSCLI "ls"</syntaxhighlight>
=={{header|Befunge}}==
{{works with|Befunge|98}}
Works with any Funge-98 on Unix, try https://tio.run/##S0pNK81LT9W1tNAtqAQz//9XKs5RsnX4/x8A
<syntaxhighlight lang="befunge">"sl"=@;pushes ls, = executes it, @ ends it;</syntaxhighlight>
=={{header|BQN}}==
<code>•SH</code> is a function defined in the BQN spec, which provides output from a shell command.
The arguments to <code>•SH</code> are the command, followed by its arguments as a flat list of strings. For example:
<syntaxhighlight lang="bqn">•SH ⟨"ls"⟩</syntaxhighlight>
Will give an output as a list of three elements: the command's exit code, text written to stdout, and text written to stderr.
=={{header|Bracmat}}==
<syntaxhighlight lang="bracmat">sys$dir</syntaxhighlight>
=={{header|Brat}}==
<syntaxhighlight lang="brat">include :subprocess
p subprocess.run :ls #Lists files in directory</syntaxhighlight>
=={{header|Brlcad}}==
<syntaxhighlight lang="brlcad">
exec ls
</syntaxhighlight>
=={{header|C}}==
ISO C & POSIX:
<syntaxhighlight lang="c">#include <stdlib.h>
int main()
{
system("ls");
return 0;
}</syntaxhighlight>
=={{header|C sharp|C#}}==
Using Windows / .NET:
<syntaxhighlight lang="csharp">using System.Diagnostics;
namespace Execute
{
class Program
{
static void Main(string[] args)
{
Process.Start("cmd.exe", "/c dir");
}
}
}</syntaxhighlight>
{{works with|MCS|1.2.3.1}}
<syntaxhighlight lang="csharp">using System;
class Execute {
static void Main() {
System.Diagnostics.Process proc = new System.Diagnostics.Process();
proc.EnableRaisingEvents=false;
proc.StartInfo.FileName="ls";
proc.Start();
}
}</syntaxhighlight>
=={{header|C++}}==
{{works with|Visual C++|2005}}
<syntaxhighlight lang="cpp">system("pause");</syntaxhighlight>
=={{header|Clojure}}==
<syntaxhighlight lang="lisp">(.. Runtime getRuntime (exec "cmd /C dir"))</syntaxhighlight>
<syntaxhighlight lang="lisp">
user=> (use '[clojure.java.shell :only [sh]])
user=> (sh "ls" "-aul")
{:exit 0,
:out total 64
drwxr-xr-x 11 zkim staff 374 Jul 5 13:21 .
drwxr-xr-x 25 zkim staff 850 Jul 5 13:02 ..
drwxr-xr-x 12 zkim staff 408 Jul 5 13:02 .git
-rw-r--r-- 1 zkim staff 13 Jul 5 13:02 .gitignore
-rw-r--r-- 1 zkim staff 12638 Jul 5 13:02 LICENSE.html
-rw-r--r-- 1 zkim staff 4092 Jul 5 13:02 README.md
drwxr-xr-x 2 zkim staff 68 Jul 5 13:15 classes
drwxr-xr-x 5 zkim staff 170 Jul 5 13:15 lib
-rw-r--r--@ 1 zkim staff 3396 Jul 5 13:03 pom.xml
-rw-r--r--@ 1 zkim staff 367 Jul 5 13:15 project.clj
drwxr-xr-x 4 zkim staff 136 Jul 5 13:15 src
, :err }
</syntaxhighlight>
<syntaxhighlight lang="lisp">
user=> (use '[clojure.java.shell :only [sh]])
user=> (println (:out (sh "cowsay" "Printing a command-line output")))
_________________________________
< Printing a command-line output. >
---------------------------------
\ ^__^
\ (oo)\_______
(__)\ )\/\
||----w |
|| ||
nil
</syntaxhighlight>
=={{header|CMake}}==
{{works with|Unix}}
<syntaxhighlight lang="cmake">execute_process(COMMAND ls)</syntaxhighlight>
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.
<syntaxhighlight lang="cmake"># Calculate pi to 40 digits after the decimal point.
execute_process(
COMMAND printf "scale = 45; 4 * a(1) + 5 / 10 ^ 41\\n"
COMMAND bc -l
COMMAND sed -e "s/.\\{5\\}$//"
OUTPUT_VARIABLE pi OUTPUT_STRIP_TRAILING_WHITESPACE)
message(STATUS "pi is ${pi}")</syntaxhighlight>
<pre>-- pi is 3.1415926535897932384626433832795028841972</pre>
=={{header|COBOL}}==
{{works with|OpenCOBOL}}
<syntaxhighlight lang="cobol">CALL "SYSTEM" USING BY CONTENT "ls"</syntaxhighlight>
=={{header|CoffeeScript}}==
{{works with|Node.js}}
<syntaxhighlight lang="coffeescript">
{ spawn } = require 'child_process'
ls = spawn 'ls'
ls.stdout.on 'data', ( data ) -> console.log "Output: #{ data }"
ls.stderr.on 'data', ( data ) -> console.error "Error: #{ data }"
ls.on 'close', -> console.log "'ls' has finished executing."
</syntaxhighlight>
=={{header|Common Lisp}}==
{{works with|CMUCL}}
<syntaxhighlight lang="lisp">(with-output-to-string (stream) (extensions:run-program "ls" nil :output stream))</syntaxhighlight>
{{works with|LispWorks}}
<syntaxhighlight lang="lisp">(system:call-system "ls")</syntaxhighlight>
{{libheader|trivial-shell}}
<syntaxhighlight lang="lisp">(trivial-shell:shell-command "ls")</syntaxhighlight>
{{libheader|uiop}}
<syntaxhighlight lang="lisp">; uiop is part of the de facto build system, asdf, so should be available to most installations.
; synchronous
(uiop:run-program "ls")
; async
(defparameter *process* (uiop:launch-program "ls"))
(uiop:wait-process *process*)</syntaxhighlight>
=={{header|D}}==
<syntaxhighlight lang="d">
import std.process, std.stdio;
//these two alternatives wait for the process to return, and capture the output
//each process function returns a Tuple of (int)"status" and (string)"output
auto ls_string = executeShell("ls -l"); //takes single string
writeln((ls_string.status == 0) ? ls_string.output : "command failed");
auto ls_array = execute(["ls", "-l"]); //takes array of strings
writeln((ls_array.status == 0) ? ls_array.output : "command failed");
//other alternatives exist to spawn processes in parallel and capture output via pipes
</syntaxhighlight>
std.process.system() is deprecated.
=={{header|dc}}==
<syntaxhighlight lang="dc">! ls</syntaxhighlight>
=={{header|DBL}}==
<syntaxhighlight lang="dbl">XCALL SPAWN ("ls *.jpg > file.txt") ;execute command and continue
XCALL EXEC ("script.sh") ;execute script or binary and exit
STOP '@/bin/ls *.jpg > file.txt' ;exit and execute command</syntaxhighlight>
=={{header|DCL}}==
<syntaxhighlight lang="dcl">Directory</syntaxhighlight>
Or, shorter<syntaxhighlight lang="dcl">dir</syntaxhighlight>
=={{header|Delphi}}==
<syntaxhighlight lang="delphi">program ExecuteSystemCommand;
{$APPTYPE CONSOLE}
uses Windows, ShellApi;
begin
ShellExecute(0, nil, 'cmd.exe', ' /c dir', nil, SW_HIDE);
end.</syntaxhighlight>
=={{header|E}}==
<syntaxhighlight lang="e">def ls := makeCommand("ls")
ls("-l")
def [results, _, _] := ls.exec(["-l"])
when (results) -> {
def [exitCode, out, err] := results
print(out)
} catch problem {
print(`failed to execute ls: $problem`)
}</syntaxhighlight>
=={{header|Emacs Lisp}}==
Synchronously (shell, interactive):
<syntaxhighlight lang="lisp">(shell-command "ls")</syntaxhighlight>
Asynchronously (shell, interactive):
<syntaxhighlight lang="lisp">(async-shell-command "ls")</syntaxhighlight>
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">os:cmd("ls").</syntaxhighlight>
=={{header|ERRE}}==
In ERRE language you have the SHELL command followed, eventually, by a string command.
SHELL itself opens a new DOS/Windows shell: you must use EXIT to end.
For example
<syntaxhighlight lang="text"> SHELL("DIR/W")</syntaxhighlight>
lists the current directory and then returns to the program.
<syntaxhighlight lang="erre">cmd$="DIR/W"
SHELL(cmd$)</syntaxhighlight>
=={{header|Euphoria}}==
Euphoria has 2 systems command functions: '''system()''' and '''system_exec()'''.
<syntaxhighlight lang="euphoria"> -- system --
-- the simplest way --
-- system spawns a new shell so I/O redirection is possible --
system( "dir /w c:\temp\ " ) -- Microsoft --
system( "/bin/ls -l /tmp" ) -- Linux BSD OSX --
----
-- system_exec() --
-- system_exec does not spawn a new shell --
-- ( like bash or cmd.exe ) --
integer exit_code = 0
sequence ls_command = ""
ifdef UNIX or LINUX or OSX then
ls_command = "/bin/ls -l "
elsifdef WINDOWS then
ls_command = "dir /w "
end ifdef
exit_code = system_exec( ls_command )
if exit_code = -1 then
puts( STDERR, " could not execute " & ls_command & "\n" )
elsif exit_code = 0 then
puts( STDERR, ls_command & " succeeded\n")
else
printf( STDERR, "command %s failed with code %d\n", ls_command, exit_code)
end if</syntaxhighlight>
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">System.Diagnostics.Process.Start("cmd", "/c dir")</syntaxhighlight>
=={{header|Factor}}==
<syntaxhighlight lang="factor">"ls" run-process wait-for-process</syntaxhighlight>
=={{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:
<syntaxhighlight lang="fantom">
class Main
{
public static Void main ()
{
p := Process (["ls"])
p.run
}
}
</syntaxhighlight>
=={{header|Forth}}==
{{works with|gforth|0.6.2}}
<syntaxhighlight lang="forth">s" ls" system</syntaxhighlight>
=={{header|Fortran}}==
execute_command_line subroutine in Fortran 2008 and later runs a system command
<syntaxhighlight lang="fortran">
program SystemTest
integer :: i
call execute_command_line ("ls", exitstat=i)
end program SystemTest
</syntaxhighlight>
{{works with|gfortran}}
The <tt>SYSTEM</tt> subroutine (and function) are a GNU extension.
<syntaxhighlight lang="fortran">program SystemTest
call system("ls")
end program SystemTest</syntaxhighlight>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64
Shell "dir"
Sleep</syntaxhighlight>
=={{header|Frink}}==
<syntaxhighlight lang="frink">r = callJava["java.lang.Runtime", "getRuntime"]
println[read[r.exec["dir"].getInputStream[]]]</syntaxhighlight>
=={{header|FunL}}==
<syntaxhighlight lang="funl">import sys.execute
execute( if $os.startsWith('Windows') then 'dir' else 'ls' )</syntaxhighlight>
=={{header|FutureBasic}}==
FB 7.0.23+
<syntaxhighlight lang="futurebasic">
print unix(@"ls -A")
</syntaxhighlight>
Classic FB using Pascal strings
<syntaxhighlight>
local fn DoUnixCommand( cmd as str255 )
str255 s
open "Unix", 2, cmd
while ( not eof(2) )
line input #2, s
print s
wend
close 2
end fn
fn DoUnixCommand( "ls -A" )
</syntaxhighlight>
Output:
<pre>
.DocumentRevisions-V100
.Spotlight-V100
.Trashes
.file
.fseventsd
.hotfiles.btree
.vol
Applications
Library
Network
System
Users
Volumes
bin
cores
dev
etc
home
mach_kernel
net
private
sbin
tmp
usr
var
</pre>
Modern FB using CFStrings
<syntaxhighlight>
include "NSLog.incl"
// For remote uses like curl
// #plist NSAppTransportSecurity @{NSAllowsArbitraryLoads:YES}
local fn RunTerminalCommand( cmd as CFStringRef ) as CFStringRef
————————————————————————————————————————————————————————————————————————————————————————————————————
ErrorRef err = NULL
CFStringRef outputStr = NULL
TaskRef task = fn TaskInit
TaskSetExecutableURL( task, fn URLFileURLWithPath( @"/bin/zsh" ) )
CFStringRef cmdStr = fn StringWithFormat( @"%@", cmd )
CFArrayRef args = fn ArrayWithObjects( @"-c", cmdStr, NULL )
TaskSetArguments( task, args )
PipeRef p = fn PipeInit
TaskSetStandardOutput( task, p )
TaskSetStandardError( task, p )
FileHandleRef fh = fn PipeFileHandleForReading( p )
fn TaskLaunch( task, NULL )
TaskWaitUntilExit( task )
CFDataRef dta = fn FileHandleReadDataToEndOfFile( fh, @err )
if err then NSLog( @"Error reading file: %@", fn ErrorLocalizedDescription( err ) ) : exit fn
fn FileHandleClose( fh, @err )
if err then NSLog( @"Error closing file: %@", fn ErrorLocalizedDescription( err ) ) : exit fn
outputStr = fn StringWithData( dta, NSUTF8StringEncoding )
end fn = outputStr
CFStringRef cmd
cmd = @"cal 2023"
NSLog( @"%@", fn RunTerminalCommand( cmd ) )
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
2023
January February March
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 4 5 6 7 1 2 3 4 1 2 3 4
8 9 10 11 12 13 14 5 6 7 8 9 10 11 5 6 7 8 9 10 11
15 16 17 18 19 20 21 12 13 14 15 16 17 18 12 13 14 15 16 17 18
22 23 24 25 26 27 28 19 20 21 22 23 24 25 19 20 21 22 23 24 25
29 30 31 26 27 28 26 27 28 29 30 31
April May June
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 1 2 3 4 5 6 1 2 3
2 3 4 5 6 7 8 7 8 9 10 11 12 13 4 5 6 7 8 9 10
9 10 11 12 13 14 15 14 15 16 17 18 19 20 11 12 13 14 15 16 17
16 17 18 19 20 21 22 21 22 23 24 25 26 27 18 19 20 21 22 23 24
23 24 25 26 27 28 29 28 29 30 31 25 26 27 28 29 30
30
July August September
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 1 2 3 4 5 1 2
2 3 4 5 6 7 8 6 7 8 9 10 11 12 3 4 5 6 7 8 9
9 10 11 12 13 14 15 13 14 15 16 17 18 19 10 11 12 13 14 15 16
16 17 18 19 20 21 22 20 21 22 23 24 25 26 17 18 19 20 21 22 23
23 24 25 26 27 28 29 27 28 29 30 31 24 25 26 27 28 29 30
30 31
October November December
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 4 5 6 7 1 2 3 4 1 2
8 9 10 11 12 13 14 5 6 7 8 9 10 11 3 4 5 6 7 8 9
15 16 17 18 19 20 21 12 13 14 15 16 17 18 10 11 12 13 14 15 16
22 23 24 25 26 27 28 19 20 21 22 23 24 25 17 18 19 20 21 22 23
29 30 31 26 27 28 29 30 24 25 26 27 28 29 30
31
</pre>
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=9460b39a86794a7346a390aeb50fc5cf Click this link to run this code]'''
<syntaxhighlight lang="gambas">Public Sub Main()
Shell "ls -aul"
End</syntaxhighlight>
Output:
<pre>
total 36364
drwxr-xr-x 88 charlie charlie 4096 May 29 10:26 .
drwxr-xr-x 5 root root 4096 May 26 15:44 ..
drwxr-xr-x 2 charlie charlie 4096 May 29 10:54 15PuzzleGame
drwx------ 3 charlie charlie 4096 May 28 13:51 .adobe
drwxr-xr-x 4 charlie charlie 4096 May 28 13:52 .audacity-data
drwxr-xr-x 4 charlie charlie 4096 May 28 13:51 .barcode
etc....
</pre>
=={{header|Genie}}==
<syntaxhighlight lang="genie">[indent=4]
/*
Execute system command, in Genie
valac executeSystemCommand.gs
./executeSystemCommand
*/
init
try
// Non Blocking
Process.spawn_command_line_async("ls")
except e : SpawnError
stderr.printf("%s\n", e.message)</syntaxhighlight>
{{out}}
Output is asynchronous (could be made synchronous with ''spawn_command_line_sync''), and elided here for the sample capture.
<pre>prompt$ valac executeSystemCommand.gs
prompt$ ./executeSystemCommand
...
aplusb executeSystemCommand hello.gs helloNoNewline.gs
memavail progress-bar readfile.vapi stringsample.vala
...
</pre>
=={{header|gnuplot}}==
<syntaxhighlight lang="gnuplot">!ls</syntaxhighlight>
=={{header|Go}}==
<syntaxhighlight lang="go">package main
import (
"log"
"os"
"os/exec"
)
func main() {
cmd := exec.Command("ls", "-l")
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
log.Fatal(err)
}
}</syntaxhighlight>
=={{header|Groovy}}==
<syntaxhighlight lang="groovy">println "ls -la".execute().text</syntaxhighlight>
=={{header|GUISS}}==
<syntaxhighlight lang="guiss">Start,Programs,Accessories,MSDOS Prompt,Type:dir[enter]</syntaxhighlight>
=={{header|Haskell}}==
{{works with|GHC|GHCi|6.6}}
<syntaxhighlight lang="haskell">import System.Cmd
main = system "ls"
</syntaxhighlight>
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}}==
<syntaxhighlight lang="hicest">SYSTEM(CoMmand='pause')
SYSTEM(CoMmand='dir & pause') </syntaxhighlight>
=={{header|HolyC}}==
HolyC is the official programming language for The Temple Operating System (TempleOS). The Temple Operating System interpreter executes just-in-time compiled HolyC code. All HolyC code is effectively executed as system commands.
For example, to execute the <code>Dir</code> command:
<syntaxhighlight lang="holyc">Dir;</syntaxhighlight>
=={{header|Icon}} and {{header|Unicon}}==
The code below selects the 'ls' or 'dir' command at runtime based on the UNIX feature.
<syntaxhighlight lang="icon">procedure main()
write("Trying command ",cmd := if &features == "UNIX" then "ls" else "dir")
system(cmd)
end</syntaxhighlight>
Unicon extends system to allow specification of files and a wait/nowait parameter as in the examples below.
<syntaxhighlight lang="icon">
pid := system(command_string,&input,&output,&errout,"wait")
pid := system(command_string,&input,&output,&errout,"nowait")
</syntaxhighlight>
=={{header|IDL}}==
<syntaxhighlight lang="idl">$ls</syntaxhighlight>
Will execute "ls" with output to the screen.
<syntaxhighlight
will execute it and store the result in the string array "result".
<syntaxhighlight
will execute it asynchronously and direct any output from it into the LUN "unit" from whence it can be read at any (later) time.
==
<syntaxhighlight lang="io">System runCommand("ls") stdout println</syntaxhighlight>
=={{header|IS-BASIC}}==
<syntaxhighlight lang="is-basic">100 EXT "dir"</syntaxhighlight>
=={{header|J}}==
The system command interface in J is provided by the standard "task" script:
<syntaxhighlight lang="j">load'task'
NB. Execute a command and wait for it to complete
shell 'dir'
NB. Execute a command but don't wait for it to complete
fork 'notepad'
NB. Execute a command and capture its stdout
stdout =: shell 'dir'
NB. Execute a command, provide it with stdin,
NB. and capture its stdout
stdin =: 'blahblahblah'
stdout =: stdin spawn 'grep blah'</syntaxhighlight>
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+}}
<syntaxhighlight lang="java5">import java.util.Scanner;
import java.io.*;
public class Program {
public static void main(String[] args) {
try {
Process p = Runtime.getRuntime().exec("cmd /C dir");//Windows command, use "ls -oa" for UNIX
Scanner sc = new Scanner(p.getInputStream());
while (sc.hasNext()) System.out.println(sc.nextLine());
}
catch (IOException e) {
System.out.println(e.getMessage());
}
}
}</syntaxhighlight>
{{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)
<syntaxhighlight lang="java">import java.io.IOException;
import java.io.InputStream;
Line 102 ⟶ 1,031:
}</syntaxhighlight>
And the right way,
<syntaxhighlight lang="java">import java.io.IOException;
import java.io.InputStream;
Line 170 ⟶ 1,097:
}
}
}</syntaxhighlight>
=={{header|JavaScript}}==
JavaScript does not have any facilities to interact with the OS. However, host environments can provide this ability.
{{works with|JScript}}
<syntaxhighlight lang="javascript">var shell = new ActiveXObject("WScript.Shell");
shell.run("cmd /c dir & pause");</syntaxhighlight>
{{works with|Rhino}}
<syntaxhighlight lang="javascript">runCommand("cmd", "/c", "dir", "d:\\");
print("===");
var options = {
// can specify arguments here in the options object
args: ["/c", "dir", "d:\\"],
// capture stdout to the options.output property
output: ''
};
runCommand("cmd", options);
print(options.output);</syntaxhighlight>
=={{header|Joy}}==
<<syntaxhighlight lang="joy">"ls" system.</syntaxhighlight>
=={{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:
<syntaxhighlight lang="julia">run(`ls`)</syntaxhighlight>
{{out}}
<pre>
$ ls
bitmap_bresenham_line.jl completed single_link_list_collection.jl
color_quantization_in.png execute_system_command.jl single_link_list_insert.jl
color_quantization.jl README.md support
$ julia execute_system_command.jl
bitmap_bresenham_line.jl completed single_link_list_collection.jl
color_quantization_in.png execute_system_command.jl single_link_list_insert.jl
color_quantization.jl README.md support
</pre>
==
Execute "ls"
<syntaxhighlight lang="k"> \ls</syntaxhighlight>
Execute "ls" and capture the output in the variable "r":
<syntaxhighlight lang="k"> r: 4:"ls"</syntaxhighlight>
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.0.6
import java.util.Scanner
fun main(args: Array<String>) {
val proc = Runtime.getRuntime().exec("cmd /C dir") // testing on Windows 10
Scanner(proc.inputStream).use {
while (it.hasNextLine()) println(it.nextLine())
}
}</syntaxhighlight>
=={{header|Lang5}}==
For one-word commands:
<syntaxhighlight lang="lang5">'ls system</syntaxhighlight>
For multi-word commands:
<syntaxhighlight lang="lang5">"ls -a" system</syntaxhighlight>
=={{header|Lasso}}==
<syntaxhighlight lang="lasso">local(
path = file_forceroot,
ls = sys_process('/bin/ls', (:'-l', #path)),
lswait = #ls -> wait
)
'<pre>'
#ls -> read
'</pre>'</syntaxhighlight>
<pre>total 16
drwxr-xr-x 8 _lasso staff 272 Nov 10 08:13 mydir
-rw-r--r-- 1 _lasso staff 38 Oct 29 16:05 myfile.lasso
-rw-r--r--@ 1 _lasso staff 175 Oct 29 18:18 rosetta.lasso</pre>
=={{header|LFE}}==
In the LFE REPL:
<syntaxhighlight lang="lisp">
> (os:cmd "ls -alrt")
</syntaxhighlight>
That will display output on a single line, with literal newlines.
For pretty output, compose with <code>io:format</code>:
<syntaxhighlight lang="lisp">
> (io:format (os:cmd "ls -alrt"))
</syntaxhighlight>
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">
drive1$ = left$(Drives$,1)
run "cmd.exe /";drive1$;" dir & pause"
</syntaxhighlight>
=={{header|Limbo}}==
There is no equivalent to Unix's exec() in Inferno per se; commands are just modules that have at least an init() function with the correct signature, and are loaded the same way as any other module. (As a result, there's nothing in the language or OS that prevents a program from acting as both a command and a library except convention.)
This version passes its argument list through to ls:
<syntaxhighlight lang="limbo">implement Runls;
include "sys.m"; sys: Sys;
include "draw.m";
include "sh.m";
Runls: module {
init: fn(ctxt: ref Draw->Context, args: list of string);
};
init(ctxt: ref Draw->Context, args: list of string)
{
sys = load Sys Sys->PATH;
ls := load Command "/dis/ls.dis";
if(ls == nil)
die("Couldn't load /dis/ls.dis");
ls->init(ctxt, "ls" :: tl args);
}
die(s: string)
{
sys->fprint(sys->fildes(2), "runls: %s: %r", s);
raise "fail:errors";
}</syntaxhighlight>
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|Lingo}}==
{{libheader|Shell Xtra}}
<syntaxhighlight lang="lingo">sx = xtra("Shell").new()
if the platform contains "win" then
put sx.shell_cmd("dir")
else
put sx.shell_cmd("ls")
end if</syntaxhighlight>
=={{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):
<syntaxhighlight lang="basic">LIST</syntaxhighlight>
=={{header|Logo}}==
{{works with|UCB Logo}}
The lines of output of the SHELL command are returned as a list.
<syntaxhighlight lang="logo">print first butfirst shell [ls -a] ; ..</syntaxhighlight>
=={{header|Logtalk}}==
Using the standard library:
<syntaxhighlight lang="logtalk">os::shell('ls -a').</syntaxhighlight>
=={{header|Lua}}==
<syntaxhighlight lang="lua">-- just executing the command
os.execute("ls")
-- to execute and capture the output, use io.popen
local f = io.popen("ls") -- store the output in a "file"
print( f:read("*a") ) -- print out the "file"'s content</syntaxhighlight>
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Locale 1033 // for the chr$(string) : converτ ANSI to UTF16LE
Dos "chdir "+quote$(dir$)+"&& dir /w > out.txt";
Wait 100
Print "Press Space or Mouse to see next page"
A$=chr$(eval$(buffer("out.txt")))
Report a$ // view text using proportional typing, and at pages, with 3/4height scroll
</syntaxhighlight>
=={{header|M4}}==
<syntaxhighlight lang="m4">syscmd(ifdef(`__windows__',`dir',`ls'))</syntaxhighlight>
=={{header|Make}}==
make can use system command in either definition of variables or in the targets
in definition
<syntaxhighlight lang="make">contents=$(shell cat foo)
curdir=`pwd`</syntaxhighlight>
in target
<syntaxhighlight lang="make">mytarget:
cat foo | grep mytext</syntaxhighlight>
=={{header|Maple}}==
<syntaxhighlight lang="maple">ssystem("dir");</syntaxhighlight>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">Run["ls"]</syntaxhighlight>
=={{header|MATLAB}}==
To execute system commands in MATLAB, use the "system" keyword.
Sample Usage:
<syntaxhighlight lang="matlab">>> system('PAUSE')
Press any key to continue . . .
ans =
0
</syntaxhighlight>
=={{header|Maxima}}==
<syntaxhighlight lang="text">system("dir > list.txt")$</syntaxhighlight>
=={{header|MAXScript}}==
<syntaxhighlight lang="maxscript">dosCommand "pause"</syntaxhighlight>
=={{header|Mercury}}==
<syntaxhighlight lang="text">
:- module execute_sys_cmd.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
main(!IO) :-
io.call_system("ls", _Result, !IO).
</syntaxhighlight>
=={{header|min}}==
{{works with|min|0.19.3}}
<syntaxhighlight lang="min">!dir</syntaxhighlight>
=={{header|Modula-2}}==
<syntaxhighlight lang="modula2">MODULE tri;
FROM SYSTEM IMPORT ADR;
FROM SysLib IMPORT system;
IMPORT TextIO, InOut, ASCII;
VAR fd : TextIO.File;
ch : CHAR;
PROCEDURE SystemCommand (VAR command : ARRAY OF CHAR) : BOOLEAN;
BEGIN
IF system (ADR (command) ) = 0 THEN
RETURN TRUE
ELSE
RETURN FALSE
END
END SystemCommand;
BEGIN
IF SystemCommand ("ls -1 tri.mod | ") = TRUE THEN
InOut.WriteString ("No error reported.")
ELSE
InOut.WriteString ("Error reported!")
END;
LOOP
InOut.Read (ch);
InOut.Write (ch);
IF ch < ' ' THEN EXIT END
END;
InOut.WriteLn;
InOut.WriteBf
END tri.</syntaxhighlight>
=={{header|Modula-3}}==
This code requires the <code>UNSAFE</code> keyword because <code>M3toC</code> deals with C strings (which are pointers), and are implemented in Modula-3 as <code>UNTRACED</code>, meaning they are not garbage collected, which is why the code calls <code>FreeCopiedS()</code>.
Also note the <code>EVAL</code> keyword, which ignores the return value of a function.
<syntaxhighlight lang="modula3">UNSAFE MODULE Exec EXPORTS Main;
IMPORT Unix, M3toC;
VAR command := M3toC.CopyTtoS("ls");
BEGIN
EVAL Unix.system(command);
M3toC.FreeCopiedS(command);
END Exec.</syntaxhighlight>
=={{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:
<syntaxhighlight lang="mumps">Set X=$ZF(-1,"DIR")</syntaxhighlight></p>
<p>In GT.M on OpenVMS, the following will work:
<syntaxhighlight lang="mumps">ZSY "DIR"</syntaxhighlight></p>
<p>GT.M on UNIX is the same:
<syntaxhighlight lang="mumps">ZSY "ls"</syntaxhighlight></p>
<p>Note: $ZF in GT.M is Unicode version of $F[ind].</p>
=={{header|Nanoquery}}==
<syntaxhighlight lang="nanoquery">shell("ls")</syntaxhighlight>
=={{header|NetRexx}}==
{{Trans|Java}}
<syntaxhighlight lang="netrexx">/* NetRexx */
options replace format comments java crossref symbols binary
import java.util.Scanner
runSample(arg)
return
-- 10:43, 27 August 2022 (UTC)10:43, 27 August 2022 (UTC)10:43, 27 August 2022 (UTC)10:43, 27 August 2022 (UTC)10:43, 27 August 2022 (UTC)10:43, 27 August 2022 (UTC)10:43, 27 August 2022 (UTC)10:43, 27 August 2022 (UTC)10:43, 27 August 2022 (UTC)10:43, 27 August 2022 (UTC)10:43, 27 August 2022 (UTC)10:43, 27 August 2022 (UTC)10:43, 27 August 2022 (UTC)10:43, 27 August 2022 (UTC)10:43, 27 August 2022 (UTC)~~
method runSample(arg) private static
parse arg command
if command = '' then command = 'ls -oa' -- for Windows change to: 'cmd /C dir'
do
say 'Executing command:' command
jprocess = Runtime.getRunTime().exec(command)
jscanner = Scanner(jprocess.getInputStream())
loop label scanning while jscanner.hasNext()
say jscanner.nextLine()
end scanning
catch ex = IOException
ex.printStackTrace()
end
return
</syntaxhighlight>
=={{header|NewLISP}}==
<syntaxhighlight lang="newlisp">(exec "ls")</syntaxhighlight>
=={{header|Nim}}==
<syntaxhighlight lang="nim">import osproc
let exitCode = execCmd "ls"
let (output, exitCode2) = execCmdEx "ls"</syntaxhighlight>
=={{header|Objective-C}}==
{{works with|GCC}}<br>
NSTask runs an external process with explicit path and arguments.
}</syntaxhighlight>
If you need to run a system command, invoke the shell:
}</syntaxhighlight>
Complete usage example:
<!-- {{libheader|Cocoa}} -->
{{works with|Cocoa}}<br>
{{works with|GNUstep}}
<syntaxhighlight lang="objc">#import <Foundation/Foundation.h>
void runSystemCommand(NSString *cmd)
{
[[NSTask launchedTaskWithLaunchPath:@"/bin/sh"
arguments:@[@"-c", cmd]]
waitUntilExit];
}
int main(int argc, const char **argv)
{
@autoreleasepool {
runSystemCommand(@"ls");
}
return 0;
}</syntaxhighlight>
Or use the C method above.
=={{header|OCaml}}==
Just run the command:
<syntaxhighlight lang="ocaml">Sys.command "ls"</syntaxhighlight>
To capture the output of the command:
<syntaxhighlight lang="ocaml">#load "unix.cma"
let syscall cmd =
let ic, oc = Unix.open_process cmd in
let buf = Buffer.create 16 in
(try
while true do
Buffer.add_channel buf ic 1
done
with End_of_file -> ());
let _ = Unix.close_process (ic, oc) in
(Buffer.contents buf)
let listing = syscall "ls" ;;</syntaxhighlight>
a more complete version which also returns the contents from stderr, and checks the exit-status, and where the environment can be specified:
<syntaxhighlight lang="ocaml">let check_exit_status = function
| Unix.WEXITED 0 -> ()
| Unix.WEXITED r -> Printf.eprintf "warning: the process terminated with exit code (%d)\n%!" r
| Unix.WSIGNALED n -> Printf.eprintf "warning: the process was killed by a signal (number: %d)\n%!" n
| Unix.WSTOPPED n -> Printf.eprintf "warning: the process was stopped by a signal (number: %d)\n%!" n
;;
let syscall ?(env=[| |]) cmd =
let ic, oc, ec = Unix.open_process_full cmd env in
let buf1 = Buffer.create 96
and buf2 = Buffer.create 48 in
(try
while true do Buffer.add_channel buf1 ic 1 done
with End_of_file -> ());
(try
while true do Buffer.add_channel buf2 ec 1 done
with End_of_file -> ());
let exit_status = Unix.close_process_full (ic, oc, ec) in
check_exit_status exit_status;
(Buffer.contents buf1,
Buffer.contents buf2)</syntaxhighlight>
val syscall : ?env:string array -> string -> string * string
=={{header|Octave}}==
<syntaxhighlight lang="octave">system("ls");</syntaxhighlight>
=={{header|Oforth}}==
<syntaxhighlight lang="oforth">System cmd("pause")</syntaxhighlight>
=={{header|Oz}}==
<syntaxhighlight lang="oz">{OS.system "ls" _}</syntaxhighlight>
A more sophisticated example can be found [http://www.mozart-oz.org/home/doc/op/node17.html here].
=={{header|PARI/GP}}==
<syntaxhighlight lang="parigp">system("ls")</syntaxhighlight>
=={{header|Pascal}}==
{{works with|Free_Pascal}} {{libheader|SysUtils}}
<syntaxhighlight lang="pascal">Program ExecuteSystemCommand;
uses
SysUtils;
begin
ExecuteProcess('/bin/ls', '-alh');
end.</syntaxhighlight>
=={{header|PDP-11 Assembly}}==
PDP-11 running Unix
<syntaxhighlight lang="pdp-11">; Execute a file - the equivalent of system() in stdio
;
; On entry, r1=>nul-terminated command string
; On exit, VS=Couldn't fork
; VC=Forked successfully, r0=return value
;
.CLIsystem
trap 2 ; fork()
br CLIchild ; Child process returns here
bcc CLIparent ; Parent process returns here
mov (sp)+,r1
tst (sp)+
sev ; Couldn't fork, set V
rts pc
.CLIparent
mov r0,-(sp) ; Save child's PID
.CLIwait
trap 7 ; wait()
cmp r0,(sp)
beq CLIfinished
cmp r0,#&FFFF
bne CLIwait ; Loop until child finished
.CLIfinished
tst (sp)+ ; Drop child's PID
mov r1,r0 ; R0=return value
mov (sp)+,r1 ; Restore R1
tst (sp)+ ; Drop original R0
swab r0 ; Move return value to bottom byte
rts pc
; CLI child process
; -----------------
.CLIchild
clr -(sp) ; end of string array
mov r1,-(sp) ; => command string
mov #UXsh3,-(sp) ; => "-c"
mov #UXsh2,-(sp) ; => "sh"
mov #&890B,TRAP_BUF ; exec
mov #UXsh1,TRAP_BUF+2 ; => "/bin/sh"
mov sp,TRAP_BUF+4 ; => pointers to command strings
;mov SV_ENVPTR,TRAP_BUF+6 ; => "PATH=etc"
trap 0 ; indir()
EQUW TRAP_BUF ; exec(shell, parameters)
add #8,sp ; If we get back, we didn't fork, we spawned
mov (sp)+,r1 ; So, restore registers
clr (sp)+ ; and return exit value in R0
rts pc
.UXsh1 EQUS "/bin/sh",0
.UXsh2 EQUS "sh",0
.UXsh3 EQUS "-c",0
ALIGN
.TRAP_BUF
EQUW 0
EQUW 0
EQUW 0
EQUW 0</syntaxhighlight>
So, call with, for example:
<syntaxhighlight lang="pdp-11">mov #cmd_ls,r1 ; => "ls" command string
jsr pc,CLIsystem
...
.cmd_ls EQUS "ls",0</syntaxhighlight>
=={{header|Perl}}==
<syntaxhighlight lang="perl">my @results = qx(ls); # run command and return STDOUT as a string
my @results = `ls`; # same, alternative syntax
system "ls"; # run command and return exit status; STDOUT of command goes program STDOUT
print `ls`; # same, but with back quotes
exec "ls"; # replace current process with another</syntaxhighlight>
See also:
http://perldoc.perl.org/perlipc.html#Using-open()-for-IPC
http://perldoc.perl.org/IPC/Open3.html
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(notonline)-->
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">cmd</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()=</span><span style="color: #004600;">WINDOWS</span><span style="color: #0000FF;">?</span><span style="color: #008000;">"dir"</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"ls"</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">system</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cmd</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">system_exec</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"pause"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
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:
<syntaxhighlight lang="php">@exec($command,$output);
echo nl2br($output);</syntaxhighlight>
'''Note:'''The '@' is here to prevent error messages to be displayed, 'nl2br' translate '\n' chars to 'br' in HTML.
Other:
<syntaxhighlight lang="php">$results = `ls`;
# runs command and returns its STDOUT as a string
system("ls");
# runs command and returns its exit status; its STDOUT gets output to our STDOUT
echo `ls`;
# the same, but with back quotes
passthru("ls");
# like system() but binary-safe</syntaxhighlight>
See also: [http://us.php.net/manual/en/function.proc-open.php proc_open()]
=={{header|PicoLisp}}==
<syntaxhighlight lang="picolisp">(call "ls")</syntaxhighlight>
=={{header|Pike}}==
<syntaxhighlight lang="pike">int main(){
// 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");
// response is now a map containing 3 fields
// stderr, stdout, and exitcode. We want stdout.
write(response["stdout"] + "\n");
// with older versions of pike it's a bit more complicated:
Stdio.File stdout = Stdio.File();
Process.create_process(({"ls", "-l"}), ([ "stdout" : stdout->pipe() ]) );
write(stdout->read() + "\n");
}</syntaxhighlight>
=={{header|Plain English}}==
<syntaxhighlight lang="text">
A command is a string.
A parameter is a string.
To run:
Start up.
Execute "dir" on the command line.
Shut down.
To execute a command on the command line:
Put "/c " then the command into a parameter.
Null terminate the parameter.
Put "cmd" into a string.
Null terminate the string.
Call "shell32.dll" "ShellExecuteA" with nil and nil and the string's first and the parameter's first and nil and 1.
</syntaxhighlight>
=={{header|Pop11}}==
The sysobey function runs commands using a shell:
<syntaxhighlight lang="pop11">sysobey('ls');</syntaxhighlight>
=={{header|PowerShell}}==
Since PowerShell is a shell, running commands is the default operation.
<syntaxhighlight lang="powershell">dir
ls
Get-ChildItem</syntaxhighlight>
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
<syntaxhighlight lang="powershell">cmd /c dir</syntaxhighlight>
=={{header|Prolog}}==
{{works with|SWI Prolog}}
{{works with|GNU Prolog}}
<syntaxhighlight lang="prolog">shell('ls').</syntaxhighlight>
=={{header|PureBasic}}==
<syntaxhighlight lang="purebasic">ImportC "msvcrt.lib"
system(str.p-ascii)
EndImport
If OpenConsole()
system("dir & pause")
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
Input()
CloseConsole()
EndIf</syntaxhighlight>
=={{header|Python}}==
<syntaxhighlight lang="python">import os
exit_code = os.system('ls') # Just execute the command, return a success/fail code
output = os.popen('ls').read() # If you want to get the output data. Deprecated.</syntaxhighlight>
or
<syntaxhighlight lang="python">import subprocess
# 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
output = subprocess.check_output(['ls', '-l']) # Python 2.7+</syntaxhighlight>
or
{{works with|Python|2.4 (and above)}}
<syntaxhighlight lang="python">from subprocess import PIPE, Popen, STDOUT
p = Popen('ls', stdout=PIPE, stderr=STDOUT)
print p.communicate()[0]</syntaxhighlight>
'''Note:''' The latter is the preferred method for calling external processes, although cumbersome, it gives you finer control over the process.
Line 222 ⟶ 1,753:
or
<syntaxhighlight lang="python">import commands
stat, out = commands.getstatusoutput('ls')
if not stat:
print out</syntaxhighlight>
=={{header|Quackery}}==
{{trans|Python}}
<syntaxhighlight lang="quackery">$ \
import os
exit_code = os.system('ls')
\ python</syntaxhighlight>
{{out}}
<pre>Quackery Quick Reference.pdf extensionsX.qky
READ ME FIRST.txt quackery.py
The Book of Quackery for print.pdf sundry
The Book of Quackery.pdf turtleduck.qky
bigrat.qky</pre>
=={{header|R}}==
<syntaxhighlight lang="r">system("ls")
output=system("ls",intern=TRUE)</syntaxhighlight>
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
;; simple execution of a shell command
(system "ls")
;; capture output
(string-split (with-output-to-string (λ() (system "ls"))) "\n")
;; Warning: passing random string to be run in a shell is a bad idea!
;; much safer: avoids shell parsing, arguments passed separately
(system* "/bin/ls" "-l")
;; avoid specifying the executable path
(system* (find-executable-path "/bin/ls") "-l")
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>run "ls" orelse .die; # output to stdout
my @ls = qx/ls/; # output to variable
my $cmd = 'ls';
@ls = qqx/$cmd/; # same thing with interpolation</syntaxhighlight>
=={{header|Raven}}==
Back tick string is auto executed:
<syntaxhighlight lang="raven">`ls -la` as listing</syntaxhighlight>
Or specifically on any string:
<syntaxhighlight lang="raven">'ls -la' shell as listing</syntaxhighlight>
=={{header|REBOL}}==
<syntaxhighlight lang="rebol">; Capture output to string variable:
x: "" call/output "dir" x
print x
; The 'console' refinement displays the command output on the REBOL command line.
call/console "dir *.r"
call/console "ls *.r"
call/console "pause"
; The 'shell' refinement may be necessary to launch some programs.
call/shell "notepad.exe"</syntaxhighlight>
=={{header|Red}}==
<syntaxhighlight lang="red">
call/show %pause ;The /show refinement forces the display of system's shell window (Windows only).
call/show %dir
call/show %notepad.exe</syntaxhighlight>
=={{header|REXX}}==
Since REXX is a shell scripting language, it's easy to execute commands:
<syntaxhighlight lang="rexx">"dir /a:d"</syntaxhighlight>
=={{header|Ring}}==
<syntaxhighlight lang="ring">
system("dir")
</syntaxhighlight>
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">string = `ls`
# runs command and returns its STDOUT as a string
string = %x{ls}
# ditto, alternative syntax
system "ls"
# runs command and returns its exit status; its STDOUT gets output to our STDOUT
print `ls`
#The same, but with back quotes
exec "ls"
# replace current process with another
# call system command and read output asynchronously
io = IO.popen('ls')
# ... later
io.each {|line| puts line}</syntaxhighlight>
=={{header|Run BASIC}}==
<syntaxhighlight lang="runbasic">print shell$("ls") ' prints the returned data from the OS
a$ = shell$("ls") ' holds returned data in a$</syntaxhighlight>
=={{header|Rust}}==
<syntaxhighlight lang="rust">use std::process::Command;
fn main() {
let output = Command::new("ls").output().unwrap_or_else(|e| {
panic!("failed to execute process: {}", e)
});
println!("{}", String::from_utf8_lossy(&output.stdout));
}
</syntaxhighlight>
=={{header|Scala}}==
<syntaxhighlight lang="scala">import scala.sys.process.Process
Process("ls", Seq("-oa"))!</syntaxhighlight>
=={{header|Scheme}}==
{{works with|Guile}}
{{works with|Chicken Scheme}}
<syntaxhighlight lang="scheme">(system "ls")</syntaxhighlight>
=={{header|Seed7}}==
System commands can make a program unportable.
Unix, Linux and BSD use the command ''ls'', while Windows respectively DOS use the command ''dir''.
The format written by ''ls'' respectively ''dir'' depends on operating system and locale.
The library [http://seed7.sourceforge.net/libraries/osfiles.htm osfiles.s7i] defines
the function [http://seed7.sourceforge.net/libraries/osfiles.htm#readDir%28in_string%29 readDir],
which reads the contents of a directory in a portable way. ''ReadDir'' works independend
from operating system and locale and supports also Unicode filenames.
Anyway, the task was to use a system command, so here is the example:
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "shell.s7i";
const proc: main is func
begin
cmd_sh("ls");
end func;</syntaxhighlight>
=={{header|SETL}}==
<syntaxhighlight lang="setl">system("ls");</syntaxhighlight>
=={{header|Sidef}}==
<syntaxhighlight lang="ruby"># Pipe in read-only mode
%p(ls).open_r.each { |line|
print line;
};
var str1 = `ls`; # backtick: returns a string
var str2 = %x(ls); # ditto, alternative syntax
Sys.system('ls'); # system: executes a command and prints the result
Sys.exec('ls'); # replaces current process with another</syntaxhighlight>
=={{header|Slate}}==
Run a command normally through the shell:
<syntaxhighlight lang="slate">Platform run: 'ls'.</syntaxhighlight>
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):
<syntaxhighlight lang="slate">shell ls: '*.slate'.</syntaxhighlight>
=={{header|Smalltalk}}==
<syntaxhighlight lang="smalltalk">Smalltalk system: 'ls'.</syntaxhighlight>
=={{header|SQL PL}}==
{{works with|Db2 LUW}}
In Linux or UNIX:
<syntaxhighlight lang="sql pl">
!ls
</syntaxhighlight>
Output:
<pre>
db2 => !ls
adm ctrlhamirror fm.ip-10-0-0-85.reg lib64 profile.env security64
adsm dasfcn function log python32 spmlog
backup db2cshrc gskit map python64 sqldbdir
bin db2dump hmonCache misc rdf tmp
bnd db2nodes.cfg include msg Readme tools
cfg db2profile infopop nodes ruby32 uif
cfgcache db2systm java nodes.reg ruby64 usercshrc
conv doc json pd samples userprofile
ctrl fm.db2-1.reg lib php32 security
ctrlha fm.db2-model.reg lib32 php64 security32
</pre>
In Windows:
<syntaxhighlight lang="sql pl">
!dir
</syntaxhighlight>
=={{header|Standard ML}}==
Just run the command:
<syntaxhighlight lang="sml">OS.Process.system "ls"</syntaxhighlight>
=={{header|Stata}}==
Stata has a built-in '''[http://www.stata.com/help.cgi?dir dir]''' command. However, it's also possible to run arbitrary external programs using the '''[http://www.stata.com/help.cgi?shell shell]''' or '''winexec''' commands.
The command '''!''' (or equivalently '''shell'''), opens a Windows console to run the command, while '''winexec''' does not.
<syntaxhighlight lang="stata">!dir
* print a message and wait
!echo Ars Longa Vita Brevis & pause
* load Excel from Stata
!start excel
* run a Python program (Python must be installed and accessible in the PATH environment variable)
!python preprocessing.py
* load Windows Notepad
winexec notepad</syntaxhighlight>
=={{header|Tcl}}==
<syntaxhighlight lang="tcl">puts [exec ls]</syntaxhighlight>
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.
Line 241 ⟶ 1,995:
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:
<syntaxhighlight
would execute "ls" and pipe the result into the
<syntaxhighlight
or read the whole shebang in a fell swoop:
<syntaxhighlight
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.
<syntaxhighlight lang="tcl">exec C:/Windows/System32/taskmgr.exe &</syntaxhighlight>
Runs the Task Manager on Windows. If running from a Tcl/Tk Gui the [ & ] prevents blocking the Gui.
=={{header|Toka}}==
<syntaxhighlight lang="toka">needs shell
" ls" system</syntaxhighlight>
=={{header|TUSCRIPT}}==
<syntaxhighlight lang="tuscript">
$$ MODE TUSCRIPT
system=SYSTEM ()
IF (system=="WIN") THEN
EXECUTE "dir"
ELSEIF (system.sw."LIN") THEN
EXECUTE "ls -l"
ENDIF
</syntaxhighlight>
=={{header|UNIX Shell}}==
UNIX shells are designed to run system commands as a default operation.
<syntaxhighlight lang="bash">ls</syntaxhighlight>
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.
<syntaxhighlight lang="bash">exec ls</syntaxhighlight>
===Command substitution===
With [[Bourne Shell]]:
<syntaxhighlight lang="bash">output=`ls`</syntaxhighlight>
With [[Korn Shell]] or any modern shell:
<syntaxhighlight lang="bash">output=$(ls)</syntaxhighlight>
* '''Note 1:''' in <code>`ls`</code>, these are "backticks" rather than quotes or apostrophes.
* '''Note 2:''' the '''$(...)''' form works in all modern shells, including the [[Almquist Shell]], [[Bash]] and any POSIX shell.
* The old `backticks` can also be used in the newer shells, but their users prefer the '''$(...)''' form when discussing such things in e-mail, on USENET, or in other online forums (such as this wiki). The only reason to use `backticks` is in scripts for old Bourne Shell.
The '''`...`''' form is difficult to nest, but the '''$(...)''' form is very nestable.
<syntaxhighlight lang="bash">output=`expr \`echo hi | wc -c\` - 1`
output=$(expr $(echo hi | wc -c) - 1)</syntaxhighlight>
Both forms, `backticks` and '''$(...)''', also work inside double-quoted strings. This prevents file name expansion and also prevents word splitting.
<syntaxhighlight lang="bash">echo "Found: `grep 80/tcp /etc/services`"
echo "Found: $(grep 80/tcp /etc/services)"</syntaxhighlight>
==={{header|C Shell}}===
C Shell also runs system commands, and has an '''exec''' built-in command, exactly like Bourne Shell.
<syntaxhighlight lang="csh">ls # run command, return to shell
exec ls # replace shell with command</syntaxhighlight>
`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.
<syntaxhighlight lang="csh">set output=( "`grep 80/ /etc/services`" )
echo "Line 1: $output[1]"
echo "Line 2: $output[2]"</syntaxhighlight>
=={{header|Ursa}}==
<syntaxhighlight lang="ursa">decl string<> arg
decl string<> output
decl iodevice iod
append "ls" arg
set iod (ursa.util.process.start arg)
set output (iod.readlines)
for (decl int i) (< i (size output)) (inc i)
out output<i> endl console
end for</syntaxhighlight>
=={{header|Ursala}}==
The library function, ask, parameterized by a shell descriptor, such as bash,
spawns a process that interacts with that shell by feeding it a list of
commands, and returns a transcript of the interaction.
Note that the output from the spawned process is captured and returned only,
not sent to the standard output stream of the parent.
Here is a self-contained command line application providing a limited replacement
for the ls command.
<syntaxhighlight lang="ursala">#import std
#import cli
#executable ('parameterized','')
myls = <.file$[contents: --<''>]>@hm+ (ask bash)/0+ -[ls --color=no]-!</syntaxhighlight>
The color option is needed to suppress terminal escape sequences.
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
Set objShell = CreateObject("WScript.Shell")
objShell.Run "%comspec% /K dir",3,True
</syntaxhighlight>
=={{header|Vedit macro language}}==
<syntaxhighlight lang="vedit">system("dir", DOS)</syntaxhighlight>
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:
<syntaxhighlight lang="vedit">system('cmd /k "dir"')</syntaxhighlight>
=={{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.
<syntaxhighlight lang="vb">Attribute VB_Name = "mdlShellAndWait"
Option Explicit
Private Declare Function OpenProcess Lib "kernel32" _
(ByVal dwDesiredAccess As Long, ByVal bInheritHandle As Long, _
ByVal dwProcessId As Long) As Long
Private Declare Function GetExitCodeProcess Lib "kernel32" _
(ByVal hProcess As Long, lpExitCode As Long) As Long
Private Const STATUS_PENDING = &H103&
Private Const PROCESS_QUERY_INFORMATION = &H400
'
' Little function go get exit code given processId
'
Function ProcessIsRunning( processId as Long ) as Boolean
Dim exitCode as Long
Call GetExitCodeProcess(lProcessId, exitCode)
ProcessIsRunning = (exitCode = STATUS_PENDING)
End Function
' Spawn subprocess and wait for it to complete.
' I believe that the command in the command line must be an exe or a bat file.
' Maybe, however, it can reference any file the system knows how to "Open"
'
' commandLine is an executable.
' expectedDuration - is for poping up a dialog for whatever
' infoText - text for progressDialog dialog
Public Function ShellAndWait( commandLine As String, _
expectedDuration As Integer ) As Boolean
Dim inst As Long
Dim startTime As Long
Dim expirationTime As Long
Dim pid As Long
Dim expiresSameDay As Boolean
On Error GoTo HandleError
'Deal with timeout being reset at Midnight ($hitForBrains VB folks)
startTime = CLng(Timer)
expirationTime = startTime + expectedDuration
expiresSameDay = expirationTime < 86400
If Not expiresSameDay Then
expirationTime = expirationTime - 86400
End If
inst = Shell(commandLine, vbMinimizedNoFocus)
If inst <> 0 Then
pid = OpenProcess(PROCESS_QUERY_INFORMATION, False, inst)
Do While ProcessIsRunning( pid)
DoEvents
If Timer > expirationTime And (expiresSameDay Or Timer < startTime) Then
Exit Do
End If
Loop
ShellAndWait = True
Else
MsgBox ("Couldn't execute command: " & commandLine)
ShellAndWait = False
End If
Exit Function
HandleError:
MsgBox ("Couldn't execute command: " & commandLine)
ShellAndWait = False
End Function
Sub SpawnDir()
ShellAndWait("dir", 10)
End Sub</syntaxhighlight>
=={{header|Visual Basic .NET}}==
{{works with|Visual Basic .NET|9.0+}}
<syntaxhighlight lang="vbnet">Module System_Command
Sub Main()
Dim cmd As New Process
cmd.StartInfo.FileName = "cmd.exe"
cmd.StartInfo.RedirectStandardInput = True
cmd.StartInfo.RedirectStandardOutput = True
cmd.StartInfo.CreateNoWindow = True
cmd.StartInfo.UseShellExecute = False
cmd.Start()
cmd.StandardInput.WriteLine("dir")
cmd.StandardInput.Flush()
cmd.StandardInput.Close()
Console.WriteLine(cmd.StandardOutput.ReadToEnd)
End Sub
End Module
</syntaxhighlight>
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">
import os
fn main() {
result := os.execute('cmd /c dir')
if result.output !='' {println(result.output)}
else {println('Error: not working') exit(1)}
}
</syntaxhighlight>
=={{header|Wart}}==
<syntaxhighlight lang="wart">system "ls"</syntaxhighlight>
=={{header|Wren}}==
Wren CLI doesn't currently expose a way to execute a system command.
However, if Wren is embedded in (say) a suitable Go program, then we can ask the latter to do it for us.
<syntaxhighlight lang="wren">/* Execute_a_system_command.wren */
class Command {
foreign static exec(name, param) // the code for this is provided by Go
}
Command.exec("ls", "-lt")
System.print()
Command.exec("dir", "")</syntaxhighlight>
which we embed in the following Go program and run it.
{{libheader|WrenGo}}
<syntaxhighlight lang="go">/* Execute_a_system_command.go*/
package main
import (
wren "github.com/crazyinfin8/WrenGo"
"log"
"os"
"os/exec"
)
type any = interface{}
func execCommand(vm *wren.VM, parameters []any) (any, error) {
name := parameters[1].(string)
param := parameters[2].(string)
var cmd *exec.Cmd
if param != "" {
cmd = exec.Command(name, param)
} else {
cmd = exec.Command(name)
}
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
log.Fatal(err)
}
return nil, nil
}
func main() {
vm := wren.NewVM()
fileName := "Execute_a_system_command.wren"
methodMap := wren.MethodMap{"static exec(_,_)": execCommand}
classMap := wren.ClassMap{"Command": wren.NewClass(nil, nil, methodMap)}
module := wren.NewModule(classMap)
vm.SetModule(fileName, module)
vm.InterpretFile(fileName)
vm.Free()
}</syntaxhighlight>
=={{header|x86 Assembly}}==
{{works with|NASM}}
{{works with|Linux}}
32 bit
<syntaxhighlight lang="asm">
; Executes '/bin/ls'
; Build with:
; nasm -felf32 execls.asm
; ld -m elf_i386 execls.o -o execls
global _start
section .text
_start:
mov eax, 0x0B ; sys_execve(char *str, char **args, char **envp)
mov ebx, .path ; pathname
push DWORD 0
push DWORD .path
lea ecx, [esp] ; arguments [pathname]
xor edx, edx ; environment variables []
int 0x80 ; syscall
.path:
db '/bin/ls', 0x00
</syntaxhighlight>
=={{header|Yabasic}}==
<syntaxhighlight lang="yabasic">system("dir")
//It will return the exit code of the command; its output (if any) will be lost.
print system$("dir")
//Returns the output as a large string.</syntaxhighlight>
=={{header|zkl}}==
<syntaxhighlight lang="zkl">System.cmd(System.isWindows and "dir" or "ls")</syntaxhighlight>
=={{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:
<syntaxhighlight lang="zxbasic">PAUSE 100</syntaxhighlight>
{{omit from|EasyLang}}
{{omit from|Retro}}
{{omit from|TI-83 BASIC}} {{omit from|TI-89 BASIC}} <!-- Does not have an external OS/command processor. -->
| |||