Command-line arguments: Difference between revisions

=={{header|11l}}==

<code>:argv</code> is a list containing all command line arguments, including the program name.

print(‘Program name: ’:argv[0])

=={{header|8080 Assembly}}==

everything CP/M gives it.

puts: equ 9 ; CP/M syscall to print $-terminated string

arglen: equ 80h ; Length of argument

cmdln: db 'Command line: $'

file1: db 13,10,'File 1: $'

{{out}}

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;

end loop;

New_Line;

=== Alternative version using Matreshka ===

Uses [http://forge.ada-ru.org/matreshka Matreshka]

with League.Application;

(League.Application.Arguments.Element (J).To_Wide_Wide_String);

end loop;

=={{header|Aikido}}==

The arguments are passed to the program as a vector of strings called <em>args</em>

foreach arg in args {

}

=={{header|Aime}}==

i = 0;

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 ...

<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>

#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)

VERSION 1:

#include <hopper.h>

next

exit(0)

VERSION 2:

#include <hopper.h>

++i,{argc,i}jle(__CNT_ARGS__)

exit(0)

VERSION 3:

#include <hopper.h>

}

exit(0)

VERSION 4:

#include <natural.h>

#include <hopper.h>

remember ( argument 'i' ); put a new line and print it; finally increment 'i' ).

exit(0)

ETCETERA...

{{out}}

=={{header|AppleScript}}==

#!/usr/bin/env osascript

-- Print first argument

return (item 1 of argv)

end run

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program commandLine.s */

bx lr @ return

=={{header|Arturo}}==

print a

