954 lines
27 KiB
Go
954 lines
27 KiB
Go
|
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
||
|
|
// Use of this source code is governed by a BSD-style
|
||
|
|
// license that can be found in the LICENSE file.
|
||
|
|
|
||
|
|
/*
|
||
|
|
Package gflag implements GNU-style command line flag parsing. It
|
||
|
|
supports the transformation of programs using the Go standard library
|
||
|
|
flag package. However it doesn't target full compatibility with the Go
|
||
|
|
standard library flag package. The Flag structure doesn't support all
|
||
|
|
fields of the flag package and the Var method and function does have a
|
||
|
|
different signature.
|
||
|
|
|
||
|
|
The typical use case looks like this:
|
||
|
|
|
||
|
|
b := Bool("flag-b", "b", false, "boolean flag")
|
||
|
|
h := Bool("help", "h", false, "prints this message")
|
||
|
|
|
||
|
|
Parse()
|
||
|
|
|
||
|
|
if *h {
|
||
|
|
gflag.Usage()
|
||
|
|
}
|
||
|
|
*/
|
||
|
|
package gflag
|
||
|
|
|
||
|
|
import (
|
||
|
|
"bytes"
|
||
|
|
"fmt"
|
||
|
|
"io"
|
||
|
|
"os"
|
||
|
|
"sort"
|
||
|
|
"strconv"
|
||
|
|
"strings"
|
||
|
|
)
|
||
|
|
|
||
|
|
// CommandLine is the default set of command-line flags parsed from
|
||
|
|
// os.Args. The top-level functions such as BoolVar, Arg, etc. are
|
||
|
|
// wrappers for the methods of command line.
|
||
|
|
var CommandLine = NewFlagSet(os.Args[0], ExitOnError)
|
||
|
|
|
||
|
|
// ErrorHandling defines how flag parsing errors are handled.
|
||
|
|
type ErrorHandling int
|
||
|
|
|
||
|
|
// The constants define how errors should be handled.
|
||
|
|
const (
|
||
|
|
ContinueOnError ErrorHandling = iota
|
||
|
|
ExitOnError
|
||
|
|
PanicOnError
|
||
|
|
)
|
||
|
|
|
||
|
|
// HasArg defines whether a flag argument is required, optional or not
|
||
|
|
// supported.
|
||
|
|
type HasArg int
|
||
|
|
|
||
|
|
// The constants define whether a flag argument is required, not
|
||
|
|
// supported or optional.
|
||
|
|
const (
|
||
|
|
RequiredArg HasArg = iota
|
||
|
|
NoArg
|
||
|
|
OptionalArg
|
||
|
|
)
|
||
|
|
|
||
|
|
// Value is the interface to the value of a specific flag.
|
||
|
|
type Value interface {
|
||
|
|
Set(string) error
|
||
|
|
Update()
|
||
|
|
Get() interface{}
|
||
|
|
String() string
|
||
|
|
}
|
||
|
|
|
||
|
|
// Flag represents a single flag.
|
||
|
|
type Flag struct {
|
||
|
|
Name string
|
||
|
|
Shorthands string
|
||
|
|
HasArg HasArg
|
||
|
|
Value Value
|
||
|
|
}
|
||
|
|
|
||
|
|
// line provides a single line of usage information.
|
||
|
|
type line struct {
|
||
|
|
flags string
|
||
|
|
usage string
|
||
|
|
}
|
||
|
|
|
||
|
|
// lineFlags computes the flags string for a usage line.
|
||
|
|
func lineFlags(name, shorthands, defaultValue string) string {
|
||
|
|
buf := new(bytes.Buffer)
|
||
|
|
if shorthands != "" {
|
||
|
|
for i, r := range shorthands {
|
||
|
|
if i > 0 {
|
||
|
|
fmt.Fprint(buf, ", ")
|
||
|
|
}
|
||
|
|
fmt.Fprintf(buf, "-%c", r)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if name != "" {
|
||
|
|
if buf.Len() > 0 {
|
||
|
|
fmt.Fprintf(buf, ", ")
|
||
|
|
}
|
||
|
|
fmt.Fprint(buf, "--", name)
|
||
|
|
if defaultValue != "" {
|
||
|
|
fmt.Fprintf(buf, "=%s", defaultValue)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return buf.String()
|
||
|
|
}
|
||
|
|
|
||
|
|
// lines provides a set of usage lines.
|
||
|
|
type lines []line
|
||
|
|
|
||
|
|
// writeLines writes usage line to the writer.
|
||
|
|
func writeLines(w io.Writer, ls lines) (n int, err error) {
|
||
|
|
l := make(lines, len(ls))
|
||
|
|
copy(l, ls)
|
||
|
|
sort.Sort(l)
|
||
|
|
maxLenFlags := 0
|
||
|
|
for _, line := range l {
|
||
|
|
k := len(line.flags)
|
||
|
|
if k > maxLenFlags {
|
||
|
|
maxLenFlags = k
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for _, line := range l {
|
||
|
|
format := fmt.Sprintf(" %%-%ds %%s\n", maxLenFlags)
|
||
|
|
var k int
|
||
|
|
k, err = fmt.Fprintf(w, format, line.flags, line.usage)
|
||
|
|
n += k
|
||
|
|
if err != nil {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
func (l lines) Len() int { return len(l) }
|
||
|
|
func (l lines) Swap(i, j int) { l[i], l[j] = l[j], l[i] }
|
||
|
|
func (l lines) Less(i, j int) bool { return l[i].flags < l[j].flags }
|
||
|
|
|
||
|
|
// FlagSet represents a set of option flags.
|
||
|
|
type FlagSet struct {
|
||
|
|
// Provides a custom usage function if set.
|
||
|
|
Usage func()
|
||
|
|
|
||
|
|
name string
|
||
|
|
parsed bool
|
||
|
|
actual map[string]*Flag
|
||
|
|
formal map[string]*Flag
|
||
|
|
lines lines
|
||
|
|
args []string
|
||
|
|
output io.Writer
|
||
|
|
errorHandling ErrorHandling
|
||
|
|
preset bool
|
||
|
|
}
|
||
|
|
|
||
|
|
// Init initializes a flag set variable.
|
||
|
|
func (f *FlagSet) Init(name string, errorHandling ErrorHandling) {
|
||
|
|
f.name = name
|
||
|
|
f.errorHandling = errorHandling
|
||
|
|
}
|
||
|
|
|
||
|
|
// NewFlagSet creates a new flag set.
|
||
|
|
func NewFlagSet(name string, errorHandling ErrorHandling) *FlagSet {
|
||
|
|
f := new(FlagSet)
|
||
|
|
f.Init(name, errorHandling)
|
||
|
|
return f
|
||
|
|
}
|
||
|
|
|
||
|
|
// Arg returns the argument number i after parsing has been successful.
|
||
|
|
func (f *FlagSet) Arg(i int) string {
|
||
|
|
if !(0 <= i && i < len(f.args)) {
|
||
|
|
return ""
|
||
|
|
}
|
||
|
|
return f.args[i]
|
||
|
|
}
|
||
|
|
|
||
|
|
// Arg provides the argument number i after parsing of the command line
|
||
|
|
// flags.
|
||
|
|
func Arg(i int) string {
|
||
|
|
return CommandLine.Arg(i)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Args returns all arguments after parsing.
|
||
|
|
func (f *FlagSet) Args() []string { return f.args }
|
||
|
|
|
||
|
|
// Args returns all arguments after the command line flags have been
|
||
|
|
// parsed.
|
||
|
|
func Args() []string { return CommandLine.args }
|
||
|
|
|
||
|
|
// NArg returns the number of remaining arguments after parsing.
|
||
|
|
func (f *FlagSet) NArg() int { return len(f.args) }
|
||
|
|
|
||
|
|
// NArg returns the number of remaining arguments after command line
|
||
|
|
// parsing.
|
||
|
|
func NArg() int { return len(CommandLine.args) }
|
||
|
|
|
||
|
|
// Parsed returns whether the command line has already been parsed.
|
||
|
|
func Parsed() bool {
|
||
|
|
return CommandLine.parsed
|
||
|
|
}
|
||
|
|
|
||
|
|
// Parsed returns whether the flag set has already been parsed.
|
||
|
|
func (f *FlagSet) Parsed() bool {
|
||
|
|
return f.parsed
|
||
|
|
}
|
||
|
|
|
||
|
|
// Parse parses the command line.
|
||
|
|
func Parse() {
|
||
|
|
// errors are ignored because CommandLine is set on ExitOnError
|
||
|
|
CommandLine.Parse(os.Args[1:])
|
||
|
|
}
|
||
|
|
|
||
|
|
// lookupLongOption looks up a long option flag.
|
||
|
|
func (f *FlagSet) lookupLongOption(name string) (flag *Flag, err error) {
|
||
|
|
if len(name) < 2 {
|
||
|
|
f.panicf("%s is not a long option", name)
|
||
|
|
}
|
||
|
|
var ok bool
|
||
|
|
if flag, ok = f.formal[name]; !ok {
|
||
|
|
return nil, fmt.Errorf("long option %s is unsupported", name)
|
||
|
|
}
|
||
|
|
if flag.Name != name {
|
||
|
|
f.panicf("got %s flag; want %s flag", flag.Name, name)
|
||
|
|
}
|
||
|
|
return flag, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// lookupShortOption looks a short option up.
|
||
|
|
func (f *FlagSet) lookupShortOption(r rune) (flag *Flag, err error) {
|
||
|
|
var ok bool
|
||
|
|
name := string([]rune{r})
|
||
|
|
if flag, ok = f.formal[name]; !ok {
|
||
|
|
return nil, fmt.Errorf("short option %s is unsupported", name)
|
||
|
|
}
|
||
|
|
if !strings.ContainsRune(flag.Shorthands, r) {
|
||
|
|
f.panicf("flag supports shorthands %q; but doesn't contain %s",
|
||
|
|
flag.Shorthands, name)
|
||
|
|
}
|
||
|
|
return flag, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// processExtraFlagArg processes a flag with extra arguments not using
|
||
|
|
// the form --long-option=arg.
|
||
|
|
func (f *FlagSet) processExtraFlagArg(flag *Flag, i int) error {
|
||
|
|
if flag.HasArg == NoArg {
|
||
|
|
// no argument required
|
||
|
|
flag.Value.Update()
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
if i < len(f.args) {
|
||
|
|
arg := f.args[i]
|
||
|
|
if len(arg) == 0 || arg[0] != '-' {
|
||
|
|
err := flag.Value.Set(arg)
|
||
|
|
switch flag.HasArg {
|
||
|
|
case RequiredArg:
|
||
|
|
f.removeArg(i)
|
||
|
|
return err
|
||
|
|
case OptionalArg:
|
||
|
|
if err != nil {
|
||
|
|
flag.Value.Update()
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
f.removeArg(i)
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// no argument
|
||
|
|
if flag.HasArg == RequiredArg {
|
||
|
|
return fmt.Errorf("no argument present")
|
||
|
|
}
|
||
|
|
// flag.HasArg == OptionalArg
|
||
|
|
flag.Value.Update()
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// removeArg removes the arguments at position i from the args field of
|
||
|
|
// the flag set.
|
||
|
|
func (f *FlagSet) removeArg(i int) {
|
||
|
|
copy(f.args[i:], f.args[i+1:])
|
||
|
|
f.args = f.args[:len(f.args)-1]
|
||
|
|
}
|
||
|
|
|
||
|
|
// parseArg parses the argument i.
|
||
|
|
func (f *FlagSet) parseArg(i int) (next int, err error) {
|
||
|
|
arg := f.args[i]
|
||
|
|
if len(arg) < 2 || arg[0] != '-' {
|
||
|
|
return i + 1, nil
|
||
|
|
}
|
||
|
|
if arg[1] == '-' {
|
||
|
|
// argument starts with --
|
||
|
|
f.removeArg(i)
|
||
|
|
if len(arg) == 2 {
|
||
|
|
// argument is --; remove it and ignore all
|
||
|
|
// following arguments
|
||
|
|
return len(f.args), nil
|
||
|
|
}
|
||
|
|
arg = arg[2:]
|
||
|
|
flagArg := strings.SplitN(arg, "=", 2)
|
||
|
|
flag, err := f.lookupLongOption(flagArg[0])
|
||
|
|
if err != nil {
|
||
|
|
return i, err
|
||
|
|
}
|
||
|
|
// case 1: no equal sign
|
||
|
|
if len(flagArg) == 1 {
|
||
|
|
err = f.processExtraFlagArg(flag, i)
|
||
|
|
return i, err
|
||
|
|
}
|
||
|
|
// case 2: equal sign
|
||
|
|
if flag.HasArg == NoArg {
|
||
|
|
err = fmt.Errorf("option %s doesn't support argument",
|
||
|
|
arg)
|
||
|
|
} else {
|
||
|
|
err = flag.Value.Set(flagArg[1])
|
||
|
|
}
|
||
|
|
return i, err
|
||
|
|
}
|
||
|
|
// short options
|
||
|
|
f.removeArg(i)
|
||
|
|
arg = arg[1:]
|
||
|
|
for _, r := range arg {
|
||
|
|
flag, err := f.lookupShortOption(r)
|
||
|
|
if err != nil {
|
||
|
|
return i, err
|
||
|
|
}
|
||
|
|
if err = f.processExtraFlagArg(flag, i); err != nil {
|
||
|
|
return i, err
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return i, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// defaultUsage provides the default usage information.
|
||
|
|
func defaultUsage(f *FlagSet) {
|
||
|
|
if f.name == "" {
|
||
|
|
fmt.Fprintf(f.out(), "Usage:\n")
|
||
|
|
} else {
|
||
|
|
fmt.Fprintf(f.out(), "Usage of %s:\n", f.name)
|
||
|
|
}
|
||
|
|
f.PrintDefaults()
|
||
|
|
}
|
||
|
|
|
||
|
|
// Usage prints the default usage message.
|
||
|
|
var Usage = func() {
|
||
|
|
fmt.Fprintf(CommandLine.out(), "Usage of %s:\n", os.Args[0])
|
||
|
|
PrintDefaults()
|
||
|
|
}
|
||
|
|
|
||
|
|
// usage provides the usage information for the flag set.
|
||
|
|
func (f *FlagSet) usage() {
|
||
|
|
if f.Usage == nil {
|
||
|
|
if f == CommandLine {
|
||
|
|
Usage()
|
||
|
|
} else {
|
||
|
|
defaultUsage(f)
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
f.Usage()
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Parse parses the arguments. If an error happens the error is printed
|
||
|
|
// as well as the usage information.
|
||
|
|
func (f *FlagSet) Parse(arguments []string) error {
|
||
|
|
f.parsed = true
|
||
|
|
f.args = arguments
|
||
|
|
for i := 0; i < len(f.args); {
|
||
|
|
var err error
|
||
|
|
i, err = f.parseArg(i)
|
||
|
|
if err == nil {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
fmt.Fprintf(f.out(), "%s: %s\n", f.name, err)
|
||
|
|
f.usage()
|
||
|
|
switch f.errorHandling {
|
||
|
|
case ContinueOnError:
|
||
|
|
return err
|
||
|
|
case ExitOnError:
|
||
|
|
os.Exit(2)
|
||
|
|
case PanicOnError:
|
||
|
|
panic(err)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// PrintDefaults prints information about all flags.
|
||
|
|
func (f *FlagSet) PrintDefaults() {
|
||
|
|
_, err := writeLines(f.out(), f.lines)
|
||
|
|
if err != nil {
|
||
|
|
f.panicf("writeLines error %s", err)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// PrintDefaults prints the information about all command line flags.
|
||
|
|
func PrintDefaults() {
|
||
|
|
CommandLine.PrintDefaults()
|
||
|
|
}
|
||
|
|
|
||
|
|
// out returns a writer. If the field output has not been set os.Stderr
|
||
|
|
// is returned.
|
||
|
|
func (f *FlagSet) out() io.Writer {
|
||
|
|
if f.output == nil {
|
||
|
|
return os.Stderr
|
||
|
|
}
|
||
|
|
return f.output
|
||
|
|
}
|
||
|
|
|
||
|
|
// SetOutput sets the default output writer for the flag set.
|
||
|
|
func (f *FlagSet) SetOutput(w io.Writer) {
|
||
|
|
f.output = w
|
||
|
|
}
|
||
|
|
|
||
|
|
// panicf prints a formatted error message and panics.
|
||
|
|
func (f *FlagSet) panicf(format string, values ...interface{}) {
|
||
|
|
var msg string
|
||
|
|
if f.name == "" {
|
||
|
|
msg = fmt.Sprintf(format, values...)
|
||
|
|
} else {
|
||
|
|
v := make([]interface{}, 1+len(values))
|
||
|
|
v[0] = f.name
|
||
|
|
copy(v[1:], values)
|
||
|
|
msg = fmt.Sprintf("%s "+format, v...)
|
||
|
|
}
|
||
|
|
fmt.Fprintln(f.out(), msg)
|
||
|
|
panic(msg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// setFormal sets the flag with the given name to the flag parameter.
|
||
|
|
func (f *FlagSet) setFormal(name string, flag *Flag) {
|
||
|
|
if name == "" {
|
||
|
|
f.panicf("no support for empty name strings")
|
||
|
|
}
|
||
|
|
if _, alreadythere := f.formal[name]; alreadythere {
|
||
|
|
f.panicf("flag redefined: %s", flag.Name)
|
||
|
|
}
|
||
|
|
if f.formal == nil {
|
||
|
|
f.formal = make(map[string]*Flag)
|
||
|
|
}
|
||
|
|
f.formal[name] = flag
|
||
|
|
}
|
||
|
|
|
||
|
|
// VarP creates a flag with a long and shorthand options.
|
||
|
|
func (f *FlagSet) VarP(value Value, name, shorthands string, hasArg HasArg) {
|
||
|
|
flag := &Flag{
|
||
|
|
Name: name,
|
||
|
|
Shorthands: shorthands,
|
||
|
|
Value: value,
|
||
|
|
HasArg: hasArg,
|
||
|
|
}
|
||
|
|
|
||
|
|
if flag.Name == "" && flag.Shorthands == "" {
|
||
|
|
f.panicf("flag with no name or shorthands")
|
||
|
|
}
|
||
|
|
if len(flag.Name) == 1 {
|
||
|
|
f.panicf("flag has single character name %q; use shorthands",
|
||
|
|
flag.Name)
|
||
|
|
}
|
||
|
|
if flag.Name != "" {
|
||
|
|
f.setFormal(flag.Name, flag)
|
||
|
|
}
|
||
|
|
if flag.Shorthands != "" {
|
||
|
|
for _, r := range flag.Shorthands {
|
||
|
|
name := string([]rune{r})
|
||
|
|
f.setFormal(name, flag)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// VarP creates a flag for the given value for the command line.
|
||
|
|
func VarP(value Value, name, shorthands string, hasArg HasArg) {
|
||
|
|
CommandLine.VarP(value, name, shorthands, hasArg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Var creates a flag for the given option name.
|
||
|
|
func (f *FlagSet) Var(value Value, name string, hasArg HasArg) {
|
||
|
|
shorthands := ""
|
||
|
|
if len(name) == 1 {
|
||
|
|
shorthands = name
|
||
|
|
name = ""
|
||
|
|
}
|
||
|
|
f.VarP(value, name, shorthands, hasArg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Var creates a flag for the given option name for the command line.
|
||
|
|
func Var(value Value, name string, hasArg HasArg) {
|
||
|
|
CommandLine.Var(value, name, hasArg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// addLine adds a usage line to the flag set.
|
||
|
|
func (f *FlagSet) addLine(l line) {
|
||
|
|
if l.flags == "" {
|
||
|
|
f.panicf("no flags for %q", l.usage)
|
||
|
|
}
|
||
|
|
f.lines = append(f.lines, l)
|
||
|
|
}
|
||
|
|
|
||
|
|
// boolValue represents a bool value in the flag.
|
||
|
|
type boolValue bool
|
||
|
|
|
||
|
|
// newBoolValue creates a new Bool Value.
|
||
|
|
func newBoolValue(val bool, p *bool) *boolValue {
|
||
|
|
*p = val
|
||
|
|
return (*boolValue)(p)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get returns the bool value as boolean.
|
||
|
|
func (b *boolValue) Get() interface{} {
|
||
|
|
return bool(*b)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Set sets the bool value to the value provided by the string.
|
||
|
|
func (b *boolValue) Set(s string) error {
|
||
|
|
v, err := strconv.ParseBool(s)
|
||
|
|
*b = boolValue(v)
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
|
||
|
|
// Update sets the bool value to true.
|
||
|
|
func (b *boolValue) Update() {
|
||
|
|
*b = true
|
||
|
|
}
|
||
|
|
|
||
|
|
// String returns the boll value as string.
|
||
|
|
func (b *boolValue) String() string {
|
||
|
|
return fmt.Sprintf("%t", *b)
|
||
|
|
}
|
||
|
|
|
||
|
|
// boolLine creates the usage line for a bool flag.
|
||
|
|
func boolLine(name, shorthands string, value bool, usage string) line {
|
||
|
|
defaultValue := ""
|
||
|
|
if value {
|
||
|
|
defaultValue = "true"
|
||
|
|
}
|
||
|
|
return line{lineFlags(name, shorthands, defaultValue), usage}
|
||
|
|
}
|
||
|
|
|
||
|
|
// BoolVarP defines a bool flag with specified name, shorthands, default
|
||
|
|
// value and usage string. The argument p points to a bool variable in
|
||
|
|
// which to store the value of the flag.
|
||
|
|
func (f *FlagSet) BoolVarP(p *bool, name, shorthands string, value bool, usage string) {
|
||
|
|
f.addLine(boolLine(name, shorthands, value, usage))
|
||
|
|
f.VarP(newBoolValue(value, p), name, shorthands, OptionalArg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// BoolP defines a bool flag with specified name, shorthands, default
|
||
|
|
// value and usage string. The return value is the address of a bool
|
||
|
|
// variable that stores the value of the flag.
|
||
|
|
func (f *FlagSet) BoolP(name, shorthands string, value bool, usage string) *bool {
|
||
|
|
p := new(bool)
|
||
|
|
f.BoolVarP(p, name, shorthands, value, usage)
|
||
|
|
return p
|
||
|
|
}
|
||
|
|
|
||
|
|
// BoolP defines a bool flag with specified name, shorthands, default
|
||
|
|
// value and usage string. The return value is the address of a bool
|
||
|
|
// variable that stores the value of the flag.
|
||
|
|
func BoolP(name, shorthands string, value bool, usage string) *bool {
|
||
|
|
return CommandLine.BoolP(name, shorthands, value, usage)
|
||
|
|
}
|
||
|
|
|
||
|
|
// BoolVarP defines a bool flag with specified name, shorthands, default
|
||
|
|
// value and usage string. The argument p points to a bool variable in
|
||
|
|
// which to store the value of the flag.
|
||
|
|
func BoolVarP(p *bool, name, shorthands string, value bool, usage string) {
|
||
|
|
CommandLine.BoolVarP(p, name, shorthands, value, usage)
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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 (f *FlagSet) BoolVar(p *bool, name string, value bool, usage string) {
|
||
|
|
f.addLine(boolLine(name, "", value, usage))
|
||
|
|
f.Var(newBoolValue(value, p), name, OptionalArg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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.BoolVar(p, name, value, usage)
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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 (f *FlagSet) Bool(name string, value bool, usage string) *bool {
|
||
|
|
p := new(bool)
|
||
|
|
f.BoolVar(p, name, value, usage)
|
||
|
|
return p
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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.Bool(name, value, usage)
|
||
|
|
}
|
||
|
|
|
||
|
|
// intValue stores an integer value.
|
||
|
|
type intValue int
|
||
|
|
|
||
|
|
// newIntValue allocates a new integer value and returns its pointer.
|
||
|
|
func newIntValue(val int, p *int) *intValue {
|
||
|
|
*p = val
|
||
|
|
return (*intValue)(p)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get returns the integer.
|
||
|
|
func (n *intValue) Get() interface{} {
|
||
|
|
return int(*n)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Set sets the integer value.
|
||
|
|
func (n *intValue) Set(s string) error {
|
||
|
|
v, err := strconv.ParseInt(s, 0, 0)
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
*n = intValue(v)
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// Update increments the integer value.
|
||
|
|
func (n *intValue) Update() {
|
||
|
|
(*n)++
|
||
|
|
}
|
||
|
|
|
||
|
|
// String represents the integer value as string.
|
||
|
|
func (n *intValue) String() string {
|
||
|
|
return fmt.Sprintf("%d", *n)
|
||
|
|
}
|
||
|
|
|
||
|
|
// counterLine returns the usage line for a counter flag.
|
||
|
|
func counterLine(name, shorthands, usage string) line {
|
||
|
|
return line{lineFlags(name, shorthands, ""), usage}
|
||
|
|
}
|
||
|
|
|
||
|
|
// CounterVarP defines a counter flag with specified name, shorthands, default
|
||
|
|
// value and usage string. The argument p points to an integer variable in
|
||
|
|
// which to store the value of the flag.
|
||
|
|
func (f *FlagSet) CounterVarP(p *int, name, shorthands string, value int, usage string) {
|
||
|
|
f.addLine(counterLine(name, shorthands, usage))
|
||
|
|
f.VarP(newIntValue(value, p), name, shorthands, OptionalArg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// CounterVarP defines a counter flag with specified name, shorthands, default
|
||
|
|
// value and usage string. The argument p points to an integer variable in
|
||
|
|
// which to store the value of the flag.
|
||
|
|
func CounterVarP(p *int, name, shorthands string, value int, usage string) {
|
||
|
|
CommandLine.CounterVarP(p, name, shorthands, value, usage)
|
||
|
|
}
|
||
|
|
|
||
|
|
// CounterP defines a counter flag with specified name, shorthands, default
|
||
|
|
// value and usage string. The return value is the address of an integer
|
||
|
|
// variable that stores the value of the flag.
|
||
|
|
func (f *FlagSet) CounterP(name, shorthands string, value int, usage string) *int {
|
||
|
|
p := new(int)
|
||
|
|
f.CounterVarP(p, name, shorthands, value, usage)
|
||
|
|
return p
|
||
|
|
}
|
||
|
|
|
||
|
|
// CounterP defines a counter flag with specified name, shorthands, default
|
||
|
|
// value and usage string. The return value is the address of an integer
|
||
|
|
// variable that stores the value of the flag.
|
||
|
|
func CounterP(name, shorthands string, value int, usage string) *int {
|
||
|
|
return CommandLine.CounterP(name, shorthands, value, usage)
|
||
|
|
}
|
||
|
|
|
||
|
|
// CounterVar defines a counter flag with specified name, default value and
|
||
|
|
// usage string. The argument p points to an integer variable in which to
|
||
|
|
// store the value of the flag.
|
||
|
|
func (f *FlagSet) CounterVar(p *int, name string, value int, usage string) {
|
||
|
|
f.addLine(counterLine(name, "", usage))
|
||
|
|
f.Var(newIntValue(value, p), name, OptionalArg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// CounterVar defines a counter flag with specified name, default value and
|
||
|
|
// usage string. The argument p points to an integer variable in which to
|
||
|
|
// store the value of the flag.
|
||
|
|
func CounterVar(p *int, name string, value int, usage string) {
|
||
|
|
CommandLine.CounterVar(p, name, value, usage)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Counter defines a counter flag with specified name, default value and
|
||
|
|
// usage string. The return value is the address of an integer variable that
|
||
|
|
// stores the value of the flag.
|
||
|
|
func (f *FlagSet) Counter(name string, value int, usage string) *int {
|
||
|
|
p := new(int)
|
||
|
|
f.CounterVar(p, name, value, usage)
|
||
|
|
return p
|
||
|
|
}
|
||
|
|
|
||
|
|
// Counter defines a counter flag with specified name, default value and
|
||
|
|
// usage string. The return value is the address of an integer variable that
|
||
|
|
// stores the value of the flag.
|
||
|
|
func Counter(name string, value int, usage string) *int {
|
||
|
|
return CommandLine.Counter(name, value, usage)
|
||
|
|
}
|
||
|
|
|
||
|
|
// intLine returns the usage line for an integer flag.
|
||
|
|
func intLine(name, shorthands string, value int, usage string) line {
|
||
|
|
defaultValue := ""
|
||
|
|
if value != 0 {
|
||
|
|
defaultValue = fmt.Sprintf("%d", value)
|
||
|
|
}
|
||
|
|
return line{lineFlags(name, shorthands, defaultValue), usage}
|
||
|
|
}
|
||
|
|
|
||
|
|
// IntVarP defines an integer flag with specified name, shorthands, default
|
||
|
|
// value and usage string. The argument p points to an integer variable in
|
||
|
|
// which to store the value of the flag.
|
||
|
|
func (f *FlagSet) IntVarP(p *int, name, shorthands string, value int, usage string) {
|
||
|
|
f.addLine(intLine(name, shorthands, value, usage))
|
||
|
|
f.VarP(newIntValue(value, p), name, shorthands, RequiredArg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// IntVarP defines an integer flag with specified name, shorthands, default
|
||
|
|
// value and usage string. The argument p points to an integer variable in
|
||
|
|
// which to store the value of the flag.
|
||
|
|
func IntVarP(p *int, name, shorthands string, value int, usage string) {
|
||
|
|
CommandLine.IntVarP(p, name, shorthands, value, usage)
|
||
|
|
}
|
||
|
|
|
||
|
|
// IntP defines an integer flag with specified name, shorthands, default
|
||
|
|
// value and usage string. The return value is the address of an integer
|
||
|
|
// variable that stores the value of the flag.
|
||
|
|
func (f *FlagSet) IntP(name, shorthands string, value int, usage string) *int {
|
||
|
|
p := new(int)
|
||
|
|
f.IntVarP(p, name, shorthands, value, usage)
|
||
|
|
return p
|
||
|
|
}
|
||
|
|
|
||
|
|
// IntP defines an integer flag with specified name, shorthands, default
|
||
|
|
// value and usage string. The return value is the address of an integer
|
||
|
|
// variable that stores the value of the flag.
|
||
|
|
func IntP(name, shorthands string, value int, usage string) *int {
|
||
|
|
return CommandLine.IntP(name, shorthands, value, usage)
|
||
|
|
}
|
||
|
|
|
||
|
|
// IntVar defines an integer flag with specified name, default value and
|
||
|
|
// usage string. The argument p points to an integer variable in which to
|
||
|
|
// store the value of the flag.
|
||
|
|
func (f *FlagSet) IntVar(p *int, name string, value int, usage string) {
|
||
|
|
f.addLine(intLine(name, "", value, usage))
|
||
|
|
f.Var(newIntValue(value, p), name, RequiredArg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// IntVar defines an integer flag with specified name, default value and
|
||
|
|
// usage string. The argument p points to an integer variable in which to
|
||
|
|
// store the value of the flag.
|
||
|
|
func IntVar(p *int, name string, value int, usage string) {
|
||
|
|
CommandLine.IntVar(p, name, value, usage)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Int defines an integer flag with specified name, default value and
|
||
|
|
// usage string. The return value is the address of an integer variable that
|
||
|
|
// stores the value of the flag.
|
||
|
|
func (f *FlagSet) Int(name string, value int, usage string) *int {
|
||
|
|
p := new(int)
|
||
|
|
f.IntVar(p, name, value, usage)
|
||
|
|
return p
|
||
|
|
}
|
||
|
|
|
||
|
|
// Int defines an integer flag with specified name, default value and
|
||
|
|
// usage string. The return value is the address of an integer variable that
|
||
|
|
// stores the value of the flag.
|
||
|
|
func Int(name string, value int, usage string) *int {
|
||
|
|
return CommandLine.Int(name, value, usage)
|
||
|
|
}
|
||
|
|
|
||
|
|
// The stringValue will store a string option.
|
||
|
|
type stringValue struct {
|
||
|
|
p *string
|
||
|
|
value string
|
||
|
|
}
|
||
|
|
|
||
|
|
// newStringValue will create a new stringValue.
|
||
|
|
func newStringValue(val string, p *string) *stringValue {
|
||
|
|
*p = val
|
||
|
|
return &stringValue{p, val}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get returns the string stored in the stringValue.
|
||
|
|
func (s *stringValue) Get() interface{} {
|
||
|
|
return *s.p
|
||
|
|
}
|
||
|
|
|
||
|
|
// Set sets the string value.
|
||
|
|
func (s *stringValue) Set(str string) error {
|
||
|
|
*s.p = str
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// Update resets the string value to its default.
|
||
|
|
func (s *stringValue) Update() {
|
||
|
|
*s.p = s.value
|
||
|
|
}
|
||
|
|
|
||
|
|
// String returns simply the string stored in the value.
|
||
|
|
func (s *stringValue) String() string {
|
||
|
|
return *s.p
|
||
|
|
}
|
||
|
|
|
||
|
|
// stringLine creates a usage line.
|
||
|
|
func stringLine(name, shorthands, value, usage string) line {
|
||
|
|
return line{lineFlags(name, shorthands, value), usage}
|
||
|
|
}
|
||
|
|
|
||
|
|
// StringVarP defines an string flag with specified name, shorthands, default
|
||
|
|
// value and usage string. The argument p points to a string variable in
|
||
|
|
// which to store the value of the flag.
|
||
|
|
func (f *FlagSet) StringVarP(p *string, name, shorthands, value, usage string) {
|
||
|
|
f.addLine(stringLine(name, shorthands, value, usage))
|
||
|
|
f.VarP(newStringValue(value, p), name, shorthands, RequiredArg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// StringVarP defines an string flag with specified name, shorthands, default
|
||
|
|
// value and usage string. The argument p points to a string variable in
|
||
|
|
// which to store the value of the flag.
|
||
|
|
func StringVarP(p *string, name, shorthands, value, usage string) {
|
||
|
|
CommandLine.StringVarP(p, name, shorthands, value, usage)
|
||
|
|
}
|
||
|
|
|
||
|
|
// StringP defines a string flag with specified name, shorthands, default
|
||
|
|
// value and usage string. The return value is the address of a string
|
||
|
|
// variable that stores the value of the flag.
|
||
|
|
func (f *FlagSet) StringP(name, shorthands, value, usage string) *string {
|
||
|
|
p := new(string)
|
||
|
|
f.StringVarP(p, name, shorthands, value, usage)
|
||
|
|
return p
|
||
|
|
}
|
||
|
|
|
||
|
|
// StringP defines a string flag with specified name, shorthands, default
|
||
|
|
// value and usage string. The return value is the address of a string
|
||
|
|
// variable that stores the value of the flag.
|
||
|
|
func StringP(name, shorthands, value, usage string) *string {
|
||
|
|
return CommandLine.StringP(name, shorthands, value, usage)
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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 (f *FlagSet) StringVar(p *string, name, value, usage string) {
|
||
|
|
f.addLine(stringLine(name, "", value, usage))
|
||
|
|
f.Var(newStringValue(value, p), name, RequiredArg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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, value, usage string) {
|
||
|
|
CommandLine.StringVar(p, name, value, usage)
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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 (f *FlagSet) String(name, value, usage string) *string {
|
||
|
|
p := new(string)
|
||
|
|
f.StringVar(p, name, value, usage)
|
||
|
|
return p
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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, value, usage string) *string {
|
||
|
|
return CommandLine.String(name, value, usage)
|
||
|
|
}
|
||
|
|
|
||
|
|
// presetValue represents an integer value that can be set with multiple
|
||
|
|
// flags as -1 ... -9.
|
||
|
|
type presetValue struct {
|
||
|
|
p *int
|
||
|
|
preset int
|
||
|
|
}
|
||
|
|
|
||
|
|
// newPresetValue allocates a new preset value and returns its pointer.
|
||
|
|
func newPresetValue(p *int, preset int) *presetValue {
|
||
|
|
return &presetValue{p, preset}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get returns the actual preset value as integer.
|
||
|
|
func (p *presetValue) Get() interface{} {
|
||
|
|
return *p.p
|
||
|
|
}
|
||
|
|
|
||
|
|
// Set sets the preset value from an integer string.
|
||
|
|
func (p *presetValue) Set(s string) error {
|
||
|
|
val, err := strconv.ParseInt(s, 0, 0)
|
||
|
|
*p.p = int(val)
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
|
||
|
|
// Update sets the preset value to the default.
|
||
|
|
func (p *presetValue) Update() {
|
||
|
|
*p.p = p.preset
|
||
|
|
}
|
||
|
|
|
||
|
|
// String returns the integer representation of the preset value.
|
||
|
|
func (p *presetValue) String() string {
|
||
|
|
return fmt.Sprintf("%d", *p.p)
|
||
|
|
}
|
||
|
|
|
||
|
|
// presetLine creates the usage line for a preset value.
|
||
|
|
func presetLine(start, end int, usage string) line {
|
||
|
|
return line{fmt.Sprintf("-%d ... -%d", start, end), usage}
|
||
|
|
}
|
||
|
|
|
||
|
|
// PresetVar defines a range of preset flags starting at start and
|
||
|
|
// ending at end. The argument p points to a preset variable in which to
|
||
|
|
// store the value of the flag.
|
||
|
|
//
|
||
|
|
// If start is 1 and end is 9 the flags -1 to -9 will be supported.
|
||
|
|
func (f *FlagSet) PresetVar(p *int, start, end, value int, usage string) {
|
||
|
|
if f.preset {
|
||
|
|
f.panicf("flagset %s has already a preset", f.name)
|
||
|
|
}
|
||
|
|
f.addLine(presetLine(start, end, usage))
|
||
|
|
*p = value
|
||
|
|
for i := start; i <= end; i++ {
|
||
|
|
f.Var(newPresetValue(p, i), fmt.Sprintf("%d", i), NoArg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// PresetVar defines a range of preset flags starting at start and
|
||
|
|
// ending at end. The argument p points to a preset variable in which to
|
||
|
|
// store the value of the flag.
|
||
|
|
//
|
||
|
|
// If start is 1 and end is 9 the flags -1 to -9 will be supported.
|
||
|
|
func PresetVar(p *int, start, end, value int, usage string) {
|
||
|
|
CommandLine.PresetVar(p, start, end, value, usage)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Preset defines a range of preset flags starting at start and
|
||
|
|
// ending at end. The return value is the address of a preset variable
|
||
|
|
// in which to store the value of the flag.
|
||
|
|
//
|
||
|
|
// If start is 1 and end is 9 the flags -1 to -9 will be supported.
|
||
|
|
func (f *FlagSet) Preset(start, end, value int, usage string) *int {
|
||
|
|
p := new(int)
|
||
|
|
f.PresetVar(p, start, end, value, usage)
|
||
|
|
return p
|
||
|
|
}
|
||
|
|
|
||
|
|
// Preset defines a range of preset flags starting at start and
|
||
|
|
// ending at end. The return value is the address of a preset variable
|
||
|
|
// in which to store the value of the flag.
|
||
|
|
//
|
||
|
|
// If start is 1 and end is 9 the flags -1 to -9 will be supported.
|
||
|
|
func Preset(start, end, value int, usage string) *int {
|
||
|
|
return CommandLine.Preset(start, end, value, usage)
|
||
|
|
}
|