Get system command output: Difference between revisions

{{works with|Commodore 64}}

Uses the system call <code>$FFED</code> which returns the screen dimensions (measured in 8x8 pixel squares).

;returns screen width in X and screen height in Y

dex ;subtract 1. This is more useful for comparisons.

dey ;subtract 1. This is more useful for comparisons.

stx $20 ;store in zero page ram

 

 

{{works with|NEOGEO MVS}}

This program uses the system command that retrieves the current time, which is used to seed a random number generator. All labels are either routines, macros, or memory locations as appropriate. Code is called during the game's vBlank routine.

;run this during vblank for best results.

JSR SYS_READ_CALENDAR

SwapRNGifEven:

MOVE.L D0,RNGout_32

 

The following macro is used in the above routine:

;\1 must be a data register.

;copies the lowest byte to all 4 bytes.

SWAP \1

popWord \1

 

=={{header|Ada}}==

{{works with|GNAT}}

with Ada.Characters.Latin_1; use Ada.Characters.Latin_1;

with GNAT.Expect; use GNAT.Expect;

end loop;

 

 

=={{header|Aime}}==

{{Out}}

<pre>-- 72 --</pre>

 

=={{header|Amazing Hopper}}==

/* JAMBO language - a flavour of Hopper */

#include <jambo.h>

Set( sys ) Prnl

End

{{out}}

<pre>

#include <jambo.h>

Main

Set( sys ) Prnl

End

=={{header|Applesoft BASIC}}==

A small machine language program is POKEd into memory starting at address P. The address of the program P is POKEd into the 54 and 55 zero page locations. CALL 1002 connects output to the program. The system command CATALOG is run, and all output is written to memory starting at address A. PR#0 reconnects output back to the screen. Variables are carefully declared before the first string in the array S$(0) is assigned. The most recent address of S$(0) is used to assign pointers and lengths to the array of strings. S$(C) is the last string in the array.

110 LET A = 24576

120 LET P = 768

510 POKE S + C * 3 + 2, FN H(I)

520 PRINT S$(C);

=={{header|Arturo}}==

 

 

{{out}}

 

=={{header|AWK}}==

BEGIN {

 

close(command)

return ship

 

result$ = EXEC$("fortune")

PRINT CHOP$(result$)

 

{{out}}

 

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

@echo off

setlocal enabledelayedexpansion

 

pause>nul

 

=={{header|Bracmat}}==

.sys$(str$(!arg " > temp"))&get$(temp,STR)

Example:

'''Output'''

<pre>Changelog

 

=={{header|C}}==

#include <stdio.h>

#include <stdlib.h>

return 0;

}

 

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

 

namespace GetSystemCommandOutput {

}

}

 

=={{header|C++}}==

#include <iostream>

 

int main() {

std::cout << execute("whoami") << '\n';

 

===Boost alternative===

{{libheader|Boost}}

#include <string>

#include <vector>

}

return EXIT_SUCCESS;

 

=={{header|Clojure}}==

sh returns a map of exit code, stdout, and stderr from the command:

 

{{out}}

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

{{libheader|trivial-shell}}

 

{{out}}

the :output keyword. We can then read from the stream:

 

(sb-ext:run-program "mplayer" (list "/path/to/groovy/tune")

:search t :output :stream :wait nil))

 

{{libheader|uiop}}

A bit more general, using [https://github.com/fare/asdf uiop] and grabbing output as a string:

 

=={{header|D}}==

import std.stdio;

 

writeln("Failed to execute command, status=", cmd.status);

}

 

{{out}}

 

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

// System Command Output. Nigel Galloway: October 6th., 2020

