The Go Programming Language

Source file src/pkg/flag/flag.go

     1	// Copyright 2009 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	/*
     6		Package flag implements command-line flag parsing.
     7	
     8		Usage:
     9	
    10		Define flags using flag.String(), Bool(), Int(), etc. Example:
    11			import "flag"
    12			var ip *int = flag.Int("flagname", 1234, "help message for flagname")
    13		If you like, you can bind the flag to a variable using the Var() functions.
    14			var flagvar int
    15			func init() {
    16				flag.IntVar(&flagvar, "flagname", 1234, "help message for flagname")
    17			}
    18		Or you can create custom flags that satisfy the Value interface (with
    19		pointer receivers) and couple them to flag parsing by
    20			flag.Var(&flagVal, "name", "help message for flagname")
    21		For such flags, the default value is just the initial value of the variable.
    22	
    23		After all flags are defined, call
    24			flag.Parse()
    25		to parse the command line into the defined flags.
    26	
    27		Flags may then be used directly. If you're using the flags themselves,
    28		they are all pointers; if you bind to variables, they're values.
    29			fmt.Println("ip has value ", *ip);
    30			fmt.Println("flagvar has value ", flagvar);
    31	
    32		After parsing, the arguments after the flag are available as the
    33		slice flag.Args() or individually as flag.Arg(i).
    34		The arguments are indexed from 0 up to flag.NArg().
    35	
    36		Command line flag syntax:
    37			-flag
    38			-flag=x
    39			-flag x  // non-boolean flags only
    40		One or two minus signs may be used; they are equivalent.
    41		The last form is not permitted for boolean flags because the
    42		meaning of the command
    43			cmd -x *
    44		will change if there is a file called 0, false, etc.  You must
    45		use the -flag=false form to turn off a boolean flag.
    46	
    47		Flag parsing stops just before the first non-flag argument
    48		("-" is a non-flag argument) or after the terminator "--".
    49	
    50		Integer flags accept 1234, 0664, 0x1234 and may be negative.
    51		Boolean flags may be 1, 0, t, f, true, false, TRUE, FALSE, True, False.
    52	
    53		The default set of command-line flags is controlled by
    54		top-level functions.  The FlagSet type allows one to define
    55		independent sets of flags, such as to implement subcommands
    56		in a command-line interface. The methods of FlagSet are
    57		analogous to the top-level functions for the command-line
    58		flag set.
    59	*/
    60	package flag
    61	
    62	import (
    63		"fmt"
    64		"os"
    65		"sort"
    66		"strconv"
    67	)
    68	
    69	// ErrHelp is the error returned if the flag -help is invoked but no such flag is defined.
    70	var ErrHelp = os.NewError("flag: help requested")
    71	
    72	// -- Bool Value
    73	type boolValue bool
    74	
    75	func newBoolValue(val bool, p *bool) *boolValue {
    76		*p = val
    77		return (*boolValue)(p)
    78	}
    79	
    80	func (b *boolValue) Set(s string) bool {
    81		v, err := strconv.Atob(s)
    82		*b = boolValue(v)
    83		return err == nil
    84	}
    85	
    86	func (b *boolValue) String() string { return fmt.Sprintf("%v", *b) }
    87	
    88	// -- Int Value
    89	type intValue int
    90	
    91	func newIntValue(val int, p *int) *intValue {
    92		*p = val
    93		return (*intValue)(p)
    94	}
    95	
    96	func (i *intValue) Set(s string) bool {
    97		v, err := strconv.Btoi64(s, 0)
    98		*i = intValue(v)
    99		return err == nil
   100	}
   101	
   102	func (i *intValue) String() string { return fmt.Sprintf("%v", *i) }
   103	
   104	// -- Int64 Value
   105	type int64Value int64
   106	
   107	func newInt64Value(val int64, p *int64) *int64Value {
   108		*p = val
   109		return (*int64Value)(p)
   110	}
   111	
   112	func (i *int64Value) Set(s string) bool {
   113		v, err := strconv.Btoi64(s, 0)
   114		*i = int64Value(v)
   115		return err == nil
   116	}
   117	
   118	func (i *int64Value) String() string { return fmt.Sprintf("%v", *i) }
   119	
   120	// -- Uint Value
   121	type uintValue uint
   122	
   123	func newUintValue(val uint, p *uint) *uintValue {
   124		*p = val
   125		return (*uintValue)(p)
   126	}
   127	
   128	func (i *uintValue) Set(s string) bool {
   129		v, err := strconv.Btoui64(s, 0)
   130		*i = uintValue(v)
   131		return err == nil
   132	}
   133	
   134	func (i *uintValue) String() string { return fmt.Sprintf("%v", *i) }
   135	
   136	// -- uint64 Value
   137	type uint64Value uint64
   138	
   139	func newUint64Value(val uint64, p *uint64) *uint64Value {
   140		*p = val
   141		return (*uint64Value)(p)
   142	}
   143	
   144	func (i *uint64Value) Set(s string) bool {
   145		v, err := strconv.Btoui64(s, 0)
   146		*i = uint64Value(v)
   147		return err == nil
   148	}
   149	
   150	func (i *uint64Value) String() string { return fmt.Sprintf("%v", *i) }
   151	
   152	// -- string Value
   153	type stringValue string
   154	
   155	func newStringValue(val string, p *string) *stringValue {
   156		*p = val
   157		return (*stringValue)(p)
   158	}
   159	
   160	func (s *stringValue) Set(val string) bool {
   161		*s = stringValue(val)
   162		return true
   163	}
   164	
   165	func (s *stringValue) String() string { return fmt.Sprintf("%s", *s) }
   166	
   167	// -- Float64 Value
   168	type float64Value float64
   169	
   170	func newFloat64Value(val float64, p *float64) *float64Value {
   171		*p = val
   172		return (*float64Value)(p)
   173	}
   174	
   175	func (f *float64Value) Set(s string) bool {
   176		v, err := strconv.Atof64(s)
   177		*f = float64Value(v)
   178		return err == nil
   179	}
   180	
   181	func (f *float64Value) String() string { return fmt.Sprintf("%v", *f) }
   182	
   183	// Value is the interface to the dynamic value stored in a flag.
   184	// (The default value is represented as a string.)
   185	type Value interface {
   186		String() string
   187		Set(string) bool
   188	}
   189	
   190	// ErrorHandling defines how to handle flag parsing errors.
   191	type ErrorHandling int
   192	
   193	const (
   194		ContinueOnError ErrorHandling = iota
   195		ExitOnError
   196		PanicOnError
   197	)
   198	
   199	// A FlagSet represents a set of defined flags.
   200	type FlagSet struct {
   201		// Usage is the function called when an error occurs while parsing flags.
   202		// The field is a function (not a method) that may be changed to point to
   203		// a custom error handler.
   204		Usage func()
   205	
   206		name          string
   207		actual        map[string]*Flag
   208		formal        map[string]*Flag
   209		args          []string // arguments after flags
   210		exitOnError   bool     // does the program exit if there's an error?
   211		errorHandling ErrorHandling
   212	}
   213	
   214	// A Flag represents the state of a flag.
   215	type Flag struct {
   216		Name     string // name as it appears on command line
   217		Usage    string // help message
   218		Value    Value  // value as set
   219		DefValue string // default value (as text); for usage message
   220	}
   221	
   222	// sortFlags returns the flags as a slice in lexicographical sorted order.
   223	func sortFlags(flags map[string]*Flag) []*Flag {
   224		list := make(sort.StringSlice, len(flags))
   225		i := 0
   226		for _, f := range flags {
   227			list[i] = f.Name
   228			i++
   229		}
   230		list.Sort()
   231		result := make([]*Flag, len(list))
   232		for i, name := range list {
   233			result[i] = flags[name]
   234		}
   235		return result
   236	}
   237	
   238	// VisitAll visits the flags in lexicographical order, calling fn for each.
   239	// It visits all flags, even those not set.
   240	func (f *FlagSet) VisitAll(fn func(*Flag)) {
   241		for _, flag := range sortFlags(f.formal) {
   242			fn(flag)
   243		}
   244	}
   245	
   246	// VisitAll visits the command-line flags in lexicographical order, calling
   247	// fn for each.  It visits all flags, even those not set.
   248	func VisitAll(fn func(*Flag)) {
   249		commandLine.VisitAll(fn)
   250	}
   251	
   252	// Visit visits the flags in lexicographical order, calling fn for each.
   253	// It visits only those flags that have been set.
   254	func (f *FlagSet) Visit(fn func(*Flag)) {
   255		for _, flag := range sortFlags(f.actual) {
   256			fn(flag)
   257		}
   258	}
   259	
   260	// Visit visits the command-line flags in lexicographical order, calling fn
   261	// for each.  It visits only those flags that have been set.
   262	func Visit(fn func(*Flag)) {
   263		commandLine.Visit(fn)
   264	}
   265	
   266	// Lookup returns the Flag structure of the named flag, returning nil if none exists.
   267	func (f *FlagSet) Lookup(name string) *Flag {
   268		return f.formal[name]
   269	}
   270	
   271	// Lookup returns the Flag structure of the named command-line flag,
   272	// returning nil if none exists.
   273	func Lookup(name string) *Flag {
   274		return commandLine.formal[name]
   275	}
   276	
   277	// Set sets the value of the named flag.  It returns true if the set succeeded; false if
   278	// there is no such flag defined.
   279	func (f *FlagSet) Set(name, value string) bool {
   280		flag, ok := f.formal[name]
   281		if !ok {
   282			return false
   283		}
   284		ok = flag.Value.Set(value)
   285		if !ok {
   286			return false
   287		}
   288		f.actual[name] = flag
   289		return true
   290	}
   291	
   292	// Set sets the value of the named command-line flag. It returns true if the
   293	// set succeeded; false if there is no such flag defined.
   294	func Set(name, value string) bool {
   295		return commandLine.Set(name, value)
   296	}
   297	
   298	// PrintDefaults prints to standard error the default values of all defined flags in the set.
   299	func (f *FlagSet) PrintDefaults() {
   300		f.VisitAll(func(f *Flag) {
   301			format := "  -%s=%s: %s\n"
   302			if _, ok := f.Value.(*stringValue); ok {
   303				// put quotes on the value
   304				format = "  -%s=%q: %s\n"
   305			}
   306			fmt.Fprintf(os.Stderr, format, f.Name, f.DefValue, f.Usage)
   307		})
   308	}
   309	
   310	// PrintDefaults prints to standard error the default values of all defined command-line flags.
   311	func PrintDefaults() {
   312		commandLine.PrintDefaults()
   313	}
   314	
   315	// defaultUsage is the default function to print a usage message.
   316	func defaultUsage(f *FlagSet) {
   317		fmt.Fprintf(os.Stderr, "Usage of %s:\n", f.name)
   318		f.PrintDefaults()
   319	}
   320	
   321	// Usage prints to standard error a usage message documenting all defined command-line flags.
   322	// The function is a variable that may be changed to point to a custom function.
   323	var Usage = func() {
   324		defaultUsage(commandLine)
   325	}
   326	
   327	// NFlag returns the number of flags that have been set.
   328	func (f *FlagSet) NFlag() int { return len(f.actual) }
   329	
   330	// NFlag returns the number of command-line flags that have been set.
   331	func NFlag() int { return len(commandLine.actual) }
   332	
   333	// Arg returns the i'th argument.  Arg(0) is the first remaining argument
   334	// after flags have been processed.
   335	func (f *FlagSet) Arg(i int) string {
   336		if i < 0 || i >= len(f.args) {
   337			return ""
   338		}
   339		return f.args[i]
   340	}
   341	
   342	// Arg returns the i'th command-line argument.  Arg(0) is the first remaining argument
   343	// after flags have been processed.
   344	func Arg(i int) string {
   345		return commandLine.Arg(i)
   346	}
   347	
   348	// NArg is the number of arguments remaining after flags have been processed.
   349	func (f *FlagSet) NArg() int { return len(f.args) }
   350	
   351	// NArg is the number of arguments remaining after flags have been processed.
   352	func NArg() int { return len(commandLine.args) }
   353	
   354	// Args returns the non-flag arguments.
   355	func (f *FlagSet) Args() []string { return f.args }
   356	
   357	// Args returns the non-flag command-line arguments.
   358	func Args() []string { return commandLine.args }
   359	
   360	// BoolVar defines a bool flag with specified name, default value, and usage string.
   361	// The argument p points to a bool variable in which to store the value of the flag.
   362	func (f *FlagSet) BoolVar(p *bool, name string, value bool, usage string) {
   363		f.Var(newBoolValue(value, p), name, usage)
   364	}
   365	
   366	// BoolVar defines a bool flag with specified name, default value, and usage string.
   367	// The argument p points to a bool variable in which to store the value of the flag.
   368	func BoolVar(p *bool, name string, value bool, usage string) {
   369		commandLine.Var(newBoolValue(value, p), name, usage)
   370	}
   371	
   372	// Bool defines a bool flag with specified name, default value, and usage string.
   373	// The return value is the address of a bool variable that stores the value of the flag.
   374	func (f *FlagSet) Bool(name string, value bool, usage string) *bool {
   375		p := new(bool)
   376		f.BoolVar(p, name, value, usage)
   377		return p
   378	}
   379	
   380	// Bool defines a bool flag with specified name, default value, and usage string.
   381	// The return value is the address of a bool variable that stores the value of the flag.
   382	func Bool(name string, value bool, usage string) *bool {
   383		return commandLine.Bool(name, value, usage)
   384	}
   385	
   386	// IntVar defines an int flag with specified name, default value, and usage string.
   387	// The argument p points to an int variable in which to store the value of the flag.
   388	func (f *FlagSet) IntVar(p *int, name string, value int, usage string) {
   389		f.Var(newIntValue(value, p), name, usage)
   390	}
   391	
   392	// IntVar defines an int flag with specified name, default value, and usage string.
   393	// The argument p points to an int variable in which to store the value of the flag.
   394	func IntVar(p *int, name string, value int, usage string) {
   395		commandLine.Var(newIntValue(value, p), name, usage)
   396	}
   397	
   398	// Int defines an int flag with specified name, default value, and usage string.
   399	// The return value is the address of an int variable that stores the value of the flag.
   400	func (f *FlagSet) Int(name string, value int, usage string) *int {
   401		p := new(int)
   402		f.IntVar(p, name, value, usage)
   403		return p
   404	}
   405	
   406	// Int defines an int flag with specified name, default value, and usage string.
   407	// The return value is the address of an int variable that stores the value of the flag.
   408	func Int(name string, value int, usage string) *int {
   409		return commandLine.Int(name, value, usage)
   410	}
   411	
   412	// Int64Var defines an int64 flag with specified name, default value, and usage string.
   413	// The argument p points to an int64 variable in which to store the value of the flag.
   414	func (f *FlagSet) Int64Var(p *int64, name string, value int64, usage string) {
   415		f.Var(newInt64Value(value, p), name, usage)
   416	}
   417	
   418	// Int64Var defines an int64 flag with specified name, default value, and usage string.
   419	// The argument p points to an int64 variable in which to store the value of the flag.
   420	func Int64Var(p *int64, name string, value int64, usage string) {
   421		commandLine.Var(newInt64Value(value, p), name, usage)
   422	}
   423	
   424	// Int64 defines an int64 flag with specified name, default value, and usage string.
   425	// The return value is the address of an int64 variable that stores the value of the flag.
   426	func (f *FlagSet) Int64(name string, value int64, usage string) *int64 {
   427		p := new(int64)
   428		f.Int64Var(p, name, value, usage)
   429		return p
   430	}
   431	
   432	// Int64 defines an int64 flag with specified name, default value, and usage string.
   433	// The return value is the address of an int64 variable that stores the value of the flag.
   434	func Int64(name string, value int64, usage string) *int64 {
   435		return commandLine.Int64(name, value, usage)
   436	}
   437	
   438	// UintVar defines a uint flag with specified name, default value, and usage string.
   439	// The argument p points to a uint variable in which to store the value of the flag.
   440	func (f *FlagSet) UintVar(p *uint, name string, value uint, usage string) {
   441		f.Var(newUintValue(value, p), name, usage)
   442	}
   443	
   444	// UintVar defines a uint flag with specified name, default value, and usage string.
   445	// The argument p points to a uint  variable in which to store the value of the flag.
   446	func UintVar(p *uint, name string, value uint, usage string) {
   447		commandLine.Var(newUintValue(value, p), name, usage)
   448	}
   449	
   450	// Uint defines a uint flag with specified name, default value, and usage string.
   451	// The return value is the address of a uint  variable that stores the value of the flag.
   452	func (f *FlagSet) Uint(name string, value uint, usage string) *uint {
   453		p := new(uint)
   454		f.UintVar(p, name, value, usage)
   455		return p
   456	}
   457	
   458	// Uint defines a uint flag with specified name, default value, and usage string.
   459	// The return value is the address of a uint  variable that stores the value of the flag.
   460	func Uint(name string, value uint, usage string) *uint {
   461		return commandLine.Uint(name, value, usage)
   462	}
   463	
   464	// Uint64Var defines a uint64 flag with specified name, default value, and usage string.
   465	// The argument p points to a uint64 variable in which to store the value of the flag.
   466	func (f *FlagSet) Uint64Var(p *uint64, name string, value uint64, usage string) {
   467		f.Var(newUint64Value(value, p), name, usage)
   468	}
   469	
   470	// Uint64Var defines a uint64 flag with specified name, default value, and usage string.
   471	// The argument p points to a uint64 variable in which to store the value of the flag.
   472	func Uint64Var(p *uint64, name string, value uint64, usage string) {
   473		commandLine.Var(newUint64Value(value, p), name, usage)
   474	}
   475	
   476	// Uint64 defines a uint64 flag with specified name, default value, and usage string.
   477	// The return value is the address of a uint64 variable that stores the value of the flag.
   478	func (f *FlagSet) Uint64(name string, value uint64, usage string) *uint64 {
   479		p := new(uint64)
   480		f.Uint64Var(p, name, value, usage)
   481		return p
   482	}
   483	
   484	// Uint64 defines a uint64 flag with specified name, default value, and usage string.
   485	// The return value is the address of a uint64 variable that stores the value of the flag.
   486	func Uint64(name string, value uint64, usage string) *uint64 {
   487		return commandLine.Uint64(name, value, usage)
   488	}
   489	
   490	// StringVar defines a string flag with specified name, default value, and usage string.
   491	// The argument p points to a string variable in which to store the value of the flag.
   492	func (f *FlagSet) StringVar(p *string, name string, value string, usage string) {
   493		f.Var(newStringValue(value, p), name, usage)
   494	}
   495	
   496	// StringVar defines a string flag with specified name, default value, and usage string.
   497	// The argument p points to a string variable in which to store the value of the flag.
   498	func StringVar(p *string, name string, value string, usage string) {
   499		commandLine.Var(newStringValue(value, p), name, usage)
   500	}
   501	
   502	// String defines a string flag with specified name, default value, and usage string.
   503	// The return value is the address of a string variable that stores the value of the flag.
   504	func (f *FlagSet) String(name string, value string, usage string) *string {
   505		p := new(string)
   506		f.StringVar(p, name, value, usage)
   507		return p
   508	}
   509	
   510	// String defines a string flag with specified name, default value, and usage string.
   511	// The return value is the address of a string variable that stores the value of the flag.
   512	func String(name string, value string, usage string) *string {
   513		return commandLine.String(name, value, usage)
   514	}
   515	
   516	// Float64Var defines a float64 flag with specified name, default value, and usage string.
   517	// The argument p points to a float64 variable in which to store the value of the flag.
   518	func (f *FlagSet) Float64Var(p *float64, name string, value float64, usage string) {
   519		f.Var(newFloat64Value(value, p), name, usage)
   520	}
   521	
   522	// Float64Var defines a float64 flag with specified name, default value, and usage string.
   523	// The argument p points to a float64 variable in which to store the value of the flag.
   524	func Float64Var(p *float64, name string, value float64, usage string) {
   525		commandLine.Var(newFloat64Value(value, p), name, usage)
   526	}
   527	
   528	// Float64 defines a float64 flag with specified name, default value, and usage string.
   529	// The return value is the address of a float64 variable that stores the value of the flag.
   530	func (f *FlagSet) Float64(name string, value float64, usage string) *float64 {
   531		p := new(float64)
   532		f.Float64Var(p, name, value, usage)
   533		return p
   534	}
   535	
   536	// Float64 defines an int flag with specified name, default value, and usage string.
   537	// The return value is the address of a float64 variable that stores the value of the flag.
   538	func Float64(name string, value float64, usage string) *float64 {
   539		return commandLine.Float64(name, value, usage)
   540	}
   541	
   542	// Var defines a flag with the specified name and usage string. The type and
   543	// value of the flag are represented by the first argument, of type Value, which
   544	// typically holds a user-defined implementation of Value. For instance, the
   545	// caller could create a flag that turns a comma-separated string into a slice
   546	// of strings by giving the slice the methods of Value; in particular, Set would
   547	// decompose the comma-separated string into the slice.
   548	func (f *FlagSet) Var(value Value, name string, usage string) {
   549		// Remember the default value as a string; it won't change.
   550		flag := &Flag{name, usage, value, value.String()}
   551		_, alreadythere := f.formal[name]
   552		if alreadythere {
   553			fmt.Fprintf(os.Stderr, "%s flag redefined: %s\n", f.name, name)
   554			panic("flag redefinition") // Happens only if flags are declared with identical names
   555		}
   556		f.formal[name] = flag
   557	}
   558	
   559	// Var defines a flag with the specified name and usage string. The type and
   560	// value of the flag are represented by the first argument, of type Value, which
   561	// typically holds a user-defined implementation of Value. For instance, the
   562	// caller could create a flag that turns a comma-separated string into a slice
   563	// of strings by giving the slice the methods of Value; in particular, Set would
   564	// decompose the comma-separated string into the slice.
   565	func Var(value Value, name string, usage string) {
   566		commandLine.Var(value, name, usage)
   567	}
   568	
   569	// failf prints to standard error a formatted error and usage message and
   570	// returns the error.
   571	func (f *FlagSet) failf(format string, a ...interface{}) os.Error {
   572		err := fmt.Errorf(format, a...)
   573		fmt.Fprintln(os.Stderr, err)
   574		f.usage()
   575		return err
   576	}
   577	
   578	// usage calls the Usage method for the flag set, or the usage function if
   579	// the flag set is commandLine.
   580	func (f *FlagSet) usage() {
   581		if f == commandLine {
   582			Usage()
   583		} else {
   584			f.Usage()
   585		}
   586	}
   587	
   588	// parseOne parses one flag. It returns whether a flag was seen.
   589	func (f *FlagSet) parseOne() (bool, os.Error) {
   590		if len(f.args) == 0 {
   591			return false, nil
   592		}
   593		s := f.args[0]
   594		if len(s) == 0 || s[0] != '-' || len(s) == 1 {
   595			return false, nil
   596		}
   597		num_minuses := 1
   598		if s[1] == '-' {
   599			num_minuses++
   600			if len(s) == 2 { // "--" terminates the flags
   601				f.args = f.args[1:]
   602				return false, nil
   603			}
   604		}
   605		name := s[num_minuses:]
   606		if len(name) == 0 || name[0] == '-' || name[0] == '=' {
   607			return false, f.failf("bad flag syntax: %s", s)
   608		}
   609	
   610		// it's a flag. does it have an argument?
   611		f.args = f.args[1:]
   612		has_value := false
   613		value := ""
   614		for i := 1; i < len(name); i++ { // equals cannot be first
   615			if name[i] == '=' {
   616				value = name[i+1:]
   617				has_value = true
   618				name = name[0:i]
   619				break
   620			}
   621		}
   622		m := f.formal
   623		flag, alreadythere := m[name] // BUG
   624		if !alreadythere {
   625			if name == "help" || name == "h" { // special case for nice help message.
   626				f.usage()
   627				return false, ErrHelp
   628			}
   629			return false, f.failf("flag provided but not defined: -%s", name)
   630		}
   631		if fv, ok := flag.Value.(*boolValue); ok { // special case: doesn't need an arg
   632			if has_value {
   633				if !fv.Set(value) {
   634					f.failf("invalid boolean value %q for flag: -%s", value, name)
   635				}
   636			} else {
   637				fv.Set("true")
   638			}
   639		} else {
   640			// It must have a value, which might be the next argument.
   641			if !has_value && len(f.args) > 0 {
   642				// value is the next arg
   643				has_value = true
   644				value, f.args = f.args[0], f.args[1:]
   645			}
   646			if !has_value {
   647				return false, f.failf("flag needs an argument: -%s", name)
   648			}
   649			ok = flag.Value.Set(value)
   650			if !ok {
   651				return false, f.failf("invalid value %q for flag: -%s", value, name)
   652			}
   653		}
   654		f.actual[name] = flag
   655		return true, nil
   656	}
   657	
   658	// Parse parses flag definitions from the argument list, which should not
   659	// include the command name.  Must be called after all flags in the FlagSet
   660	// are defined and before flags are accessed by the program.
   661	// The return value will be ErrHelp if -help was set but not defined.
   662	func (f *FlagSet) Parse(arguments []string) os.Error {
   663		f.args = arguments
   664		for {
   665			seen, err := f.parseOne()
   666			if seen {
   667				continue
   668			}
   669			if err == nil {
   670				break
   671			}
   672			switch f.errorHandling {
   673			case ContinueOnError:
   674				return err
   675			case ExitOnError:
   676				os.Exit(2)
   677			case PanicOnError:
   678				panic(err)
   679			}
   680		}
   681		return nil
   682	}
   683	
   684	// Parse parses the command-line flags from os.Args[1:].  Must be called
   685	// after all flags are defined and before flags are accessed by the program.
   686	func Parse() {
   687		// Ignore errors; commandLine is set for ExitOnError.
   688		commandLine.Parse(os.Args[1:])
   689	}
   690	
   691	// The default set of command-line flags, parsed from os.Args.
   692	var commandLine = NewFlagSet(os.Args[0], ExitOnError)
   693	
   694	// NewFlagSet returns a new, empty flag set with the specified name and
   695	// error handling property.
   696	func NewFlagSet(name string, errorHandling ErrorHandling) *FlagSet {
   697		f := &FlagSet{
   698			name:          name,
   699			actual:        make(map[string]*Flag),
   700			formal:        make(map[string]*Flag),
   701			errorHandling: errorHandling,
   702		}
   703		f.Usage = func() { defaultUsage(f) }
   704		return f
   705	}

release.r60.3. Except as noted, this content is licensed under a Creative Commons Attribution 3.0 License.