flag.go

别看内容挺多一千多行，核心也就只有 FlagSet 的 parseOne 方法

  1. // src/flag/flag.go ---- line 315
  2. // A FlagSet represents a set of defined flags. The zero value of a FlagSet
  3. // has no name and has ContinueOnError error handling.
  4. //
  5. // Flag names must be unique within a FlagSet. An attempt to define a flag whose
  6. // name is already in use will cause a panic.
  7. type FlagSet struct {
  8.     // Usage is the function called when an error occurs while parsing flags.
  9.     // The field is a function (not a method) that may be changed to point to
  10.     // a custom error handler. What happens after Usage is called depends
  11.     // on the ErrorHandling setting; for the command line, this defaults
  12.     // to ExitOnError, which exits the program after calling Usage.
  13.     Usage func()
  15.     name          string
  16.     parsed        bool
  17.     actual        map[string]*Flag
  18.     formal        map[string]*Flag
  19.     args          []string // arguments after flags
  20.     errorHandling ErrorHandling
  21.     output        io.Writer // nil means stderr; use out() accessor
  22. }
  24. // A Flag represents the state of a flag.
  25. type Flag struct {
  26.     Name     string // name as it appears on command line
  27.     Usage    string // help message
  28.     Value    Value  // value as set
  29.     DefValue string // default value (as text); for usage message
  30. }
  32. // src/flag/flag.go ---- line 888
  33. // parseOne parses one flag. It reports whether a flag was seen.
  34. func (f *FlagSet) parseOne() (bool, error) {
  35.     if len(f.args) == 0 {
  36.         return false, nil
  37.     }
  38.     s := f.args[0]
  39.     if len(s) < 2 || s[0] != '-' {
  40.         return false, nil
  41.     }
  42.     numMinuses := 1
  43.     if s[1] == '-' {
  44.         numMinuses++
  45.         if len(s) == 2 { // "--" terminates the flags
  46.             f.args = f.args[1:]
  47.             return false, nil
  48.         }
  49.     }
  50.     name := s[numMinuses:]
  51.     if len(name) == 0 || name[0] == '-' || name[0] == '=' {
  52.         return false, f.failf("bad flag syntax: %s", s)
  53.     }
  55.     // it's a flag. does it have an argument?
  56.     f.args = f.args[1:]
  57.     hasValue := false
  58.     value := ""
  59.     for i := 1; i < len(name); i++ { // equals cannot be first
  60.         if name[i] == '=' {
  61.             value = name[i+1:]
  62.             hasValue = true
  63.             name = name[0:i]
  64.             break
  65.         }
  66.     }
  67.     m := f.formal
  68.     flag, alreadythere := m[name] // BUG
  69.     if !alreadythere {
  70.         if name == "help" || name == "h" { // special case for nice help message.
  71.             f.usage()
  72.             return false, ErrHelp
  73.         }
  74.         return false, f.failf("flag provided but not defined: -%s", name)
  75.     }
  77.     if fv, ok := flag.Value.(boolFlag); ok && fv.IsBoolFlag() { // special case: doesn't need an arg
  78.         if hasValue {
  79.             if err := fv.Set(value); err != nil {
  80.                 return false, f.failf("invalid boolean value %q for -%s: %v", value, name, err)
  81.             }
  82.         } else {
  83.             if err := fv.Set("true"); err != nil {
  84.                 return false, f.failf("invalid boolean flag %s: %v", name, err)
  85.             }
  86.         }
  87.     } else {
  88.         // It must have a value, which might be the next argument.
  89.         if !hasValue && len(f.args) > 0 {
  90.             // value is the next arg
  91.             hasValue = true
  92.             value, f.args = f.args[0], f.args[1:]
  93.         }
  94.         if !hasValue {
  95.             return false, f.failf("flag needs an argument: -%s", name)
  96.         }
  97.         if err := flag.Value.Set(value); err != nil {
  98.             return false, f.failf("invalid value %q for flag -%s: %v", value, name, err)
  99.         }
  100.     }
  101.     if f.actual == nil {
  102.         f.actual = make(map[string]*Flag)
  103.     }
  104.     f.actual[name] = flag
  105.     return true, nil
  106. }

当然说是核心，其实也就只是长了一点，没有什么花式的技巧，从头看到尾就知道干啥了。