=={{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

=={{header|AWK}}==

BEGIN {

print "Argument " l " is " ARGV[l]

}

=={{header|Babel}}==

Invoke Babel in interactive mode with arguments using the -i switch:

Print the argv list with newlines:

{{out}}

Print the argv list with spaces:

{{out}}

To access an individual argument, use the ith operator to select an element from the argv list; print with newline using say:

{{out}}

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:

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$

FOR i = 0 TO __FB_ARGC__ - 1

PRINT "arg "; i; " = '"; *__FB_ARGV__[i]; "'"

Sample output:

==={{header|BaCon}}===

PRINT "Entire command line: ", ARGUMENT$

PRINT " " & cli$[i];

NEXT

{{out}}

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

{{works with|Windows NT|4 or later (includes Windows XP and onward)}}

setlocal enabledelayedexpansion

for /l %%a in (1,1,%count%) do (

echo !parameter[%%a]!

Another way of doing it

@echo off

setlocal enabledelayedexpansion

for /l %%i in (1,1,%p#%) do (

echo p%%i=!p%%i!

Invocation:

fn=d:\bin\args2.cmd

p0=args2

p2=bar baz

p3=quux

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

=={{header|Blue}}==

Linux/x86-64

global _start

bye

;

=={{header|BQN}}==

BQN has a system value for getting pre-parsed command line arguments.

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.

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>

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>

(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 {

}

}

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 {

}

}

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

This example uses iostream. Traditional C I/O also works.

int main(int argc, char* argv[])

return 0;

=={{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).

=={{header|Clojure}}==

The value of ''*command-line-args*'' is a sequence of the supplied command line arguments, or ''nil'' if none were supplied.

=={{header|CLU}}==

Note that unlike C, the program name itself is not included in the list of arguments.

% where get_argv lives.

%

stream$putl(po, "arg: " || arg)

end

{{out}}

<pre>$ ./cmdline -c "alpha beta" -h "gamma"

Getting the arguments in one go, exactly as they were passed in:

PROGRAM-ID. accept-all-args.

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.

GOBACK

Passing arguments from UNIX/Linux Systems to COBOL.

{{works with|OpenCOBOL}}

{{works with|gnuCOBOL}}

*>Created By Zwiegnet 8/19/2004

STOP RUN.

=={{header|CoffeeScript}}==

{{works with|Node.js}}

console.log arg for arg in process.argv

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

The following function could be used to create a uniform way to access the arguments:

(or

#+clisp (ext:argv)

#+allegro (sys:command-line-arguments)

#+lispworks sys:*line-arguments-list*

=={{header|Cowgol}}==

The manner in which arguments are parsed is, however, dependent on the operating system.

include "argv.coh";

print(arg);

print("'\n");

{{out}}

=={{header|D}}==

import std.stdio;

foreach (immutable i, arg; args[1 .. $])

writefln("#%2d : %s", i + 1, arg);

=={{header|Dart}}==

for(var arg in args)

print(arg);

=={{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

{{out}}

<pre>$ @command_line_arguments -c "alpha beta" -h "gamma"

=={{header|Delphi}}==

// param[0] , so given the axample of myprogram -c "alpha beta" -h "gamma"

// param[3] = -h

// param[4] = gamma

=={{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

if has !opts :four:

{{out}}

<pre>$ vu args-3.deja one two -c three --four=five

This is however a limitation of the CP/M operating system, and not of Draco.

proc nonrec main() void:

writeln(i:3, ": '", par, "'")

od

{{out}}

=={{header|E}}==

=={{header|Eiffel}}==

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

io.read_line -- Keep console window open

end

Output (for command line arguments: -c "alpha beta" -h "gamma"):

=={{header|Elena}}==

ELENA 4.x :

import extensions;

program_arguments.forEvery:(int i)

{ console.printLine("Argument ",i," is ",program_arguments[i]) }

{{out}}

<pre>

=={{header|Elixir}}==

Elixir provides command line arguments via the <tt>System.argv()</tt> function.

IO.puts 'Arguments:'

Example run:

Arguments:

a

b=2

--3

=={{header|Emacs Lisp}}==

Invoke script:

=={{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

result

{progname,["erl"]},

{home,["/home/me"]},

{c,["alpha beta"]},

init:get_argument(name) can be used to fetch value of a particular flag

{ok,[["gamma"]]}

5> init:get_argument(c).

=={{header|Euphoria}}==

printf(1,"Interpreter/executable name: %s\n",{cmd[1]})

printf(1,"Program file name: %s\n",{cmd[2]})

printf(1,"#%d : %s\n",{i,cmd[i]})

end for

=={{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

=={{header|Factor}}==

=={{header|Fancy}}==

a println # print each given command line argument

=={{header|Fantom}}==

class Main

{

}

}

=={{header|Forth}}==

{{works with|gforth|0.6.2}}

: main

argc @ 0 do i arg type cr loop ;

Here is output from a sample run.

gforth

args.f

beta gamma

delta

=={{header|Fortran}}==

{{works with|Fortran|2003 and later}}

implicit none

end program command_line_arguments

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:

./a.out

-c

alpha beta

-h

=={{header|FreeBASIC}}==

' Program (myprogram.exe) invoke as follows:

Print

Print "Press any key to quit"

{{out}}

=={{header|Free Pascal}}==

Program listArguments(input, output, stdErr);

End;

End.

{{out}}

<pre>

=={{header|Frink}}==

Arguments to a program are available in the <CODE>ARGS</CODE> array variable.

println[ARGS]

=={{header|FunL}}==

=={{header|Gambas}}==

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

DIM l AS Integer

DIM numparms AS Integer

PRINT l; " : "; parm

NEXT

=={{header|Genie}}==

/*

Command line arguments, in Genie

// to reiterate, args[0] is the command

if args[0] is not null

{{out}}

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.

=={{header|Go}}==

package main

import (

}

}

=={{header|Groovy}}==

Command-line arguments are accessible via the '''args''' list variable. The following is saved as the file "Echo.groovy":

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:

=={{header|Harbour}}==

Uses the Harbour-specific hb_PValue() function

LOCAL i

NEXT

=={{header|Haskell}}==

myprog.hs:

<pre>

myprog a -h b c

=={{header|HicEst}}==

EDIT(Text=$CMD_LINE, SePaRators='-"', ITeM=i, IF ' ', EXit, ENDIF, Parse=cmd, GetPosition=position)

IF(position > 0) WRITE(Messagebox) cmd

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

Command line parameters are passed to Icon/Unicon programs as a list of strings.

every write(!arglist)

{{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}}==

=={{header|J}}==

The global <code>ARGV</code> holds the command line arguments. Thus, a program to display them:

In a non-interactive context, we would instead use <code>echo ARGV</code>.

=={{header|Java}}==

public static void main(String[] args) {

System.out.println("There are " + args.length + " arguments given.");

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}}

console.log(`${index}: ${val}`);

{{works with|JScript}}

for (var i = 0; i < objArgs.length; i++)

{{works with|JScript.NET (compiled with jsc.exe)}}

var argv:String[] = Environment.GetCommandLineArgs();

for (var i in argv)

{{works with|Rhino}}

{{works with|SpiderMonkey}}

=={{header|jq}}==

$ jq -n '$ARGS' --args a b

"positional": [

"a",

],

"named": {}

Arguments specified with ''--args'' are always read as JSON strings; arguments specified with ''--jsonargs''

=={{header|Jsish}}==

puts(Info.argv0());

{{out}}

=={{header|Julia}}==

Works when the Julia program is run as a file argument to julia.exe.

prog = Base.basename(Base.source_path())

println(" ", s)

end

{{out}}

per line:

.p'.a

=={{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|Lasso}}==

iterate($argv) => {

stdoutnl("Argument " + loop_count + ": " + loop_value)

Output:

Argument 1: arguments.lasso

Argument 2: -c

Argument 3: alpha beta

Argument 4: -h

=={{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"

Once we're in the shell, we can get all the initializing arguments with this call:

> (: init get_arguments)

(#(root ("/opt/erlang/r15b03"))

#(c ("alpha beta"))

#(h ("gamma")))

We can also get specific arguments if we know their keys:

> (: init get_argument 'c)

#(ok (("alpha beta")))

> (: init get_argument 'h)

#(ok (("gamma")))

=={{header|Liberty BASIC}}==

=={{header|Lingo}}==

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}}

=={{header|Logo}}==

logo file.logo - arg1 arg2 arg3

Then the arguments after the "-" are found in a list in variable :COMMAND.LINE

Alternatively, make the first line of an executable logo script:

#! /usr/bin/logo -

=={{header|LSE64}}==

0 # argument

dup arg dup 0 = || ,t 1 + repeat

=={{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] )

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

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).

Module Checkit {

Document a$ = {

}

Checkit

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

myprogram:

Output:

<pre>{myprogram,-c,alpha beta,-h,gamma}</pre>

=={{header|Mercury}}==

:- module cmd_line_args.

:- interface.

print_arg(Arg, ArgNum, ArgNum + 1, !IO) :-

io.format("the argument #%d is %s\n", [i(ArgNum), s(Arg)], !IO).

=={{header|min}}==

{{works with|min|0.19.3}}

=={{header|MMIX}}==

argc IS $0

i IS $2

TRAP 0,Halt,0

=={{header|Modula-2}}==

FROM Arguments IMPORT GetArgs, ArgTable, GetEnv;

INC (item)

UNTIL item = count

Example:

jan@Beryllium:~/modula/test$ try jantje zag eens pruimen hangen

Count = 6

4 : pruimen

5 : hangen

=={{header|Modula-3}}==

Command line parameters are accessed using the <tt>Params</tt> module.

IMPORT IO, Params;

END;

END;

Output:

=={{header|Nanoquery}}==

{{trans|Ursa}}

// command-line arguments

//

for i in range(0, len(args) - 1)

println args[i]

{{out}}

<pre>$ java -jar ../nanoquery-2.3_1700.jar -b cmdline.nq "alpha beta" -h "gamma"

=={{header|Neko}}==

var argc = $asize($loader.args)

var arg = 0

{{out}}

=={{header|Nemerle}}==

using System.Console;

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

'''Output:'''

<pre>

=={{header|Nim}}==

echo "program name: ", getAppFilename()

echo "Arguments:"

for arg in commandLineParams():

=={{header|Oberon-2}}==

{{works with|oo2c}}

MODULE CommandLineArguments;

IMPORT

Out.String("4.-: ");Out.String(Args.AsString(4));Out.Ln

END CommandLineArguments.

{{out}}

<pre>

=={{header|Objeck}}==

class Line {

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

}

}

=={{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}}==

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)

=== Using the [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Arg.html Arg] module ===

let somebool = ref false

let somestr = ref ""

Printf.printf " %b %d '%s'\n" !somebool !someint !somestr;

The first argument is the program name, so this list is never empty.

=={{header|Oz}}==

===Raw arguments===

Like in C, but without the program name:

import Application System

define

{ForAll ArgList System.showInfo}

{Application.exit 0}

===Preprocessed arguments===

import Application System

define

{System.showInfo Args.h}

{Application.exit 0}

=={{header|Pascal}}==

@ARGV is the array containing all command line parameters

my $params_size = @ARGV;

my $second = $ARGV[1];

If you don't mind importing a module: