Module Arg


module Arg: sig  end
Parsing of command line arguments.

This module provides a general mechanism for extracting options and arguments from the command line to the program.

Syntax of command lines: A keyword is a character string starting with a -. An option is a keyword alone or followed by an argument. The types of keywords are: Unit, Bool, Set, Clear, String, Set_string, Int, Set_int, Float, Set_float, Tuple, Symbol, and Rest. Unit, Set and Clear keywords take no argument. A Rest keyword takes the remaining of the command line as arguments. Every other keyword takes the following word on the command line as argument. Arguments not preceded by a keyword are called anonymous arguments.

Examples (cmd is assumed to be the command name):




type spec =
| Unit of (unit -> unit) (*Call the function with unit argument*)
| Bool of (bool -> unit) (*Call the function with a bool argument*)
| Set of bool Pervasives.ref (*Set the reference to true*)
| Clear of bool Pervasives.ref (*Set the reference to false*)
| String of (string -> unit) (*Call the function with a string argument*)
| Set_string of string Pervasives.ref (*Set the reference to the string argument*)
| Int of (int -> unit) (*Call the function with an int argument*)
| Set_int of int Pervasives.ref (*Set the reference to the int argument*)
| Float of (float -> unit) (*Call the function with a float argument*)
| Set_float of float Pervasives.ref (*Set the reference to the float argument*)
| Tuple of spec list (*Take several arguments according to the spec list*)
| Symbol of string list * (string -> unit) (*Take one of the symbols as argument and call the function with the symbol*)
| Rest of (string -> unit) (*Stop interpreting keywords and call the function with each remaining argument*)

The concrete type describing the behavior associated with a keyword.

type key = string 
type doc = string 
type usage_msg = string 
type anon_fun = string -> unit 
val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit
Arg.parse speclist anon_fun usage_msg parses the command line. speclist is a list of triples (key, spec, doc). key is the option keyword, it must start with a '-' character. spec gives the option type and the function to call when this option is found on the command line. doc is a one-line description of this option. anon_fun is called on anonymous arguments. The functions in spec and anon_fun are called in the same order as their arguments appear on the command line.

If an error occurs, Arg.parse exits the program, after printing an error message as follows:

For the user to be able to specify anonymous arguments starting with a -, include for example ("-", String anon_fun, doc) in speclist.

By default, parse recognizes two unit options, -help and --help, which will display usage_msg and the list of options, and exit the program. You can override this behaviour by specifying your own -help and --help options in speclist.

val parse_argv : string array ->
(key * spec * doc) list -> anon_fun -> usage_msg -> unit
Arg.parse_argv args speclist anon_fun usage_msg parses the array args as if it were the command line. It uses and updates the value of Arg.current. You must set Arg.current before calling parse_argv, and restore it afterward if needed. If an error occurs, Arg.parse_argv raises Arg.Bad with the error message as argument. If option -help or --help is given, Arg.parse_argv raises Arg.Help with the help message as argument.
exception Help of string
Raised by Arg.parse_argv when the user asks for help.
exception Bad of string
Functions in spec or anon_fun can raise Arg.Bad with an error message to reject invalid arguments. Arg.Bad is also raised by Arg.parse_argv in case of an error.
val usage : (key * spec * doc) list -> usage_msg -> unit
Arg.usage speclist usage_msg prints an error message including the list of valid options. This is the same message that Arg.parse prints in case of error. speclist and usage_msg are the same as for Arg.parse.
val current : int Pervasives.ref
Position (in Sys.argv) of the argument being processed. You can change this value, e.g. to force Arg.parse to skip some arguments.