Parse command-line arguments: Difference between revisions

Many languages provide a library (getopt or GetOpt) to parse the raw command line options in an intelligent way.

<br><br>

 

=={{header|AutoHotkey}}==

For AutoHotkey v1.1+

if 0 > 0

{

}

 

'''Output (MsgBox):'''

<pre>Parsed Arguments :

=={{header|AWK}}==

{{works with|gawk}}

# -E instead of -f so program arguments don't conflict with Gawk arguments

@include "getopt.awk"

if(tval) print "-t = " tval

if(uval) print "-u = " uval

 

=={{header|Bracmat}}==

=={{header|C}}==

The man page for getopt (man 3 getopt) provides better option handling with examples. But if you just want to parse one argument... (adapted from simple database task):

int main(int argc, char **argv){

int i;

}

return 0;

 

=={{header|Clojure}}==

 

=={{header|D}}==

The [http://dlang.org/phobos/std_getopt.html getopt module] in D's standard library is inspired by Perl's Getopt::Long module. The syntax of Phobos getopt infers the expected parameter types from the static types of the passed-in pointers.

 

void main(string[] args) {

writeln("verbose: ", verbose);

writeln("color: ", color);

{{out|Usage example}}

<pre>C:\getopt_test --verbose --length 12

verbose: true

color: no</pre>

 

=={{header|Elixir}}==

Elixir provides an option parser in a library module called <tt>OptionParser</tt>.

 

IO.puts 'Arguments:'

 

Arguments:

{[a: true, b: true, c: "yes", no_flag: true, verbose: true],

 

=={{header|FreeBASIC}}==

 

' Program (commandline.exe) invoked like this:

Print

Print "Press any key to quit"

 

{{out}}

=={{header|Go}}==

Most simply, implementing the suggested example from the talk page:

 

import (

fmt.Println("s:", *s)

fmt.Println("n:", *n)

Example runs:

<pre>

The Icon Programming Library provides a procedure for processing command line options. See the library reference for detailed documentation. The code below is an example.

 

 

procedure main(ARGLIST)

i := opttable(i) # assign an integer

...

 

{{libheader|Icon Programming Library}}

:Test if an argument is present:

 

 

::This is true if the argument is present and false, if it is not.

:Or, find the name of an optional file:

 

 

::This is the name of the first file named after the first -f argument, or empty if there was no such file.

Other concepts are also possible...

 

The command line is parsed and stored into a list of strings to ease manual handling by list processing functions.

=={{header|PARI/GP}}==

GP exists in a REPL and so it doesn't make sense to parse command-line arguments. But PARI can parse them just like [[#C|C]]:

#include <stdio.h>

 

pari_printf("8 + 1 = %Ps\n", addii(int2u(3), gen_1));

return 0;

 

=={{header|Perl}}==

Use the <tt>Getopt::Long</tt> module:

 

 

use strict;

($verbose ? "Verbosity" : "No verbosity"),

" and a length of $length.\n";

 

The output from it is:

</pre>

 

{{out}}

 

 

 

 

 

 

=={{header|PicoLisp}}==

PicoLisp doesn't have a library to get options. Instead, the command line is parsed at startup and handled in the following way: Each command line argument is executed (interpreted) as a Lisp source file, except that if the first character is a hypen '-', then that arguments is taken as a Lisp function call (without the surrounding parentheses). For example, the command line

has the effect that

# The file "abc.l" is executed

=={{header|PowerShell}}==

Powershell functions and filters handle options organically, with advanced .NET support to handle complex and advanced options including aliases, ranges, sets, datatypes, and more. [https://msdn.microsoft.com/en-us/powershell/reference/5.0/microsoft.powershell.core/about/about_parsing See] [https://msdn.microsoft.com/powershell/reference/5.1/Microsoft.PowerShell.Core/about/about_Functions more] [https://msdn.microsoft.com/en-us/powershell/reference/5.0/microsoft.powershell.core/about/about_functions_advanced here]. However, to parse options 'classically', you can write a custom parser. A slightly messy version (inspired by ruby optparse) that can only handle switches and relies on RegEx:

$options = @{

opt1 = [bool] 0

return [array]$argv,$options

}#fn

Usage (in some function or script):

 

$argv,$options = parseOptions $args $options

$bar = $argv | SomeOtherFilter | Baz

}

Usage in shell:

Note that this works in Powershell. All of the arguments after the function name will be passed as strings to the function, which then calls them as an array with the automatic variable, $args. The custom parser/function does the work from there, turning the strings into flags and typed arguments. WARNING: This is reinventing the wheel to an extreme degree.

 

=={{header|Racket}}==

Racket has a good command-line parsing library, the following demonstrates some of its features:

 

#!/usr/bin/env racket

#lang racket

(printf "Log level: ~s\n" loglevel)

(printf "Operations: ~a\n" (string-join ops ", ")))

 

Sample runs:

Operations: add, add, edit, delete

</pre>

 

=={{header|REXX}}==

╚═════════════════════════════════════════════════════════════════════════════╝

</pre>

parse arg opts /*this preserves the case of options. */

opts=space(opts) /*elide superfluous blanks in options. */

isInt: return datatype(arg(1), 'W') /*return 1 if argument is an integer*/

isNum: return datatype(arg(1), 'N') /*return 1 if argument is a number.*/

<pre>

╔═══════════════════════════════════════════════════════════════════════╗

 

=== Ruby with 'getoptlong' ===

 

# == Synopsis

nil

end

 

<pre>$ ./pargs.rb -h

 

=== Ruby with 'optparse' ===

 

sflag = false

Fruit: #{fruit}

Arguments: #{ARGV.inspect}

 

<pre>$ ruby takeopts.rb -h

Fruit: orange

Arguments: ["-arg"]</pre>

 

=={{header|Scala}}==

{{libheader|Scala}}

println(s"Received the following arguments: + ${args.mkString("", ", ", ".")}")

 

=={{header|Standard ML}}==

{{works with|MLton}}

The following code listing can be compiled with both [[SML/NJ]] and [[MLton]]:

 

exception FatalError of string

 

(* MLton *)

 

=== SML/NJ ===

[[SML/NJ]] can compile source code to a "heap file", witch can than be executed by the interpreter with arguments given (see [http://stackoverflow.com/questions/5053149/sml-nj-how-to-compile-standalone-executable this entry on stackowerflow.com] for more information).

The <code>source.cm</code> file should lock like this:

is

SOURCE_FILE.sml

To compile the program, use <code>ml-build sources.cm</code>. This should create a "heap file" <code>sources.x86-linux</code>, depending on your architecture.

The heap file can be executed with <code>sml @SMLload=sources.x86-linux ARGUMENTS</code>, or the script [http://www.smlnj.org/doc/heap2exec/index.html <code>heap2exec</code>] can be used to make a single executable.

=={{header|Tcl}}==

The following proc detects and removes argument-less (-b) and one-argument options from the argument vector.

upvar 1 $_argv argv $_var var

set pos [lsearch -regexp $argv ^$name]

return 0

}

Usage examples:

getopt argv -sep sep ";" ;# possibly override default with user preference

Searching with -regexp allows to specify longer mnemonic names, so it still succeeds on longer flags, e.g.

$ myscript.tcl -separator '\t' ...

 

=={{header|zkl}}==

 

File myprogram.zkl:

argh := Utils.Argh(

T("v","v","print version",fcn{println("Version stub")}),

case("z") { println("zazzle") }

}

<pre>zkl myprogram nc -v -n -z --ip 192.168.1.2 1-1000</pre>

{{out}}