Merge pull request #7 from alecthomas/master
Compatibility: commandLine -> CommandLine
diff --git a/bool.go b/bool.go
index 4fd891a..60beb54 100644
--- a/bool.go
+++ b/bool.go
@@ -35,12 +35,12 @@
// BoolVar defines a bool flag with specified name, default value, and usage string.
// The argument p points to a bool variable in which to store the value of the flag.
func BoolVar(p *bool, name string, value bool, usage string) {
- commandLine.VarP(newBoolValue(value, p), name, "", usage)
+ CommandLine.VarP(newBoolValue(value, p), name, "", usage)
}
// Like BoolVar, but accepts a shorthand letter that can be used after a single dash.
func BoolVarP(p *bool, name, shorthand string, value bool, usage string) {
- commandLine.VarP(newBoolValue(value, p), name, shorthand, usage)
+ CommandLine.VarP(newBoolValue(value, p), name, shorthand, usage)
}
// Bool defines a bool flag with specified name, default value, and usage string.
@@ -61,10 +61,10 @@
// Bool defines a bool flag with specified name, default value, and usage string.
// The return value is the address of a bool variable that stores the value of the flag.
func Bool(name string, value bool, usage string) *bool {
- return commandLine.BoolP(name, "", value, usage)
+ return CommandLine.BoolP(name, "", value, usage)
}
// Like Bool, but accepts a shorthand letter that can be used after a single dash.
func BoolP(name, shorthand string, value bool, usage string) *bool {
- return commandLine.BoolP(name, shorthand, value, usage)
+ return CommandLine.BoolP(name, shorthand, value, usage)
}
diff --git a/duration.go b/duration.go
index d885f7c..db59463 100644
--- a/duration.go
+++ b/duration.go
@@ -39,12 +39,12 @@
// DurationVar defines a time.Duration flag with specified name, default value, and usage string.
// The argument p points to a time.Duration variable in which to store the value of the flag.
func DurationVar(p *time.Duration, name string, value time.Duration, usage string) {
- commandLine.VarP(newDurationValue(value, p), name, "", usage)
+ CommandLine.VarP(newDurationValue(value, p), name, "", usage)
}
// Like DurationVar, but accepts a shorthand letter that can be used after a single dash.
func DurationVarP(p *time.Duration, name, shorthand string, value time.Duration, usage string) {
- commandLine.VarP(newDurationValue(value, p), name, shorthand, usage)
+ CommandLine.VarP(newDurationValue(value, p), name, shorthand, usage)
}
// Duration defines a time.Duration flag with specified name, default value, and usage string.
@@ -65,10 +65,10 @@
// Duration defines a time.Duration flag with specified name, default value, and usage string.
// The return value is the address of a time.Duration variable that stores the value of the flag.
func Duration(name string, value time.Duration, usage string) *time.Duration {
- return commandLine.DurationP(name, "", value, usage)
+ return CommandLine.DurationP(name, "", value, usage)
}
// Like Duration, but accepts a shorthand letter that can be used after a single dash.
func DurationP(name, shorthand string, value time.Duration, usage string) *time.Duration {
- return commandLine.DurationP(name, shorthand, value, usage)
+ return CommandLine.DurationP(name, shorthand, value, usage)
}
diff --git a/export_test.go b/export_test.go
index 8c74635..9318fee 100644
--- a/export_test.go
+++ b/export_test.go
@@ -15,7 +15,7 @@
// After calling ResetForTesting, parse errors in flag handling will not
// exit the program.
func ResetForTesting(usage func()) {
- commandLine = &FlagSet{
+ CommandLine = &FlagSet{
name: os.Args[0],
errorHandling: ContinueOnError,
output: ioutil.Discard,
@@ -23,7 +23,7 @@
Usage = usage
}
-// CommandLine returns the default FlagSet.
-func CommandLine() *FlagSet {
- return commandLine
+// GetCommandLine returns the default FlagSet.
+func GetCommandLine() *FlagSet {
+ return CommandLine
}
diff --git a/flag.go b/flag.go
index b4b7b85..1e574d7 100644
--- a/flag.go
+++ b/flag.go
@@ -187,7 +187,7 @@
// VisitAll visits the command-line flags in lexicographical order, calling
// fn for each. It visits all flags, even those not set.
func VisitAll(fn func(*Flag)) {
- commandLine.VisitAll(fn)
+ CommandLine.VisitAll(fn)
}
// Visit visits the flags in lexicographical order, calling fn for each.
@@ -201,7 +201,7 @@
// Visit visits the command-line flags in lexicographical order, calling fn
// for each. It visits only those flags that have been set.
func Visit(fn func(*Flag)) {
- commandLine.Visit(fn)
+ CommandLine.Visit(fn)
}
// Lookup returns the Flag structure of the named flag, returning nil if none exists.
@@ -212,7 +212,7 @@
// Lookup returns the Flag structure of the named command-line flag,
// returning nil if none exists.
func Lookup(name string) *Flag {
- return commandLine.formal[name]
+ return CommandLine.formal[name]
}
// Set sets the value of the named flag.
@@ -234,7 +234,7 @@
// Set sets the value of the named command-line flag.
func Set(name, value string) error {
- return commandLine.Set(name, value)
+ return CommandLine.Set(name, value)
}
// PrintDefaults prints, to standard error unless configured
@@ -257,7 +257,7 @@
// PrintDefaults prints to standard error the default values of all defined command-line flags.
func PrintDefaults() {
- commandLine.PrintDefaults()
+ CommandLine.PrintDefaults()
}
// defaultUsage is the default function to print a usage message.
@@ -266,7 +266,7 @@
f.PrintDefaults()
}
-// NOTE: Usage is not just defaultUsage(commandLine)
+// NOTE: Usage is not just defaultUsage(CommandLine)
// because it serves (via godoc flag Usage) as the example
// for how to write your own usage function.
@@ -281,7 +281,7 @@
func (f *FlagSet) NFlag() int { return len(f.actual) }
// NFlag returns the number of command-line flags that have been set.
-func NFlag() int { return len(commandLine.actual) }
+func NFlag() int { return len(CommandLine.actual) }
// Arg returns the i'th argument. Arg(0) is the first remaining argument
// after flags have been processed.
@@ -295,20 +295,20 @@
// Arg returns the i'th command-line argument. Arg(0) is the first remaining argument
// after flags have been processed.
func Arg(i int) string {
- return commandLine.Arg(i)
+ return CommandLine.Arg(i)
}
// NArg is the number of arguments remaining after flags have been processed.
func (f *FlagSet) NArg() int { return len(f.args) }
// NArg is the number of arguments remaining after flags have been processed.
-func NArg() int { return len(commandLine.args) }
+func NArg() int { return len(CommandLine.args) }
// Args returns the non-flag arguments.
func (f *FlagSet) Args() []string { return f.args }
// Args returns the non-flag command-line arguments.
-func Args() []string { return commandLine.args }
+func Args() []string { return CommandLine.args }
// Var defines a flag with the specified name and usage string. The type and
// value of the flag are represented by the first argument, of type Value, which
@@ -361,12 +361,12 @@
// of strings by giving the slice the methods of Value; in particular, Set would
// decompose the comma-separated string into the slice.
func Var(value Value, name string, usage string) {
- commandLine.VarP(value, name, "", usage)
+ CommandLine.VarP(value, name, "", usage)
}
// Like Var, but accepts a shorthand letter that can be used after a single dash.
func VarP(value Value, name, shorthand, usage string) {
- commandLine.VarP(value, name, shorthand, usage)
+ CommandLine.VarP(value, name, shorthand, usage)
}
// failf prints to standard error a formatted error and usage message and
@@ -379,9 +379,9 @@
}
// usage calls the Usage method for the flag set, or the usage function if
-// the flag set is commandLine.
+// the flag set is CommandLine.
func (f *FlagSet) usage() {
- if f == commandLine {
+ if f == CommandLine {
Usage()
} else if f.Usage == nil {
defaultUsage(f)
@@ -512,22 +512,22 @@
// Parse parses the command-line flags from os.Args[1:]. Must be called
// after all flags are defined and before flags are accessed by the program.
func Parse() {
- // Ignore errors; commandLine is set for ExitOnError.
- commandLine.Parse(os.Args[1:])
+ // Ignore errors; CommandLine is set for ExitOnError.
+ CommandLine.Parse(os.Args[1:])
}
// Whether to support interspersed option/non-option arguments.
func SetInterspersed(interspersed bool) {
- commandLine.SetInterspersed(interspersed)
+ CommandLine.SetInterspersed(interspersed)
}
// Parsed returns true if the command-line flags have been parsed.
func Parsed() bool {
- return commandLine.Parsed()
+ return CommandLine.Parsed()
}
// The default set of command-line flags, parsed from os.Args.
-var commandLine = NewFlagSet(os.Args[0], ExitOnError)
+var CommandLine = NewFlagSet(os.Args[0], ExitOnError)
// NewFlagSet returns a new, empty flag set with the specified name and
// error handling property.
diff --git a/flag_test.go b/flag_test.go
index 42d5483..aa8682f 100644
--- a/flag_test.go
+++ b/flag_test.go
@@ -97,7 +97,7 @@
func TestUsage(t *testing.T) {
called := false
ResetForTesting(func() { called = true })
- if CommandLine().Parse([]string{"--x"}) == nil {
+ if GetCommandLine().Parse([]string{"--x"}) == nil {
t.Error("parse did not fail for unknown flag")
}
if !called {
@@ -224,7 +224,7 @@
func TestParse(t *testing.T) {
ResetForTesting(func() { t.Error("bad parse") })
- testParse(CommandLine(), t)
+ testParse(GetCommandLine(), t)
}
func TestFlagSetParse(t *testing.T) {
@@ -279,7 +279,7 @@
defer func() { os.Args = oldArgs }()
os.Args = []string{"cmd", "--before", "subcmd"}
before := Bool("before", false, "")
- if err := CommandLine().Parse(os.Args[1:]); err != nil {
+ if err := GetCommandLine().Parse(os.Args[1:]); err != nil {
t.Fatal(err)
}
cmd := Arg(0)
diff --git a/float32.go b/float32.go
index 7d37a10..a0041e2 100644
--- a/float32.go
+++ b/float32.go
@@ -35,12 +35,12 @@
// Float32Var defines a float32 flag with specified name, default value, and usage string.
// The argument p points to a float32 variable in which to store the value of the flag.
func Float32Var(p *float32, name string, value float32, usage string) {
- commandLine.VarP(newFloat32Value(value, p), name, "", usage)
+ CommandLine.VarP(newFloat32Value(value, p), name, "", usage)
}
// Like Float32Var, but accepts a shorthand letter that can be used after a single dash.
func Float32VarP(p *float32, name, shorthand string, value float32, usage string) {
- commandLine.VarP(newFloat32Value(value, p), name, shorthand, usage)
+ CommandLine.VarP(newFloat32Value(value, p), name, shorthand, usage)
}
// Float32 defines a float32 flag with specified name, default value, and usage string.
@@ -61,10 +61,10 @@
// Float32 defines a float32 flag with specified name, default value, and usage string.
// The return value is the address of a float32 variable that stores the value of the flag.
func Float32(name string, value float32, usage string) *float32 {
- return commandLine.Float32P(name, "", value, usage)
+ return CommandLine.Float32P(name, "", value, usage)
}
// Like Float32, but accepts a shorthand letter that can be used after a single dash.
func Float32P(name, shorthand string, value float32, usage string) *float32 {
- return commandLine.Float32P(name, shorthand, value, usage)
+ return CommandLine.Float32P(name, shorthand, value, usage)
}
diff --git a/float64.go b/float64.go
index 87ae59c..8d79be0 100644
--- a/float64.go
+++ b/float64.go
@@ -35,12 +35,12 @@
// Float64Var defines a float64 flag with specified name, default value, and usage string.
// The argument p points to a float64 variable in which to store the value of the flag.
func Float64Var(p *float64, name string, value float64, usage string) {
- commandLine.VarP(newFloat64Value(value, p), name, "", usage)
+ CommandLine.VarP(newFloat64Value(value, p), name, "", usage)
}
// Like Float64Var, but accepts a shorthand letter that can be used after a single dash.
func Float64VarP(p *float64, name, shorthand string, value float64, usage string) {
- commandLine.VarP(newFloat64Value(value, p), name, shorthand, usage)
+ CommandLine.VarP(newFloat64Value(value, p), name, shorthand, usage)
}
// Float64 defines a float64 flag with specified name, default value, and usage string.
@@ -61,10 +61,10 @@
// Float64 defines a float64 flag with specified name, default value, and usage string.
// The return value is the address of a float64 variable that stores the value of the flag.
func Float64(name string, value float64, usage string) *float64 {
- return commandLine.Float64P(name, "", value, usage)
+ return CommandLine.Float64P(name, "", value, usage)
}
// Like Float64, but accepts a shorthand letter that can be used after a single dash.
func Float64P(name, shorthand string, value float64, usage string) *float64 {
- return commandLine.Float64P(name, shorthand, value, usage)
+ return CommandLine.Float64P(name, shorthand, value, usage)
}
diff --git a/int.go b/int.go
index fca1a25..cb85e14 100644
--- a/int.go
+++ b/int.go
@@ -35,12 +35,12 @@
// IntVar defines an int flag with specified name, default value, and usage string.
// The argument p points to an int variable in which to store the value of the flag.
func IntVar(p *int, name string, value int, usage string) {
- commandLine.VarP(newIntValue(value, p), name, "", usage)
+ CommandLine.VarP(newIntValue(value, p), name, "", usage)
}
// Like IntVar, but accepts a shorthand letter that can be used after a single dash.
func IntVarP(p *int, name, shorthand string, value int, usage string) {
- commandLine.VarP(newIntValue(value, p), name, shorthand, usage)
+ CommandLine.VarP(newIntValue(value, p), name, shorthand, usage)
}
// Int defines an int flag with specified name, default value, and usage string.
@@ -61,10 +61,10 @@
// Int defines an int flag with specified name, default value, and usage string.
// The return value is the address of an int variable that stores the value of the flag.
func Int(name string, value int, usage string) *int {
- return commandLine.IntP(name, "", value, usage)
+ return CommandLine.IntP(name, "", value, usage)
}
// Like Int, but accepts a shorthand letter that can be used after a single dash.
func IntP(name, shorthand string, value int, usage string) *int {
- return commandLine.IntP(name, shorthand, value, usage)
+ return CommandLine.IntP(name, shorthand, value, usage)
}
diff --git a/int32.go b/int32.go
index d41f315..2e1a317 100644
--- a/int32.go
+++ b/int32.go
@@ -35,12 +35,12 @@
// Int32Var defines an int32 flag with specified name, default value, and usage string.
// The argument p points to an int32 variable in which to store the value of the flag.
func Int32Var(p *int32, name string, value int32, usage string) {
- commandLine.VarP(newInt32Value(value, p), name, "", usage)
+ CommandLine.VarP(newInt32Value(value, p), name, "", usage)
}
// Like Int32Var, but accepts a shorthand letter that can be used after a single dash.
func Int32VarP(p *int32, name, shorthand string, value int32, usage string) {
- commandLine.VarP(newInt32Value(value, p), name, shorthand, usage)
+ CommandLine.VarP(newInt32Value(value, p), name, shorthand, usage)
}
// Int32 defines an int32 flag with specified name, default value, and usage string.
@@ -61,10 +61,10 @@
// Int32 defines an int32 flag with specified name, default value, and usage string.
// The return value is the address of an int32 variable that stores the value of the flag.
func Int32(name string, value int32, usage string) *int32 {
- return commandLine.Int32P(name, "", value, usage)
+ return CommandLine.Int32P(name, "", value, usage)
}
// Like Int32, but accepts a shorthand letter that can be used after a single dash.
func Int32P(name, shorthand string, value int32, usage string) *int32 {
- return commandLine.Int32P(name, shorthand, value, usage)
+ return CommandLine.Int32P(name, shorthand, value, usage)
}
diff --git a/int64.go b/int64.go
index adb4bdc..43aeced 100644
--- a/int64.go
+++ b/int64.go
@@ -35,12 +35,12 @@
// Int64Var defines an int64 flag with specified name, default value, and usage string.
// The argument p points to an int64 variable in which to store the value of the flag.
func Int64Var(p *int64, name string, value int64, usage string) {
- commandLine.VarP(newInt64Value(value, p), name, "", usage)
+ CommandLine.VarP(newInt64Value(value, p), name, "", usage)
}
// Like Int64Var, but accepts a shorthand letter that can be used after a single dash.
func Int64VarP(p *int64, name, shorthand string, value int64, usage string) {
- commandLine.VarP(newInt64Value(value, p), name, shorthand, usage)
+ CommandLine.VarP(newInt64Value(value, p), name, shorthand, usage)
}
// Int64 defines an int64 flag with specified name, default value, and usage string.
@@ -61,10 +61,10 @@
// Int64 defines an int64 flag with specified name, default value, and usage string.
// The return value is the address of an int64 variable that stores the value of the flag.
func Int64(name string, value int64, usage string) *int64 {
- return commandLine.Int64P(name, "", value, usage)
+ return CommandLine.Int64P(name, "", value, usage)
}
// Like Int64, but accepts a shorthand letter that can be used after a single dash.
func Int64P(name, shorthand string, value int64, usage string) *int64 {
- return commandLine.Int64P(name, shorthand, value, usage)
+ return CommandLine.Int64P(name, shorthand, value, usage)
}
diff --git a/int8.go b/int8.go
index a169c1a..539c4eb 100644
--- a/int8.go
+++ b/int8.go
@@ -35,12 +35,12 @@
// Int8Var defines an int8 flag with specified name, default value, and usage string.
// The argument p points to an int8 variable in which to store the value of the flag.
func Int8Var(p *int8, name string, value int8, usage string) {
- commandLine.VarP(newInt8Value(value, p), name, "", usage)
+ CommandLine.VarP(newInt8Value(value, p), name, "", usage)
}
// Like Int8Var, but accepts a shorthand letter that can be used after a single dash.
func Int8VarP(p *int8, name, shorthand string, value int8, usage string) {
- commandLine.VarP(newInt8Value(value, p), name, shorthand, usage)
+ CommandLine.VarP(newInt8Value(value, p), name, shorthand, usage)
}
// Int8 defines an int8 flag with specified name, default value, and usage string.
@@ -61,10 +61,10 @@
// Int8 defines an int8 flag with specified name, default value, and usage string.
// The return value is the address of an int8 variable that stores the value of the flag.
func Int8(name string, value int8, usage string) *int8 {
- return commandLine.Int8P(name, "", value, usage)
+ return CommandLine.Int8P(name, "", value, usage)
}
// Like Int8, but accepts a shorthand letter that can be used after a single dash.
func Int8P(name, shorthand string, value int8, usage string) *int8 {
- return commandLine.Int8P(name, shorthand, value, usage)
+ return CommandLine.Int8P(name, shorthand, value, usage)
}
diff --git a/ip.go b/ip.go
index dccddc2..3a411fc 100644
--- a/ip.go
+++ b/ip.go
@@ -40,12 +40,12 @@
// IPVar defines an net.IP flag with specified name, default value, and usage string.
// The argument p points to an net.IP variable in which to store the value of the flag.
func IPVar(p *net.IP, name string, value net.IP, usage string) {
- commandLine.VarP(newIPValue(value, p), name, "", usage)
+ CommandLine.VarP(newIPValue(value, p), name, "", usage)
}
// Like IPVar, but accepts a shorthand letter that can be used after a single dash.
func IPVarP(p *net.IP, name, shorthand string, value net.IP, usage string) {
- commandLine.VarP(newIPValue(value, p), name, shorthand, usage)
+ CommandLine.VarP(newIPValue(value, p), name, shorthand, usage)
}
// IP defines an net.IP flag with specified name, default value, and usage string.
@@ -66,10 +66,10 @@
// IP defines an net.IP flag with specified name, default value, and usage string.
// The return value is the address of an net.IP variable that stores the value of the flag.
func IP(name string, value net.IP, usage string) *net.IP {
- return commandLine.IPP(name, "", value, usage)
+ return CommandLine.IPP(name, "", value, usage)
}
// Like IP, but accepts a shorthand letter that can be used after a single dash.
func IPP(name, shorthand string, value net.IP, usage string) *net.IP {
- return commandLine.IPP(name, shorthand, value, usage)
+ return CommandLine.IPP(name, shorthand, value, usage)
}
diff --git a/ipmask.go b/ipmask.go
index 35dc685..b8a164a 100644
--- a/ipmask.go
+++ b/ipmask.go
@@ -50,12 +50,12 @@
// IPMaskVar defines an net.IPMask flag with specified name, default value, and usage string.
// The argument p points to an net.IPMask variable in which to store the value of the flag.
func IPMaskVar(p *net.IPMask, name string, value net.IPMask, usage string) {
- commandLine.VarP(newIPMaskValue(value, p), name, "", usage)
+ CommandLine.VarP(newIPMaskValue(value, p), name, "", usage)
}
// Like IPMaskVar, but accepts a shorthand letter that can be used after a single dash.
func IPMaskVarP(p *net.IPMask, name, shorthand string, value net.IPMask, usage string) {
- commandLine.VarP(newIPMaskValue(value, p), name, shorthand, usage)
+ CommandLine.VarP(newIPMaskValue(value, p), name, shorthand, usage)
}
// IPMask defines an net.IPMask flag with specified name, default value, and usage string.
@@ -76,10 +76,10 @@
// IPMask defines an net.IPMask flag with specified name, default value, and usage string.
// The return value is the address of an net.IPMask variable that stores the value of the flag.
func IPMask(name string, value net.IPMask, usage string) *net.IPMask {
- return commandLine.IPMaskP(name, "", value, usage)
+ return CommandLine.IPMaskP(name, "", value, usage)
}
// Like IP, but accepts a shorthand letter that can be used after a single dash.
func IPMaskP(name, shorthand string, value net.IPMask, usage string) *net.IPMask {
- return commandLine.IPMaskP(name, shorthand, value, usage)
+ return CommandLine.IPMaskP(name, shorthand, value, usage)
}
diff --git a/string.go b/string.go
index b1ae258..65c0cb7 100644
--- a/string.go
+++ b/string.go
@@ -31,12 +31,12 @@
// StringVar defines a string flag with specified name, default value, and usage string.
// The argument p points to a string variable in which to store the value of the flag.
func StringVar(p *string, name string, value string, usage string) {
- commandLine.VarP(newStringValue(value, p), name, "", usage)
+ CommandLine.VarP(newStringValue(value, p), name, "", usage)
}
// Like StringVar, but accepts a shorthand letter that can be used after a single dash.
func StringVarP(p *string, name, shorthand string, value string, usage string) {
- commandLine.VarP(newStringValue(value, p), name, shorthand, usage)
+ CommandLine.VarP(newStringValue(value, p), name, shorthand, usage)
}
// String defines a string flag with specified name, default value, and usage string.
@@ -57,10 +57,10 @@
// String defines a string flag with specified name, default value, and usage string.
// The return value is the address of a string variable that stores the value of the flag.
func String(name string, value string, usage string) *string {
- return commandLine.StringP(name, "", value, usage)
+ return CommandLine.StringP(name, "", value, usage)
}
// Like String, but accepts a shorthand letter that can be used after a single dash.
func StringP(name, shorthand string, value string, usage string) *string {
- return commandLine.StringP(name, shorthand, value, usage)
+ return CommandLine.StringP(name, shorthand, value, usage)
}
diff --git a/uint.go b/uint.go
index cb0576d..40b9ebb 100644
--- a/uint.go
+++ b/uint.go
@@ -35,12 +35,12 @@
// UintVar defines a uint flag with specified name, default value, and usage string.
// The argument p points to a uint variable in which to store the value of the flag.
func UintVar(p *uint, name string, value uint, usage string) {
- commandLine.VarP(newUintValue(value, p), name, "", usage)
+ CommandLine.VarP(newUintValue(value, p), name, "", usage)
}
// Like UintVar, but accepts a shorthand letter that can be used after a single dash.
func UintVarP(p *uint, name, shorthand string, value uint, usage string) {
- commandLine.VarP(newUintValue(value, p), name, shorthand, usage)
+ CommandLine.VarP(newUintValue(value, p), name, shorthand, usage)
}
// Uint defines a uint flag with specified name, default value, and usage string.
@@ -61,10 +61,10 @@
// Uint defines a uint flag with specified name, default value, and usage string.
// The return value is the address of a uint variable that stores the value of the flag.
func Uint(name string, value uint, usage string) *uint {
- return commandLine.UintP(name, "", value, usage)
+ return CommandLine.UintP(name, "", value, usage)
}
// Like Uint, but accepts a shorthand letter that can be used after a single dash.
func UintP(name, shorthand string, value uint, usage string) *uint {
- return commandLine.UintP(name, shorthand, value, usage)
+ return CommandLine.UintP(name, shorthand, value, usage)
}
diff --git a/uint16.go b/uint16.go
index 284fba1..182dc40 100644
--- a/uint16.go
+++ b/uint16.go
@@ -36,12 +36,12 @@
// Uint16Var defines a uint flag with specified name, default value, and usage string.
// The argument p points to a uint variable in which to store the value of the flag.
func Uint16Var(p *uint16, name string, value uint16, usage string) {
- commandLine.VarP(newUint16Value(value, p), name, "", usage)
+ CommandLine.VarP(newUint16Value(value, p), name, "", usage)
}
// Like Uint16Var, but accepts a shorthand letter that can be used after a single dash.
func Uint16VarP(p *uint16, name, shorthand string, value uint16, usage string) {
- commandLine.VarP(newUint16Value(value, p), name, shorthand, usage)
+ CommandLine.VarP(newUint16Value(value, p), name, shorthand, usage)
}
// Uint16 defines a uint flag with specified name, default value, and usage string.
@@ -62,10 +62,10 @@
// Uint16 defines a uint flag with specified name, default value, and usage string.
// The return value is the address of a uint variable that stores the value of the flag.
func Uint16(name string, value uint16, usage string) *uint16 {
- return commandLine.Uint16P(name, "", value, usage)
+ return CommandLine.Uint16P(name, "", value, usage)
}
// Like Uint16, but accepts a shorthand letter that can be used after a single dash.
func Uint16P(name, shorthand string, value uint16, usage string) *uint16 {
- return commandLine.Uint16P(name, shorthand, value, usage)
+ return CommandLine.Uint16P(name, shorthand, value, usage)
}
diff --git a/uint32.go b/uint32.go
index 25b646b..165c8b2 100644
--- a/uint32.go
+++ b/uint32.go
@@ -36,12 +36,12 @@
// Uint32Var defines a uint32 flag with specified name, default value, and usage string.
// The argument p points to a uint32 variable in which to store the value of the flag.
func Uint32Var(p *uint32, name string, value uint32, usage string) {
- commandLine.VarP(newUint32Value(value, p), name, "", usage)
+ CommandLine.VarP(newUint32Value(value, p), name, "", usage)
}
// Like Uint32Var, but accepts a shorthand letter that can be used after a single dash.
func Uint32VarP(p *uint32, name, shorthand string, value uint32, usage string) {
- commandLine.VarP(newUint32Value(value, p), name, shorthand, usage)
+ CommandLine.VarP(newUint32Value(value, p), name, shorthand, usage)
}
// Uint32 defines a uint32 flag with specified name, default value, and usage string.
@@ -62,10 +62,10 @@
// Uint32 defines a uint32 flag with specified name, default value, and usage string.
// The return value is the address of a uint32 variable that stores the value of the flag.
func Uint32(name string, value uint32, usage string) *uint32 {
- return commandLine.Uint32P(name, "", value, usage)
+ return CommandLine.Uint32P(name, "", value, usage)
}
// Like Uint32, but accepts a shorthand letter that can be used after a single dash.
func Uint32P(name, shorthand string, value uint32, usage string) *uint32 {
- return commandLine.Uint32P(name, shorthand, value, usage)
+ return CommandLine.Uint32P(name, shorthand, value, usage)
}
diff --git a/uint64.go b/uint64.go
index 4d892a7..f41c5a2 100644
--- a/uint64.go
+++ b/uint64.go
@@ -35,12 +35,12 @@
// Uint64Var defines a uint64 flag with specified name, default value, and usage string.
// The argument p points to a uint64 variable in which to store the value of the flag.
func Uint64Var(p *uint64, name string, value uint64, usage string) {
- commandLine.VarP(newUint64Value(value, p), name, "", usage)
+ CommandLine.VarP(newUint64Value(value, p), name, "", usage)
}
// Like Uint64Var, but accepts a shorthand letter that can be used after a single dash.
func Uint64VarP(p *uint64, name, shorthand string, value uint64, usage string) {
- commandLine.VarP(newUint64Value(value, p), name, shorthand, usage)
+ CommandLine.VarP(newUint64Value(value, p), name, shorthand, usage)
}
// Uint64 defines a uint64 flag with specified name, default value, and usage string.
@@ -61,10 +61,10 @@
// Uint64 defines a uint64 flag with specified name, default value, and usage string.
// The return value is the address of a uint64 variable that stores the value of the flag.
func Uint64(name string, value uint64, usage string) *uint64 {
- return commandLine.Uint64P(name, "", value, usage)
+ return CommandLine.Uint64P(name, "", value, usage)
}
// Like Uint64, but accepts a shorthand letter that can be used after a single dash.
func Uint64P(name, shorthand string, value uint64, usage string) *uint64 {
- return commandLine.Uint64P(name, shorthand, value, usage)
+ return CommandLine.Uint64P(name, shorthand, value, usage)
}
diff --git a/uint8.go b/uint8.go
index 44cab5d..174f99c 100644
--- a/uint8.go
+++ b/uint8.go
@@ -35,12 +35,12 @@
// Uint8Var defines a uint8 flag with specified name, default value, and usage string.
// The argument p points to a uint8 variable in which to store the value of the flag.
func Uint8Var(p *uint8, name string, value uint8, usage string) {
- commandLine.VarP(newUint8Value(value, p), name, "", usage)
+ CommandLine.VarP(newUint8Value(value, p), name, "", usage)
}
// Like Uint8Var, but accepts a shorthand letter that can be used after a single dash.
func Uint8VarP(p *uint8, name, shorthand string, value uint8, usage string) {
- commandLine.VarP(newUint8Value(value, p), name, shorthand, usage)
+ CommandLine.VarP(newUint8Value(value, p), name, shorthand, usage)
}
// Uint8 defines a uint8 flag with specified name, default value, and usage string.
@@ -61,10 +61,10 @@
// Uint8 defines a uint8 flag with specified name, default value, and usage string.
// The return value is the address of a uint8 variable that stores the value of the flag.
func Uint8(name string, value uint8, usage string) *uint8 {
- return commandLine.Uint8P(name, "", value, usage)
+ return CommandLine.Uint8P(name, "", value, usage)
}
// Like Uint8, but accepts a shorthand letter that can be used after a single dash.
func Uint8P(name, shorthand string, value uint8, usage string) *uint8 {
- return commandLine.Uint8P(name, shorthand, value, usage)
+ return CommandLine.Uint8P(name, shorthand, value, usage)
}
