import (
	flag "github.com/docker/docker/pkg/mflag"
	...
)

flag.Parse()

flVersion     = flag.Bool([]string{"v", "-version"}, false, "Print version information and quit")
flDaemon      = flag.Bool([]string{"d", "-daemon"}, false, "Enable daemon mode")
flDebug       = flag.Bool([]string{"D", "-debug"}, false, "Enable debug mode")
...
flLogLevel    = flag.String([]string{"l", "-log-level"}, "info", "Set the logging level")

 func Bool(names []string, value bool, usage string) *bool {
	 return CommandLine.Bool(names, value, usage)
 }

 var CommandLine = NewFlagSet(os.Args[0], ExitOnError)

 func NewFlagSet(name string, errorHandling ErrorHandling) *FlagSet {
	 f := &FlagSet{
		 name:          name,
		 errorHandling: errorHandling,
	 }
	 return f
 }

 type FlagSet struct {
	 Usage func()
	 name          string
	 parsed        bool
	 actual        map[string]*Flag
	 formal        map[string]*Flag
	 args          []string
	 errorHandling ErrorHandling
	 output        io.Writer 
}

 type Flag struct {
	 Names    []string // name as it appears on command line
	 Usage    string   // help message
	 Value    Value    // value as set
	 DefValue string   // default value (as text); for usage message
 }

 flEnableCors  = flag.Bool([]string{"#api-enable-cors", "-api-enable-cors"}, false, "Enable CORS headers in the remote API")

for i, n := range flag.Names {
	if n == fmt.Sprintf("#%s", name) {
		replacement := ""
		for j := i; j < len(flag.Names); j++ {
			if flag.Names[j][0] != '#' {
				replacement = flag.Names[j]
				break
			}
		}
		if replacement != "" { // 内容过长，省略部分。
			fmt.Fprintf(f.out(), "Warning: '-%s' is deprecated, ...)
		} else {
			fmt.Fprintf(f.out(), "Warning: '-%s' is deprecated, ...)
		}
    }
}  

 flDaemon      = flag.Bool([]string{"d", "-daemon"}, false, "Enable daemon mode")

func (f *FlagSet) Bool(names []string, value bool, usage string) *bool {
	p := new(bool)
	f.BoolVar(p, names, value, usage)
	return p
}

func BoolVar(p *bool, names []string, value bool, usage string) {
	CommandLine.Var(newBoolValue(value, p), names, usage)
}

type boolValue bool
	
func newBoolValue(val bool, p *bool) *boolValue {
	*p = val
	return (*boolValue)(p)
}

type Value interface {
	String() string
	Set(string) error
}

type intValue int

func newIntValue(val int, p *int) *intValue {
	*p = val
	return (*intValue)(p)
}

func (i *intValue) Set(s string) error {
	v, err := strconv.ParseInt(s, 0, 64)
	*i = intValue(v)
	return err
}

func (i *intValue) Get() interface{} { return int(*i) }

func (i *intValue) String() string { return fmt.Sprintf("%v", *i) }

func (b *boolValue) IsBoolFlag() bool { return true }

type boolFlag interface {
	Value
	IsBoolFlag() bool
}

func (f *FlagSet) Var(value Value, names []string, usage string) {
	flag := &Flag{names, usage, value, value.String()}
	for _, name := range names {
		name = strings.TrimPrefix(name, "#")
		_, alreadythere := f.formal[name]
		if alreadythere {
			var msg string
			if f.name == "" {
				msg = fmt.Sprintf("flag redefined: %s", name)
			} else {
				msg = fmt.Sprintf("%s flag redefined: %s", f.name, name)
			}
			fmt.Fprintln(f.out(), msg)
			panic(msg) 
		}
		if f.formal == nil {
			f.formal = make(map[string]*Flag)
		}
		f.formal[name] = flag
	}
}

func Parse() {
	CommandLine.Parse(os.Args[1:])
}

if len(f.args) == 0 {
	return false, "", nil
}
s := f.args[0]
if len(s) == 0 || s[0] != '-' || len(s) == 1 {
	return false, "", nil
}
if s[1] == '-' && len(s) == 2 { // "--" terminates the flags
	f.args = f.args[1:]
	return false, "", nil
}
name := s[1:]
if len(name) == 0 || name[0] == '=' {
	return false, "", f.failf("bad flag syntax: %s", s)
}

f.args = f.args[1:]
has_value := false
value := ""
if i := strings.Index(name, "="); i != -1 {
	value = trimQuotes(name[i+1:])
	has_value = true
	name = name[:i]
}

flag, alreadythere := m[name] // BUG
if !alreadythere {
	if name == "-help" || name == "help" || name == "h" { 
		f.usage()
		return false, "", ErrHelp
	}
	if len(name) > 0 && name[0] == '-' {
		return false, "", f.failf("flag provided but not defined: -%s", name)
	}
	return false, name, ErrRetry
}

if fv, ok := flag.Value.(boolFlag); ok && fv.IsBoolFlag() { 
	if has_value {
		if err := fv.Set(value); err != nil {
			return false, "", f.failf("invalid boolean value %q for  -%s: %v", value, name, err)
		}
	} else {
		fv.Set("true") //默认为 true
	}
}

else {
	// It must have a value, which might be the next argument.
	if !has_value && len(f.args) > 0 {
		// value is the next arg
		has_value = true
		value, f.args = f.args[0], f.args[1:]
	}
	if !has_value {
		return false, "", f.failf("flag needs an argument: -%s", name)
	}
	if err := flag.Value.Set(value); err != nil {
		return false, "", f.failf("invalid value %q for flag -%s: %v", value, name, err)
	}
}

if *flVersion {
	showVersion()
	return
}

VERSION=$(cat ./VERSION)

if *flLogLevel != "" {
	lvl, err := log.ParseLevel(*flLogLevel)
	if err != nil {
		log.Fatalf("Unable to parse logging level: %s", *flLogLevel)
	}
	initLogging(lvl)
} else {
	initLogging(log.InfoLevel)
}

if *flDebug {
	os.Setenv("DEBUG", "1")
	initLogging(log.DebugLevel)
}

if len(flHosts) == 0 {
	defaultHost := os.Getenv("DOCKER_HOST")
	if defaultHost == "" || *flDaemon {
		// If we do not have a host, default to unix socket
		defaultHost = fmt.Sprintf("unix://%s", api.DEFAULTUNIXSOCKET)
	}
	defaultHost, err := api.ValidateHost(defaultHost)
	if err != nil {
		log.Fatal(err)
	}
	flHosts = append(flHosts, defaultHost)
}

if *flDaemon {
	mainDaemon()
	return
}

protoAddrParts := strings.SplitN(flHosts[0], "://", 2)

if *flTls || *flTlsVerify {
	cli = client.NewDockerCli(os.Stdin, os.Stdout, os.Stderr, nil, protoAddrParts[0], protoAddrParts[1], &tlsConfig)
} else {
	cli = client.NewDockerCli(os.Stdin, os.Stdout, os.Stderr, nil, protoAddrParts[0], protoAddrParts[1], nil)
}

if err := cli.Cmd(flag.Args()...); err != nil {
	if sterr, ok := err.(*utils.StatusError); ok {
		if sterr.Status != "" {
			log.Println(sterr.Status)
		}
		os.Exit(sterr.StatusCode)
	}
	log.Fatal(err)
}