Command-line arguments: Difference between revisions
Line 1,132: | Line 1,132: | ||
#6 : gamma |
#6 : gamma |
||
C:\Program Files (x86)\Phix>p -c testcl -c "alpha beta" -h "gamma" |
C:\Program Files (x86)\Phix>p -c testcl -c "alpha beta" -h "gamma" |
||
{"C:\\Program Files (x86)\\Phix\\testcl.exe","C:\\Program Files (x86)\\Phix\\testcl.exe","-c","alpha |
{"C:\\Program Files (x86)\\Phix\\testcl.exe","C:\\Program Files (x86)\\Phix\\testcl.exe","-c","alpha beta","-h","gamma"} |
||
Compiled executable name: C:\Program Files (x86)\Phix\testcl.exe |
Compiled executable name: C:\Program Files (x86)\Phix\testcl.exe |
||
Command line arguments: |
Command line arguments: |
Revision as of 03:49, 4 September 2015
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
Retrieve the list of command-line arguments given to the program. For programs that only print the arguments when run directly, see Scripted main.
See also Program name.
For parsing command line arguments intelligently, see Parsing command-line arguments.
Example command line:
myprogram -c "alpha beta" -h "gamma"
Ada
In Ada95 and later versions, command line arguments are available through the predefined package Ada.Command_Line. In Ada83, this would be implementation dependent.
<lang ada>with Ada.Command_line; use Ada.Command_Line; with Ada.Text_IO; use Ada.Text_IO;
procedure Print_Commands is begin
-- The number of command line arguments is retrieved from the function Argument_Count -- The actual arguments are retrieved from the function Argument -- The program name is retrieved from the function Command_Name Put(Command_Name & " "); for Arg in 1..Argument_Count loop Put(Argument(Arg) & " "); end loop; New_Line;
end Print_Commands;</lang>
Alternative version using Matreshka
Uses Matreshka
<lang ada>with Ada.Wide_Wide_Text_IO;
with League.Application; with League.Strings;
procedure Main is begin
for J in 1 .. League.Application.Arguments.Length loop Ada.Wide_Wide_Text_IO.Put_Line (League.Application.Arguments.Element (J).To_Wide_Wide_String); end loop;
end Main;</lang>
Aikido
The arguments are passed to the program as a vector of strings called args <lang aikido>
foreach arg in args {
println ("arg: " + arg)
}
</lang>
Aime
<lang aime>integer i;
i = 0; while (i < argc()) {
o_text(argv(i)); o_byte('\n'); i += 1;
}</lang>
ALGOL 68
<lang algol68>main:(
FOR i TO argc DO printf(($"the argument #"g(-0)" is "gl$, i, argv(i))) OD
)</lang> Linux command:
/usr/bin/a68g Command-line_arguments.a68 - 1 2 3 ...
Output:
the argument #1 is /usr/bin/a68g the argument #2 is ./Command-line_arguments.a68 the argument #3 is - the argument #4 is 1 the argument #5 is 2 the argument #6 is 3 the argument #7 is ...
AppleScript
<lang applescript>
- !/usr/bin/env osascript
-- Print first argument on run argv
return (item 1 of argv)
end run </lang>
AutoHotkey
From the AutoHotkey documentation: "The script sees incoming parameters as the variables %1%, %2%, and so on. In addition, %0% contains the number of parameters passed (0 if none). " <lang autohotkey>Loop %0% ; number of parameters
params .= %A_Index% . A_Space
If params !=
MsgBox, %0% parameters were passed:`n`n %params%
Else
Run, %A_AhkPath% "%A_ScriptFullPath%" -c "\"alpha beta\"" -h "\"gamma\""</lang>
AWK
<lang awk>#!/usr/bin/awk -f
BEGIN {
print "There are " ARGC "command line parameters" for(l=1; l<ARGC; l++) { print "Argument " l " is " ARGV[l] }
}</lang>
BASIC
For most older BASICs that supply the keyword COMMAND$
, all arguments are returned in a single string that must then be parsed inside the program. (Unlike modern BASICs, there is often no easy way to retrieve the program's name.)
<lang qbasic>PRINT "args: '"; COMMAND$; "'"</lang>
Sample output:
args: 'This is a test.'
FreeBASIC supplies three ways to retrieve the arguments: COMMAND$
(which works identically to QuickBASIC's COMMAND$
), COMMAND$()
(a string array which works like C's argv[]
), and __FB_ARGV__
(an array of pointers which works even more like C's argv[]
) and __FB_ARGC__ (which works like C's argc
).
<lang freebasic>DIM i AS INTEGER
PRINT COMMAND$
PRINT "This program is named "; COMMAND$(0) i = 1 DO WHILE(LEN(COMMAND$(i)))
PRINT "The argument "; i; " is "; COMMAND$(i) i = i + 1
LOOP
FOR i = 0 TO __FB_ARGC__ - 1
PRINT "arg "; i; " = '"; *__FB_ARGV__[i]; "'"
NEXT i</lang>
Sample output:
C:\>cla 1 2 3 1 2 3 This program is named cla The argument 1 is 1 The argument 2 is 2 The argument 3 is 3 arg 0 = 'cla' arg 1 = '1' arg 2 = '2' arg 3 = '3'
Batch File
<lang dos>@echo off setlocal enabledelayedexpansion
set Count=0
- loop
if not "%1"=="" (
set /a count+=1 set parameter[!count!]=%1 shift goto loop
)
for /l %%a in (1,1,%count%) do (
echo !parameter[%%a]!
)</lang>
Another way of doing it
<lang dos>::args2.cmd @echo off setlocal enabledelayedexpansion set fn=%~f0 set p0=%~0 set p*=%* set /a c=1
- loop
if @%1==@ goto done set p%c%=%~1 set /a c=c+1 shift goto loop
- done
set /a c=c-1 set p#=%c% echo fn=%fn% echo p0=%p0% echo p*=%p*% echo p#=%p#% for /l %%i in (1,1,%p#%) do ( echo p%%i=!p%%i! )</lang>
Invocation:
<lang dos>>args2 foo "bar baz" quux fn=d:\bin\args2.cmd p0=args2 p*=foo "bar baz" quux p#=3 p1=foo p2=bar baz p3=quux </lang>
BBC BASIC
<lang bbcbasic>PRINT @cmd$</lang>
Bracmat
When Bracmat is started with one or more arguments, each argument is evaluated as if it were a Bracmat expression unless an argument (for example the first one) consumes the next argument(s) by calling arg$
. Each invocation of arg$
pops one argument from the remaining list of arguments. Calling arg$
when no more arguments are available results in failure. The following program iterates over all arguments following the currently evaluated argument and outputs the argument to standard output.
<lang>whl'(arg$:?a&out$(str$("next arg=" !a)))</lang>
Now run Bracmat with this program as the first argument in a DOS environment:
bracmat "whl'(arg$:?a&out$(str$(\"next arg=\" !a)))" "a" /b -c 2+3 'd;' "out$(\"13+7=\" 13+7)"
Instead of starting in interactive mode, Bracmat interprets the first argument, which consumes all following arguments. This is output to standard output:
next arg=a next arg=/b next arg=-c next arg=2+3 next arg='d;' next arg=out$("13+7=" 13+7)
If given an argument index, arg$<arg index>
returns the indexed argument without consuming any argument.
bracmat "0:?n&whl'(arg$!n:?a&out$str$(arg[ !n \"]=\" !a)&1+!n:?n)" "a" /b -c 2+3 'd;' "out$(\"13+7=\" 13+7)"
Output:
arg[0]=bracmat arg[1]=0:?n&whl'(arg$!n:?a&out$str$(arg[ !n "]=" !a)&1+!n:?n) arg[2]=a arg[3]=/b arg[4]=-c arg[5]=2+3 arg[6]='d;' arg[7]=out$("13+7=" 13+7) 13+7= 20
The last line demonstrates that not only the first argument is evaluated, but also the following arguments.
If Bracmat is run without arguments, Bracmat starts in interactive mode. In that situation calling arg$
fails. The same is true if Bracmat is compiled as a shared library (DLL or so).
C
Command line arguments are passed to main. Since the program name is also passed as "argument", the provided count is actually one more than the number of program arguments. Traditionally the argument count is named argc and the array of argument strings is called argv, but that's not mandatory; any (non-reserved) name will work just as well. It is, however, a good idea to stick to the conventional names.
Be careful on systems that use Unicode or other multibyte character sets. You may need to use a type of _wchar* and multi-byte-character-set-aware versions of printf.
<lang c>#include <stdlib.h>
- include <stdio.h>
int main(int argc, char* argv[]) {
int i; (void) printf("This program is named %s.\n", argv[0]); for (i = 1; i < argc; ++i) (void) printf("the argument #%d is %s\n", i, argv[i]); return EXIT_SUCCESS;
}</lang>
C++
Command line arguments are passed the same way as in C.
This example uses iostream. Traditional C I/O also works.
<lang cpp>#include <iostream>
int main(int argc, char* argv[]) {
std::cout << "This program is named " << argv[0] << std::endl; std::cout << "There are " << argc-1 << " arguments given." << std::endl; for (int i = 1; i < argc; ++i) std::cout << "the argument #" << i << " is " << argv[i] << std::endl;
return 0;
}</lang>
C#
There are at least two methods to access the command-line arguments. The first method is to access the string array passed to Main. This method only accesses the arguments and not the path to the executable. <lang csharp>using System;
namespace RosettaCode {
class Program { static void Main(string[] args) { for (int i = 0; i < args.Length; i++) Console.WriteLine(String.Format("Argument {0} is '{1}'", i, args[i])); } }
}</lang>
The second method is to call the Environment.GetCommandLineArgs function. This method also returns the path to the executable as args[0] followed by the actual command line arguments. <lang csharp>using System;
namespace RosettaCode {
class Program { static void Main() { string[] args = Environment.GetCommandLineArgs(); for (int i = 0; i < args.Length; i++) Console.WriteLine(String.Format("Argument {0} is '{1}'", i, args[i])); } }
}</lang>
Clean
getCommandLine from the module ArgEnv returns an array of command-line arguments (the first element is the name of the program).
<lang clean>import ArgEnv
Start = getCommandLine</lang>
Clojure
The value of *command-line-args* is a sequence of the supplied command line arguments, or nil if none were supplied.
<lang Clojure>(dorun (map println *command-line-args*))</lang>
COBOL
The COBOL standard appears to say nothing regarding the retrieval of command-line arguments, although methods of retrieving them are provided by most vendors.
Getting the arguments in one go, exactly as they were passed in: <lang cobol> IDENTIFICATION DIVISION.
PROGRAM-ID. accept-all-args. DATA DIVISION. WORKING-STORAGE SECTION. 01 args PIC X(50). PROCEDURE DIVISION. main-line. ACCEPT args FROM COMMAND-LINE DISPLAY args GOBACK .</lang>
Getting the arguments one at a time, with arguments being split by whitespace if not in quotes: <lang cobol> IDENTIFICATION DIVISION.
PROGRAM-ID. accept-args-one-at-a-time. DATA DIVISION. WORKING-STORAGE SECTION. 01 arg PIC X(50) VALUE SPACES. PROCEDURE DIVISION. ACCEPT arg FROM ARGUMENT-VALUE PERFORM UNTIL arg = SPACES DISPLAY arg MOVE SPACES TO arg ACCEPT arg FROM ARGUMENT-VALUE END-PERFORM GOBACK .</lang>
CoffeeScript
<lang coffeescript> console.log arg for arg in process.argv </lang>
Common Lisp
The Common Lisp standard does not specify anything relating to external invocation of a Common Lisp system. The method for getting command-line arguments varies by implementation.
The following function could be used to create a uniform way to access the arguments:
<lang lisp>(defun argv ()
(or #+clisp (ext:argv) #+sbcl sb-ext:*posix-argv* #+abcl ext:*command-line-argument-list* #+clozure (ccl::command-line-arguments) #+gcl si:*command-args* #+ecl (loop for i from 0 below (si:argc) collect (si:argv i)) #+cmu extensions:*command-line-strings* #+allegro (sys:command-line-arguments) #+lispworks sys:*line-arguments-list* nil))</lang>
D
<lang d>void main(in string[] args) {
import std.stdio;
foreach (immutable i, arg; args[1 .. $]) writefln("#%2d : %s", i + 1, arg);
}</lang>
DCL
case is not preserved unless the parameter is in quotes <lang DCL>$ i = 1 $ loop: $ write sys$output "the value of Pi' is ", p'i $ i = i + 1 $ if i .le. 8 then $ goto loop</lang>
- Output:
$ @command_line_arguments -c "alpha beta" -h "gamma" the value of P1 is -C the value of P2 is alpha beta the value of P3 is -H the value of P4 is gamma the value of P5 is the value of P6 is the value of P7 is the value of P8 is
Déjà Vu
Command line arguments are found in !args
and !opts
.
<lang dejavu>for i range 0 -- len !args: print\( "Argument #" i " is " ) . get-from !args i
if has !opts :c: !print "Ah, the -c option."
if has !opts :four: !. get-from !opts :four</lang>
- Output:
$ vu args-3.deja one two -c three --four=five Argument #0 is "args-3.deja" Argument #1 is "one" Argument #2 is "two" Argument #3 is "three" Ah, the -c option. "five"
The order of command line options is lost.
Delphi
<lang delphi>// The program name and the directory it was called from are in // param[0] , so given the axample of myprogram -c "alpha beta" -h "gamma"
for x := 0 to paramcount do writeln('param[',x,'] = ',param[x]);
// will yield ( assuming windows and the c drive as the only drive) :
// param[0] = c:\myprogram // param[1] = -c // param[2] = alpha beta // param[3] = -h // param[4] = gamma </lang>
E
<lang e>interp.getArgs()</lang>
Eiffel
This class inherits functionality for dealing with command line arguments from class ARGUMENTS
. It uses the feature separate_character_option_value
to return the values by option name for each of the two arguments.
<lang eiffel >class
APPLICATION
inherit
ARGUMENTS
create
make
feature {NONE} -- Initialization
make -- Print values for arguments with options 'c' and 'h'. do print ("Command line argument value for option 'c' is: ") print (separate_character_option_value ('c') + "%N") print ("Command line argument value for option 'h' is: ") print (separate_character_option_value ('h') + "%N") io.read_line -- Keep console window open end
end</lang>
Output (for command line arguments: -c "alpha beta" -h "gamma"):
Command line argument value for option 'c' is: alpha beta Command line argument value for option 'h' is: gamma
Emacs Lisp
<lang emacslisp>
- !/usr/bin/env emacs --script
(dolist (arg command-line-args-left) (message arg)) </lang>
Erlang
When used as a script language the arguments is a list to the main/1 function. When compiled use init:get_arguments/0 <lang erlang>3> init:get_arguments().</lang> result <lang erlang>[{root,["/usr/erlang/erl5.5"]}, {progname,["erl"]}, {home,["/home/me"]}, {c,["alpha beta"]}, {h,["gamma"]}]</lang>
init:get_argument(name) can be used to fetch value of a particular flag
<lang erlang>4> init:get_argument(h). {ok,"gamma"} 5> init:get_argument(c). {ok,"alpha beta"}</lang>
Euphoria
<lang Euphoria>constant cmd = command_line() printf(1,"Interpreter/executable name: %s\n",{cmd[1]}) printf(1,"Program file name: %s\n",{cmd[2]}) if length(cmd)>2 then
puts(1,"Command line arguments:\n") for i = 3 to length(cmd) do printf(1,"#%d : %s\n",{i,cmd[i]}) end for
end if</lang>
F#
The entry-point function accepts the comment line arguments as an array of strings. The following program will print each argument on a separate line. <lang fsharp>#light [<EntryPoint>] let main args =
Array.iter (fun x -> printfn "%s" x) args 0</lang>
Factor
USING: io sequences command-line ; (command-line) [ print ] each
Fancy
<lang fancy>ARGV each: |a| {
a println # print each given command line argument
}</lang>
Fantom
<lang fantom> class Main {
public static Void main (Str[] args) { echo ("command-line args are: " + args) }
} </lang>
Forth
Access to command line arguments is not a standard feature of Forth, since it is designed to be used without an operating system. The popular GNU implementation gforth runs from a shell and can access command line arguments similar to C: variable argc contains the count (including the command itself) and arg is a function that returns the nth argument as a string.
<lang forth>\ args.f: print each command line argument on a separate line
- main
argc @ 0 do i arg type cr loop ;
main bye</lang>
Here is output from a sample run. <lang forth>$ gforth args.f alpha "beta gamma" delta gforth args.f alpha beta gamma delta $</lang>
Fortran
<lang fortran>program command_line_arguments
implicit none integer, parameter :: len_max = 256 integer :: i , nargs character (len_max) :: arg nargs = command_argument_count() !nargs = iargc() do i = 0, nargs call get_command_argument (i, arg) !call getarg (i, arg) write (*, '(a)') trim (arg) end do
end program command_line_arguments
</lang>
Note: This sample uses the Fortran 2003 intrinsic routines command_argument_count
and get_command_argument
instead of the nonstandard extensions iargc
and getarg
. Most Fortran compilers support both.
Sample usage: <lang>> ./a.out -c "alpha beta" -h "gamma" ./a.out -c alpha beta -h gamma</lang>
Frink
Arguments to a program are available in the ARGS
array variable.
<lang frink>
println[ARGS]
</lang>
FunL
<lang funl>println( args )</lang>
Gambas
<lang gambas>PUBLIC SUB main()
DIM l AS Integer DIM numparms AS Integer DIM parm AS String numparms = Application.Args.Count FOR l = 0 TO numparms - 1 parm = Application.Args[l] PRINT l; " : "; parm NEXT
END SUB</lang>
Go
<lang go>package main import (
"fmt" "os"
)
func main() {
for i, x := range os.Args { if i == 0 { fmt.Printf("This program is named %s.\n", x) } else { fmt.Printf("the argument #%d is %s\n", i, x) } }
}</lang>
Groovy
Command-line arguments are accessible via the args list variable. The following is saved as the file "Echo.groovy": <lang groovy>println args</lang>
The existence of command-line arguments presupposes the existence of a command line interpreter. The following test runs were entered in a cygwin bash shell in a Microsoft Windows XP system:
$ groovy Echo this is an argument list [this, is, an, argument, list] $ groovy Echo -x alkfrew4oij -cdkjei +22 [-x, alkfrew4oij, -cdkjei, +22] $
For more sophisticated command-line option and option-argument parsing use the CliBuilder (command-line interface builder) library, which extends the functionality of the Java-based Apache Commons CLI library to Groovy.
Harbour
Uses the Harbour-specific hb_PValue() function <lang visualfoxpro>PROCEDURE Main()
LOCAL i
FOR i := 1 TO PCount() ? "argument", hb_ntos( i ), "=", hb_PValue( i ) NEXT
RETURN</lang>
Haskell
Defined by the System module, getArgs :: IO [String] provides the command-line arguments in a list.
myprog.hs: <lang haskell>import System main = getArgs >>= print</lang>
myprog a -h b c => ["a","-h","b","c"]
HicEst
<lang hicest>DO i = 2, 100 ! 1 is HicEst.exe
EDIT(Text=$CMD_LINE, SePaRators='-"', ITeM=i, IF ' ', EXit, ENDIF, Parse=cmd, GetPosition=position) IF(position > 0) WRITE(Messagebox) cmd
ENDDO</lang>
Icon and Unicon
Command line parameters are passed to Icon/Unicon programs as a list of strings. <lang Icon>procedure main(arglist) every write(!arglist) end</lang>
includes options that parses the command line as switches and arguments and returns the results in a table.
Io
<lang io>System args foreach(a, a println)</lang>
Ioke
<lang ioke>System programArguments each(println)</lang>
J
The global ARGV
holds the command line arguments. Thus, a program to display them:
<lang J> ARGV</lang>
Java
<lang java>public class Arguments {
public static void main(String[] args) { System.out.println("There are " + args.length + " arguments given."); for(int i = 0; i < args.length; i++) System.out.println("The argument #" + (i+1) + " is " + args[i] + " and is at index " + i); }
}</lang>
For more sophisticated command-line option and option-argument parsing use the Apache Commons CLI (command-line interface) library.
JavaScript
<lang javascript>var objArgs = WScript.Arguments; for (var i = 0; i < objArgs.length; i++)
WScript.Echo(objArgs.Item(i));</lang>
<lang javascript>import System; var argv:String[] = Environment.GetCommandLineArgs(); for (var i in argv)
print(argv[i]);</lang>
<lang javascript>for (var i = 0; i < arguments.length; i++)
print(arguments[i]);</lang>
Julia
<lang Julia> prog = basename(Base.source_path())
println(prog, "'s command-line arguments are:") for s in ARGS
println(" ", s)
end </lang>
- Output:
$ julia command_line_arguments.jl -c "alpha beta" -h "gamma" command_line_arguments.jl's command-line arguments are: -c alpha beta -h gamma
Lasso
<lang lasso>#!/usr/bin/lasso9
iterate($argv) => {
stdoutnl("Argument " + loop_count + ": " + loop_value)
}</lang> Output: <lang shell>$ lasso9 arguments.lasso -c "alpha beta" -h "gamma" Argument 1: arguments.lasso Argument 2: -c Argument 3: alpha beta Argument 4: -h Argument 5: gamma</lang>
LFE
To demonstrate this, we can start the LFE REPL up with the parameters for this example: <lang shell> $ ./bin/lfe -pa ebin/ -c "alpha beta" -h "gamma" </lang>
Once we're in the shell, we can get all the initializing arguments with this call: <lang lisp> > (: init get_arguments) (#(root ("/opt/erlang/r15b03"))
#(progname ("erl")) #(home ("/Users/oubiwann")) #(user ("lfe_boot")) #(pa ("ebin/")) #(c ("alpha beta")) #(h ("gamma")))
</lang>
We can also get specific arguments if we know their keys: <lang lisp> > (: init get_argument 'c)
- (ok (("alpha beta")))
> (: init get_argument 'h)
- (ok (("gamma")))
</lang>
Liberty BASIC
<lang lb>print CommandLine$</lang>
Logo
If the command line to a logo script is written
logo file.logo - arg1 arg2 arg3
Then the arguments after the "-" are found in a list in variable :COMMAND.LINE <lang logo>show :COMMAND.LINE [arg1 arg2 arg3]</lang> Alternatively, make the first line of an executable logo script:
#! /usr/bin/logo -
to be able to invoke the script with arguments.
file.logo arg1 arg2 arg3
LSE64
<lang lse64>argc , nl # number of arguments (including command itself) 0 # argument dup arg dup 0 = || ,t 1 + repeat drop</lang>
Lua
The lua scripting language does not use argc and argv conventions for the command line parameters. Instead, the command line parameters to the main script are provided through the global table arg. The script name is placed into element zero of arg, and the script parameters go into the subsequent elements:
<lang lua>print( "Program name:", arg[0] )
print "Arguments:" for i = 1, #arg do
print( i," ", arg[i] )
end</lang>
Mathematica
myprogram: <lang Mathematica>#!/usr/local/bin/MathematicaScript -script $CommandLine</lang> Output:
{myprogram,-c,alpha beta,-h,gamma}
Mercury
<lang>
- - module cmd_line_args.
- - interface.
- - import_module io.
- - pred main(io::di, io::uo) is det.
- - implementation.
- - import_module int, list, string.
main(!IO) :-
io.progname("", ProgName, !IO), io.format("This program is named %s.\n", [s(ProgName)], !IO), io.command_line_arguments(Args, !IO), list.foldl2(print_arg, Args, 1, _, !IO).
- - pred print_arg(string::in, int::in, int::out, io::di, io::uo) is det.
print_arg(Arg, ArgNum, ArgNum + 1, !IO) :-
io.format("the argument #%d is %s\n", [i(ArgNum), s(Arg)], !IO).
</lang>
MMIX
<lang mmix>argv IS $1 argc IS $0 i IS $2
LOC #100
Main LOC @
SETL i,1 % i = 1
Loop CMP $3,argc,2 % argc < 2 ?
BN $3,1F % then jump to end XOR $255,$255,$255 % clear $255 8ADDU $255,i,argv % i*8 + argv LDOU $255,$255,0 % argv[i] TRAP 0,Fputs,StdOut % write the argument GETA $255,NewLine % add a newline TRAP 0,Fputs,StdOut INCL i,1 % increment index SUB argc,argc,1 % argc-- BP argc,Loop % argc > 0? then Loop
1H LOC @
XOR $255,$255,$255 % exit(0) TRAP 0,Halt,0
NewLine BYTE #a,0</lang>
Modula-2
<lang modula2>MODULE try;
FROM Arguments IMPORT GetArgs, ArgTable, GetEnv; FROM InOut IMPORT WriteCard, WriteLn, WriteString;
VAR count, item : SHORTCARD;
storage : ArgTable;
BEGIN
GetArgs (count, storage); WriteString ('Count ='); WriteCard (count, 4); WriteLn; item := 0; REPEAT WriteCard (item, 4); WriteString (' : '); WriteString (storage^ [item]^); WriteLn; INC (item) UNTIL item = count
END try.</lang> Example: <lang Modula-2> jan@Beryllium:~/modula/test$ try jantje zag eens pruimen hangen Count = 6
0 : try 1 : jantje 2 : zag 3 : eens 4 : pruimen 5 : hangen
</lang>
Modula-3
Command line parameters are accessed using the Params module. <lang modula3>MODULE Args EXPORTS Main;
IMPORT IO, Params;
BEGIN
IO.Put(Params.Get(0) & "\n"); IF Params.Count > 1 THEN FOR i := 1 TO Params.Count - 1 DO IO.Put(Params.Get(i) & "\n"); END; END;
END Args.</lang>
Output:
martin@thinkpad:~$ ./prog ./prog martin@thinkpad:~$ ./prog 10 ./prog 10 martin@thinkpad:~$ ./prog 10 20 ./prog 10 20
Nemerle
<lang Nemerle>using System; using System.Console;
module CLArgs {
Main(args : array[string]) : void { foreach (arg in args) Write($"$arg "); // using the array passed to Main(), everything after the program name Write("\n"); def cl_args = Environment.GetCommandLineArgs(); // also gets program name foreach (cl_arg in cl_args) Write($"$cl_arg "); }
}</lang>
NetRexx
In a stand-alone application NetRexx places the command string passed to it in a variable called arg. <lang NetRexx>/* NetRexx */ -- sample arguments: -c "alpha beta" -h "gamma" say "program arguments:" arg </lang> Output:
program arguments: -c "alpha beta" -h "gamma"
Nim
<lang nim>import os let programName = paramStr(0) let arguments = commandLineParams()</lang>
Objeck
<lang objeck> bundle Default {
class Line { function : Main(args : String[]) ~ Nil { each(i : args) { args[i]->PrintLine(); }; } }
} </lang>
Objective-C
In addition to the regular C mechanism of arguments to main(), Objective-C also has another way to get the arguments as string objects inside an array object: <lang objc>NSArray *args = [[NSProcessInfo processInfo] arguments]; NSLog(@"This program is named %@.", [args objectAtIndex:0]); NSLog(@"There are %d arguments.", [args count] - 1); for (i = 1; i < [args count]; ++i){
NSLog(@"the argument #%d is %@", i, [args objectAtIndex:i]);
}</lang>
OCaml
The program name is also passed as "argument", so the array length is actually one more than the number of program arguments.
<lang ocaml>let () =
Printf.printf "This program is named %s.\n" Sys.argv.(0); for i = 1 to Array.length Sys.argv - 1 do Printf.printf "the argument #%d is %s\n" i Sys.argv.(i) done</lang>
Using the Arg module
<lang ocaml>(* default values *) let somebool = ref false let somestr = ref "" let someint = ref 0
let usage = "usage: " ^ Sys.argv.(0) ^ " [-b] [-s string] [-d int]"
let speclist = [
("-b", Arg.Set somebool, ": set somebool to true"); ("-s", Arg.Set_string somestr, ": what follows -s sets some string"); ("-d", Arg.Set_int someint, ": some int parameter"); ]
let () =
(* Read the arguments *) Arg.parse speclist (fun x -> raise (Arg.Bad ("Bad argument : " ^ x))) usage;
Printf.printf " %b %d '%s'\n" !somebool !someint !somestr;
- </lang>
% ocaml arg.ml --help usage: tmp.ml [-b] [-s string] [-d int] -b : set somebool to true -s : what follows -s sets some string -d : some int parameter --help Display this list of options % ocaml arg.ml -d 4 -b -s blabla true 4 'blabla' % ocaml arg.ml false 0 ''
Oforth
System.Args returns command line arguments.
All arguments that begin with "--" are not included into this list. The first argument is the program name, so this list is never empty.
<lang Oforth>System.Args println</lang>
Oz
Raw arguments
Like in C, but without the program name: <lang oz>functor import Application System define
ArgList = {Application.getArgs plain} {ForAll ArgList System.showInfo} {Application.exit 0}
end</lang>
Preprocessed arguments
<lang oz>functor import Application System define
ArgSpec = record( c(type:string single %% option "--c" expects a string, may only occur once,
optional:false char:&c) %% is not optional and has a shortcut "-c"
h(type:string single %% option "--h" expects a string, may only occur once,
default:"default h" %% is optional and has a default value if not given char:&h) %% and has a shortcut "-h"
) Args = {Application.getArgs ArgSpec} {System.showInfo Args.c} {System.showInfo Args.h} {Application.exit 0}
end</lang>
Pascal
Depends on implementation.
Perl
@ARGV is the array containing all command line parameters
<lang perl>my @params = @ARGV; my $params_size = @ARGV; my $second = $ARGV[1]; my $fifth = $ARGV[4];</lang>
If you don't mind importing a module:
<lang perl>use Getopt::Long; GetOptions (
'help|h' => \my $help, 'verbose|v' => \my $verbose,
);</lang>
Perl 6
Perl 5's @ARGV
is available as @*ARGS
. Alternatively, if you define a subroutine named MAIN
, Perl will automatically process @*ARGS
according to Unix conventions and MAIN
's signature (or signatures, if your MAIN
is a multi sub) and then call MAIN
with appropriate arguments; see Synopsis 6 or [1].
<lang perl6># with arguments supplied $ perl6 -e 'sub MAIN($x, $y) { say $x + $y }' 3 5 8
- missing argument:
$ perl6 -e 'sub MAIN($x, $y) { say $x + $y }' 3 Usage: -e '...' x y</lang>
If the program is stored in a file, the file name is printed instead of -e '...'
.
Phix
<lang Phix>constant cmd = command_line() ?cmd if cmd[1]=cmd[2] then
printf(1,"Compiled executable name: %s\n",{cmd[1]})
else
printf(1,"Interpreted (using %s) source name: %s\n",cmd[1..2])
end if if length(cmd)>2 then
puts(1,"Command line arguments:\n") for i = 3 to length(cmd) do printf(1,"#%d : %s\n",{i,cmd[i]}) end for
end if</lang>
When interpreting, the first two elements returned by command_line() are {interpreter,source}.
When compiled, the first two elements are instead {executable,executable}, so the parameters (if any) are consistently the 3rd element onwards.
- Output:
C:\Program Files (x86)\Phix>p testcl -c "alpha beta" -h "gamma" {"C:\\Program Files (x86)\\Phix\\p.exe","C:\\Program Files (x86)\\Phix\\testcl.exw","-c","alpha beta","-h","gamma"} Interpreted (using C:\Program Files (x86)\Phix\p.exe) source name: C:\Program Files (x86)\Phix\testcl.exw Command line arguments: #3 : -c #4 : alpha beta #5 : -h #6 : gamma C:\Program Files (x86)\Phix>p -c testcl -c "alpha beta" -h "gamma" {"C:\\Program Files (x86)\\Phix\\testcl.exe","C:\\Program Files (x86)\\Phix\\testcl.exe","-c","alpha beta","-h","gamma"} Compiled executable name: C:\Program Files (x86)\Phix\testcl.exe Command line arguments: #3 : -c #4 : alpha beta #5 : -h #6 : gamma C:\Program Files (x86)\Phix>testcl -c "alpha beta" -h "gamma" {"C:\\Program Files (x86)\\Phix\\testcl.exe","C:\\Program Files (x86)\\Phix\\testcl.exe","-c","alpha beta","-h","gamma"} Compiled executable name: C:\Program Files (x86)\Phix\testcl.exe Command line arguments: #3 : -c #4 : alpha beta #5 : -h #6 : gamma C:\Program Files (x86)\Phix>
PHP
When PHP is run from the command line, the special variables $argv and $argc contain the array of arguments, and the number of arguments, respectively. The program name is passed as the first argument.
<lang php><?php $program_name = $argv[0]; $second_arg = $argv[2]; $all_args_without_program_name = array_shift($argv); </lang>
PicoLisp
There are three ways to handle command-line arguments in PicoLisp:
1. Obtain all arguments as a list of strings via 'argv'
2. Fetch each argument individually with 'opt'
3. Use the built-in command-line interpretation, where arguments starting with a hyphen are executed as functions.
Here we use the third option, as it is not so obvious, sometimes more flexible, and in fact the most commonly used one for application development.
We define 'c' and 'h' as functions, which retrieve their argument with 'opt', and then 'load' all remaining command line arguments. <lang PicoLisp>#!/usr/bin/picolisp /usr/lib/picolisp/lib.l
(de c ()
(prinl "Got 'c': " (opt)) )
(de h ()
(prinl "Got 'h': " (opt)) )
(load T) (bye)</lang> Output:
$ ./myprogram -c "alpha beta" -h "gamma" Got 'c': alpha beta Got 'h': gamma
PL/I
<lang pli> /* The entire command line except the command word itself is passed */ /* to the parameter variable in PL/I. */ program: procedure (command_line) options (main);
declare command_line character (100) varying;
...
end program; </lang>
Pop11
variable poparglist contains list of command line arguments (as strings). One can use iteration over list to process then (for example print).
<lang pop11>lvars arg; for arg in poparglist do
printf(arg, '->%s<-\n');
endfor;</lang>
PowerBASIC
For versions of PowerBASIC prior to PB/Win 9 and PB/CC 5, the only option available is identical to the one used by QuickBASIC above: <lang powerbasic>? "args: '"; COMMAND$; "'"</lang>
Current versions of PowerBASIC (with the likely exception of PB/DOS) include COMMAND$()
that works similarly to FreeBASIC's COMMAND$()
, except that you can't retrieve the application's name:
<lang powerbasic>'these two both return ALL args
? COMMAND$
? COMMAND$(0)
DO WHILE(LEN(COMMAND$(i)))
PRINT "The argument "; i; " is "; COMMAND$(i) i = i + 1
LOOP</lang>
PowerShell
In PowerShell the arguments to a script can be accessed with the $args
array:
<lang powershell>$i = 0
foreach ($s in $args) {
Write-Host Argument (++$i) is $s
}</lang>
Pure
Arguments are in global variables, argc and argv.
<lang pure> using system;
printf "There are %d command line argumants\n" argc; puts "They are " $$ map (puts) argv; </lang>
PureBasic
Reading all parameters
You can easily read all parameters by using ProgramParameter() without argument. <lang PureBasic>If OpenConsole()
Define n=CountProgramParameters() PrintN("Reading all parameters") While n PrintN(ProgramParameter()) n-1 Wend Print(#CRLF$+"Press Enter") Input() CloseConsole()
EndIf</lang>
Reading specific parameters
You can specify which parameter 'n' to read. <lang PureBasic>If OpenConsole()
Define n PrintN("Reading specific pameters") For n=0 To CountProgramParameters() PrintN(ProgramParameter(n)) Next Print(#CRLF$+"Press Enter") Input() CloseConsole()
EndIf</lang>
Python
sys.argv is a list containing all command line arguments, including the program name. Typically you slice the list to access the actual command line argument:
<lang python>import sys program_name = sys.argv[0] arguments = sys.argv[1:] count = len(arguments)</lang>
When running a module by invoking Python, the Python interpreter processes and removes some of the arguments, and the module cannot access them. To process command line arguments, run the module directly. sys.argv is a copy of the command line arguments; modifying sys.argv will not change the arguments seen by other processes, e.g. ps. (In other words sys.argv is an object which contains a copy of the process' command line arguments ... modifying that copy is only visible from within the Python program and not externally).
For powerful option parsing capabilities check out the optparse module.
R
Following adapted from this post by Forester:
Suppose you want to call your script test.r with the arguments a=1 b=c(2,5,6), where b is a numeric vector. Suppose you also want to redirect your output to test.out (not that you have a choice--I still don't know how to make R send shell-script output to stdout). You would then run
<lang R>R CMD BATCH --vanilla --slave '--args a=1 b=c(2,5,6)' test.r test.out</lang>
from the commandline, with the following text in test.r:
<lang R># Read the commandline arguments args <- (commandArgs(TRUE))
- args is now a list of character vectors
- First check to see if any arguments were passed,
- then evaluate each argument.
if (length(args)==0) {
print("No arguments supplied.") # Supply default values a <- 1 b <- c(1,1,1)
} else {
for (i in 1:length(args)) { eval(parse(text=argsi)) }
} print(a*2) print(b*3)</lang>
(possibly preceding code that actually does something :-) Your output test.out would then contain (e.g., if you cat it)
[1] 2 [1] 6 15 18 > proc.time() user system elapsed 0.168 0.026 0.178
If you know how to get the output
- sent to stdout (i.e., as is normal with shell scripts)
- done without the profiling
please update this example!
Racket
The following is the simplest program that prints the command-line arguments:
<lang scheme>#lang racket (current-command-line-arguments)</lang>
You can also explicitly print each argument to standard output:
<lang scheme>#lang racket
(for ([arg (current-command-line-arguments)]) (displayln arg))</lang>
RapidQ
<lang rapidq>PRINT "This program is named "; Command$(0) FOR i=1 TO CommandCount
PRINT "The argument "; i; " is "; Command$(i)
NEXT i</lang>
Raven
<lang raven>ARGS print
stack (6 items)
0 => "raven" 1 => "myprogram" 2 => "-c" 3 => "alpha beta" 4 => "-h" 5 => "gamma"</lang>
REALbasic
<lang vb>Function Run(args() as String) As Integer
For each arg As String In args Stdout.WriteLine(arg) Next
End Function</lang> Output (given arguments: --foo !bar "bat bang"):
appName.exe --foo !bar bat bang
REXX
The entire command line is passed by REXX to the program. <lang rexx>say 'command arguments:' say arg(1)</lang> Input:
myprogram -c "alpha beta" -b "gamma"
However, the the example shown, it's suggestted that (maybe) only options that start with a minus (-) are to be examined and assumed to be options. <lang rexx>parse arg aaa /*get the arguments. */
/*another version: */ /* aaa=arg(1) */
say 'command arguments:' say aaa
opts= /*placeholder for options. */ data= /*placeholder for data. */
do j=1 to words(aaa) x=word(aaa,j) if left(x,1)=='-' then opts=opts x /*Option? Then add to opts.*/ else data=data x /*Must be data. Add to data.*/ end
/*the above process adds a leading blank to OPTS and DATA*/
opts=strip(opts,'L') /*strip leading blanks. */ data=strip(data,'l') /*strip leading blanks. */ say say 'options='opts say ' data='data</lang>
Notes to users of Microsoft Windows
Note that some REXX pass the command line as is, but Regina REXX lets the operating system parse it first (for instance Windows), and Windows will pass anything in inside double quotes (") to the program as is. Any other data not in double quotes is passed as is.
Output from Regina REXX under Windows with the invocation:
myprogram -c "alpha beta" -h "gamma"
command arguments: -c alpha beta -h gamma options=-c -h data=alpha beta gamma
Output from others REXXes under Windows with the invocation:
myprogram -c "alpha beta" -h "gamma"
command arguments: -c "alpha beta" -h "gamma" options=-c -h data="alpha beta" "gamma"
Notes to Unix users
The rexx programming language does not preserve command line parameters containing spaces. This renders it unsuitable for use for wrapperscript applications, where filenames containing spaces need to be preserved, because there is no way to differentiate between a space within a parameter, and a space used to separate parameters.
Scenario
If a script is called as follows:
ccwrapper "foo bar.c" "bar bar.c"
From the shell:
argv[0] = ccwrapper argv[1] = foo bar.c argv[2] = bar bar.c
It is a requirement of a wrapper that !argv[1] and !argv[2] are preserved when passed to the target application (a C compiler, in this example). Current implementations of rexx treat the command line arguments as one long argument:
arg() = 1 arg(1) = "foo bar.c bar bar.c"
The [parser] would separates the command line arguments by spaces. this results in !argv[1] and !argv[2] becoming split, so the target application would be called with different arguments:
argv[1] = foo argv[2] = bar.c argv[3] = bar argv[4] = bar.c
This has a different meaning to the compiler, so the arguments forwarded from rexx are rendered useless.
Workaround
A workaround would be to create a wrapper around the rexx interpreter that encodes the commandline before calling rexx. The rexx application then decodes it. Some rexx interpreters, such as regina also provide a !-a switch as a workaround.
Ruby
Command line arguments are available in the constant Object::ARGV.
myprog: <lang ruby>#! /usr/bin/env ruby p ARGV</lang>
myprog a -h b c => ["a","-h","b","c"]
Rust
<lang rust>use std::env;
fn main(){
let args: Vec<_> = env::args().collect(); println!("{:?}", args);
}</lang> Run: <lang>./program -c "alpha beta" -h "gamma" ["./program", "-c", "alpha beta", "-h", "gamma"]</lang>
Sather
<lang sather>class MAIN is
main(args:ARRAY{STR}) is loop #OUT + args.elt! + "\n"; end; end;
end;</lang>
As in C (and others), the first element is the command itself (exactly as it is written in the command line and after shell variable expansion); e.g.
$ /home/home/rosetta/sather/a.out arg1 arg2 arg3
prints
/home/home/rosetta/sather/a.out arg1 arg2 arg3
Scala
Calling Scala from command line means invoking a method called main
, defined on an
object
, whose type is (Array[String]):Unit
, meaning it receives an
array of strings, and returns unit. That array contains the command line arguments.
<lang scala>object CommandLineArguments extends App {
println(s"Received the following arguments: + ${args.mkString("", ", ", ".")}")
}</lang>
When running a Scala script, where the whole body is executed, the arguments get stored in an array of strings called argv
:
<lang scala>println(s"Received the following arguments: + ${argv.mkString("", ", ", ".")}")</lang>
Scheme
<lang scheme> (define (main args)
(for-each (lambda (arg) (display arg) (newline)) args))</lang>
Seed7
<lang seed7>$ include "seed7_05.s7i";
const proc: main is func
local var integer: i is 0; begin writeln("This program is named " <& name(PROGRAM) <& "."); for i range 1 to length(argv(PROGRAM)) do writeln("The argument #" <& i <& " is " <& argv(PROGRAM)[i]); end for; end func;</lang>
Sidef
Command line arguments are available in the ARGV array. <lang ruby>say ARGV.dump;</lang>
- Output:
% myprog -c "alpha beta" -h "gamma" ['-c', 'alpha beta', '-h', 'gamma']
Slate
<lang slate>StartupArguments do: [| :arg | inform: arg]</lang>
Smalltalk
<lang smalltalk>(1 to: Smalltalk getArgc) do: [ :i |
(Smalltalk getArgv: i) displayNl
]</lang>
<lang smalltalk>Smalltalk commandLineArguments printCR</lang>
Standard ML
<lang sml>print ("This program is named " ^ CommandLine.name () ^ ".\n"); val args = CommandLine.arguments (); Array.appi
(fn (i, x) => print ("the argument #" ^ Int.toString (i+1) ^ " is " ^ x ^ "\n")) (Array.fromList args);</lang>
Swift
<lang swift>let args = Process.arguments println("This program is named \(args[0]).") println("There are \(args.count-1) arguments.") for i in 1..<args.count {
println("the argument #\(i) is \(args[i])")
}</lang>
Alternately:
<lang swift>println("This program is named \(String.fromCString(Process.unsafeArgv[0])!).") println("There are \(Process.argc-1) arguments.") for i in 1 ..< Int(Process.argc) {
println("the argument #\(i) is \(String.fromCString(Process.unsafeArgv[i])!)")
}</lang>
<lang swift>println("This program is named \(String.fromCString(C_ARGV[0])!).") println("There are \(C_ARGC-1) arguments.") for i in 1 ..< Int(C_ARGC) {
println("the argument #\(i) is \(String.fromCString(C_ARGV[i])!)")
}</lang>
Tcl
The predefined global variable argc contains the number of arguments passed to the program after the script being executed, argv contains those arguments as a list. (The name of the script is in the argv0 global variable, and the name of the executable interpreter itself is returned by the command info nameofexecutable
.) Retrieving the second argument might look something like this:
<lang tcl>if { $argc > 1 } {
puts [lindex $argv 1]
}</lang>
(Tcl counts from zero, thus [lindex $list 1] retrieves the second item in the list)
Toka
Arguments are stored into an array. The first element in the array is the name of the program, the rest are the arguments in order. The number of arguments is provided by #args.
<lang toka>[ arglist array.get type cr ] is show-arg [ dup . char: = emit space ] is #= 1 #args [ i #= show-arg ] countedLoop</lang>
TXR
Command line arguments in TXR's pattern-based extraction language can be treated as the lines of a text stream, which is arranged using the directive @(next :args)
. Thus TXR's text parsing capabilities work over the argument list.
This @(next :args)
should be written as the first line of the TXR program, because TXR otherwise interprets the first argument as the name of an input file to open.
<lang txr>@(next :args) @(collect) @arg @(end) @(output) My args are: {@(rep)@arg, @(last)@arg@(end)} @(end)</lang>
$ ./txr args.txr My args are: {} $ ./txr args.txr 1 My args are: {1} $ ./txr args.txr 1 2 3 My args are: {1, 2, 3}
Arguments are also available via two predefined variables: *full-args*
and *args*
, which are lists of strings, such that *args*
is a suffic of *full-args*
. *full-args*
includes the arguments that were processed by TXR itself; *args*
omits them.
Here is an example program which requires exactly three arguments. Note how ldiff
is used to compute the arguments that are processed by TXR (the interpreter name, any special arguments and script name), to print an accurate usage message.
<lang txr>@(do
(tree-case *args* ((a b c) (put-line "got three args, thanks!")) (else (put-line `usage: @(ldiff *full-args* *args*) <arg1> <arg2> <arg3>`))))</lang>
- Output:
$ txr command-line-args.txr 1 2 usage: txr command-line-args.txr <arg1> <arg2> <arg3> $ txr command-line-args.txr 1 2 3 4 usage: txr command-line-args.txr <arg1> <arg2> <arg3> $ txr command-line-args.txr 1 2 3 got three args, thanks!
UNIX Shell
Bourne Shell
To retrieve the entire list of arguments: <lang bash>WHOLELIST="$@"</lang> To retrieve the second and fifth arguments: <lang bash>SECOND=$2 FIFTH=$5</lang>
Ursala
Command line arguments are accessible to an application through a data structure initialized by the run-time system. This example application does nothing but display the data structure on standard output. <lang Ursala>#import std
- executable ('parameterized',)
clarg = <.file$[contents: --<>+ _option%LP]>+ ~command.options</lang> Here is a bash terminal session.
$ clarg -c alpha,beta -h gamma --foo=bar,baz < option[ keyword: 'c', parameters: <'alpha','beta'>], option[ position: 1, keyword: 'h', parameters: <'gamma'>], option[ position: 2, longform: true, keyword: 'foo', parameters: <'bar','baz'>]>
V
The arguments to the program are stored in the stack,
args.v <lang v>$stack puts
./args.v a b c =[args.v a b c]</lang>
Visual Basic
Like Qbasic, Visual Basic returns all of the args in the built-in variable Command$
:
<lang vb>Sub Main
MsgBox Command$
End Sub</lang>
Visual Basic .NET
This syntax will tokenize the command line arguments. Tokens are normally delimited by spaces, but spaces can be part of a token if surrounded by quotes.
<lang vbnet>Sub Main(ByVal args As String())
For Each token In args Console.WriteLine(token) Next
End Sub</lang>
zkl
File myprogram.zkl: <lang zkl>System.argv.println(); vm.arglist.println();</lang> zkl myprogram -c "alpha beta" -h "gamma"
- Output:
L("/home/craigd/Projects/ZKL/Bin/zkl","myprogram","-c","alpha beta","-h","gamma") L("-c","alpha beta","-h","gamma")
- Programming Tasks
- Solutions by Programming Task
- Selection/Short Circuit/Console Program Basics
- Basic language learning
- Programming environment operations
- Initialization
- Ada
- Aikido
- Aime
- ALGOL 68
- AppleScript
- AutoHotkey
- AWK
- BASIC
- Batch File
- BBC BASIC
- Bracmat
- C
- C++
- C sharp
- Clean
- Clojure
- COBOL
- CoffeeScript
- Common Lisp
- D
- DCL
- Déjà Vu
- Delphi
- E
- Eiffel
- Emacs Lisp
- Erlang
- Euphoria
- F Sharp
- Factor
- Fancy
- Fantom
- Forth
- Fortran
- Frink
- FunL
- Gambas
- Go
- Groovy
- Harbour
- Haskell
- HicEst
- Icon
- Unicon
- Icon Programming Library
- Io
- Ioke
- J
- Java
- JavaScript
- Julia
- Lasso
- LFE
- Liberty BASIC
- Logo
- LSE64
- Lua
- Mathematica
- Mercury
- MMIX
- Modula-2
- Modula-3
- Nemerle
- NetRexx
- Nim
- Objeck
- Objective-C
- OCaml
- Oforth
- Oz
- Pascal
- Perl
- Perl 6
- Phix
- PHP
- PicoLisp
- PL/I
- Pop11
- PowerBASIC
- PowerShell
- Pure
- PureBasic
- Python
- R
- Racket
- RapidQ
- Raven
- REALbasic
- REXX
- Ruby
- Rust
- Sather
- Scala
- Scheme
- Seed7
- Sidef
- Slate
- Smalltalk
- Standard ML
- Swift
- Tcl
- Toka
- TXR
- UNIX Shell
- Ursala
- V
- Visual Basic
- Visual Basic .NET
- Zkl
- Axe/Omit
- Brainf***/Omit
- Bc/Omit
- Dc/Omit
- GUISS/Omit
- Lotus 123 Macro Scripting/Omit
- M4/Omit
- Maxima/Omit
- Metafont/Omit
- MUMPS/Omit
- PARI/GP/Omit
- PostScript/Omit
- Retro/Omit
- TI-89 BASIC/Omit
- Vim Script/Omit
- ZX Spectrum Basic/Omit