Command-line arguments: Difference between revisions
no edit summary
No edit summary |
|||
(105 intermediate revisions by 59 users not shown) | |||
Line 8:
myprogram -c "alpha beta" -h "gamma"
=={{header|11l}}==
<code>:argv</code> is a list containing all command line arguments, including the program name.
<syntaxhighlight lang="11l">:start:
print(‘Program name: ’:argv[0])
print("Arguments:\n":argv[1..].join("\n"))</syntaxhighlight>
=={{header|8080 Assembly}}==
This program runs under CP/M. CP/M includes some very rudimentary argument parsing: it assumes that the
first two space-separated arguments are filenames. Apart from that you can get the raw command line, except
that all lowercase letters are made uppercase.
If you need any further parsing, the program needs to do that by itself, which led to many people not bothering.
(The CP/M assembler in particular is infamous for abusing the file extension to take arguments.) The following program shows
everything CP/M gives it.
<syntaxhighlight lang="8080asm">putch: equ 2 ; CP/M syscall to print character
puts: equ 9 ; CP/M syscall to print $-terminated string
arglen: equ 80h ; Length of argument
argmt: equ 81h ; Argument string
fcb1: equ 5Ch ; FCBs
fcb2: equ 6Ch
org 100h
;;; Print all argument(s) as given
lxi d,cmdln ; Print 'Command line: '
mvi c,puts
call 5
lda arglen ; Retrieve the length of the argument
lxi h,argmt ; Pointer to argument string
call plstr
;;; CP/M also assumes that the first two words on the command
;;; line are filenames, and prepares two FCBs with the filenames
;;; in them. If there are no filenames, they will be blank.
lxi d,file1 ; Print the first one
mvi c,puts
call 5
mvi a,11 ; Filenames are 8+3 characters long and padded with
lxi h,fcb1+1 ; spaces
call plstr
lxi d,file2 ; Print the second one
mvi c,puts
call 5
mvi a,11
lxi h,fcb2+1
; ... fall through - on small systems saving bytes is a virtue
;;; This subroutine prints a length-A string in HL.
plstr: ana a ; If A=0, print nothing.
rz
push psw ; Save A and HL registers on the stack
push h ; (CP/M syscalls clobber all registers)
mov e,m ; Print character under HL
mvi c,putch
call 5
pop h ; Restore A and HL registers
pop psw
inx h ; Increment string pointer
dcr a ; Decrement character counter
jnz plstr ; Print next character if not zero
ret
cmdln: db 'Command line: $'
file1: db 13,10,'File 1: $'
file2: db 13,10,'File 2: $'</syntaxhighlight>
{{out}}
<pre>A>args
A>args
Command line:
File 1:
File 2:
A>args -c "alpha beta" -h "gamma"
Command line: -C "ALPHA BETA" -H "GAMMA"
File 1: -C
File 2: "ALPHA
A>args foobar.baz barbaz.qux
Command line: FOOBAR.BAZ BARBAZ.QUX
File 1: FOOBAR BAZ
File 2: BARBAZ QUX
</pre>
=={{header|8086 Assembly}}==
The method for doing this depends on the memory model of your program. For a COM file, everything is contained in one segment, including the command line arguments. The program starts at offset 100h and the command line arguments start at 81h. It's as simple as reading from that memory address.
For an EXE file, both the <code>DS</code> and <code>ES</code> registers are set to the program segment prefix as soon as the program begins. You'll need to load from offset 81h to FFh to get the command line arguments.
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}
<syntaxhighlight lang AArch64 Assembly>
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program commandLine64.s */
/************************************/
/* Constantes */
/************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
/************************************/
/* Initialized data */
/************************************/
.data
szCarriageReturn: .asciz "\n"
/************************************/
/* UnInitialized data */
/************************************/
.bss
.align 4
/************************************/
/* code section */
/************************************/
.text
.global main
main: // entry of program
mov fp,sp // fp <- start address
ldr x4,[fp] // number of Command line arguments
add x5,fp,#8 // first parameter address
mov x2,#0 // init loop counter
1:
ldr x0,[x5,x2,lsl #3] // string address parameter
bl affichageMess // display string
ldr x0,qAdrszCarriageReturn
bl affichageMess // display carriage return
add x2,x2,#1 // increment counter
cmp x2,x4 // number parameters ?
blt 1b // loop
100: // standard end of the program
mov x0, #0 // return code
mov x8,EXIT
svc 0 // perform the system call
qAdrszCarriageReturn: .quad szCarriageReturn
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeARM64.inc"
</syntaxhighlight>
{{Out}}
<pre>
~/.../rosetta/asm4 $ commandLine64 toto tutu
commandLine64
toto
tutu
</pre>
=={{header|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.
<
with Ada.Text_IO; use Ada.Text_IO;
Line 25 ⟶ 171:
end loop;
New_Line;
end Print_Commands;</
=== Alternative version using Matreshka ===
Line 31 ⟶ 177:
Uses [http://forge.ada-ru.org/matreshka Matreshka]
<
with League.Application;
Line 42 ⟶ 188:
(League.Application.Arguments.Element (J).To_Wide_Wide_String);
end loop;
end Main;</
=={{header|Aikido}}==
The arguments are passed to the program as a vector of strings called <em>args</em>
<
foreach arg in args {
Line 52 ⟶ 198:
}
</syntaxhighlight>
=={{header|Aime}}==
<
i = 0;
Line 62 ⟶ 208:
o_byte('\n');
i += 1;
}</
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386 - ''argc'' and ''argv'' are not part of the standard's prelude}}
<
FOR i TO argc DO
printf(($"the argument #"g(-0)" is "gl$, i, argv(i)))
OD
)</
Linux command:
/usr/bin/a68g Command-line_arguments.a68 - 1 2 3 ...
Line 82 ⟶ 228:
the argument #6 is 3
the argument #7 is ...
</pre>
=={{header|Amazing Hopper}}==
<p>The main function "main(argv,argc)" is a macro-defined in HOPPER.H: get the arguments, and put them into array ARGV; ARGC have total arguments.</p>
<p>Macro MAIN(ARGV, ARGC):</p>
<syntaxhighlight lang="amazing hopper">
#defn main(_V_,_N_) #RAND, main:, V#RNDV=1,_V_={#VOID}, \
_N_=0,totalarg,mov(_N_), \
LOOPGETARG_#RNDV:, {[ V#RNDV ]},push(_V_),++V#RNDV,\
{_N_,V#RNDV},jle(LOOPGETARG_#RNDV),clear(V#RNDV)
</syntaxhighlight>
VERSION 1:
<syntaxhighlight lang="amazing hopper">
#include <hopper.h>
main(argv, argc)
{"This program named: "},[1]get(argv),println
for(i=2, {i}lethan(argc),++i)
{"Argument #",i," = "}[i]get(argv),println
next
exit(0)
</syntaxhighlight>
VERSION 2:
<syntaxhighlight lang="amazing hopper">
#include <hopper.h>
main:
total arg, argc=0,mov(argc)
{"This program named: ",[&1]},println
i=2
__CNT_ARGS__:
{"Argumento #",i," = ",[&i]}println
++i,{argc,i}jle(__CNT_ARGS__)
exit(0)
</syntaxhighlight>
VERSION 3:
<syntaxhighlight lang="amazing hopper">
#include <hopper.h>
main(argv, argc)
i=2
#hl{
print( "This program named: ",argv[1],"\n")
while( i <= argc )
print("Argument #",i," = ",argv[i],"\n")
i += 1
wend
}
exit(0)
</syntaxhighlight>
VERSION 4:
<syntaxhighlight lang="amazing hopper">
#include <natural.h>
#include <hopper.h>
main:
get total arguments, and remember as 'total arguments'.
remember ("This program named: "),
now remember ( argument '1' ), and print with a new line.
secondly, declare 'i', take '2', and store in 'i'
do while ( variable 'i' is less or equal than 'total arguments', \
consider this ( {"Argument #",i," = "} );\
remember ( argument 'i' ); put a new line and print it; finally increment 'i' ).
exit(0)
</syntaxhighlight>
ETCETERA...
{{out}}
<pre>
xu@MrDalien:~/Proyectos/xuesp/HOPPER$ hopper src/args1.com 1 "Rosseta code" 100
This program named: src/args1.com
Argumento #2 = 1
Argumento #3 = Rosseta code
Argumento #4 = 100
</pre>
=={{header|AppleScript}}==
<
#!/usr/bin/env osascript
-- Print first argument
Line 92 ⟶ 310:
return (item 1 of argv)
end run
</syntaxhighlight>
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program commandLine.s */
/* Constantes */
.equ STDOUT, 1 @ Linux output console
.equ EXIT, 1 @ Linux syscall
.equ WRITE, 4 @ Linux syscall
/* Initialized data */
.data
szCarriageReturn: .asciz "\n"
/* UnInitialized data */
.bss
.align 4
/* code section */
.text
.global main
main: @ entry of program
push {fp,lr} @ saves registers
add fp,sp,#8 @ fp <- start address
ldr r4,[fp] @ number of Command line arguments
add r5,fp,#4 @ first parameter address
mov r2,#0 @ init loop counter
loop:
ldr r0,[r5,r2,lsl #2] @ string address parameter
bl affichageMess @ display string
ldr r0,iAdrszCarriageReturn
bl affichageMess @ display carriage return
add r2,#1 @ increment counter
cmp r2,r4 @ number parameters ?
blt loop @ loop
100: @ standard end of the program
mov r0, #0 @ return code
pop {fp,lr} @restaur registers
mov r7, #EXIT @ request to exit program
swi 0 @ perform the system call
iAdrszCarriageReturn: .int szCarriageReturn
/******************************************************************/
/* display text with size calculation */
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
push {r0,r1,r2,r7,lr} @ save registres
mov r2,#0 @ counter length
1: @ loop length calculation
ldrb r1,[r0,r2] @ read octet start position + index
cmp r1,#0 @ if 0 its over
addne r2,r2,#1 @ else add 1 in the length
bne 1b @ and loop
@ so here r2 contains the length of the message
mov r1,r0 @ address message in r1
mov r0,#STDOUT @ code to write to the standard output Linux
mov r7, #WRITE @ code call system "write"
svc #0 @ call systeme
pop {r0,r1,r2,r7,lr} @ restaur 2 registres
bx lr @ return
</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">loop arg 'a [
print a
]</syntaxhighlight>
=={{header|AutoHotkey}}==
From the AutoHotkey [http://www.autohotkey.com/docs/Scripts.htm 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). "
<
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\""</
=={{header|AWK}}==
<
BEGIN {
Line 113 ⟶ 403:
print "Argument " l " is " ARGV[l]
}
}</
=={{header|Babel}}==
Invoke Babel in interactive mode with arguments using the -i switch:
<syntaxhighlight lang
Print the argv list with newlines:
<syntaxhighlight lang
{{out}}
Line 133 ⟶ 422:
Print the argv list with spaces:
<syntaxhighlight lang
{{out}}
Line 140 ⟶ 429:
To access an individual argument, use the ith operator to select an element from the argv list; print with newline using say:
<syntaxhighlight lang
{{out}}
Line 151 ⟶ 440:
For most older BASICs that supply the keyword <code>COMMAND$</code>, 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.)
<
Sample output:
Line 160 ⟶ 449:
FreeBASIC supplies three ways to retrieve the arguments: <code>COMMAND$</code> (which works identically to QuickBASIC's <code>COMMAND$</code>), <code>COMMAND$()</code> (a string array which works like [[#C|C]]'s <code>argv[]</code>), and <code>__FB_ARGV__</code> (an array of pointers which works even more like C's <code>argv[]</code>) and __FB_ARGC__ (which works like C's <code>argc</code>).
<
PRINT COMMAND$
Line 173 ⟶ 462:
FOR i = 0 TO __FB_ARGC__ - 1
PRINT "arg "; i; " = '"; *__FB_ARGV__[i]; "'"
NEXT i</
Sample output:
Line 186 ⟶ 475:
arg 2 = '2'
arg 3 = '3'
==={{header|BaCon}}===
<syntaxhighlight lang="freebasic">' Command line arguments including program name
PRINT "Entire command line: ", ARGUMENT$
SPLIT ARGUMENT$ BY " " TO cli$ SIZE args
PRINT "Skip program name:";
FOR i = 1 TO args - 1
PRINT " " & cli$[i];
NEXT
PRINT</syntaxhighlight>
{{out}}
<pre>prompt$ bacon command-line.bac
Converting 'command-line.bac'... done, 9 lines were processed in 0.002 seconds.
Compiling 'command-line.bac'... cc -c command-line.bac.c
cc -o command-line command-line.bac.o -lbacon -lm
Done, program 'command-line' ready.
prompt$ ./command-line -c "alpha beta" -h "gamma"
Entire command line: ./command-line -c "alpha beta" -h gamma
Skip program name: -c "alpha beta" -h gamma</pre>
=={{header|Batch File}}==
{{works with|Windows NT|4 or later (includes Windows XP and onward)}}
<
setlocal enabledelayedexpansion
Line 203 ⟶ 514:
for /l %%a in (1,1,%count%) do (
echo !parameter[%%a]!
)</
Another way of doing it
<
@echo off
setlocal enabledelayedexpansion
Line 229 ⟶ 540:
for /l %%i in (1,1,%p#%) do (
echo p%%i=!p%%i!
)</
Invocation:
<
fn=d:\bin\args2.cmd
p0=args2
Line 241 ⟶ 552:
p2=bar baz
p3=quux
</syntaxhighlight>
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<syntaxhighlight lang
=={{header|Blue}}==
Linux/x86-64
<syntaxhighlight lang="blue">
global _start
: syscall ( num:eax -- result:eax | rcx ) syscall ;
: exit ( status:edi -- noret ) 60 syscall ;
: bye ( -- noret ) 0 exit ;
: die ( err:eax -- noret ) neg exit ;
: unwrap ( result:eax -- value:eax ) dup 0 cmp ' die xl ;
: ordie ( result -- ) unwrap drop ;
1 const stdout
: write ( buf:esi len:edx fd:edi -- ) 1 syscall ordie ;
: print ( buf len -- ) stdout write ;
: newline ( -- ) s" \n" print ;
: println ( buf len -- ) print newline ;
: find0 ( start:rsi -- end:rsi ) lodsb 0 cmp latest xne ;
: cstrlen ( str:rdi -- len:rsi ) dup find0 swap sub dec ;
: cstr>str ( cstr:rdx -- str:rsi len:rdx ) dup cstrlen xchg ;
: print-arg ( arg -- ) cstr>str println ;
: _start ( rsp -- noret ) dup @ swap
: print-args ( argc:rcx argv:rsp -- noret )
8 add @ print-arg latest loop
bye
;
</syntaxhighlight>
=={{header|BQN}}==
BQN has a system value for getting pre-parsed command line arguments.
<syntaxhighlight lang="text">•Show •args</syntaxhighlight>
should show the full list of args.
=={{header|Bracmat}}==
When Bracmat is started with one or more arguments, each argument is evaluated as if it were a Bracmat expression <i>unless</i> an argument (for example the first one) consumes the next argument(s) by calling <code>arg$</code>. Each invocation of <code>arg$</code> pops one argument from the remaining list of arguments. Calling <code>arg$</code> 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.
<syntaxhighlight lang="text">whl'(arg$:?a&out$(str$("next arg=" !a)))</
Now run Bracmat with this program as the first argument in a DOS environment:
<pre>bracmat "whl'(arg$:?a&out$(str$(\"next arg=\" !a)))" "a" /b -c 2+3 'd;' "out$(\"13+7=\" 13+7)"</pre>
Line 281 ⟶ 636:
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.
<
#include <stdio.h>
Line 291 ⟶ 646:
(void) printf("the argument #%d is %s\n", i, argv[i]);
return EXIT_SUCCESS;
}</
=={{header|C sharp|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.
<
namespace RosettaCode {
Line 321 ⟶ 659:
}
}
}</
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.
<
namespace RosettaCode {
Line 334 ⟶ 672:
}
}
}</
=={{header|C++}}==
Command line arguments are passed the same way as in C.
This example uses <code><iostream></code>. C-style i/o also works.
<syntaxhighlight lang="cpp">#include <iostream>
int main(int argc, const char* argv[]) {
std::cout << "This program is named " << argv[0] << '\n'
<< "There are " << argc - 1 << " arguments given.\n";
for (int i = 1; i < argc; ++i)
std::cout << "The argument #" << i << " is " << argv[i] << '\n';
}</syntaxhighlight>
=={{header|C3}}==
Command line arguments are passed to main and will be converted to UTF-8 strings on all platforms.
<syntaxhighlight lang="c3">import std::io;
fn void main(String[] args)
{
io::printfn("This program is named %s.", args[0]);
for (int i = 1; i < args.len; i++)
{
io::printfn("the argument #%d is %s\n", i, args[i]);
}
}</syntaxhighlight>
=={{header|Clean}}==
<tt>getCommandLine</tt> from the module <tt>ArgEnv</tt> returns an array of command-line arguments (the first element is the name of the program).
<
Start = getCommandLine</
=={{header|Clojure}}==
Line 347 ⟶ 715:
The value of ''*command-line-args*'' is a sequence of the supplied command line arguments, or ''nil'' if none were supplied.
<
=={{header|CLU}}==
While it is not part of the language standard as specified in the reference manual,
[[Portable CLU]] includes a library function <code>get_argv</code> which returns
all the arguments in order.
Note that unlike C, the program name itself is not included in the list of arguments.
<syntaxhighlight lang="clu">% This program needs to be merged with PCLU's "useful.lib",
% where get_argv lives.
%
% pclu -merge $CLUHOME/lib/useful.lib -compile cmdline.clu
start_up = proc ()
po: stream := stream$primary_output()
args: sequence[string] := get_argv()
for arg: string in sequence[string]$elements(args) do
stream$putl(po, "arg: " || arg)
end
end start_up</syntaxhighlight>
{{out}}
<pre>$ ./cmdline -c "alpha beta" -h "gamma"
arg: -c
arg: alpha beta
arg: -h
arg: gamma</pre>
=={{header|COBOL}}==
Line 356 ⟶ 753:
Getting the arguments in one go, exactly as they were passed in:
<
PROGRAM-ID. accept-all-args.
Line 369 ⟶ 766:
GOBACK
.</
Getting the arguments one at a time, with arguments being split by whitespace if not in quotes:
<
PROGRAM-ID. accept-args-one-at-a-time.
Line 388 ⟶ 785:
GOBACK
.</
Passing arguments from UNIX/Linux Systems to COBOL.
{{works with|OpenCOBOL}}
{{works with|gnuCOBOL}}
<syntaxhighlight lang="cobol">
*>Created By Zwiegnet 8/19/2004
IDENTIFICATION DIVISION.
PROGRAM-ID. arguments.
ENVIRONMENT DIVISION.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 command1 PIC X(50).
01 command2 PIC X(50).
01 command3 PIC X(50).
PROCEDURE DIVISION.
PERFORM GET-ARGS.
*> Display Usage for Failed Checks
ARGUSAGE.
display "Usage: <command1> <command2> <command3>"
STOP RUN.
*> Evaluate Arguments
GET-ARGS.
ACCEPT command1 FROM ARGUMENT-VALUE
IF command1 = SPACE OR LOW-VALUES THEN
PERFORM ARGUSAGE
ELSE
INSPECT command1 REPLACING ALL SPACES BY LOW-VALUES
ACCEPT command2 from ARGUMENT-VALUE
IF command2 = SPACE OR LOW-VALUES THEN
PERFORM ARGUSAGE
ELSE
INSPECT command2 REPLACING ALL SPACES BY LOW-VALUES
ACCEPT command3 from ARGUMENT-VALUE
IF command3 = SPACE OR LOW-VALUES THEN
PERFORM ARGUSAGE
ELSE
INSPECT command3 REPLACING ALL SPACES BY LOW-VALUES
*> Display Final Output
display command1 " " command2 " " command3
STOP RUN.
.</syntaxhighlight>
=={{header|CoffeeScript}}==
{{works with|Node.js}}
<
console.log arg for arg in process.argv
</syntaxhighlight>
=={{header|Common Lisp}}==
Line 402 ⟶ 861:
The following function could be used to create a uniform way to access the arguments:
<
(or
#+clisp (ext:argv)
Line 413 ⟶ 872:
#+allegro (sys:command-line-arguments)
#+lispworks sys:*line-arguments-list*
nil))</
=={{header|Cowgol}}==
Cowgol includes a function to retrieve command-line arguments in its standard library.
The manner in which arguments are parsed is, however, dependent on the operating system.
<syntaxhighlight lang="cowgol">include "cowgol.coh";
include "argv.coh";
ArgvInit();
var i: uint8 := 0;
loop
var arg := ArgvNext();
if arg == 0 as [uint8] then break; end if;
i := i + 1;
print_i8(i);
print(": '");
print(arg);
print("'\n");
end loop;</syntaxhighlight>
{{out}}
On Linux:
<pre>$ ./args -c "alpha beta" -h "gamma"
1: '-c'
2: 'alpha beta'
3: '-h'
4: 'gamma'</pre>
On CP/M:
<pre>A>args -c "alpha beta" -h "gamma"
1: '-C'
2: '"ALPHA'
3: 'BETA"'
4: '-H'
5: '"GAMMA"'</pre>
=={{header|D}}==
<
import std.stdio;
foreach (immutable i, arg; args[1 .. $])
writefln("#%2d : %s", i + 1, arg);
}</
=={{header|Dart}}==
<syntaxhighlight lang="csharp">main(List<String> args) {
for(var arg in args)
print(arg);
}</syntaxhighlight>
=={{header|DCL}}==
case is not preserved unless the parameter is in quotes
<
$ loop:
$ write sys$output "the value of P''i' is ", p'i
$ i = i + 1
$ if i .le. 8 then $ goto loop</
{{out}}
<pre>$ @command_line_arguments -c "alpha beta" -h "gamma"
Line 439 ⟶ 941:
the value of P7 is
the value of P8 is</pre>
=={{header|Delphi}}==
<syntaxhighlight 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
</syntaxhighlight>
=={{header|Déjà Vu}}==
Command line arguments are found in <code>!args</code> and <code>!opts</code>.
<
print\( "Argument #" i " is " )
. get-from !args i
Line 451 ⟶ 970:
if has !opts :four:
!. get-from !opts :four</
{{out}}
<pre>$ vu args-3.deja one two -c three --four=five
Line 463 ⟶ 982:
The order of command line ''options'' is lost.
=={{header|
Draco comes with a library function that will return each command line argument
in turn. It simply splits the command line on whitespace, and does not support
quotes.
In the example below, the arguments are additionally all made uppercase.
This is however a limitation of the CP/M operating system, and not of Draco.
<syntaxhighlight lang="draco">\util.g
proc nonrec main() void:
*char par;
word i;
i := 0;
while par := GetPar(); par ~= nil do
i := i + 1;
writeln(i:3, ": '", par, "'")
od
corp</syntaxhighlight>
{{out}}
2: '"ALPHA'
3: 'BETA"'
4: '-H'
5: '"GAMMA"'</pre>
=={{header|E}}==
<syntaxhighlight lang
=={{header|Eiffel}}==
Line 488 ⟶ 1,019:
This class inherits functionality for dealing with command line arguments from class <code lang="eiffel">ARGUMENTS</code>. It uses the feature <code lang="eiffel">separate_character_option_value</code> to return the values by option name for each of the two arguments.
<
APPLICATION
inherit
Line 504 ⟶ 1,035:
io.read_line -- Keep console window open
end
end</
Output (for command line arguments: -c "alpha beta" -h "gamma"):
Line 513 ⟶ 1,044:
=={{header|Elena}}==
ELENA 6.x :
{
program_arguments.forEvery::(int i)
}</syntaxhighlight>
{{out}}
<pre>
Argument 0 is myprogram.exe
Argument 1 is -c
Argument 2 is alpha beta
Argument 3 is -h
Argument 4 is gamma
</pre>
=={{header|Elixir}}==
Elixir provides command line arguments via the <tt>System.argv()</tt> function.
<
IO.puts 'Arguments:'
Enum.map(System.argv(),&IO.puts(&1))</
Example run:
<
Arguments:
a
b=2
--3
-4</
=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">(while argv
(message "Argument: %S" (pop argv)))</syntaxhighlight>
Invoke script:
emacs --script test.el foo bar baz
=={{header|Erlang}}==
When used as a script language the arguments is a list to the main/1 function. When compiled use init:get_arguments/0
<syntaxhighlight lang
result
<
{progname,["erl"]},
{home,["/home/me"]},
{c,["alpha beta"]},
{h,["gamma"]}]</
init:get_argument(name) can be used to fetch value of a particular flag
<
{ok,[["gamma"]]}
5> init:get_argument(c).
{ok,[["alpha beta"]]}</
=={{header|Euphoria}}==
<
printf(1,"Interpreter/executable name: %s\n",{cmd[1]})
printf(1,"Program file name: %s\n",{cmd[2]})
Line 569 ⟶ 1,110:
printf(1,"#%d : %s\n",{i,cmd[i]})
end for
end if</
=={{header|F_Sharp|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.
<
[<EntryPoint>]
let main args =
Array.iter (fun x -> printfn "%s" x) args
0</
=={{header|Factor}}==
USING: io sequences command-line ;
Line 583 ⟶ 1,125:
=={{header|Fancy}}==
<
a println # print each given command line argument
}</
=={{header|Fantom}}==
<
class Main
{
Line 597 ⟶ 1,139:
}
}
</syntaxhighlight>
=={{header|Forth}}==
Line 603 ⟶ 1,145:
{{works with|gforth|0.6.2}}
<
: main
argc @ 0 do i arg type cr loop ;
main bye</
Here is output from a sample run.
<
gforth
args.f
Line 616 ⟶ 1,158:
beta gamma
delta
$</
=={{header|Fortran}}==
{{works with|Fortran|2003 and later}}
<
implicit none
Line 635 ⟶ 1,178:
end program command_line_arguments
</syntaxhighlight>
Note: This sample uses the Fortran 2003 intrinsic routines <code>command_argument_count</code> and <code>get_command_argument</code> instead of the nonstandard extensions <code>iargc</code> and <code>getarg</code>. Most Fortran compilers support both.
Sample usage:
<syntaxhighlight lang="text">> ./a.out -c "alpha beta" -h "gamma"
./a.out
-c
alpha beta
-h
gamma</
=={{header|FreeBASIC}}==
<
' Program (myprogram.exe) invoke as follows:
Line 655 ⟶ 1,198:
Print
Print "Press any key to quit"
Sleep</
{{out}}
Line 664 ⟶ 1,207:
=={{header|Frink}}==
Arguments to a program are available in the <CODE>ARGS</CODE> array variable.
<
println[ARGS]
</syntaxhighlight>
=={{header|FunL}}==
<syntaxhighlight lang
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=a1374aa441520314ad0c7decb1e91c97 Click this link to run this code]'''
<
DIM l AS Integer
DIM numparms AS Integer
Line 682 ⟶ 1,225:
PRINT l; " : "; parm
NEXT
END
=={{header|Genie}}==
<syntaxhighlight lang="genie">[indent=4]
/*
Command line arguments, in Genie
valac commandLine.gs
./commandLine sample arguments 'four in total here, including args 0'
*/
init
// Output the number of arguments
print "%d command line argument(s):", args.length
// Enumerate all command line arguments
for s in args
print s
// to reiterate, args[0] is the command
if args[0] is not null
print "\nWith Genie, args[0] is the command: %s", args[0]</syntaxhighlight>
{{out}}
<pre>prompt$ valac commandLine.gs
prompt$ ./commandLine -c "alpha beta" -h "gamma"
5 command line argument(s):
./commandLine
-c
alpha beta
-h
gamma
With Genie, args[0] is the command: ./commandLine</pre>
=={{header|Global Script}}==
Command-line arguments are passed to the main program as a linked list of strings (which are also linked lists).
This uses the <code>gsio</code> I/O operations, which are designed to be simple to implement on top of Haskell and simple to use. It also uses impmapM, which is a specific specialization of mapM for the HSGS implementation.
<syntaxhighlight lang="global script">λ 'as. impmapM (λ 'a. print qq{Argument: §(a)\n}) as</syntaxhighlight>
=={{header|Go}}==
<syntaxhighlight lang
package main
import (
)
func main() {
fmt.Printf("the argument #%d is %s\n", i, x)
}
}
</syntaxhighlight>
=={{header|Groovy}}==
Command-line arguments are accessible via the '''args''' list variable. The following is saved as the file "Echo.groovy":
<syntaxhighlight 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:
Line 716 ⟶ 1,298:
=={{header|Harbour}}==
Uses the Harbour-specific hb_PValue() function
<
LOCAL i
Line 724 ⟶ 1,306:
NEXT
RETURN</
=={{header|Haskell}}==
Line 731 ⟶ 1,313:
myprog.hs:
<
main = getArgs >>= print</
<pre>
myprog a -h b c
Line 739 ⟶ 1,321:
=={{header|HicEst}}==
<
EDIT(Text=$CMD_LINE, SePaRators='-"', ITeM=i, IF ' ', EXit, ENDIF, Parse=cmd, GetPosition=position)
IF(position > 0) WRITE(Messagebox) cmd
ENDDO</
=={{header|Icon}} and {{header|Unicon}}==
Command line parameters are passed to Icon/Unicon programs as a list of strings.
<
every write(!arglist)
end</
{{libheader|Icon Programming Library}} includes [http://www.cs.arizona.edu/icon/library/procs/options.htm options] that parses the command line as switches and arguments and returns the results in a table.
=={{header|Io}}==
<
=={{header|Ioke}}==
<syntaxhighlight lang
=={{header|J}}==
Line 762 ⟶ 1,344:
The global <code>ARGV</code> holds the command line arguments. Thus, a program to display them:
<syntaxhighlight lang
In a non-interactive context, we would instead use <code>echo ARGV</code>.
=={{header|Jakt}}==
The main function can recieve the command line arguments as an arbitrarily named array of String. argv[0] will be the name of the program.
<syntaxhighlight lang="jakt">
fn main(arguments: [String]) {
println("{}", arguments)
}
</syntaxhighlight>
=={{header|Java}}==
The arguments will be passed to <code>main</code> as the only parameter.<br />
The array is non-null.
<syntaxhighlight lang="java">
public static void main(String[] args)
</syntaxhighlight>
Running this command
<syntaxhighlight lang="bash">
myprogram -c "alpha beta" -h "gamma"
</syntaxhighlight>
Will produce the following
<pre>
-c
alpha beta
-h
gamma
</pre>
<br />
And alternate demonstration.
<syntaxhighlight lang="java">public class Arguments {
public static void main(String[] args) {
System.out.println("There are " + args.length + " arguments given.");
Line 772 ⟶ 1,382:
System.out.println("The argument #" + (i+1) + " is " + args[i] + " and is at index " + i);
}
}</
For more sophisticated command-line option and option-argument parsing use the [http://commons.apache.org/cli '''Apache Commons CLI'''] (command-line interface) library.
=={{header|JavaScript}}==
{{works with|Node.js}}
<syntaxhighlight lang="javascript">process.argv.forEach((val, index) => {
console.log(`${index}: ${val}`);
});</syntaxhighlight>
{{works with|JScript}}
<
for (var i = 0; i < objArgs.length; i++)
WScript.Echo(objArgs.Item(i));</
{{works with|JScript.NET (compiled with jsc.exe)}}
<
var argv:String[] = Environment.GetCommandLineArgs();
for (var i in argv)
print(argv[i]);</
{{works with|Rhino}}
{{works with|SpiderMonkey}}
<
print(arguments[i]);</
=={{header|Joy}}==
<syntaxhighlight lang="joy">#!/usr/bin/joy
argv rest put.</syntaxhighlight>
{{out}}
<pre>["-c" "alpha beta" "-h" "gamma"]</pre>
=={{header|jq}}==
{{works with|jq|after February 17, 2017}}
<br/>
jq distinguishes between command-line arguments and command-line options.
Only the former are available programmatically.
Specifically, both named and positional command-line arguments are available in the
global constant '''$ARGS''', a JSON object, as follows:
$ARGS.positional contains an array of the positional arguments as JSON strings
$ARGS.names is a JSON object of giving the mapping of name to value.
For example, the invocation:
$ jq -n '$ARGS' --args a b
yields:<syntaxhighlight lang="json">{
"positional": [
"a",
"b"
],
"named": {}
}</syntaxhighlight>
Arguments specified with ''--args'' are always read as JSON strings; arguments specified with ''--jsonargs''
are interpreted as JSON, as illustrated here:
<pre>
$ jq -n '$ARGS' --argjson x 0 --jsonargs 0 '{"a":1}'
{
"positional": [
0,
{
"a": 1
}
],
"named": {
"x": 0
}
}</pre>
=={{header|Jsish}}==
<syntaxhighlight lang="javascript">#!/usr/local/bin/jsish
puts(Info.argv0());
puts(console.args);</syntaxhighlight>
{{out}}
<pre>$ jsish command-line-arguments.jsi -c "alpha beta" -h "gamma"
/home/btiffin/lang/jsish/command-line-arguments.jsi
[ "-c", "alpha beta", "-h", "gamma" ]</pre>
=={{header|Julia}}==
Works when the Julia program is run as a file argument to julia.exe.
<syntaxhighlight lang="julia">using Printf
prog = Base.basename(Base.source_path())
println(prog, "'s command-line arguments are:")
Line 799 ⟶ 1,473:
println(" ", s)
end
</syntaxhighlight>
{{out}}
Line 810 ⟶ 1,484:
gamma
</pre>
=={{header|Klong}}==
Command line arguments (but not the program name itself) are bound
to the variable ".a". The following program prints them, one argument
per line:
<syntaxhighlight lang="k">
.p'.a
</syntaxhighlight>
=={{header|Kotlin}}==
{{trans|Java}}
<
println("There are " + args.size + " arguments given.")
args.forEachIndexed { i, a -> println("The argument #${i+1} is $a and is at index $i") }
}</
{{out}}
See Java output.
=={{header|Lang}}==
In lang command line arguments are stored in &LANG_ARGS.
<syntaxhighlight lang="lang">
$ele
foreach($[ele], &LANG_ARGS) {
fn.println($ele)
}
</syntaxhighlight>
Calling a Lang program with command line arguments depends on the implementation.
The following example shows, how this can be achieved in Standard Lang (-- defines the start of the command line arguments for the Lang program):
<syntaxhighlight lang="shell">
$ lang cmdarg.lang -- 2 abc test text
</syntaxhighlight>
{{out}}
<pre>
2
abc
test
text
</pre>
=={{header|Lasso}}==
<
iterate($argv) => {
stdoutnl("Argument " + loop_count + ": " + loop_value)
}</
Output:
<
Argument 1: arguments.lasso
Argument 2: -c
Argument 3: alpha beta
Argument 4: -h
Argument 5: gamma</
=={{header|LFE}}==
To demonstrate this, we can start the LFE REPL up with the parameters for this example:
<
$ ./bin/lfe -pa ebin/ -c "alpha beta" -h "gamma"
</syntaxhighlight>
Once we're in the shell, we can get all the initializing arguments with this call:
<
> (: init get_arguments)
(#(root ("/opt/erlang/r15b03"))
Line 851 ⟶ 1,555:
#(c ("alpha beta"))
#(h ("gamma")))
</syntaxhighlight>
We can also get specific arguments if we know their keys:
<
> (: init get_argument 'c)
#(ok (("alpha beta")))
> (: init get_argument 'h)
#(ok (("gamma")))
</syntaxhighlight>
=={{header|Liberty BASIC}}==
<syntaxhighlight lang
=={{header|Lingo}}==
<
-- "-c alpha beta -h gamma"</
In latest versions of Mac OS X, the above approach doesn't work anymore. But there is a free "Xtra" (binary plugin/shared library) called "CommandLine Xtra" that works both in Windows and Mac OS X and returns the command-line parsed into a lingo list (array):
{{libheader|CommandLine Xtra}}
<
-- ["-c", "alpha beta", "-h", "gamma"]</
=={{header|Logo}}==
Line 879 ⟶ 1,583:
logo file.logo - arg1 arg2 arg3
Then the arguments after the "-" are found in a list in variable :COMMAND.LINE
<
[arg1 arg2 arg3]</
Alternatively, make the first line of an executable logo script:
#! /usr/bin/logo -
Line 887 ⟶ 1,591:
=={{header|LSE64}}==
<
0 # argument
dup arg dup 0 = || ,t 1 + repeat
drop</
=={{header|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:
<
print "Arguments:"
for i = 1, #arg do
print( i," ", arg[i] )
end</
=={{header|
function quote$("a") return "a" a string in ""
Arguments in command line maybe two kinds, in first part those three letters identifiers with + or - for switches for interpreter and the last part to executed before loading the actual script.
For this example we make a script, save to temporary directory, and call it passing arguments. We can use Win as shell substitute in M2000 environment, or the Use statement. Reading the shell statement Win we can see how the command line composed. We call the m2000.exe in the appdir$ (application directory, is the path to M2000.exe), and pass a string as a file with a path. That path will be the current path for the new start of m2000.exe the host for M2000 Interpreter (an activeX dll).
<syntaxhighlight lang="m2000 interpreter">
Module Checkit {
Document a$ = {
Module Global A {
Show
Read a$="nothing", x=0
Print a$, x
A$=Key$
}
A: End
}
Dir temporary$
Save.doc a$, "program.gsb"
\\ open if gsb extension is register to m2000.exe
Win quote$(dir$+"program.gsb")
\\ +txt is a switch for interpreter to use string comparison as text (not binary)
\\ so we can send switches and commands before the program loading
Win appdir$+"m2000.exe", quote$(dir$+"program.gsb +txt : Data {Hello}, 100")
\\ no coma after name (we can use "program.gsb" for names with spaces)
Use program.gsb "From Use statement", 200
\\ delete file
Wait 5000
Dos "del "+quote$(dir$+"program.gsb");
\\ open directory
Rem : Win temporary$
}
Checkit
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
myprogram:
<
$CommandLine</
Output:
<pre>{myprogram,-c,alpha beta,-h,gamma}</pre>
=={{header|Mercury}}==
<syntaxhighlight lang="text">
:- module cmd_line_args.
:- interface.
Line 930 ⟶ 1,671:
print_arg(Arg, ArgNum, ArgNum + 1, !IO) :-
io.format("the argument #%d is %s\n", [i(ArgNum), s(Arg)], !IO).
</syntaxhighlight>
=={{header|min}}==
{{works with|min|0.19.3}}
<syntaxhighlight lang="min">args</syntaxhighlight>
=={{header|MMIX}}==
<
argc IS $0
i IS $2
Line 955 ⟶ 1,700:
TRAP 0,Halt,0
NewLine BYTE #a,0</
=={{header|Modula-2}}==
<
FROM Arguments IMPORT GetArgs, ArgTable, GetEnv;
Line 977 ⟶ 1,722:
INC (item)
UNTIL item = count
END try.</
Example:
<syntaxhighlight lang="modula-2">
jan@Beryllium:~/modula/test$ try jantje zag eens pruimen hangen
Count = 6
Line 988 ⟶ 1,733:
4 : pruimen
5 : hangen
</syntaxhighlight>
=={{header|Modula-3}}==
Command line parameters are accessed using the <tt>Params</tt> module.
<
IMPORT IO, Params;
Line 1,003 ⟶ 1,748:
END;
END;
END Args.</
Output:
Line 1,017 ⟶ 1,762:
20
</pre>
=={{header|Nanoquery}}==
{{trans|Ursa}}
<syntaxhighlight lang="nanoquery">//
// command-line arguments
//
// output all arguments
for i in range(0, len(args) - 1)
println args[i]
end</syntaxhighlight>
{{out}}
<pre>$ java -jar ../nanoquery-2.3_1700.jar -b cmdline.nq "alpha beta" -h "gamma"
-b
cmdline.nq
alpha beta
-h
gamma</pre>
=={{header|Neko}}==
<syntaxhighlight lang="actionscript">/* command line arguments, neko */
var argc = $asize($loader.args)
/* Display count and arguments, indexed from 0, no script name included */
$print("There are ", argc, " arguments\n")
var arg = 0
while arg < argc $print($loader.args[arg ++= 1], "\n")</syntaxhighlight>
{{out}}
<pre>prompt$ nekoc command-line-arguments.neko
prompt$ neko ./command-line-arguments.n -c "alpha beta" -h "gamma"
There are 4 arguments
-c
alpha beta
-h
gamma</pre>
=={{header|Nemerle}}==
<
using System.Console;
Line 1,032 ⟶ 1,814:
foreach (cl_arg in cl_args) Write($"$cl_arg ");
}
}</
=={{header|NetRexx}}==
In a stand-alone application NetRexx places the command string passed to it in a variable called <tt>arg</tt>.
<
-- sample arguments: -c "alpha beta" -h "gamma"
say "program arguments:" arg
</syntaxhighlight>
'''Output:'''
<pre>
Line 1,046 ⟶ 1,828:
=={{header|Nim}}==
<
echo "program name: ", getAppFilename()
echo "Arguments:"
for arg in commandLineParams():
echo arg</syntaxhighlight>
=={{header|Nu}}==
In Nu, the special <code>main</code> function can be declared, which gets passed the cli arguments.
<syntaxhighlight lang="nu">
def main [...argv] {
$argv | print
}
</syntaxhighlight>
{{out}}
<pre>
~> nu cli.nu A B C "Hello World!"
╭───┬──────────────╮
│ 0 │ A │
│ 1 │ B │
│ 2 │ C │
│ 3 │ Hello World! │
╰───┴──────────────╯
</pre>
=={{header|Oberon-2}}==
{{works with|oo2c}}
<
MODULE CommandLineArguments;
IMPORT
Line 1,066 ⟶ 1,868:
Out.String("4.-: ");Out.String(Args.AsString(4));Out.Ln
END CommandLineArguments.
</syntaxhighlight>
{{out}}
<pre>
Line 1,078 ⟶ 1,880:
=={{header|Objeck}}==
<
class Line {
function : Main(args : String[]) ~ Nil {
};
}
}
</syntaxhighlight>
=={{header|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:
<
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]);
}</
=={{header|OCaml}}==
Line 1,104 ⟶ 1,904:
The program name is also passed as "argument", so the array length is actually one more than the number of program arguments.
<
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</
=== Using the [
<syntaxhighlight lang="ocaml">(* default values *)
let somebool = ref false
let somestr = ref ""
Line 1,131 ⟶ 1,930:
(fun x -> raise (Arg.Bad ("Bad argument : " ^ x)))
usage;
Printf.printf " %b %d '%s'\n" !somebool !someint !somestr</syntaxhighlight>
<pre>
$ ocaml arg.ml --help
usage: arg.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
--help Display this list of options
$ ocaml arg.ml -d 4 -b -s blabla
true 4 'blabla'
$ ocaml arg.ml
false 0 ''
</pre>
=={{header|Odin}}==
<syntaxhighlight lang="odin">package main
import "core:os"
import "core:fmt"
main :: proc() {
fmt.println(os.args)
}
// Run: ./program -c "alpha beta" -h "gamma"
// Output: ["./program", "-c", "alpha beta", "-h", "gamma"]
</syntaxhighlight>
=={{header|Oforth}}==
Line 1,157 ⟶ 1,969:
The first argument is the program name, so this list is never empty.
<syntaxhighlight lang
=={{header|Oz}}==
===Raw arguments===
Like in C, but without the program name:
<
import Application System
define
Line 1,168 ⟶ 1,980:
{ForAll ArgList System.showInfo}
{Application.exit 0}
end</
===Preprocessed arguments===
<
import Application System
define
Line 1,187 ⟶ 1,999:
{System.showInfo Args.h}
{Application.exit 0}
end</
=={{header|Pascal}}==
==={{header|Free Pascal}}===
<syntaxhighlight lang="pascal">
Program listArguments(input, output, stdErr);
Var
i: integer;
Begin
writeLn('program was called from: ',paramStr(0));
For i := 1 To paramCount() Do
Begin
writeLn('argument',i:2,' : ', paramStr(i));
End;
End.
</syntaxhighlight>
{{out}}
<pre>
./Commandlinearguments -c "alpha beta" -h "gamma"
program was called from: /home/user/Documents/GitHub/rosettacode/Commandlinearguments
argument 1 : -c
argument 2 : alpha beta
argument 3 : -h
argument 4 : gamma
</pre>
=={{header|Perl}}==
Line 1,196 ⟶ 2,031:
@ARGV is the array containing all command line parameters
<
my $params_size = @ARGV;
my $second = $ARGV[1];
my $fifth = $ARGV[4];</
If you don't mind importing a module:
<
GetOptions (
'help|h' => \my $help,
'verbose|v' => \my $verbose,
);</
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">cmd</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">command_line</span><span style="color: #0000FF;">()</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">cmd</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">cmd</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]=</span><span style="color: #000000;">cmd</span><span style="color: #0000FF;">[</span><span style="color: #000000;">2</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Compiled executable name: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">cmd</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]})</span>
<span style="color: #008080;">else</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Interpreted (using %s) source name: %s\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">cmd</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">2</span><span style="color: #0000FF;">])</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cmd</span><span style="color: #0000FF;">)></span><span style="color: #000000;">2</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Command line arguments:\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">3</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cmd</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"#%d : %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">cmd</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<!--</syntaxhighlight>-->
When interpreting, the first two elements returned by command_line() are {interpreter,source}.<br>
When compiled, the first two elements are instead {executable,executable}, so the parameters (if any) are consistently the 3rd element onwards.
{{out}}
desktop/Phix (Windows, Linux would be fairly similar but obviously with different paths):
<pre>
C:\Program Files (x86)\Phix>p testcl -c "alpha beta" -h "gamma"
Line 1,266 ⟶ 2,091:
#6 : gamma
C:\Program Files (x86)\Phix>
</pre>
pwa/p2js: There isn't really a command line, you always get a result of length 2.
<pre>
{"p2js","file:///C:/Program%20Files%20(x86)/Phix/pwa/test.htm"}
Interpreted (using p2js) source name: file:///C:/Program%20Files%20(x86)/Phix/pwa/test.htm
</pre>
Line 1,271 ⟶ 2,101:
When PHP is run from the command line, the special variables <tt>$argv</tt> and <tt>$argc</tt> contain the array of arguments, and the number of arguments, respectively. The program name is passed as the first argument.
<
$program_name = $argv[0];
$second_arg = $argv[2];
$all_args_without_program_name = array_shift($argv);
</syntaxhighlight>
=={{header|Picat}}==
Picat has no built-in option parser, and the user must write a specific parser for each use case. The arguments to a Picat programs are available via <code>main/1</code> as a list of strings.
<syntaxhighlight lang="picat">main(ARGS) =>
println(ARGS).
main(_) => true.</syntaxhighlight>
{{out}}
<pre>picat command_line_arguments.pi -c "alpha beta" -h "gamma"
[-c,alpha beta,-h,gamma]</pre>
See the task [http://rosettacode.org/wiki/Command-line_arguments Command-line_arguments] for a simple option parser.
=={{header|PicoLisp}}==
Line 1,292 ⟶ 2,135:
and then '[http://software-lab.de/doc/refL.html#load load]' all remaining
command line arguments.
<
(de c ()
Line 1,301 ⟶ 2,144:
(load T)
(bye)</
Output:
<pre>$ ./myprogram -c "alpha beta" -h "gamma"
Line 1,308 ⟶ 2,151:
=={{header|PL/I}}==
<
/* The entire command line except the command word itself is passed */
/* to the parameter variable in PL/I. */
Line 1,317 ⟶ 2,160:
end program;
</syntaxhighlight>
=={{header|Pop11}}==
Line 1,323 ⟶ 2,166:
variable poparglist contains list of command line arguments (as strings). One can use iteration over list to process then (for example print).
<
for arg in poparglist do
printf(arg, '->%s<-\n');
endfor;</
=={{header|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 [[#BASIC|QuickBASIC]] above:
<
Current versions of PowerBASIC (with the likely exception of [[PB/DOS]]) include <code>COMMAND$()</code> that works similarly to [[FreeBASIC]]'s <code>COMMAND$()</code>, except that you can't retrieve the application's name:
<
? COMMAND$
? COMMAND$(0)
Line 1,340 ⟶ 2,183:
PRINT "The argument "; i; " is "; COMMAND$(i)
i = i + 1
LOOP</
=={{header|PowerShell}}==
In PowerShell the arguments to a script can be accessed with the <code>$args</code> array:
<
foreach ($s in $args) {
Write-Host Argument (++$i) is $s
}</
=={{header|Prolog}}==
The command line arguments supplied to a Prolog interpreter can be accessed by passing <code>os_argv</code> to <code>current_prolog_flag/2</code>.
<syntaxhighlight lang="prolog">:-
current_prolog_flag(os_argv, Args),
write(Args).</syntaxhighlight>
Alternatively, <code>argv</code> can be used to access only the arguments *not* consumed by the Prolog interpreter.
<syntaxhighlight lang="prolog">:-
current_prolog_flag(argv, Args),
write(Args).</syntaxhighlight>
This omits the interpreter name, the input Prolog filename, and any other arguments directed at the Prolog interpreter.
=={{header|Pure}}==
Arguments are in global variables, argc and argv.
<
using system;
printf "There are %d command line argumants\n" argc;
puts "They are " $$ map (puts) argv;
</syntaxhighlight>
=={{header|PureBasic}}==
Line 1,363 ⟶ 2,219:
===Reading all parameters===
You can easily read all parameters by using ProgramParameter() without argument.
<
Define n=CountProgramParameters()
PrintN("Reading all parameters")
Line 1,373 ⟶ 2,229:
Input()
CloseConsole()
EndIf</
===Reading specific parameters===
You can specify which parameter 'n' to read.
<
Define n
PrintN("Reading specific pameters")
Line 1,385 ⟶ 2,241:
Input()
CloseConsole()
EndIf</
=={{header|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:
<
program_name = sys.argv[0]
arguments = sys.argv[1:]
count = len(arguments)</
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).
Line 1,405 ⟶ 2,261:
Suppose you want to call your script <tt>test.r</tt> with the arguments <tt>a=1 b=c(2,5,6)</tt>, where <tt>b</tt> is a numeric vector. Suppose you also want to redirect your output to <tt>test.out</tt> (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
<
from the commandline, with the following text in <tt>test.r</tt>:
<
args <- (commandArgs(TRUE))
Line 1,426 ⟶ 2,282:
}
print(a*2)
print(b*3)</
(possibly preceding code that actually does something :-) Your output <tt>test.out</tt> would then contain (e.g., if you <tt>cat</tt> it)
Line 1,448 ⟶ 2,304:
The following is the simplest program that prints the command-line arguments:
<
(current-command-line-arguments)</
You can also explicitly print each argument to standard output:
<
(for ([arg (current-command-line-arguments)]) (displayln arg))</
=={{header|Raku}}==
(formerly Perl 6)
Perl 5's <code>@ARGV</code> is available as <code>@*ARGS</code>. Alternatively, if you define a subroutine named <code>MAIN</code>, Perl will automatically process <code>@*ARGS</code> according to Unix conventions and <code>MAIN</code>'s signature (or signatures, if your <code>MAIN</code> is a multi sub) and then call <code>MAIN</code> with appropriate arguments; for more detailed information see: https://docs.raku.org/language/create-cli
<syntaxhighlight lang="raku" line># with arguments supplied
$ raku -e 'sub MAIN($x, $y) { say $x + $y }' 3 5
8
# missing argument:
$ raku -e 'sub MAIN($x, $y) { say $x + $y }' 3
Usage:
-e '...' x y</syntaxhighlight>
If the program is stored in a file, the file name is printed instead of <code>-e '...'</code>.
=={{header|RapidQ}}==
<
FOR i=1 TO CommandCount
PRINT "The argument "; i; " is "; Command$(i)
NEXT i</
=={{header|Raven}}==
<
stack (6 items)
Line 1,473 ⟶ 2,344:
3 => "alpha beta"
4 => "-h"
5 => "gamma"</
=={{header|REALbasic}}==
<
For each arg As String In args
Stdout.WriteLine(arg)
Next
End Function</
Output (given arguments: ''--foo !bar "bat bang"''):
appName.exe
Line 1,489 ⟶ 2,360:
=={{header|REXX}}==
The entire command line arguments (as a single string) are passed by REXX to the program.
<
say arg(1)</
Input:
Line 1,498 ⟶ 2,369:
only options that start with a minus (-) are to be examined
and assumed to be options.
<
/*another version: */
/* aaa=arg(1) */
Line 1,519 ⟶ 2,390:
say
say 'options='opts
say ' data='data</
;Note to users of Microsoft Windows and Regina REXX:
Line 1,582 ⟶ 2,453:
=={{header|Ring}}==
<
see copy("=",30) + nl
see "Command Line Parameters" + nl
Line 1,591 ⟶ 2,462:
see x + nl
next
</syntaxhighlight>
=={{header|Ruby}}==
Line 1,597 ⟶ 2,468:
myprog:
<
p ARGV</
myprog a -h b c
Line 1,604 ⟶ 2,475:
=={{header|Rust}}==
<
fn main(){
let args: Vec<_> = env::args().collect();
println!("{:?}", args);
}</
Run:
<syntaxhighlight lang="text">./program -c "alpha beta" -h "gamma"
["./program", "-c", "alpha beta", "-h", "gamma"]</
=={{header|S-lang}}==
The command-line arguments exist in the array __argv:
<
foreach a (__argv)
print(a);
</
__set_argc_argv(new_argv)
Note 2: When a script is run as a parameter to slsh, __argv does not
Line 1,635 ⟶ 2,506:
=={{header|Sather}}==
<
main(args:ARRAY{STR}) is
loop
Line 1,641 ⟶ 2,512:
end;
end;
end;</
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.
Line 1,660 ⟶ 2,531:
array of strings, and returns unit. That array contains the command line arguments.
<
println(s"Received the following arguments: + ${args.mkString("", ", ", ".")}")
}</
When running a Scala script, where the whole body is executed, the arguments get stored in an array of strings called <code>argv</code>:
<
=={{header|Scheme}}==
<
(for-each (lambda (arg) (display arg) (newline)) args))</
=={{header|Seed7}}==
<
const proc: main is func
Line 1,685 ⟶ 2,556:
writeln("The argument #" <& i <& " is " <& argv(PROGRAM)[i]);
end for;
end func;</
=={{header|Sidef}}==
Command line arguments are available in the ARGV array.
<syntaxhighlight lang
{{out}}
<pre>% myprog -c "alpha beta" -h "gamma"
Line 1,696 ⟶ 2,567:
=={{header|Slate}}==
<
=={{header|Slope}}==
Command line arguments are available in the '''sys-args''' list.
<syntaxhighlight lang="slope">(display sys-args)</syntaxhighlight>
=={{header|Smalltalk}}==
{{works with|GNU Smalltalk}}
<
(Smalltalk getArgv: i) displayNl
]</
{{works with|Smalltalk/X}}
<syntaxhighlight lang
Smalltalk commandLineArguments do:[:each | each printCR]</syntaxhighlight>
=={{header|SparForte}}==
As a structured script.
<syntaxhighlight lang="ada">#!/usr/local/bin/spar
pragma annotate( summary, "printargs" )
@( description, "Retrieve the list of command-line arguments given to the program." )
@( description, "Example command line: " )
@( description, "myprogram -c 'alpha beta' -h 'gamma'" )
@( category, "tutorials" )
@( author, "Ken O. Burtch" )
@( see_also, "http://rosettacode.org/wiki/Command-line_arguments" );
pragma license( unrestricted );
pragma software_model( nonstandard );
pragma restriction( no_external_commands );
procedure printargs is
begin
put_line( "The command is '" & command_line.command_name & "'" );
for Arg in 1..command_line.argument_count loop
put( "Argument" ) @ (Arg ) @ ( " is '" ) @
( command_line.argument(Arg) ) @ ("'");
new_line;
end loop;
end printargs;</syntaxhighlight>
=={{header|Standard ML}}==
<
val args = CommandLine.arguments ();
Array.appi
(fn (i, x) => print ("the argument #" ^ Int.toString (i+1) ^ " is " ^ x ^ "\n"))
(Array.fromList args);</
=={{header|Swift}}==
<
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])")
}</
Alternately:
{{works with|Swift|1.2+}}
<
println("There are \(Process.argc-1) arguments.")
for i in 1 ..< Int(Process.argc) {
println("the argument #\(i) is \(String.fromCString(Process.unsafeArgv[i])!)")
}</
{{works with|Swift|1.0-1.1}}
<
println("There are \(C_ARGC-1) arguments.")
for i in 1 ..< Int(C_ARGC) {
println("the argument #\(i) is \(String.fromCString(C_ARGV[i])!)")
}</
=={{header|Tailspin}}==
<syntaxhighlight lang="tailspin">
$ARGS -> !OUT::write
</syntaxhighlight>
{{out}}
<pre>
[-c, alpha beta, -h, gamma]
</pre>
=={{header|Tcl}}==
Line 1,743 ⟶ 2,653:
The predefined global variable <tt>argc</tt> contains the number of arguments passed to the program after the script being executed, <tt>argv</tt> contains those arguments as a list. (The name of the script is in the <tt>argv0</tt> global variable, and the name of the executable interpreter itself is returned by the command <code>info nameofexecutable</code>.) Retrieving the second argument might look something like this:
<
puts [lindex $argv 1]
}</
(Tcl counts from zero, thus <tt>[lindex $list 1]</tt> retrieves the second item in the list)
Line 1,755 ⟶ 2,665:
number of arguments is provided by #args.
<
[ dup . char: = emit space ] is #=
1 #args [ i #= show-arg ] countedLoop</
=={{header|Transd}}==
<syntaxhighlight lang="Scheme">#lang transd
MainModule: {
_start: (λ
(textout "Number of arguments: " @numArgs
"\nArgument list: " @progArgs)
)
}</syntaxhighlight>
Linux command ('tree3' is the name of Transd interpreter):
tree3 progname -c "alpha beta" -h "gamma"
{{out}}
<pre>
Number of arguments: 5
Argument list: ["progname", "-c", "alpha beta", "-h", "gamma"]
</pre>
=={{header|TXR}}==
Line 1,765 ⟶ 2,694:
This <code>@(next :args)</code> 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.
<
@(collect)
@arg
Line 1,771 ⟶ 2,700:
@(output)
My args are: {@(rep)@arg, @(last)@arg@(end)}
@(end)</
<pre>$ ./txr args.txr
Line 1,784 ⟶ 2,713:
Here is an example program which requires exactly three arguments. Note how <code>ldiff</code> 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.
<
((a b c) (put-line "got three args, thanks!"))
(else (put-line `usage: @(ldiff *full-args* *args*) <arg1> <arg2> <arg3>`)))</
{{out}}
<pre>$ txr command-line-args.txr 1 2
Line 1,798 ⟶ 2,727:
===[[Bourne Shell]]===
To retrieve the entire list of arguments:
<
To retrieve the second and fifth arguments:
<
FIFTH=$5</
=={{header|Ursa}}==
In Ursa, all command line arguments (including the program name as invoked) are contained in the string stream args.
<
# command-line arguments
#
Line 1,812 ⟶ 2,741:
for (decl int i) (< i (size args)) (inc i)
out args<i> endl console
end for</
Sample shell session in the Bourne shell:
Line 1,827 ⟶ 2,756:
This example application does nothing but display the data
structure on standard output.
<
#executable ('parameterized','')
clarg = <.file$[contents: --<''>+ _option%LP]>+ ~command.options</
Here is a bash terminal session.
<pre>$ clarg -c alpha,beta -h gamma --foo=bar,baz
Line 1,852 ⟶ 2,781:
args.v
<
./args.v a b c
=[args.v a b c]</
=={{header|vbScript}}==
<syntaxhighlight lang="vbscript">
'Command line arguments can be accessed all together by
For Each arg In Wscript.Arguments
Wscript.Echo "arg=", arg
Next
'You can access only the named arguments such as /arg:value
For Each arg In Wscript.Arguments.Named
Wscript.Echo "name=", arg, "value=", Wscript.Arguments.Named(arg)
Next
'Or just the unnamed arguments
For Each arg In Wscript.Arguments.Unnamed
Wscript.Echo "arg=", arg
Next
</syntaxhighlight>
=={{header|Visual Basic}}==
Like [[#BASIC|Qbasic]], Visual Basic returns all of the args in the built-in variable <code>Command$</code>:
<
MsgBox Command$
End Sub</
=={{header|Visual Basic .NET}}==
Line 1,868 ⟶ 2,819:
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.
<
For Each token In args
Console.WriteLine(token)
Next
End Sub</
=={{header|V (Vlang)}}==
This assumes that the following script, myscript.v, is run as follows:
$ v run myscript.v -c "alpha beta" -h "gamma"
<syntaxhighlight lang="v (vlang)">import os
fn main() {
for i, x in os.args[1..] {
println("the argument #$i is $x")
}
}</syntaxhighlight>
{{out}}
<pre>
the argument #0 is -c
the argument #1 is alpha beta
the argument #2 is -h
the argument #3 is gamma
</pre>
=={{header|Wren}}==
This assumes that the following script, Command-line_arguments.wren, is run as follows:
$ wren Command-line_arguments.wren -c "alpha beta" -h "gamma"
<syntaxhighlight lang="wren">import "os" for Process
System.print(Process.arguments)</syntaxhighlight>
{{out}}
<pre>
[-c, alpha beta, -h, gamma]
</pre>
=={{header|XPL0}}==
Characters following the program name are copied into a buffer that is accessible as device 8.
This displays the example command line with quote marks stripped off.
<syntaxhighlight lang="xpl0">int C;
[loop [C:= ChIn(8);
if C = \EOF\$1A then quit;
ChOut(0, C);
];
CrLf(0);
]</syntaxhighlight>
{{out}}
<pre>
-c alpha beta -h gamma
</pre>
=={{header|zkl}}==
File myprogram.zkl:
<
vm.arglist.println();</
zkl myprogram -c "alpha beta" -h "gamma"
{{out}}
Line 1,888 ⟶ 2,886:
{{omit from|Brainf***}}
{{omit from|bc}}
{{omit from|Commodore BASIC}}
{{omit from|dc}}
{{omit from|EasyLang|Programs cannot be executed outside the IDE, not even in a command line.}}
{{omit from|GUISS}}
{{omit from|Lotus 123 Macro Scripting}}
Line 1,898 ⟶ 2,898:
{{omit from|PostScript}}
{{omit from|Retro}}
{{omit from|SmileBASIC|No command line.}}
{{omit from|TI-89 BASIC|Does not have an external OS/command processor.}}
{{omit from|Vim Script}}
|