Source file src/cmd/internal/objabi/flag.go

Documentation: cmd/internal/objabi

  // Copyright 2015 The Go Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  package objabi
  
  import (
  	"flag"
  	"fmt"
  	"os"
  	"strconv"
  	"strings"
  )
  
  func Flagcount(name, usage string, val *int) {
  	flag.Var((*count)(val), name, usage)
  }
  
  func Flagfn1(name, usage string, f func(string)) {
  	flag.Var(fn1(f), name, usage)
  }
  
  func Flagprint(fd int) {
  	if fd == 1 {
  		flag.CommandLine.SetOutput(os.Stdout)
  	}
  	flag.PrintDefaults()
  }
  
  func Flagparse(usage func()) {
  	flag.Usage = usage
  	flag.Parse()
  }
  
  func AddVersionFlag() {
  	flag.Var(versionFlag{}, "V", "print version and exit")
  }
  
  var buildID string // filled in by linker
  
  type versionFlag struct{}
  
  func (versionFlag) IsBoolFlag() bool { return true }
  func (versionFlag) Get() interface{} { return nil }
  func (versionFlag) String() string   { return "" }
  func (versionFlag) Set(s string) error {
  	name := os.Args[0]
  	name = name[strings.LastIndex(name, `/`)+1:]
  	name = name[strings.LastIndex(name, `\`)+1:]
  	name = strings.TrimSuffix(name, ".exe")
  	p := Expstring()
  	if p == DefaultExpstring() {
  		p = ""
  	}
  	sep := ""
  	if p != "" {
  		sep = " "
  	}
  
  	// The go command invokes -V=full to get a unique identifier
  	// for this tool. It is assumed that the release version is sufficient
  	// for releases, but during development we include the full
  	// build ID of the binary, so that if the compiler is changed and
  	// rebuilt, we notice and rebuild all packages.
  	if s == "full" && strings.HasPrefix(Version, "devel") {
  		p += " buildID=" + buildID
  	}
  	fmt.Printf("%s version %s%s%s\n", name, Version, sep, p)
  	os.Exit(0)
  	return nil
  }
  
  // count is a flag.Value that is like a flag.Bool and a flag.Int.
  // If used as -name, it increments the count, but -name=x sets the count.
  // Used for verbose flag -v.
  type count int
  
  func (c *count) String() string {
  	return fmt.Sprint(int(*c))
  }
  
  func (c *count) Set(s string) error {
  	switch s {
  	case "true":
  		*c++
  	case "false":
  		*c = 0
  	default:
  		n, err := strconv.Atoi(s)
  		if err != nil {
  			return fmt.Errorf("invalid count %q", s)
  		}
  		*c = count(n)
  	}
  	return nil
  }
  
  func (c *count) Get() interface{} {
  	return int(*c)
  }
  
  func (c *count) IsBoolFlag() bool {
  	return true
  }
  
  func (c *count) IsCountFlag() bool {
  	return true
  }
  
  type fn0 func()
  
  func (f fn0) Set(s string) error {
  	f()
  	return nil
  }
  
  func (f fn0) Get() interface{} { return nil }
  
  func (f fn0) String() string { return "" }
  
  func (f fn0) IsBoolFlag() bool {
  	return true
  }
  
  type fn1 func(string)
  
  func (f fn1) Set(s string) error {
  	f(s)
  	return nil
  }
  
  func (f fn1) String() string { return "" }
  

View as plain text