Execute a system command: Difference between revisions
m
Replace deprecated function
(added FunL) |
m (Replace deprecated function) |
||
(122 intermediate revisions by 66 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>
=={{header|11l}}==
<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:
<
procedure Execute_A_System_Command is
Line 12 ⟶ 158:
POSIX.Append (Arguments, "ls");
POSIX.Unsafe_Process_Primitives.Exec_Search ("ls", Arguments);
end Execute_A_System_Command;</
Importing the C system() function:
<
procedure Execute_System is
Line 23 ⟶ 169:
begin
Ret_Val := Sys(To_C("ls"));
end Execute_System;</
Using the GNAT run-time library:
<
with Ada.Text_IO; use Ada.Text_IO;
with System.OS_Lib; use System.OS_Lib;
Line 47 ⟶ 193:
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).
<
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;
<
exec ("ls")
</syntaxhighlight>
You also have the regular <code>fork</code> and <code>execv</code> calls available:
<
var pid = fork()
if (pid == 0) {
Line 72 ⟶ 218:
waitpid (pid, status)
</syntaxhighlight>
=={{header|Aime}}==
<
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.}}
<
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))
FI</
=={{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}}==
<
=={{header|Applesoft BASIC}}==
<
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">print execute "ls"</syntaxhighlight>
=={{header|AutoHotkey}}==
<
=={{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}}==
<
==={{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
=={{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|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
=={{header|Brat}}==
<
p subprocess.run :ls #Lists files in directory</
=={{header|Brlcad}}==
<
exec ls
</syntaxhighlight>
=={{header|C}}==
ISO C & POSIX:
<
int main()
Line 150 ⟶ 390:
system("ls");
return 0;
}</
=={{header|C sharp|C#}}==
Using Windows / .NET:
<
namespace Execute
Line 169 ⟶ 405:
}
}
}</
{{works with|MCS|1.2.3.1}}
<
class Execute {
Line 181 ⟶ 417:
proc.Start();
}
}</
=={{header|C++}}==
{{works with|Visual C++|2005}}
<syntaxhighlight lang="cpp">system("pause");</syntaxhighlight>
=={{header|Clojure}}==
<
<
user=> (use '[clojure.java.shell :only [sh]])
Line 205 ⟶ 446:
drwxr-xr-x 4 zkim staff 136 Jul 5 13:15 src
, :err }
</syntaxhighlight>
<
user=> (use '[clojure.java.shell :only [sh]])
Line 222 ⟶ 463:
nil
</syntaxhighlight>
=={{header|CMake}}==
{{works with|Unix}}
<syntaxhighlight lang
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
<
execute_process(
COMMAND printf "scale = 45; 4 * a(1) + 5 / 10 ^ 41\\n"
Line 238 ⟶ 479:
COMMAND sed -e "s/.\\{5\\}$//"
OUTPUT_VARIABLE pi OUTPUT_STRIP_TRAILING_WHITESPACE)
message(STATUS "pi is ${pi}")</
<pre>-- pi is 3.1415926535897932384626433832795028841972</pre>
Line 244 ⟶ 485:
=={{header|COBOL}}==
{{works with|OpenCOBOL}}
<
=={{header|CoffeeScript}}==
{{works with|Node.js}}
<
{ spawn } = require 'child_process'
Line 258 ⟶ 499:
ls.on 'close', -> console.log "'ls' has finished executing."
</syntaxhighlight>
=={{header|Common Lisp}}==
{{works with|CMUCL}}
<
{{works with|LispWorks}}
<
{{libheader|trivial-shell}}
<
{{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">
//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
=={{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
Or, shorter<syntaxhighlight lang
=={{header|Delphi}}==
<
{$APPTYPE CONSOLE}
Line 291 ⟶ 560:
begin
ShellExecute(0, nil, 'cmd.exe', ' /c dir', nil, SW_HIDE);
end.</
=={{header|E}}==
<
ls("-l")
Line 303 ⟶ 572:
} catch problem {
print(`failed to execute ls: $problem`)
}</
=={{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}}==
<
=={{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#}}==
<
=={{header|Factor}}==
<
=={{header|Fantom}}==
Line 319 ⟶ 644:
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
{
Line 328 ⟶ 653:
}
}
</syntaxhighlight>
=={{header|Forth}}==
{{works with|gforth|0.6.2}}
<
=={{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.
<
call system("ls")
end program SystemTest</
=={{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}}==
<
execute( if $os.startsWith('Windows') then 'dir' else 'ls' )</
=={{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}}==
<
import (
Line 362 ⟶ 888:
log.Fatal(err)
}
}</
=={{header|Groovy}}==
<
=={{header|GUISS}}==
<
=={{header|Haskell}}==
{{works with|GHC|GHCi|6.6}}
<
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}}==
<
SYSTEM(CoMmand='dir & pause') </
=={{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.
<
write("Trying command ",cmd := if &features == "UNIX" then "ls" else "dir")
system(cmd)
end</
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
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|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:
<
NB. Execute a command and wait for it to complete
Line 436 ⟶ 969:
NB. and capture its stdout
stdin =: 'blahblahblah'
stdout =: stdin spawn 'grep blah'</
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.*;
Line 455 ⟶ 989:
}
}
}</
{{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;
Line 497 ⟶ 1,031:
}</
And the right way, which uses threading to read the InputStream given by the process.
<
import java.io.InputStream;
Line 563 ⟶ 1,097:
}
}
}</
=={{header|JavaScript}}==
Line 569 ⟶ 1,103:
{{works with|JScript}}
<
shell.run("cmd /c dir & pause");</
{{works with|Rhino}}
<
print("===");
var options = {
Line 582 ⟶ 1,116:
};
runCommand("cmd", options);
print(options.output);</
=={{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:
<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>
=={{header|K}}==
Execute "ls"
<syntaxhighlight lang
Execute "ls" and capture the output in the variable "r":
<
=={{header|
<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}}==
<
path = file_forceroot,
ls = sys_process('/bin/ls', (:'-l', #path)),
Line 607 ⟶ 1,171:
'<pre>'
#ls -> read
'</pre>'</
<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"
</
=={{header|Limbo}}==
Line 625 ⟶ 1,205:
This version passes its argument list through to ls:
<
include "sys.m"; sys: Sys;
Line 648 ⟶ 1,228:
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|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}}==
Line 656 ⟶ 1,245:
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
=={{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:
<syntaxhighlight lang="logtalk">os::shell('ls -a').</syntaxhighlight>
=={{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"
print( f:read("*a") ) -- print out the "file"'s content</
=={{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}}==
<
=={{header|Make}}==
Line 679 ⟶ 1,285:
in definition
<
curdir=`pwd`</
in target
<
cat foo | grep mytext</
=={{header|Maple}}==
<
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
=={{header|MATLAB}}==
Line 697 ⟶ 1,303:
Sample Usage:
<
Press any key to continue . . .
Line 705 ⟶ 1,311:
0
</syntaxhighlight>
=={{header|Maxima}}==
<syntaxhighlight lang="text">system("dir > list.txt")$</
=={{header|MAXScript}}==
<
=={{header|Mercury}}==
<syntaxhighlight lang="text">
:- module execute_sys_cmd.
:- interface.
Line 725 ⟶ 1,331:
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}}==
<
FROM SYSTEM IMPORT ADR;
Line 762 ⟶ 1,371:
InOut.WriteLn;
InOut.WriteBf
END tri.</
=={{header|Modula-3}}==
Line 768 ⟶ 1,377:
Also note the <code>EVAL</code> keyword, which ignores the return value of a function.
<
IMPORT Unix, M3toC;
Line 777 ⟶ 1,386:
EVAL Unix.system(command);
M3toC.FreeCopiedS(command);
END Exec.</
=={{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|Nanoquery}}==
<syntaxhighlight lang="nanoquery">shell("ls")</syntaxhighlight>
=={{header|NetRexx}}==
{{Trans|Java}}
<
options replace format comments java crossref symbols binary
Line 799 ⟶ 1,412:
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
Line 814 ⟶ 1,427:
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.
<
{
[[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:
Line 836 ⟶ 1,458:
{{works with|Cocoa}}<br>
{{works with|GNUstep}}
<
void runSystemCommand(NSString *cmd)
Line 852 ⟶ 1,474:
}
return 0;
}</
Or use the C method above.
Line 858 ⟶ 1,480:
Just run the command:
<
To capture the output of the command:
<
let syscall cmd =
Line 875 ⟶ 1,497:
(Buffer.contents buf)
let listing = syscall "ls" ;;</
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
Line 900 ⟶ 1,522:
check_exit_status exit_status;
(Buffer.contents buf1,
Buffer.contents buf2)</
val syscall : ?env:string array -> string -> string * string
=={{header|Octave}}==
<
=={{header|Oforth}}==
<syntaxhighlight lang="oforth">System cmd("pause")</syntaxhighlight>
=={{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
Line 923 ⟶ 1,549:
begin
ExecuteProcess('/bin/ls', '-alh');
end.</
=={{header|PDP-11 Assembly}}==
PDP-11 running Unix
<
;
; On entry, r1=>nul-terminated command string
Line 1,011 ⟶ 1,610:
EQUW 0
EQUW 0
EQUW 0</
So, call with, for example:
<
jsr pc,CLIsystem
...
.cmd_ls EQUS "ls",0</
=={{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:
<
echo nl2br($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
Line 1,035 ⟶ 1,658:
passthru("ls");
# like system() but binary-safe</
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");
Line 1,054 ⟶ 1,677:
Process.create_process(({"ls", "-l"}), ([ "stdout" : stdout->pipe() ]) );
write(stdout->read() + "\n");
}</
=={{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
=={{header|PowerShell}}==
Since PowerShell is a shell, running commands is the default operation.
<
ls
Get-ChildItem</
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
=={{header|Prolog}}==
Line 1,073 ⟶ 1,714:
{{works with|GNU Prolog}}
<syntaxhighlight lang
=={{header|PureBasic}}==
<
system(str.p-ascii)
EndImport
Line 1,085 ⟶ 1,727:
Input()
CloseConsole()
EndIf</
=={{header|Python}}==
<
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.</
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
output = subprocess.check_output(['ls', '-l']) # Python 2.7+</
or
{{works with|Python|2.4 (and above)}}
<
p = Popen('ls', stdout=PIPE, stderr=STDOUT)
print p.communicate()[0]</
'''Note:''' The latter is the preferred method for calling external processes, although cumbersome, it gives you finer control over the process.
Line 1,112 ⟶ 1,754:
{{works with|Python|2.2 (and above)}}
<
stat, out = commands.getstatusoutput('ls')
if not stat:
print out</
=={{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}}==
<
output=system("ls",intern=TRUE)</
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
Line 1,137 ⟶ 1,796:
;; 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
Or specifically on any string:
<
=={{header|REBOL}}==
<
x: "" call/output "dir" x
Line 1,163 ⟶ 1,831:
; The 'shell' refinement may be necessary to launch some programs.
call/shell "notepad.exe"</
=={{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:
<
=={{header|Ring}}==
<syntaxhighlight lang="ring">
system("dir")
</syntaxhighlight>
=={{header|Ruby}}==
<
# runs command and returns its STDOUT as a string
string = %x{ls}
Line 1,187 ⟶ 1,866:
io = IO.popen('ls')
# ... later
io.each {|line| puts line}</
=={{header|Run BASIC}}==
<
a$ = shell$("ls") ' holds returned data in a$</
=={{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}}==
<
Process("ls", Seq("-oa"))!</
=={{header|Scheme}}==
{{works with|Guile}}
{{works with|Chicken Scheme}}
<
=={{header|Seed7}}==
Line 1,212 ⟶ 1,901:
Anyway, the task was to use a system command, so here is the example:
<
include "shell.s7i";
const proc: main is func
begin
end func;</
=={{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}}==
Line 1,224 ⟶ 1,928:
Run a command normally through the shell:
<syntaxhighlight lang
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}}==
<syntaxhighlight lang
=={{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:
<
=={{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
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 1,247 ⟶ 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:
<
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:
<syntaxhighlight lang
or read the whole shebang in a fell swoop:
<syntaxhighlight lang
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}}==
<
" ls" system</
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
system=SYSTEM ()
Line 1,272 ⟶ 2,024:
EXECUTE "ls -l"
ENDIF
</syntaxhighlight>
=={{header|UNIX Shell}}==
UNIX shells are designed to run system commands as a default operation.
<syntaxhighlight lang
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
===Command substitution===
Line 1,286 ⟶ 2,038:
With [[Bourne Shell]]:
<
With [[Korn Shell]] or any modern shell:
<
* '''Note 1:''' in <code>`ls`</code>, these are "backticks" rather than quotes or apostrophes.
Line 1,297 ⟶ 2,049:
The '''`...`''' form is difficult to nest, but the '''$(...)''' form is very nestable.
<
output=$(expr $(echo hi | wc -c) - 1)</
Both forms, `backticks` and '''$(...)''', also work inside double-quoted strings. This prevents file name expansion and also prevents word splitting.
<
echo "Found: $(grep 80/tcp /etc/services)"</
==={{header|C Shell}}===
C Shell also runs system commands, and has an '''exec''' built-in command, exactly like Bourne Shell.
<
exec ls # replace shell with command</
`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]"
echo "Line 2: $output[2]"</
=={{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}}==
Line 1,327 ⟶ 2,092:
Here is a self-contained command line application providing a limited replacement
for the ls command.
<
#import cli
#executable ('parameterized','')
myls = <.file$[contents: --<''>]>@hm+ (ask bash)/0+ -[ls --color=no]-!</
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}}==
<
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
Line 1,422 ⟶ 2,193:
Sub SpawnDir()
ShellAndWait("dir", 10)
End Sub</
=={{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}}==
<
=={{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}}==
<
=={{header|ZX Spectrum Basic}}==
Line 1,434 ⟶ 2,329:
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
{{omit from|EasyLang}}
{{omit from|Retro}}
{{omit from|TI-83 BASIC}} {{omit from|TI-89 BASIC}} <!-- Does not have an external OS/command processor. -->
|