let n=new System.Diagnostics.Process(StartInfo=System.Diagnostics.ProcessStartInfo(RedirectStandardOutput=true,RedirectStandardError=true,UseShellExecute=false,

printfn "%s" ((n.StandardOutput).ReadToEnd())

n.Close()

{{out}}

<pre style="height:64ex;overflow:scroll">

=={{header|Factor}}==

<code>with-process-reader</code> is a combinator that encapsulates reading the output of a system command. It also throws an error along with the appropriate exit status in the event of failure.

{{out}}

<pre>

=={{header|Forth}}==

Using Gforth 0.7.9

\ read via pipe into buffer

create buffer 266 allot

buffer swap type \ output is the same like above

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

 

'capture the output of the 'dir' command and print it to a text file

Close #2

Close #1

 

 

=={{header|FutureBasic}}==

Simple system commands can be run in FB's open "UNIX" function. However, more common are functions such as this example which uses a notification observer to watch as data is downloaded in the background. The command in this example returns the mdls man page.

include "NSLog.incl"

 

local fn ObserverOne( ref as NotificationRef )

end fn

 

local fn RunCommand( cmdStr as CFStringRef )

end fn

 

 

HandleEvents

<pre>

 

=={{header|Gambas}}==

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

Dim sStore As String

 

Print sStore

 

 

Output:

 

=={{header|Genie}}==

/*

Get system command output, in Genie

print standard_output

except e : SpawnError

 

{{out}}

 

=={{header|Go}}==

 

import (

}

fmt.Print(string(output))

 

=={{header|Haskell}}==

{{libheader|process}}

 

-- stack --resolver lts-8.15 --install-ghc runghc --package process

 

-- print each line in reverse

 

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

# piped.icn, Get system command output

#

 

close(p)

 

{{out}}

 

=={{header|IS-BASIC}}==

110 SET DEFAULT CHANNEL 1

120 EXT "dir"

130 CLOSE #1

 

=={{header|J}}==

We will box the result of uname -imp on a linux system, to show that we have captured the command output in J:

 

<shell 'uname -imp'

┌─────────────────────┐

│x86_64 x86_64 x86_64 │

 

Caution: I have sometimes seen some versions of linux refuse to execute subshells after a few hundred thousand shell commands (the exec system call fails). I've not found any satisfying documentation on why this happens, but I strongly suspect kernel memory fragmentation (the examples where this happened were also using a lot of memory to accumulate results and it happened much more frequently on machines with little memory than on machines with more memory). Exiting J and starting a new process has cleared it up when it has happened. When that becomes an issue, I usually prefer to do subshell result capture before J starts, just to be safe.

=={{header|Java}}==

{{works with|Java|7}}

import java.util.*;

 

}

}

 

Output:

 

=={{header|Jsish}}==

 

The jsish ''exec'' command (like many jsish commands) accepts an optional option object, details available with interactive help:

 

In a single string:

 

In multiple lines:

 

=={{header|Kotlin}}==

 

import java.util.Scanner

println(sc.nextLine())

sc.close()

 

{{out}}

The library from lil.c does not include a system command, but main.c for the lil shell does.

 

 

{{out}}

=={{header|Lingo}}==

{{libheader|Shell Xtra}}

put sx.shell_cmd("cd C:\dev\lsw\lib & dir")

 

23.06.2016 18:22 <DIR> base64

23.06.2016 18:21 <DIR> base9

 

=={{header|Lua}}==

{{out}}

<pre>Hurrah!</pre>

=={{header|M2000 Interpreter}}==

Make a UTF-16LE txt.out from dir using a new cmd with /U

Module CheckIt {

Dos "cd "+quote$(Dir$) +" & cmd /U /C dir *.txt >txt.out";

}

Checkit

 

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

{{out}}

<pre><|"ExitCode" -> 0, "StandardOutput" -> "Wed Oct 4 14:01:01 BST 2017", "StandardError" -> ""|></pre>

 

=={{header|Neko}}==

var process_run = $loader.loadprim("std@process_run", 2);

var process_stdout_read = $loader.loadprim("std@process_stdout_read", 4);

/* Get the exit status */

var ps = process_exit(proc);

 

{{out}}

 

=={{header|Nim}}==

 

# Output string and error code

 

echo "Output: " & lsStr

 

=={{header|Objeck}}==

function : Main(args : String[]) ~ Nil {

output := System.Runtime->CommandOutput("ls -l");

}

}

 

=={{header|ooRexx}}==

===version 1===

trace normal

 

 

/* Exit with the system command's return code. */

===version 2===

cmd '| rxqueue'

Say 'Output of "'cmd'"'

parse pull text

Say text

{{out}}

<pre>Output of "dir tu*.rex /od"

0 Verzeichnis(se), 3.357.933.568 Bytes frei </pre>

===version 3===

cmd='dir t*.rex /od'

cmd '>'dir

Say linein(dir)

End

{{out}}

<pre>identical to version 2's output</pre>

 

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

 

=={{header|Perl}}==

Uses the qx{} construct (which is a synonym for backticks, e.g. `command`) to execute a given command and redirect its output.

A (somewhat contrived*) example, capturing only STDOUT:

for (@directories) {

chomp;

...; # Operate on directories

* Perl's opendir function should be used in preference to parsing ls--it's safer, faster, and more portable.

 

Perl also honors shell redirections:

qx// is implemented internally with the built-in function readpipe, which can be invoked directly as readpipe EXPR (where EXPR is some command) and assigned to scalars or lists just like qx/command/ or `command`.

 

The open command can also be used to open pipes using the -| mode:

my $enc = ':encoding(UTF-8)';

my $child_pid = open(my $pipe, "-|$enc", 'ls');

# Print all files whose names are all lowercase

print if m/[^A-Z]+/;

 

=={{header|Phix}}==

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- system_exec, file i/o</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">tmp</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"hostname.txt"</span><span style="color: #0000FF;">,</span>

<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">delete_file</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tmp</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">host</span>

{{out}}

<pre>

 

=={{header|Phixmonti}}==

"hostname > " hname chain cmd

hname "r" fopen

dup fgets print fclose

 

=={{header|PicoLisp}}==

 

=={{header|PowerShell}}==

Capture system disk label information as an array of strings:

[string[]]$volume = cmd /c vol

 

$volume

{{Out}}

<pre>

 

=={{header|PureBasic}}==

rp=RunProgram("ls", "-l", "",#PB_Program_Open|#PB_Program_Read)

While ProgramRunning(rp)

Input()

EndIf

 

=={{header|Python}}==

>>> returned_text = subprocess.check_output("dir", shell=True, universal_newlines=True)

>>> type(returned_text)

9 Dir(s) 46,326,947,840 bytes free

 

 

=={{header|Quackery}}==

 

=={{header|R}}==

system("wc -l /etc/passwd /etc/group", intern = TRUE)

{{out}}

<pre>

We use <code>#lang racket/base</code> to show which module system is in. It would be imported anyway if we use the larger <code>#lang racket</code>.

 

 

See [http://docs.racket-lang.org/reference/subprocess.html?q=system#%28def._%28%28lib._racket%2Fsystem..rkt%29._system%29%29 documentation for <code>system</code> and friends].

 

 

(require racket/system

(system "echo -n foo; echo bar 1>&2"))))

(values system-rv (get-output-string out-str-port) (get-output-string err-str-port)))

 

{{out}}

 

If you don't want to execute it in shell (and you probably don't), then use this:

 

