Anonymous user
Shell one-liner: Difference between revisions
→{{header|Binary Lambda Calculus}}
imported>Tromp |
|||
(48 intermediate revisions by 28 users not shown) | |||
Line 6:
Avoid depending on the particular shell or operating system used as much as is reasonable; if the language has notable implementations which have different command argument syntax, or the systems those implementations run on have different styles of shells, it would be good to show multiple examples.
<br><br>
=={{header|11l}}==
{{trans|Nim}}
The following works on Windows.
<pre>...>echo L(i) 0..10 {print("Hello World"[0..i])} > oneliner.11l && 11l oneliner.11l && oneliner.exe
H
He
Hel
Hell
Hello
Hello
Hello W
Hello Wo
Hello Wor
Hello Worl
Hello World
</pre>
=={{header|ACL2}}==
<
=={{header|Ada}}==
Line 14 ⟶ 31:
'''under a unixoid shell''' (bash, sh, ...)
<
Note that this mercilessly overwrites and later deletes any files x.adb, x.ali, x,o and x in the current directory.
=={{header|Aikido}}==
<
=={{header|Aime}}==
<
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386 - Interpret straight off}}
<
Output:
<pre>Hello</pre>
{{works with|ELLA ALGOL 68|Any - tested with release 1.8.8d.fc9.i386 - translate to [[C]] and then compile and run}}
For an [[ELLA ALGOL 68]] one-liner, merge these lines of shell code:
<
a=/tmp/algol$$ s=/usr/share/algol68toc;
echo -e "PROGRAM algol$$ CONTEXT VOID\nUSE standard\nBEGIN\n$code\nEND\nFINISH\n" > $a.a68 &&
a68toc -lib $s -dir $s -uname TMP -tmp $a.a68 && rm $a.a68 &&
gcc $s/Afirst.o $a.c -l{a68s,a68,m,c} -o $a && rm $a.c &&
$a; rm $a</
Output:
<pre>Hello</pre>
=={{header|AppleScript}}==
<
=={{header|Arturo}}==
You may run any arbitrary code string directly using the <code>-e</code> (or <code>--evaluate</code>) flag:
<syntaxhighlight lang="bash">$ arturo -e:"print {Hello World!}"</syntaxhighlight>
{{out}}
<pre>Hello World!</pre>
=={{header|AWK}}==
Maybe the most common way one can use awk is from the command line for one-liners, feeding the interpreter with an input.
<
A more "complex" and "real" example:
<
''Select'' field 2 and 4 of lines matching the regular expression <tt>/IN/</tt> (i.e. where IN appears)
Line 54 ⟶ 81:
=={{header|BASIC}}==
The name of the BASIC executable will vary (common ones are ''basic'', ''bas'', and ''bwbasic''), but in general, a short program can be piped to the interpreter like any other language:
<
Note that under Windows (and presumably DOS) the two apostrophes (a.k.a. single quotes) should be omitted, since Windows doesn't remove them from the piped text (and the apostrophe is the comment character in many modern BASICs):
<
Also, some popular interpreters (including [http://www.moria.de/~michael/bas/ Michael Haardt's '''bas'''] and [[Chipmunk Basic]]) will include an extra prompt before exiting unless you include <code>exit</code> or <code>system</code> (depending on the specific interpreter's syntax). This sample output shows both with and without <code>system</code> in bas:
Line 74 ⟶ 101:
Note that this is rather specific to [[Unix]]-like systems; most [[DOS]] and [[Windows]] interpreters are generally unable to handle programs in this manner, unless they were ported from a *nix system in the first place.
==={{
On the ZX Spectrum, the ROM basic allows direct commands to be entered from the system prompt:
<
==={{header|BaCon}}===
BaCon is not an interpreter so we need to compile the code
a short explanation echo a command to file a.bac
then compile a.bac using bacon then run ./a
<syntaxhighlight lang="bash">
echo "PRINT \"Hello World\" " > a.bac && bacon a && ./a
</syntaxhighlight>
Converting 'a.bac'... done, 2 lines were processed in 0.003 seconds.
Compiling 'a.bac'... cc -c a.bac.c
cc -o a a.bac.o -lm
Done, program 'a' ready.
Hello World
=={{header|Bc}}==
<
{{out}}
<pre>Hello 123</pre>
=={{header|Binary Lambda Calculus}}==
Several such one liners are shown on https://www.ioccc.org/2012/tromp/hint.html, such as
<syntaxhighlight lang="bash">echo "*Hello, world" | ./tromp</syntaxhighlight>
<syntaxhighlight lang="bash">echo "00010001100110010100011010000000010110000010010001010111110111101001000110100001110011010000000000101101110011100111111101111000000001111100110111000000101100000110110" | ./tromp -b | head -c 70</syntaxhighlight>
=={{header|Bracmat}}==
Line 88 ⟶ 135:
DOS:
<
Linux:
<
Output:
<pre> 1
Line 116 ⟶ 163:
=={{header|Burlesque}}==
<syntaxhighlight lang="text">
Burlesque.exe --no-stdin "5 5 .+"
</syntaxhighlight>
Using the official interpreter.
=={{header|C}}==
Line 127 ⟶ 174:
delete it to avoid to call another shell/system dependent command/program). The
''current directory'' is not specified by <tt>./</tt> in every system...
<
=={{header|C sharp|C#}}==
Line 133 ⟶ 180:
Requires PowerShell 2:
<
> [HelloWorld]::SayHi()
Hi!</
=={{header|Clojure}}==
Line 142 ⟶ 189:
clj-env-dir comes with clojure-contrib.
<
#'user/add2
42</
=={{header|CMake}}==
This only works with [[Unix]] systems that have the device node <code>/dev/stdin</code>.
<
=={{header|COBOL}}==
Works with GnuCOBOL 2.0 or later
<
Longer, but avoids two relaxed syntax warnings:
<
=={{header|Common Lisp}}==
Line 163 ⟶ 210:
{{works with|SBCL}}
<
{{works with|CLISP}}
<
=={{header|D}}==
{{works with|D|2}}
requires [https://github.com/D-Programming-Language/tools/blob/master/rdmd.d rdmd]
<
<pre>Hello World!</pre>
=={{header|Dc}}==
<
=={{header|Delphi}}==
Run in cmd.exe.
<syntaxhighlight lang="batch">echo program Prog;begin writeln('Hi');end. >> "./a.dpt" & dcc32 -Q -CC -W- "./a.dpt" & a.exe</syntaxhighlight>
The output has the default Delphi header, before the output of executable ("Hi").
=={{header|E}}==
<
The <code>--src</code> option ends with the the filename extension the provided type of program would have:
<syntaxhighlight lang="text">rune --src.e-awt 'def f := <swing:makeJFrame>("Hello"); f.show(); f.addWindowListener(def _{to windowClosing(_) {interp.continueAtTop()} match _{}}); interp.blockAtTop()'</
=={{header|Elixir}}==
<
Hello, World!</
=={{header|Emacs Lisp}}==
<
Or another example that does something useful: indent a [[C]] source file:
<
=={{header|Erlang}}==
Erlang always starts other applications that can run in parallel in the background, and as such will not die by itself. To kill erl, we sequentially run the 'halt' function from the 'erlang' module (the -S is there to guarantee 'halt' will be evaluated after the io function).
<
hello</
=={{header|F_Sharp|F#}}==
<
Hello from F#</
=={{header|Factor}}==
<
=={{header|Forth}}==
{{works with|GNU Forth}}
<
Hello</
=={{header|Fortran}}==
This example, stolen from the [[Shell_one-liner#c|c]] example is subject to the same caveats. While contrived, FORTRAN as a one liner can easily handle some unique tasks. Let's plot a Bessel function:
<
$ gawk 'BEGIN{print"write(6,\"(2(g12.3,x))\")(i/10.0,besj1(i/10.0), i=0,1000)\nend";exit(0)}'|gfortran -ffree-form -x f95 - | gnuplot -p -e 'plot "<./a.out" t "Bessel function of 1st kind" w l'
</syntaxhighlight>
Sorry, I don't know how to upload my jpeg file for the Image tag. Let's use the dumb display instead.
<pre>
Line 239 ⟶ 290:
</pre>
=={{header|Free Pascal}}==
The FPC (Free Pascal compiler) comes with the utility <tt>instantfpc(1)</tt> or <tt>ifpc(1)</tt> for short (Debian or FreeBSD package <tt>fpc-utils</tt>):
<syntaxhighlight lang="bash">echo "begin writeLn('Hi'); end." | ifpc /dev/stdin</syntaxhighlight>
=={{header|FreeBASIC}}==
<
Shell "echo For i As Integer = 1 To 10 : Print i : Next > zzz.bas && fbc zzz.bas && zzz"
Sleep</
{{out}}
Line 258 ⟶ 313:
9
10
</pre>
=={{header|Frink}}==
Frink is distributed as a single <CODE>.jar</CODE> file that will run in a Java Virtual Machine. On many operating systems, just double-clicking this <CODE>.jar</CODE> file will run Frink with a graphical interface in an interactive mode. By specifying a different main-class (<CODE>frink.parser.Frink</CODE>) when starting Frink, it can be run in text-mode interactive mode as well. These options and sample starter scripts for various operating systems are provided in the [https://frinklang.org/#RunningFrink Running Frink] section of the documentation.
The <CODE>-e</CODE> command-line option executes a command or commands and prints its value.
<syntaxhighlight lang="frink">$ frink -e "factorFlat[2^67-1]"</syntaxhighlight>
{{out}}
<pre>
[193707721, 761838257287]
</pre>
=={{header|FutureBasic}}==
This is forcing the issue. FB has much more elegant ways of interacting with the Unix Shell.
<
</syntaxhighlight>
Output
Line 279 ⟶ 346:
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=4385adf6a841435779a7afff3dadb58b Click this link to run this code]'''
<
Shell "echo Hello World"
End</
Output:
<pre>
Line 290 ⟶ 357:
=={{header|Gema}}==
<
Hello</
=={{header|Go}}==
<
{{out}}
<pre>
Line 302 ⟶ 369:
=={{header|Groovy}}==
{{works with|UNIX Shell}}
<
Hello</
{{works with|Windows Command Interpreter}}
<
Hello</
=={{header|Haskell}}==
<
Hello</
=={{header|Huginn}}==
Result of an expression is printed by default:
<
Output:
<pre>"Hello"</pre>
Even with an explicit `print` function was used:
<
Output:
<pre>Hello
none</pre>
Unless the last expression ended with a semicolon:
<
Output:
<pre>Hello</pre>
Line 332 ⟶ 399:
These examples work with posix shells.
<
<
=={{Header|Insitux}}==
When Insitux has been already been installed system-wide (<code>npm i -g insitux</code>).
<pre>
$ npx ix -e "(+ 2 2)"
</pre>
{{out}}
<pre>
4
</pre>
=={{header|J}}==
<
Hello
</syntaxhighlight>
Here, the (empty) result of <code>echo</code> is used as the exit code argument for <code>exit</code>. And, since it's empty, the the default exit code of 0 is what's actually used. The exit command here is used to prevent the default behavior of jconsole (which is to start the J [[wp:Command_shell|command shell]]) and to instead return to the OS command shell.
We could have instead used:
<syntaxhighlight lang="bash">$ :|jconsole -js "echo 'Hello'"
Hello
</syntaxhighlight>
for nearly identical behavior, but this issues J's command prompt before exiting. (But since J's command prompt is three space characters, this would be nearly invisible in many contexts, including here because the mediawiki implementation deletes those trailing spaces when rendering this page into html.)
=={{header|Java}}==
Line 346 ⟶ 436:
These three lines work with Bourne Shell (or compatible) or C Shell (or compatible), or bash on Unix/Linux/MacOSX/Windows+cygwin
<
> 'System.out.println("Hello Java!");}}' >X.java
$ javac X.java && java X</
A user can also enter this as one (very long) line:
<
{{works with|MS-DOS}} Compatible Environments (such as [[wp:cmd.exe|cmd.exe]])
Works with cmd.exe on Windows (tested on Microsoft Windows XP [Version 5.1.2600])
<
Hello Java!</
=={{header|JavaScript}}==
{{works with|SpiderMonkey}}
<
hello</
=={{header|jq}}==
<
2</
=={{header|Julia}}==
<
foo
bar</
=={{header|K}}==
{{works with|Kona}}
<
=={{header|Kotlin}}==
Line 386 ⟶ 476:
Hello Kotlin!
</pre>
=={{header|Lang}}==
This is an example for the Standard Lang implementation of Lang.
<syntaxhighlight lang="lang">
$ lang -e "fn.println(Hello World)"
</syntaxhighlight>
=={{header|langur}}==
=== Linux ===
<syntaxhighlight lang="langur">$ langur -e 'writeln "Are we reaching Fiji?"'
</syntaxhighlight>
=== Windows ===
<syntaxhighlight lang="langur">C:\> langur /e 'writeln "Are we reaching Fiji?"'
</syntaxhighlight>
{{out}}
<pre>Are we reaching Fiji?</pre>
=={{header|Lasso}}==
Line 391 ⟶ 499:
From stdin:
<
Or alternatively:
<
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">
echo print "hello">oneLiner.bas & liberty -r oneLiner.bas echo print "hello">oneLiner.bas & liberty -r oneLiner.bas
</syntaxhighlight>
=={{header|Lua}}==
<
=={{header|Maple}}==
<
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
=={{header|min}}==
<syntaxhighlight lang="min">min -e:"\"hi from min\" puts!"</syntaxhighlight>
=={{header|Nanoquery}}==
<syntaxhighlight lang="bash">nq -e "println \"Hello Nanoquery!\""</syntaxhighlight>
=={{header|NetLogo}}==
Commands can be entered into the NetLogo Command Center. NetLogo is white-space delimited. Variables can be defined with the LET command and used in the statement. The CC can be in various modes, such as Turtle mode, where entered commands are ran as if contained in an ASK TURTLES statement.
=== Observer Mode ===
<syntaxhighlight lang="netlogo">let x 15 ask turtles [ set xcor x set x x + 1 ]</syntaxhighlight>
=== Turtle Mode ===
<syntaxhighlight lang="netlogo">right random 90 forward 10</syntaxhighlight>
=={{header|NetRexx}}==
{{works with|UNIX Shell}}
Create a temporary file, execute the file via the NetRexx interpreter then delete the temporary file and any files generated via the translation. (i.e. Java class files etc.)
<
$ TNRX=`mktemp T_XXXXXXXXXXXX` && test ! -e $TNRX.* && (echo 'say "Goodbye, World!"' >$TNRX; nrc -exec $TNRX; rm $TNRX $TNRX.*; unset TNRX)
</syntaxhighlight>
'''Output:'''
Line 431 ⟶ 553:
=={{header|NewLISP}}==
<
->"Hello"</
=={{header|Nim}}==
The following works on any Linux system. With some minor changes, it should work on other systems too.
<pre>$ echo 'for i in 0..10: echo "Hello World"[0..i]' >/tmp/oneliner.nim; nim r oneliner
H
He
Hel
Line 446 ⟶ 569:
Hello Wor
Hello Worl
Hello World</pre>
=={{header|Objeck}}==
{{works with|UNIX Shell}}
<
=={{header|OCaml}}==
<
Hello</
{{works with|OCaml|4.00+}}
<
Hello</
=={{header|Octave}}==
<
Hello World, it is 28-Aug-2013 17:53:47!</
=={{header|Oforth}}==
<
{{out}}
Line 475 ⟶ 596:
=={{header|ooRexx}}==
<
rexx -e "say 'Goodbye, world.'"
</syntaxhighlight>
=={{header|Oz}}==
This is difficult to do in Oz because the compiler/interpreter always wants the source code in a file and does not read from stdin. We can do somethings like this on Unix-like systems:
<
hello</
With <code>-l System</code> we make the System module available so that we can print something.
=={{header|PARI/GP}}==
<
=={{header|Pascal}}==
''See [[#Free Pascal|Free Pascal]]''
=={{header|Perl}}==
<
Hello</
More information about the many ways of invoking perl can be found in [http://perldoc.perl.org/perlrun.html perlrun].
=={{header|
<!--(notonline)-->
Command line option -e added for 0.8.1. Outer quotes only rqd if snippet contains spaces, otherwise ignored. <br>
Most one-liners will probably start with '?' since eg "1+2" gives a compilation error.
<pre>
C:\Program Files (x86)\Phix>p -e ?357+452
809
C:\Program Files (x86)\Phix>p -e "?357+452"
809
</pre>
=={{header|PHP}}==
assuming you have the PHP CLI (command-line interface) installed, not just the web server plugin
<
Hello</
=={{header|PicoLisp}}==
<
Hello world!</
=={{header|Pike}}==
<
Hello</
=={{header|PowerShell}}==
<
Hello</
=={{header|Processing}}==
The command-line tool processing-java takes a sketch directory (not a file) and so a simple program cannot be piped in from the shell using process substitution. However, a long shell one-liner may write a sketch file to disk, then run it, so long as the folder name and the PDE file name match, e.g. /Tmp/Tmp.pde
In bash:
<syntaxhighlight lang="processing">mkdir -p Tmp; echo "println(\"hello world\");" > Tmp/Tmp.pde; processing-java --sketch="`pwd`/Tmp" --run</syntaxhighlight>
{{out}}
<pre>
hello world
</pre>
=={{header|Prolog}}==
===Command-Line Options===
<
hello world
$</
<
goodbye
$</
<
yap</
=== <<< ===
<
swi
$ yap -q <<< "current_prolog_flag(dialect,D), writeln(D), halt."
yap</
=== Pipe ===
<
swi
$ echo "current_prolog_flag(dialect,D), writeln(D), halt." | yap -q
yap</
=={{header|PureBasic}}==
Runs on Linux with(thanks to) bash. Path variables must be set as decribed in INSTALL.
<
=={{header|Python}}==
===Prints "Hello"===
<
Hello</
===Web server with CGI===
The python CGIHTTPServer module is also an [[Executable library|executable library]] that performs as a web server with CGI. to start enter:
<syntaxhighlight lang
It returns with:
<pre>Serving HTTP on 0.0.0.0 port 8000 ...</pre>
=={{header|Quackery}}==
<syntaxhighlight lang="bash">$ QUACK=$(mktemp); echo "say 'hello'" > $QUACK; quackery $QUACK; rm $QUACK
hello</syntaxhighlight>
===Via Python 3===
As Quackery is implemented as a Python 3 function, assuming that quackery.py is in the module search path:
<syntaxhighlight lang="bash">$ python3 -c 'import quackery ; quackery.quackery(r""" say '\''hello'\'' cr """)'
hello</syntaxhighlight>
=={{header|R}}==
<
Hello</
Alternatively, using the Rscript front-end,
<
Hello</
=={{header|Racket}}==
<
Hello World</
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|#22 "Thousand Oaks"}}
<syntaxhighlight lang="bash">$ raku -e 'say "Hello, world!"'
Hello, world!</syntaxhighlight>
=={{header|REBOL}}==
<
Output:
Line 578 ⟶ 734:
=={{header|Retro}}==
<
=={{header|REXX}}==
Note: Regina REXX is the only version of REXX that supports this type of behavior (taking it's input from a console stream).
<
╔══════════════════════════════════════════════╗
║ ║
Line 590 ⟶ 746:
echo do j=10 by 20 for 4; say right('hello',j); end | regina</
'''output''' when entering the (above) from the (DOS) command line:
<pre>
Line 600 ⟶ 756:
=={{header|Ring}}==
<
see "Hello World!" + nl
</syntaxhighlight>
Output:
<pre>
Hello World!
</pre>
=={{header|RPL}}==
RPL command-line interpreter allows to pass several instructions and values in one line, provided there is no program branch instruction among them. It is nevertheless possible to have a program structure in the line by bracketing it with <code>≪ ≫</code>, which means "this is an unnamed program". Adding the word <code>EVAL</code> at the end will execute the code, otherwise it would stay at level 1 of the stack.
" World" "Hello" SWAP +
≪ " World" "Hello" SWAP + ≫ EVAL
This less trivial one-liner example calculates S(5), where S(n) is a Machin-like formula :
≪ 0 0 5 '''FOR''' k 2 k * 1 + → n ≪ -1 k ^ n / 4 5 n ^ / 239 n ^ INV - * + ≫ '''NEXT''' 4 * ≫ EVAL
{{out}}
<pre>
3: "Hello world"
2: "Hello world"
1: 3.14159265262
</pre>
=={{header|Ruby}}==
From [[Unix]]:
<
Hello</
{{works with|JRuby}}
<
Hello from JRuby</
{{works with|Rubinius}}
<
Hello from Rubinius</
=={{header|Run BASIC}}==
<
=={{header|Rust}}==
Line 628 ⟶ 798:
delete it to avoid to call another shell/system dependent command/program). The
''current directory'' is not specified by <tt>./</tt> in every system...
<
=={{header|S-lang}}==
<
Or, in MSW cmd.exe:
<
Note that print() is included w/slsh, but is not part of S-Lang itself.
Line 641 ⟶ 811:
=={{header|Scala}}==
{{libheader|Scala}}
<
Hello</
<
PS C:\> scala -e 'println(\"Hello\")'
Hello</
The escaping of quotes is required by Windows.
Line 653 ⟶ 823:
=={{header|Scheme}}==
{{works with|Guile}}
<
=={{header|sed}}==
The first non-option argument is interpreted as the script.
<syntaxhighlight lang="sh">$ sed q /proc/meminfo</syntaxhighlight>
Alternatively, scripts can be passed via the <code>-e</code> option.
<syntaxhighlight lang="sh">$ sed -e 's/[[:space:]]*$//' -e '/./!d' file.txt</syntaxhighlight>
=={{header|Shiny}}==
<
=={{header|Sidef}}==
<
=={{header|Slate}}==
<
=={{header|SNOBOL4}}==
Portable version
<
Bash version
<
=={{header|Tcl}}==
This is an area where Tcl is lacking, though when shell one-liners are required a construct like this is typically used:
<
Hello</
=={{header|TXR}}==
<
a="123"
b="456"
c="7890"
</syntaxhighlight>
Most useful txr queries consist of multiple lines, and the line structure is important. Multi-liners can be passed via <code>-c</code> easily, but there is no provision in the syntax that would allow multi-liners to be actually written as one physical line. There are opposite provisions for splitting long logical lines into multiple physical lines.
Line 689 ⟶ 865:
TXR Lisp:
<
4</
<
$ ls -ld foo
drwxrwxr-x 2 kaz kaz 4096 Mar 4 23:36 foo</
=={{header|UNIX Shell}}==
Explicit call of the shell, passing the shell command via the <code>-c</code> option:
<syntaxhighlight lang
<
To invoke a specific shell like [[Bash]], [[Korn Shell]] or [[Z Shell]]:
<
$ ksh -c 'let i=3+4; print $i'
$ zsh -c 'if [[ 5 -lt 6 ]] { echo ok };'</
Shell scripts almost never use <code>sh -c</code>, because there are various implicit ways whereby the shell command language evaluates a command in a subshell:
<
$ VAR=$(echo hello) # modern POSIX notation
$ (echo hello) # execute in another shell process, not in this one</
There are more details about <code>`echo hello`</code> and <code>$(echo hello)</code> at [[Execute a system command#UNIX Shell]].
Line 718 ⟶ 894:
Run a C shell command from any shell:
<
==={{header|es}}===
Run a command, in extensible shell, from any shell:
<
=={{header|Ursala}}==
The command to execute the Ursala compiler is fun. An expression supplied as a parameter to the --main option is compiled and evaluated. If the expression evaluates to a list of character strings, it can be displayed on standard output with --show. If it's some other type, it can be formatted for display by --cast <type expression>,
<
hello
$ fun --main="power/2 32" --cast %n
4294967296
$ fun --m="..mp2str mpfr..pi 120" --c %s
'3.1415926535897932384626433832795028847E+00'</
=={{header|Vedit macro language}}==
The following DOS command starts Vedit and displays a message.
When the user presses any key, Vedit exits.
<
=={{header|Wart}}==
<
=={{header|Wren}}==
<syntaxhighlight lang="bash">echo 'System.print("Hello from Wren!")' > tmp.wren; wren tmp.wren</syntaxhighlight>
{{out}}
<pre>
Hello from Wren!
</pre>
=={{header|zkl}}==
With a unix like shell, just pipe the program into the REPL. Kinda greasy and noisy. To shut it up, send stdout to /dev/null
<
{{out}}
<pre>
Line 752 ⟶ 936:
Hello World 11
</pre>
{{omit from|6502 Assembly|Anything can be a one-liner if you JSR to it.}}
{{omit from|68000 Assembly}}
{{omit from|Z80 Assembly}}
{{omit from|8086 Assembly}}
{{omit from|x86 Assembly}}
{{omit from|ARM Assembly}}
{{omit from|AutoHotkey|No interactive shell}}
{{
{{omit from|Java}}
{{omit from|Maxima}}
{{omit from|Modula-3}}
|