Command Line Arguments

From Rosetta Code

Retrieve the list of command-line arguments given to the program.

Example command line:

myprogram -c "alpha beta" -h "gamma"

Contents 1 Ada 2 BASIC 3 C 4 C++ 5 Clean 6 D 7 DOS Batch File 8 E 9 Erlang 10 Forth 11 Haskell 12 J 13 Java 14 LSE64 15 OCaml 16 Perl 17 PHP 18 Pop11 19 Python 20 RapidQ 21 Raven 22 Ruby 23 Tcl 24 Toka 25 UNIX Shell 25.1 Bourne Shell 26 V

[edit] Ada

Command line arguments are available through the predefined package Ada.Command_Line.

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;

[edit] BASIC

Works with: FreeBASIC

DIM i AS Integer
 
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

See also: RapidQ

[edit] 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.

#include <stdio.h>
 
int main(int argc, char* argv[])
{
  int i;
  printf("This program is named %s.\n", argv[0]);
  for (i = 1; i < argc; ++i)
    printf("the argument #%d is %s\n", i, argv[i]);
}

[edit] C++

Command line arguments are passed the same way as in C.

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

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

[edit] Clean

getCommandLine from the module ArgEnv returns an array of command-line arguments (the first element is the name of the program).

import ArgEnv

Start = getCommandLine

[edit] D

import std.stdio ;
 
void main(string[] args) {
  foreach(i, e ; args[1..$])
    writefln("#%2d : %s", i + 1, e) ;
}

[edit] DOS Batch File

@if not [%1]==[] echo %~1 & call %0 %2 %3 %4 %5 %6 %7 %8 %9

[edit] E

interp.getArgs()

[edit] Erlang

3> init:get_arguments().

result

[{root,["/usr/erlang/erl5.5"]},
{progname,["erl"]},
{home,["/home/me"]},
{c,["alpha beta"]},
{h,["gamma"]}]

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

4> init:get_argument(h).
{ok,"gamma"}
5> init:get_argument(c).
{ok,"alpha beta"}

[edit] 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.

Works with: gforth version 0.6.2

\ args.f: print each command line argument on a separate line
: main
  argc @ 0 do i arg type cr loop ;

main bye

Here is output from a sample run.

$ gforth args.f alpha "beta gamma" delta
gforth
args.f
alpha
beta gamma
delta
$

[edit] Haskell

Defined by the System module, getArgs :: IO [String] provides the command-line arguments in a list.

myprog.hs:

import System
main = getArgs >>= print

myprog a -h b c
=> ["a","-h","b","c"]

[edit] J

The global ARGV holds the command line arguments.

[edit] 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);
  }
}

[edit] LSE64

argc , nl  # number of arguments (including command itself)
0         # argument
dup arg dup 0 = || ,t  1 + repeat
drop

[edit] OCaml

The program name is also passed as "argument", so the array length is actually one more than the number of program arguments.

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

[edit] Perl

Works with: Perl version 5.x

@ARGV is the array containing all command line parameters

my @params = @ARGV;
my $second = $ARGV[1];
my $fifth = $ARGV[4];

[edit] 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.

<?php
$program_name = $argv[0];
$second_arg = $argv[2];
?>

[edit] Pop11

variable poparglist contains list of command line arguments (as strings). One can use iteration over list to process then (for example print).

lvars arg;
for arg in poparglist do
   printf(arg, '->%s<-\n');
endfor;

[edit] 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:

import sys
program_name = sys.argv[0]
arguments = sys.argv[1:]
count = len(arguments)

When running a module by invoking Python, Python process and remove some of the arguments, and the module can not 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.

[edit] RapidQ

PRINT "This program is named "; Command$(0)
FOR i=1 TO CommandCount
    PRINT "The argument "; i; " is "; Command$(i)
NEXT i

[edit] Raven

ARGS print

stack (6 items)
 0 => "raven"
 1 => "myprogram"
 2 => "-c"
 3 => "alpha beta"
 4 => "-h"
 5 => "gamma"

[edit] Ruby

Command line arguments are available in the constant Object::ARGV.

myprog:

#! /usr/bin/env ruby
p ARGV

 myprog a -h b c
 => ["a","-h","b","c"]

[edit] Tcl

The predefined variable argc contains the number of arguments passed to the routine, argv contains the arguments as a list. Retrieving the second argument might look something like this:

 if { $argc > 1 } { puts [lindex $argv 1] }

(Tcl counts from zero, thus [lindex $list 1] retrieves the second item in the list)

[edit] 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.

 [ arglist array.get type cr ] is show-arg
 [ dup . char: = emit space ] is #= 
 1 #args [ i #= show-arg ] countedLoop

[edit] UNIX Shell

[edit] Bourne Shell

To retrieve the entire list of arguments:

WHOLELIST="$@"

To retrieve the second and fifth arguments:

SECOND=$2
FIFTH=$5

[edit] V

The arguments to the program are stored in the stack,

args.v

$stack puts

./args.v a b c
=[args.v a b c]