Unfortunately, it is very long to type, but that is the only way to pass your variables as arguments safely.

 

You might be tempted to start using shell when you have to pipe something, but even in that case there is no need to do so. See this code:

my $p2 = run 'cat', '-n', :in($p1.out), :out;

See [https://docs.raku.org/type/Proc docs] for more info.

 

If you really want to run something in shell and you understand potential security problems, then you can use <code>qx//</code> (interpolates environment variables) or <code>qqx//</code> (interpolates normally). See [https://docs.raku.org/language/quoting the docs for more info].

 

{{out}}

<pre>Find_URI_in_text.p6 History_variables.p6 K-d_tree.pl

=={{header|REXX}}==

{{works with|Regina REXX}}

parse arg xxxCmd /*obtain the (system) command from CL.*/

trace off /*suppress REXX error msgs for fails. */

say strip(@.#, 'T') /*display one line at a time──►terminal*/

end /*#*/ /* [↑] displays all the output. */

{{out|output|text=&nbsp; from the executed command &nbsp; (under Windows/XP): &nbsp; &nbsp; <tt> &nbsp; dir &nbsp; g:sub*.2*</tt>}}

<pre>

 

=={{header|Ring}}==

system("dir C:\Ring\doc")

Output:

<pre>

=={{header|Ruby}}==

Many options, google exec or system or %x. Demonstrating backticks:

 

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

print a$ ' prints the directory

 

=={{header|Rust}}==

use std::io::{Write, self};

 

 

io::stdout().write(&output.stdout);

 

=={{header|Scala}}==

 

val command = "cmd /c echo Time at %DATE% %TIME%"

val p = Runtime.getRuntime.exec(command)

val sc = Source.fromInputStream(p.getInputStream)

 

=={{header|Sidef}}==

Using backticks:

 

Using pipes:

var pipe_h = pipe.open_r # open the pipe for reading

var lines = [] # will store the lines of the output

 

=={{header|Stata}}==

Redirect the output to a temporary file, then read its contents into a result macro r(out).

 

tempfile f

tempname m

return local out "`s'"

}

 

'''Example:'''

 

. display r(out)

auto.dta

. shellout python -V

. display r(out)

 

=={{header|Swift}}==

 

let process = Process()

let output = String.init(data: data, encoding: String.Encoding.utf8)

 

 

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

let

val text = String.translate (fn #"\"" => "\\\""|n=>str n ) input ;

)

end;

call

useOS "This is my text, zip it now" ;

=={{header|Tcl}}==

The <code>exec</code> makes this straight-forward for most commands.

There are a few exceptions, such as the <tt>DIR</tt> command on Windows, where they need to be run slightly differently due to being system shell builtins rather than executables. In that case, the <code>auto_execok</code> standard library command is used to look up how to run the command (strictly it can be used for any command — it will do path resolution, etc. — but is only necessary for system builtins).

By default, Tcl will use the system encoding (as reported by <code>encoding system</code>) to understand the output byte-stream as characters, and will auto-convert all the various types of newline terminators into <tt>U+00000A</tt> characters. Control over this is possible by launching the subprocess as a pipe, configuring the pipe, and then reading the pipe in its entirety.

set pipe [open |[list ls -l] "r"]

fconfigure $pipe -encoding iso8859-1 -translation lf

set data [read $pipe]

This is usually not necessary except when dealing with binary data output.

 

=={{header|Ursa}}==

This program reads the output of the ifconfig command into the string stream 'output', then writes it to the screen.

> decl string<> arg

> append "ifconfig" arg

media: autoselect

status: inactive

 

=={{header|VBScript}}==

This program implements a function that executes a DOS command and returns the output to the caller.

Wscript.Echo line

Next

'Return as a text array

ExecCmd = Split(Mid(res,2),vbLf)

 

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

{{trans|C#}}

 

Sub Main()

End Sub

 

 

=={{header|Wren}}==

However, if Wren is embedded in (say) a suitable Go program, then we can ask the latter to do it for us.

 

class Command {

foreign static output(name, param) // the code for this is provided by Go

}

 

 

which we embed in the following Go program and run it.

{{libheader|WrenGo}}

package main

 

func main() {

vm := wren.NewVM()

methodMap := wren.MethodMap{"static output(_,_)": getCommandOutput}

classMap := wren.ClassMap{"Command": wren.NewClass(nil, nil, methodMap)}

vm.InterpretFile(fileName)

vm.Free()

 

=={{header|Yabasic}}==

// by Jjuanhdez, 06/2022

 

open("dir_output.txt") for writing as #1

print #1 system$(c$)

 

=={{header|zkl}}==

From the REPL on Linux. Runs a command in the shell with stdout redirected to file, then slurps the file. A bit greasy since there isn't a way to find/generate a unique unused file name.

0 // date return code

zkl: File("foo.txt").read().text