Command-line arguments: Difference between revisions
(→[[Toka]]: Updated to work with Toka R1) |
No edit summary |
||
Line 134: | Line 134: | ||
program_name = sys.argv[0] # gets the program name |
program_name = sys.argv[0] # gets the program name |
||
all_arguments = sys.argv[1:] # arguments, excluding the program name |
all_arguments = sys.argv[1:] # arguments, excluding the program name |
||
==[[Ruby]] |
|||
[[Category:Ruby]] |
|||
Command line arguments are available in the constant Object::ARGV. |
|||
arg: |
|||
#! /usr/bin/env ruby |
|||
p ARGV |
|||
./arg a b c |
|||
=> ["a","b","c"] |
|||
==[[Tcl]]== |
==[[Tcl]]== |
||
[[Category: Tcl]] |
[[Category: Tcl]] |
Revision as of 02:38, 13 September 2007
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.
Example command line:
myprogram -c "alpha beta" -h "gamma"
Ada
Command line arguments are available through the pre-defined 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;
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]); }
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] << "\n"; std::cout << "There are " << argc-1 << " arguments given.\n"; for (int i = 1; i < argc; ++i) std::cout << "the argument #" << i << " is " << argv[i] << "\n"; }
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
E
interp.getArgs()
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.
Interpreter: gforth 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 $
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]); } }
Perl
Interpreter: Perl v5.x
@ARGV is the array containing all command line parameters
my @params = @ARGV; my $second = $ARGV[1]; my $fifth = $ARGV[4];
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;
Python
argv in the sys module is a list containing all command line parameters, including the program name.
import sys program_name = sys.argv[0] # gets the program name all_arguments = sys.argv[1:] # arguments, excluding the program name
==Ruby Command line arguments are available in the constant Object::ARGV.
arg:
#! /usr/bin/env ruby p ARGV
./arg a b c => ["a","b","c"]
Tcl
The pre-defined 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)
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
UNIX Shell
Bourne Shell
To retrieve the entire list of arguments:
WHOLELIST="$@"
To retrieve the second and fifth arguments:
SECOND=$2 FIFTH=$5