Merge branch 'newgen' of b612/starlog into master

archive.go

@@ -0,0 +1,274 @@
+package starlog
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"time"
+
+	"b612.me/staros"
+
+	"b612.me/starmap"
+)
+
+type Archive interface {
+	ShouldArchiveNow(string, os.FileInfo) bool
+	NextLogFilePath(string, os.FileInfo) string
+	Interval() int64
+	HookBeforArchive() func(string, os.FileInfo) error
+	HookAfterArchive() func(string, string, os.FileInfo) error
+}
+
+type logfileinfo struct {
+	fullpath string
+	pointer  *os.File
+}
+
+func SetLogFile(path string, logger *StarLogger, appendMode bool) error {
+	var fileMode int
+	if appendMode {
+		fileMode = os.O_APPEND | os.O_CREATE
+	} else {
+		fileMode = os.O_CREATE | os.O_WRONLY
+	}
+	fullpath, err := filepath.Abs(path)
+	if err != nil {
+		return err
+	}
+	if !appendMode && staros.Exists(fullpath) {
+		os.Remove(fullpath)
+	}
+	fp, err := os.OpenFile(fullpath, fileMode, 0644)
+	if err != nil {
+		return err
+	}
+	if starmap.MustGet(logger.logcore.id) != nil {
+		logger.SetSwitching(true)
+		err := starmap.MustGet(logger.logcore.id).(logfileinfo).pointer.Close()
+		if err != nil {
+			logger.logcore.output = nil
+			logger.SetSwitching(false)
+			return err
+		}
+		err = starmap.Delete(logger.logcore.id)
+		if err != nil {
+			logger.logcore.output = nil
+			logger.SetSwitching(false)
+			return err
+		}
+	}
+
+	err = starmap.Store(logger.logcore.id, logfileinfo{
+		fullpath: fullpath,
+		pointer:  fp,
+	})
+	if err != nil {
+		fp.Close()
+		logger.logcore.output = nil
+		logger.SetSwitching(false)
+		return err
+	}
+	logger.SetSwitching(true)
+	logger.logcore.output = fp
+	logger.SetSwitching(false)
+	return nil
+}
+
+func Close(logger *StarLogger) error {
+	defer logger.SetSwitching(false)
+	if starmap.MustGet(logger.logcore.id) != nil {
+		logger.SetSwitching(true)
+		err := starmap.MustGet(logger.logcore.id).(*os.File).Close()
+		if err != nil {
+			logger.logcore.output = nil
+			return err
+		}
+		err = starmap.Delete(logger.logcore.id)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func GetLogFileInfo(logger *StarLogger) (os.FileInfo, error) {
+	if starmap.MustGet(logger.logcore.id) != nil {
+		return starmap.MustGet(logger.logcore.id).(logfileinfo).pointer.Stat()
+	}
+	return nil, errors.New("logger don't have a register logfile")
+}
+
+func StartArchive(logger *StarLogger, arch Archive) error {
+	if starmap.MustGet("arch"+logger.logcore.id) != nil {
+		return errors.New("already running")
+	}
+	stopChan := make(chan int)
+	starmap.Store("arch"+logger.logcore.id, stopChan)
+	go func(stopChan chan int, arch Archive, logger *StarLogger) {
+		for {
+			select {
+			case <-stopChan:
+				return
+			case <-time.After(time.Second * time.Duration(arch.Interval())):
+			}
+			fileinfo, err := GetLogFileInfo(logger)
+			if err != nil {
+				logger.Errorf("cannot get log file info,reason is %v\n", err)
+				continue
+			}
+			if starmap.MustGet(logger.logcore.id) == nil {
+				logger.Errorf("cannot get log core info from the map:no such keys\n")
+				continue
+			}
+			fullpath := starmap.MustGet(logger.logcore.id).(logfileinfo).fullpath
+			if !arch.ShouldArchiveNow(fullpath, fileinfo) {
+				continue
+			}
+			newLogPath := arch.NextLogFilePath(fullpath, fileinfo)
+			if arch.HookBeforArchive() != nil {
+				if err := arch.HookBeforArchive()(fullpath, fileinfo); err != nil {
+					logger.Errorf("error occur while executing hook before archive,detail is %v\n", err)
+					continue
+				}
+			}
+			if err := SetLogFile(newLogPath, logger, false); err != nil {
+				logger.Errorf("error occur while executing coverting new log file,detail is %v\n", err)
+				continue
+			} else {
+				logger.Debugln("Set Log Success")
+			}
+			fileinfo, err = GetLogFileInfo(logger)
+			if err != nil {
+				logger.Errorf("cannot get new log core info from the map:no such keys\n")
+				continue
+			}
+			if arch.HookAfterArchive() != nil {
+				if err := arch.HookAfterArchive()(fullpath, newLogPath, fileinfo); err != nil {
+					logger.Errorf("error occur while executing hook after archive,detail is %v\n", err)
+					continue
+				}
+			}
+		}
+	}(stopChan, arch, logger)
+	return nil
+}
+
+func IsArchiveRun(logger *StarLogger) bool {
+	if starmap.MustGet("arch"+logger.logcore.id) == nil {
+		return false
+	}
+	return true
+}
+
+func StopArchive(logger *StarLogger) {
+	if starmap.MustGet("arch"+logger.logcore.id) == nil {
+		return
+	}
+	starmap.MustGet("arch" + logger.logcore.id).(chan int) <- 1
+}
+
+type ArchiveByDate struct {
+	interval         int64
+	checkInterval    int64
+	newFileNameStyle string
+	hookBefor        func(string, os.FileInfo) error
+	hookAfter        func(string, string, os.FileInfo) error
+}
+
+func (abd *ArchiveByDate) ShouldArchiveNow(fullpath string, info os.FileInfo) bool {
+	if time.Now().Unix()-staros.GetFileCreationTime(info).Unix() > abd.interval {
+		return true
+	}
+	return false
+}
+
+func (abd *ArchiveByDate) NextLogFilePath(oldpath string, info os.FileInfo) string {
+	dir := filepath.Dir(oldpath)
+	newName := time.Now().Format(abd.newFileNameStyle)
+	return filepath.Join(dir, newName)
+}
+
+func (abd *ArchiveByDate) Interval() int64 {
+	return abd.checkInterval
+}
+
+func (abd *ArchiveByDate) HookBeforArchive() func(string, os.FileInfo) error {
+
+	return abd.hookBefor
+}
+
+func (abd *ArchiveByDate) HookAfterArchive() func(string, string, os.FileInfo) error {
+	return abd.hookAfter
+}
+
+func (abd *ArchiveByDate) SetHookBeforArchive(f func(string, os.FileInfo) error) {
+
+	abd.hookBefor = f
+}
+
+func (abd *ArchiveByDate) SetHookAfterArchive(f func(string, string, os.FileInfo) error) {
+	abd.hookAfter = f
+}
+
+func NewArchiveByDate(archInterval int64, checkInterval int64, fileStyle string, hookbefor func(string, os.FileInfo) error, hookafter func(string, string, os.FileInfo) error) *ArchiveByDate {
+	return &ArchiveByDate{
+		interval:         archInterval,
+		checkInterval:    checkInterval,
+		newFileNameStyle: fileStyle,
+		hookBefor:        hookbefor,
+		hookAfter:        hookafter,
+	}
+}
+
+type ArchiveBySize struct {
+	size             int64
+	checkInterval    int64
+	newFileNameStyle string
+	hookBefor        func(string, os.FileInfo) error
+	hookAfter        func(string, string, os.FileInfo) error
+}
+
+func (abd *ArchiveBySize) ShouldArchiveNow(fullpath string, info os.FileInfo) bool {
+	if info.Size() > abd.size {
+		return true
+	}
+	return false
+}
+
+func (abd *ArchiveBySize) NextLogFilePath(oldpath string, info os.FileInfo) string {
+	dir := filepath.Dir(oldpath)
+	newName := time.Now().Format(abd.newFileNameStyle)
+	return filepath.Join(dir, newName)
+}
+
+func (abd *ArchiveBySize) Interval() int64 {
+	return abd.checkInterval
+}
+
+func (abd *ArchiveBySize) HookBeforArchive() func(string, os.FileInfo) error {
+
+	return abd.hookBefor
+}
+
+func (abd *ArchiveBySize) HookAfterArchive() func(string, string, os.FileInfo) error {
+	return abd.hookAfter
+}
+
+func (abd *ArchiveBySize) SetHookBeforArchive(f func(string, os.FileInfo) error) {
+
+	abd.hookBefor = f
+}
+
+func (abd *ArchiveBySize) SetHookAfterArchive(f func(string, string, os.FileInfo) error) {
+	abd.hookAfter = f
+}
+
+func NewArchiveBySize(size int64, checkInterval int64, fileStyle string, hookbefor func(string, os.FileInfo) error, hookafter func(string, string, os.FileInfo) error) *ArchiveBySize {
+	return &ArchiveBySize{
+		size:             size,
+		checkInterval:    checkInterval,
+		newFileNameStyle: fileStyle,
+		hookBefor:        hookbefor,
+		hookAfter:        hookafter,
+	}
+}

core.go

@@ -0,0 +1,249 @@
+package starlog
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+)
+
+func (logger *starlog) build(thread string, isStd bool, handler func([]Attr, string), level int, logDetail string) {
+	logger.mu.Lock()
+	defer logger.mu.Unlock()
+	var skip, line int = 3, 0
+	var funcname, fileName string
+	now := time.Now()
+	if isStd {
+		skip++
+	}
+	if logger.showDeatilFile || logger.showFuncName {
+		pc, fName, codeln, ok := runtime.Caller(skip)
+		if !ok {
+			return
+		}
+		line = codeln
+		funcname = runtime.FuncForPC(pc).Name()
+		funcname = filepath.Ext(funcname)
+		funcname = strings.TrimPrefix(funcname, ".")
+		fileName = filepath.Base(fName)
+	}
+
+	y, m, d := now.Date()
+	h, i, s := now.Clock()
+	micro := now.Nanosecond() / 1e3
+	logStr := fmt.Sprintf("%04d-%02d-%02d %02d:%02d:%02d.%06d", y, m, d, h, i, s, micro)
+	if logger.showDeatilFile {
+		logStr += " " + fileName + ":" + strconv.Itoa(line)
+	}
+	if logger.showFuncName {
+		logStr += " <" + funcname + ">"
+	}
+	if logger.showThread {
+		logStr += " |" + thread + "|"
+	}
+	if logger.showLevel {
+		logStr += " " + `[` + levels[level] + `]`
+	}
+	logStr += " " + logDetail
+	if logger.showStd {
+		if !logger.showColor {
+			fmt.Print(logStr)
+		} else {
+			//logcolor := NewColor(logger.colorList[level]...)
+			logger.colorMe[level].Fprint(stdScreen, logStr)
+		}
+	}
+	if handler != nil {
+		stacks.Push(logTransfer{
+			handlerFunc: handler,
+			colors:      logger.colorList[level],
+			logStr:      logStr,
+		})
+	}
+	if !logger.stopWriter {
+		logger.write(logStr)
+	}
+}
+
+func (logger *starlog) write(logStr string) {
+	if logger.output == nil || logger.stopWriter {
+		return
+	}
+	var count int = 0
+	for logger.switching {
+		time.Sleep(time.Millisecond * 100)
+		count++
+		if count > 50 {
+			return
+		}
+	}
+	if logger.output == nil {
+		return
+	}
+	logger.output.Write([]byte(logStr))
+}
+
+func (logger *starlog) print(str ...interface{}) string {
+	return fmt.Sprint(str...)
+}
+
+func (logger *starlog) printf(format string, str ...interface{}) string {
+	return fmt.Sprintf(format, str...)
+}
+
+func (logger *starlog) println(str ...interface{}) string {
+	return fmt.Sprintln(str...)
+}
+
+func (logger *starlog) Debug(thread string, isStd bool, handler func([]Attr, string), str ...interface{}) {
+	strs := fmt.Sprint(str...)
+	logger.build(thread, isStd, handler, LvDebug, strs)
+}
+
+func (logger *starlog) Debugf(thread string, isStd bool, handler func([]Attr, string), format string, str ...interface{}) {
+	strs := fmt.Sprintf(format, str...)
+	logger.build(thread, isStd, handler, LvDebug, strs)
+}
+
+func (logger *starlog) Debugln(thread string, isStd bool, handler func([]Attr, string), str ...interface{}) {
+	strs := fmt.Sprintln(str...)
+	logger.build(thread, isStd, handler, LvDebug, strs)
+}
+
+func (logger *starlog) Info(thread string, isStd bool, handler func([]Attr, string), str ...interface{}) {
+	strs := fmt.Sprint(str...)
+	logger.build(thread, isStd, handler, LvInfo, strs)
+}
+
+func (logger *starlog) Infof(thread string, isStd bool, handler func([]Attr, string), format string, str ...interface{}) {
+	strs := fmt.Sprintf(format, str...)
+	logger.build(thread, isStd, handler, LvInfo, strs)
+}
+
+func (logger *starlog) Infoln(thread string, isStd bool, handler func([]Attr, string), str ...interface{}) {
+	strs := fmt.Sprintln(str...)
+	logger.build(thread, isStd, handler, LvInfo, strs)
+}
+
+func (logger *starlog) Notice(thread string, isStd bool, handler func([]Attr, string), str ...interface{}) {
+	strs := fmt.Sprint(str...)
+	logger.build(thread, isStd, handler, LvNotice, strs)
+}
+
+func (logger *starlog) Noticef(thread string, isStd bool, handler func([]Attr, string), format string, str ...interface{}) {
+	strs := fmt.Sprintf(format, str...)
+	logger.build(thread, isStd, handler, LvNotice, strs)
+}
+
+func (logger *starlog) Noticeln(thread string, isStd bool, handler func([]Attr, string), str ...interface{}) {
+	strs := fmt.Sprintln(str...)
+	logger.build(thread, isStd, handler, LvNotice, strs)
+}
+
+func (logger *starlog) Warning(thread string, isStd bool, handler func([]Attr, string), str ...interface{}) {
+	strs := fmt.Sprint(str...)
+	logger.build(thread, isStd, handler, LvWarning, strs)
+}
+
+func (logger *starlog) Warningf(thread string, isStd bool, handler func([]Attr, string), format string, str ...interface{}) {
+	strs := fmt.Sprintf(format, str...)
+	logger.build(thread, isStd, handler, LvWarning, strs)
+}
+
+func (logger *starlog) Warningln(thread string, isStd bool, handler func([]Attr, string), str ...interface{}) {
+	strs := fmt.Sprintln(str...)
+	logger.build(thread, isStd, handler, LvWarning, strs)
+}
+
+func (logger *starlog) Error(thread string, isStd bool, handler func([]Attr, string), str ...interface{}) {
+	strs := fmt.Sprint(str...)
+	logger.build(thread, isStd, handler, LvError, strs)
+}
+
+func (logger *starlog) Errorf(thread string, isStd bool, handler func([]Attr, string), format string, str ...interface{}) {
+	strs := fmt.Sprintf(format, str...)
+	logger.build(thread, isStd, handler, LvError, strs)
+}
+
+func (logger *starlog) Errorln(thread string, isStd bool, handler func([]Attr, string), str ...interface{}) {
+	strs := fmt.Sprintln(str...)
+	logger.build(thread, isStd, handler, LvError, strs)
+}
+
+func (logger *starlog) Critical(thread string, isStd bool, handler func([]Attr, string), str ...interface{}) {
+	strs := fmt.Sprint(str...)
+	logger.build(thread, isStd, handler, LvCritical, strs)
+}
+
+func (logger *starlog) Criticalf(thread string, isStd bool, handler func([]Attr, string), format string, str ...interface{}) {
+	strs := fmt.Sprintf(format, str...)
+	logger.build(thread, isStd, handler, LvCritical, strs)
+}
+
+func (logger *starlog) Criticalln(thread string, isStd bool, handler func([]Attr, string), str ...interface{}) {
+	strs := fmt.Sprintln(str...)
+	logger.build(thread, isStd, handler, LvCritical, strs)
+}
+
+func (logger *starlog) Fatal(thread string, isStd bool, handler func([]Attr, string), str ...interface{}) {
+	strs := fmt.Sprint(str...)
+	logger.build(thread, isStd, handler, LvFatal, strs)
+	os.Exit(9)
+}
+
+func (logger *starlog) Fatalf(thread string, isStd bool, handler func([]Attr, string), format string, str ...interface{}) {
+	strs := fmt.Sprintf(format, str...)
+	logger.build(thread, isStd, handler, LvFatal, strs)
+	os.Exit(9)
+}
+
+func (logger *starlog) Fatalln(thread string, isStd bool, handler func([]Attr, string), str ...interface{}) {
+	strs := fmt.Sprintln(str...)
+	logger.build(thread, isStd, handler, LvFatal, strs)
+	os.Exit(9)
+}
+
+func (logger *starlog) Panic(thread string, isStd bool, handler func([]Attr, string), str ...interface{}) {
+	strs := fmt.Sprint(str...)
+	logger.build(thread, isStd, handler, LvPanic, strs)
+	panic(str)
+}
+
+func (logger *starlog) Panicf(thread string, isStd bool, handler func([]Attr, string), format string, str ...interface{}) {
+	strs := fmt.Sprintf(format, str...)
+	logger.build(thread, isStd, handler, LvPanic, strs)
+	panic(fmt.Sprintf(format, str...))
+}
+
+func (logger *starlog) Panicln(thread string, isStd bool, handler func([]Attr, string), str ...interface{}) {
+	strs := fmt.Sprintln(str...)
+	logger.build(thread, isStd, handler, LvPanic, strs)
+	panic(fmt.Sprintln(str...))
+}
+
+func (logger *starlog) Print(thread string, isStd bool, handler func([]Attr, string), str ...interface{}) {
+	strs := fmt.Sprint(str...)
+	if logger.showStd {
+		fmt.Print(strs)
+	}
+	logger.write(strs)
+}
+
+func (logger *starlog) Printf(thread string, isStd bool, handler func([]Attr, string), format string, str ...interface{}) {
+	strs := fmt.Sprintf(format, str...)
+	if logger.showStd {
+		fmt.Print(strs)
+	}
+	logger.write(strs)
+}
+
+func (logger *starlog) Println(thread string, isStd bool, handler func([]Attr, string), str ...interface{}) {
+	strs := fmt.Sprintln(str...)
+	if logger.showStd {
+		fmt.Print(strs)
+	}
+	logger.write(strs)
+}

standed.go

@@ -0,0 +1,271 @@
+package starlog
+
+import (
+	"io"
+	"math/rand"
+	"sync"
+	"time"
+)
+
+var Std *StarLogger
+var stdmu sync.Mutex
+
+func init() {
+	rand.Seed(time.Now().UnixNano())
+	stackStopChan = make(chan int)
+	StartStacks()
+	Std = NewStarlog(nil)
+}
+
+func SetShowColor(val bool) {
+	Std.SetShowColor(val)
+}
+
+func GetShowColor() bool {
+	return Std.GetShowColor()
+}
+
+func SetLevelColor(level int, color []Attr) {
+	Std.SetLevelColor(level, color)
+}
+
+func GetLevelColor(level int) []Attr {
+	return Std.GetLevelColor(level)
+}
+
+func Debug(str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Debug(str...)
+	Std.isStd = false
+}
+
+func Debugf(format string, str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Debugf(format, str...)
+	Std.isStd = false
+}
+
+func Debugln(str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Debugln(str...)
+	Std.isStd = false
+}
+
+func Info(str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Info(str...)
+	Std.isStd = false
+}
+
+func Infof(format string, str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Infof(format, str...)
+	Std.isStd = false
+}
+
+func Infoln(str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Infoln(str...)
+	Std.isStd = false
+}
+
+func Notice(str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Notice(str...)
+	Std.isStd = false
+}
+
+func Noticef(format string, str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Noticef(format, str...)
+	Std.isStd = false
+}
+
+func Noticeln(str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Noticeln(str...)
+	Std.isStd = false
+}
+
+func Warning(str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Warning(str...)
+	Std.isStd = false
+}
+
+func Warningf(format string, str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Warningf(format, str...)
+	Std.isStd = false
+}
+
+func Warningln(str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Warningln(str...)
+	Std.isStd = false
+}
+
+func Error(str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Error(str...)
+	Std.isStd = false
+}
+
+func Errorf(format string, str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Errorf(format, str...)
+	Std.isStd = false
+}
+
+func Errorln(str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Errorln(str...)
+	Std.isStd = false
+}
+
+func Critical(str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Critical(str...)
+	Std.isStd = false
+}
+
+func Criticalf(format string, str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Criticalf(format, str...)
+	Std.isStd = false
+}
+
+func Criticalln(str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Criticalln(str...)
+	Std.isStd = false
+}
+
+func Fatal(str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Fatal(str...)
+	Std.isStd = false
+}
+
+func Fatalf(format string, str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Fatalf(format, str...)
+	Std.isStd = false
+}
+
+func Panicln(str ...interface{}) {
+	stdmu.Lock()
+	defer stdmu.Unlock()
+	Std.isStd = true
+	Std.Fatal(str...)
+	Std.isStd = false
+}
+
+func SetWriter(wr io.Writer) {
+	Std.SetWriter(wr)
+}
+func GetWriter() io.Writer {
+	return Std.GetWriter()
+}
+
+func SetHandler(f func([]Attr, string)) {
+	Std.SetHandler(f)
+}
+func GetHandler() func([]Attr, string) {
+	return Std.GetHandler()
+}
+func SetSwitching(sw bool) {
+	Std.SetSwitching(sw)
+}
+
+func SetShowOriginFile(val bool) {
+	Std.SetShowOriginFile(val)
+}
+
+func GetShowOriginFile() bool {
+	return Std.GetShowOriginFile()
+}
+
+func SetShowFuncName(val bool) {
+	Std.logcore.showFuncName = val
+}
+
+func GetShowFuncName() bool {
+	return Std.logcore.showFuncName
+}
+
+func SetShowLevel(val bool) {
+	Std.SetShowLevel(val)
+}
+
+func GetShowLevel() bool {
+	return Std.GetShowLevel()
+}
+
+func SetShowFlag(val bool) {
+	Std.SetShowFlag(val)
+}
+
+func GetShowFlag() bool {
+	return Std.GetShowFlag()
+}
+
+func SetShowStd(val bool) {
+	Std.SetShowStd(val)
+}
+
+func GetShowStd() bool {
+	return Std.GetShowStd()
+}
+
+func StopWrite() {
+	Std.StopWrite()
+}
+
+func EnbaleWrite() {
+	Std.EnbaleWrite()
+}
+
+func IsWriteStoed() bool {
+	return Std.IsWriteStoed()
+}

starlog.go

@@ -1,489 +1,175 @@
 package starlog
 
 import (
-	"fmt"
 	"io"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strconv"
-	"sync"
-	"time"
-
-	"github.com/mattn/go-colorable"
 )
 
-const (
+func (logger *StarLogger) SetShowColor(val bool) {
-	LvDebug = iota
+	logger.logcore.showColor = val
-	LvInfo
-	LvNotice
-	LvWarning
-	LvError
-	LvCritical
-	LvPanic
-	LvFatal
-)
-
-var (
-	levels = map[int]string{
-		LvDebug:    "DEBUG",
-		LvInfo:     "INFO",
-		LvNotice:   "NOTICE",
-		LvWarning:  "WARNING",
-		LvError:    "ERROR",
-		LvCritical: "CRITICAL",
-		LvPanic:    "PANIC",
-		LvFatal:    "FATAL",
-	}
-	Colors = map[int][]Attr{
-		LvDebug:    []Attr{FgWhite},
-		LvInfo:     []Attr{FgGreen},
-		LvNotice:   []Attr{FgBlue},
-		LvWarning:  []Attr{FgYellow},
-		LvError:    []Attr{FgMagenta},
-		LvCritical: []Attr{FgRed, Bold},
-		LvPanic:    []Attr{FgRed, Bold},
-		LvFatal:    []Attr{FgRed},
 }
-)
 
-type StarLogger struct {
+func (logger *StarLogger) GetShowColor() bool {
-	mu        sync.Mutex
+	return logger.logcore.showColor
-	lock      sync.Mutex
-	out       io.Writer
-	ShowLine  bool
-	ShowLevel bool
-	DoWrite   bool
-	DoShow    bool
-	switching bool
-	//HandleFunc
-	waiting      chan int
-	outshow      io.Writer
-	LogLevel     int
-	HandleFunc   func([]Attr, string)
-	StdFuncColor bool
 }
 
-var Std = New(nil)
+func (logger *StarLogger) SetLevelColor(level int, color []Attr) {
-
+	logger.logcore.colorList[level] = color
-func init() {
+	logger.logcore.colorMe[level] = NewColor(color...)
-	Std.DoShow = true
 }
 
-func New(out io.Writer) *StarLogger {
+func (logger *StarLogger) GetLevelColor(level int) []Attr {
-	logger := new(StarLogger)
+	return logger.logcore.colorList[level]
-	logger.DoShow = false
-	logger.ShowLevel = true
-	logger.ShowLine = true
-	logger.DoWrite = true
-	logger.out = out
-	logger.outshow = colorable.NewColorableStdout()
-	logger.StdFuncColor = true
-	return logger
 }
 
-func (logger *StarLogger) write(logstr string) {
+func (logger *StarLogger) SetWriter(wr io.Writer) {
-	if (!logger.DoWrite) || (logger.out == nil) {
+	logger.logcore.output = wr
-		return
 }
-	i := 0
+func (logger *StarLogger) GetWriter() io.Writer {
-	for logger.switching {
+	return logger.logcore.output
-		time.Sleep(time.Millisecond * 100)
-		i++
-		if i > 20 {
-			return
 }
+
+func (logger *StarLogger) SetHandler(f func([]Attr, string)) {
+	logger.handlerFunc = f
 }
-	if &(logger.out) == nil {
+func (logger *StarLogger) GetHandler() func([]Attr, string) {
-		return
+	return logger.handlerFunc
 }
-	logger.out.Write([]byte(logstr))
+func (logger *StarLogger) SetSwitching(sw bool) {
+	logger.logcore.switching = sw
 }
 
-func (logger *StarLogger) OutPut(logstr string) {
+func (logger *StarLogger) SetShowOriginFile(val bool) {
-	logger.out.Write([]byte(logstr))
+	logger.logcore.showDeatilFile = val
 }
 
-func (logger *StarLogger) output(level int, logstr string) {
+func (logger *StarLogger) GetShowOriginFile() bool {
-	var logs string
+	return logger.logcore.showDeatilFile
-	logger.mu.Lock()
-	defer logger.mu.Unlock()
-	if level < logger.LogLevel {
-		return
-	}
-	_, fname, line, _ := runtime.Caller(3)
-	fname = filepath.Base(fname)
-	date := time.Now().Format("2006-01-02 15:04:05.000 Mon")
-	if logger.ShowLine && logger.ShowLevel {
-		logs = fmt.Sprintf("%s %s %s %s", date, fname+":"+strconv.Itoa(line), `[`+levels[level]+`]`, logstr)
-	} else if logger.ShowLine && !logger.ShowLevel {
-		logs = fmt.Sprintf("%s %s %s", date, fname+":"+strconv.Itoa(line), logstr)
-	} else if !logger.ShowLine && logger.ShowLevel {
-		logs = fmt.Sprintf("%s %s %s", date, `[`+levels[level]+`]`, logstr)
-	} else {
-		logs = fmt.Sprintf("%s %s", date, logstr)
-	}
-	if logger.DoShow {
-		logcolor := NewColor(Colors[level]...)
-		logcolor.Fprint(logger.outshow, logs)
-	}
-	if logger.HandleFunc != nil {
-		go logger.HandleFunc(Colors[level], logs)
-	}
-	if logger.DoWrite {
-		logger.write(logs)
-	}
 }
 
-func (logger *StarLogger) Debug(str ...interface{}) {
+func (logger *StarLogger) SetShowFuncName(val bool) {
-	logger.lock.Lock()
+	logger.logcore.showFuncName = val
-	defer logger.lock.Unlock()
-	strs := fmt.Sprint(str...)
-	logger.output(LvDebug, strs)
 }
 
-func Debug(str ...interface{}) {
+func (logger *StarLogger) GetShowFuncName() bool {
-	Std.Debug(str...)
+	return logger.logcore.showFuncName
 }
 
-func (logger *StarLogger) Debugf(format string, str ...interface{}) {
+func (logger *StarLogger) SetShowLevel(val bool) {
-	logger.lock.Lock()
+	logger.logcore.showLevel = val
-	defer logger.lock.Unlock()
-	strs := fmt.Sprintf(format, str...)
-	logger.output(LvDebug, strs)
 }
 
-func Debugf(format string, str ...interface{}) {
+func (logger *StarLogger) GetShowLevel() bool {
-	Std.Debugf(format, str...)
+	return logger.logcore.showLevel
 }
 
-func (logger *StarLogger) Debugln(str ...interface{}) {
+func (logger *StarLogger) SetShowFlag(val bool) {
-	logger.lock.Lock()
+	logger.logcore.showThread = val
-	defer logger.lock.Unlock()
-	strs := fmt.Sprintln(str...)
-	logger.output(LvDebug, strs)
 }
 
-func Debugln(str ...interface{}) {
+func (logger *StarLogger) GetShowFlag() bool {
-	Std.Debugln(str...)
+	return logger.logcore.showThread
 }
 
-func (logger *StarLogger) Info(str ...interface{}) {
+func (logger *StarLogger) SetShowStd(val bool) {
-	logger.lock.Lock()
+	logger.logcore.showStd = val
-	defer logger.lock.Unlock()
-	strs := fmt.Sprint(str...)
-	logger.output(LvInfo, strs)
 }
 
-func Info(str ...interface{}) {
+func (logger *StarLogger) GetShowStd() bool {
-	Std.Info(str...)
+	return logger.logcore.showStd
 }
 
-func (logger *StarLogger) Infof(format string, str ...interface{}) {
+func (logger *StarLogger) StopWrite() {
-	logger.lock.Lock()
+	logger.logcore.stopWriter = true
-	defer logger.lock.Unlock()
-	strs := fmt.Sprintf(format, str...)
-	logger.output(LvInfo, strs)
 }
 
-func Infof(format string, str ...interface{}) {
+func (logger *StarLogger) EnbaleWrite() {
-	Std.Infof(format, str...)
+	logger.logcore.stopWriter = false
 }
 
-func (logger *StarLogger) Infoln(str ...interface{}) {
+func (logger *StarLogger) IsWriteStoed() bool {
-	logger.lock.Lock()
+	return logger.logcore.stopWriter
-	defer logger.lock.Unlock()
-	strs := fmt.Sprintln(str...)
-	logger.output(LvInfo, strs)
 }
 
-func Infoln(str ...interface{}) {
+func (logger *StarLogger) Debug(str ...interface{}) {
-	Std.Infoln(str...)
+	logger.logcore.Debug(logger.thread, logger.isStd, logger.handlerFunc, str...)
 }
 
-func (logger *StarLogger) Notice(str ...interface{}) {
+func (logger *StarLogger) Debugf(format string, str ...interface{}) {
-	logger.lock.Lock()
+	logger.logcore.Debugf(logger.thread, logger.isStd, logger.handlerFunc, format, str...)
-	defer logger.lock.Unlock()
-	strs := fmt.Sprint(str...)
-	logger.output(LvNotice, strs)
 }
 
-func Notice(str ...interface{}) {
+func (logger *StarLogger) Debugln(str ...interface{}) {
-	Std.Notice(str...)
+	logger.logcore.Debugln(logger.thread, logger.isStd, logger.handlerFunc, str...)
 }
 
-func (logger *StarLogger) Noticef(format string, str ...interface{}) {
+func (logger *StarLogger) Info(str ...interface{}) {
-	logger.lock.Lock()
+	logger.logcore.Info(logger.thread, logger.isStd, logger.handlerFunc, str...)
-	defer logger.lock.Unlock()
-	strs := fmt.Sprintf(format, str...)
-	logger.output(LvNotice, strs)
 }
 
-func Noticef(format string, str ...interface{}) {
+func (logger *StarLogger) Infof(format string, str ...interface{}) {
-	Std.Noticef(format, str...)
+	logger.logcore.Infof(logger.thread, logger.isStd, logger.handlerFunc, format, str...)
 }
 
-func (logger *StarLogger) Noticeln(str ...interface{}) {
+func (logger *StarLogger) Infoln(str ...interface{}) {
-	logger.lock.Lock()
+	logger.logcore.Infoln(logger.thread, logger.isStd, logger.handlerFunc, str...)
-	defer logger.lock.Unlock()
-	strs := fmt.Sprintln(str...)
-	logger.output(LvNotice, strs)
 }
 
-func Noticeln(str ...interface{}) {
+func (logger *StarLogger) Notice(str ...interface{}) {
-	Std.Noticeln(str...)
+	logger.logcore.Notice(logger.thread, logger.isStd, logger.handlerFunc, str...)
 }
 
-func (logger *StarLogger) Warning(str ...interface{}) {
+func (logger *StarLogger) Noticef(format string, str ...interface{}) {
-	logger.lock.Lock()
+	logger.logcore.Noticef(logger.thread, logger.isStd, logger.handlerFunc, format, str...)
-	defer logger.lock.Unlock()
-	strs := fmt.Sprint(str...)
-	logger.output(LvWarning, strs)
 }
 
-func Warning(str ...interface{}) {
+func (logger *StarLogger) Noticeln(str ...interface{}) {
-	Std.Warning(str...)
+	logger.logcore.Noticeln(logger.thread, logger.isStd, logger.handlerFunc, str...)
 }
 
-func (logger *StarLogger) Warningf(format string, str ...interface{}) {
+func (logger *StarLogger) Warning(str ...interface{}) {
-	logger.lock.Lock()
+	logger.logcore.Warning(logger.thread, logger.isStd, logger.handlerFunc, str...)
-	defer logger.lock.Unlock()
-	strs := fmt.Sprintf(format, str...)
-	logger.output(LvWarning, strs)
 }
 
-func Warningf(format string, str ...interface{}) {
+func (logger *StarLogger) Warningf(format string, str ...interface{}) {
-	Std.Warningf(format, str...)
+	logger.logcore.Warningf(logger.thread, logger.isStd, logger.handlerFunc, format, str...)
 }
 
 func (logger *StarLogger) Warningln(str ...interface{}) {
-	logger.lock.Lock()
+	logger.logcore.Warningln(logger.thread, logger.isStd, logger.handlerFunc, str...)
-	defer logger.lock.Unlock()
-	strs := fmt.Sprintln(str...)
-	logger.output(LvWarning, strs)
-}
-
-func Warningln(str ...interface{}) {
-	Std.Warningln(str...)
 }
 
 func (logger *StarLogger) Error(str ...interface{}) {
-	logger.lock.Lock()
+	logger.logcore.Error(logger.thread, logger.isStd, logger.handlerFunc, str...)
-	defer logger.lock.Unlock()
-	strs := fmt.Sprint(str...)
-	logger.output(LvError, strs)
-}
-
-func Error(str ...interface{}) {
-	Std.Error(str...)
 }
 
 func (logger *StarLogger) Errorf(format string, str ...interface{}) {
-	logger.lock.Lock()
+	logger.logcore.Errorf(logger.thread, logger.isStd, logger.handlerFunc, format, str...)
-	defer logger.lock.Unlock()
-	strs := fmt.Sprintf(format, str...)
-	logger.output(LvError, strs)
-}
-
-func Errorf(format string, str ...interface{}) {
-	Std.Errorf(format, str...)
 }
 
 func (logger *StarLogger) Errorln(str ...interface{}) {
-	logger.lock.Lock()
+	logger.logcore.Errorln(logger.thread, logger.isStd, logger.handlerFunc, str...)
-	defer logger.lock.Unlock()
-	strs := fmt.Sprintln(str...)
-	logger.output(LvError, strs)
-}
-
-func Errorln(str ...interface{}) {
-	Std.Errorln(str...)
 }
 
 func (logger *StarLogger) Critical(str ...interface{}) {
-	logger.lock.Lock()
+	logger.logcore.Critical(logger.thread, logger.isStd, logger.handlerFunc, str...)
-	defer logger.lock.Unlock()
-	strs := fmt.Sprint(str...)
-	logger.output(LvCritical, strs)
-}
-
-func Critical(str ...interface{}) {
-	Std.Critical(str...)
 }
 
 func (logger *StarLogger) Criticalf(format string, str ...interface{}) {
-	logger.lock.Lock()
+	logger.logcore.Criticalf(logger.thread, logger.isStd, logger.handlerFunc, format, str...)
-	defer logger.lock.Unlock()
-	strs := fmt.Sprintf(format, str...)
-	logger.output(LvCritical, strs)
-}
-
-func Criticalf(format string, str ...interface{}) {
-	Std.Criticalf(format, str...)
 }
 
 func (logger *StarLogger) Criticalln(str ...interface{}) {
-	logger.lock.Lock()
+	logger.logcore.Criticalln(logger.thread, logger.isStd, logger.handlerFunc, str...)
-	defer logger.lock.Unlock()
-	strs := fmt.Sprintln(str...)
-	logger.output(LvCritical, strs)
-}
-
-func Criticalln(str ...interface{}) {
-	Std.Criticalln(str...)
 }
 
 func (logger *StarLogger) Fatal(str ...interface{}) {
-	logger.lock.Lock()
+	logger.logcore.Fatal(logger.thread, logger.isStd, logger.handlerFunc, str...)
-	defer logger.lock.Unlock()
-	strs := fmt.Sprint(str...)
-	logger.output(LvFatal, strs)
-	os.Exit(9)
-}
-
-func Fatal(str ...interface{}) {
-	Std.Fatal(str...)
 }
 
 func (logger *StarLogger) Fatalf(format string, str ...interface{}) {
-	logger.lock.Lock()
+	logger.logcore.Fatalf(logger.thread, logger.isStd, logger.handlerFunc, format, str...)
-	defer logger.lock.Unlock()
-	strs := fmt.Sprintf(format, str...)
-	logger.output(LvFatal, strs)
-	os.Exit(9)
-}
-
-func Fatalf(format string, str ...interface{}) {
-	Std.Fatalf(format, str...)
 }
 
 func (logger *StarLogger) Fatalln(str ...interface{}) {
-	logger.lock.Lock()
+	logger.logcore.Fatalln(logger.thread, logger.isStd, logger.handlerFunc, str...)
-	defer logger.lock.Unlock()
-	strs := fmt.Sprintln(str...)
-	logger.output(LvFatal, strs)
-	os.Exit(9)
-}
-
-func Fatalln(str ...interface{}) {
-	Std.Fatalln(str...)
-}
-
-func (logger *StarLogger) Panic(str ...interface{}) {
-	logger.lock.Lock()
-	defer logger.lock.Unlock()
-	strs := fmt.Sprint(str...)
-	logger.output(LvPanic, strs)
-	panic(str)
-}
-
-func Panic(str ...interface{}) {
-	Std.Panic(str...)
-}
-
-func (logger *StarLogger) Panicf(format string, str ...interface{}) {
-	logger.lock.Lock()
-	defer logger.lock.Unlock()
-	strs := fmt.Sprintf(format, str...)
-	logger.output(LvPanic, strs)
-	panic(fmt.Sprintf(format, str...))
-}
-
-func Panicf(format string, str ...interface{}) {
-	Std.Panicf(format, str...)
-}
-
-func (logger *StarLogger) Panicln(str ...interface{}) {
-	logger.lock.Lock()
-	defer logger.lock.Unlock()
-	strs := fmt.Sprintln(str...)
-	logger.output(LvPanic, strs)
-	panic(fmt.Sprintln(str...))
-}
-
-func Panicln(str ...interface{}) {
-	Std.Panicln(str...)
-}
-
-func (logger *StarLogger) Print(str ...interface{}) {
-	logger.lock.Lock()
-	defer logger.lock.Unlock()
-	strs := fmt.Sprint(str...)
-	logger.OutPut(strs)
-}
-
-func Print(str ...interface{}) {
-	Std.Print(str...)
-}
-
-func (logger *StarLogger) Printf(format string, str ...interface{}) {
-	logger.lock.Lock()
-	defer logger.lock.Unlock()
-	strs := fmt.Sprintf(format, str...)
-	logger.OutPut(strs)
-}
-
-func Printf(format string, str ...interface{}) {
-	Std.Printf(format, str...)
-}
-
-func (logger *StarLogger) Println(str ...interface{}) {
-	logger.lock.Lock()
-	defer logger.lock.Unlock()
-	strs := fmt.Sprintln(str...)
-	logger.OutPut(strs)
-}
-
-func Println(str ...interface{}) {
-	Std.Println(str...)
-}
-
-func StdPrint(c []Attr, str ...interface{}) {
-	Std.lock.Lock()
-	defer Std.lock.Unlock()
-	colorstr := NewColor(c...)
-	colorstr.Print(str...)
-	if Std.StdFuncColor && Std.HandleFunc != nil {
-		go Std.HandleFunc(c, fmt.Sprint(str...))
-	}
-}
-
-func StdPrintf(c []Attr, format string, str ...interface{}) {
-	Std.lock.Lock()
-	defer Std.lock.Unlock()
-	colorstr := NewColor(c...)
-	colorstr.Printf(format, str...)
-	if Std.StdFuncColor && Std.HandleFunc != nil {
-		go Std.HandleFunc(c, fmt.Sprintf(format, str...))
-	}
-}
-
-func StdPrintln(c []Attr, str ...interface{}) {
-	Std.lock.Lock()
-	defer Std.lock.Unlock()
-	colorstr := NewColor(c...)
-	colorstr.Println(str...)
-	if Std.StdFuncColor && Std.HandleFunc != nil {
-		go Std.HandleFunc(c, fmt.Sprintln(str...))
-	}
-}
-
-func (logger *StarLogger) SwitchOut(out io.Writer) {
-	logger.lock.Lock()
-	defer logger.lock.Unlock()
-	logger.switching = true
-	logger.out = out
-	logger.switching = false
-}
-
-func SetLogFile(path string) error {
-	var err error
-	Std.out, err = os.Create(path)
-	Std.switching = false
-	return err
-}
-
-func SwitchFile(path string) error {
-	Std.switching = true
-	return SetLogFile(path)
 }

starlog_test.go

@@ -2,8 +2,11 @@ package starlog
 
 import (
 	"testing"
+	"time"
 )
 
 func Test_LOG(t *testing.T) {
-
+	go Debugln("nb")
+	Debugln("nb2")
+	time.Sleep(time.Second)
 }

typed.go

@@ -0,0 +1,179 @@
+package starlog
+
+import (
+	"fmt"
+	"io"
+	"math/rand"
+	"sync"
+	"time"
+
+	"b612.me/starmap"
+	"github.com/mattn/go-colorable"
+)
+
+const (
+	LvDebug = iota
+	LvInfo
+	LvNotice
+	LvWarning
+	LvError
+	LvCritical
+	LvPanic
+	LvFatal
+)
+
+var (
+	levels = map[int]string{
+		LvDebug:    "DEBUG",
+		LvInfo:     "INFO",
+		LvNotice:   "NOTICE",
+		LvWarning:  "WARNING",
+		LvError:    "ERROR",
+		LvCritical: "CRITICAL",
+		LvPanic:    "PANIC",
+		LvFatal:    "FATAL",
+	}
+	stacks        starmap.StarStack
+	stackStarted  bool = false
+	stackStopChan chan int
+	stdScreen     io.Writer = colorable.NewColorableStdout()
+)
+
+type starlog struct {
+	mu             *sync.Mutex
+	output         io.Writer
+	showFuncName   bool
+	showThread     bool
+	showLevel      bool
+	showDeatilFile bool
+	showColor      bool
+	switching      bool
+	showStd        bool
+	stopWriter     bool
+	id             string
+
+	colorList map[int][]Attr
+	colorMe   map[int]*Color
+}
+
+type StarLogger struct {
+	thread      string
+	handlerFunc func([]Attr, string)
+	logcore     *starlog
+	isStd       bool
+}
+
+type logTransfer struct {
+	handlerFunc func([]Attr, string)
+	colors      []Attr
+	logStr      string
+}
+
+func newLogCore(out io.Writer) *starlog {
+	return &starlog{
+		mu:             &sync.Mutex{},
+		output:         out,
+		showFuncName:   true,
+		showThread:     true,
+		showLevel:      true,
+		showStd:        true,
+		showDeatilFile: true,
+		switching:      false,
+		stopWriter:     false,
+		showColor:      true,
+		id:             generateId(),
+		colorList: map[int][]Attr{
+			LvDebug:    []Attr{FgWhite},
+			LvInfo:     []Attr{FgGreen},
+			LvNotice:   []Attr{FgBlue},
+			LvWarning:  []Attr{FgYellow},
+			LvError:    []Attr{FgMagenta},
+			LvCritical: []Attr{FgRed, Bold},
+			LvPanic:    []Attr{FgRed, Bold},
+			LvFatal:    []Attr{FgRed},
+		},
+		colorMe: map[int]*Color{
+			LvDebug:    NewColor([]Attr{FgWhite}...),
+			LvInfo:     NewColor([]Attr{FgGreen}...),
+			LvNotice:   NewColor([]Attr{FgBlue}...),
+			LvWarning:  NewColor([]Attr{FgYellow}...),
+			LvError:    NewColor([]Attr{FgMagenta}...),
+			LvCritical: NewColor([]Attr{FgRed, Bold}...),
+			LvPanic:    NewColor([]Attr{FgRed, Bold}...),
+			LvFatal:    NewColor([]Attr{FgRed}...),
+		},
+	}
+}
+
+func NewStarlog(out io.Writer) *StarLogger {
+	return &StarLogger{
+		handlerFunc: nil,
+		thread:      "MAN",
+		logcore:     newLogCore(out),
+		isStd:       false,
+	}
+}
+
+func (logger *StarLogger) NewFlag() *StarLogger {
+	return &StarLogger{
+		thread:      getRandomFlag(false),
+		handlerFunc: logger.handlerFunc,
+		logcore:     logger.logcore,
+		isStd:       false,
+	}
+}
+func (logger *StarLogger) SetNewRandomFlag() {
+	logger.thread = getRandomFlag(false)
+}
+
+func getRandomFlag(isMain bool) string {
+	rand.Seed(time.Now().UnixNano())
+	if isMain {
+		return "MAN"
+	}
+	flag := "MAN"
+	for flag == "MAN" {
+		flag = string([]byte{uint8(rand.Intn(26) + 65), uint8(rand.Intn(26) + 65), uint8(rand.Intn(26) + 65)})
+	}
+	return flag
+}
+
+func generateId() string {
+	rand.Seed(time.Now().UnixNano())
+	return fmt.Sprintf("%dstar%db612%d", time.Now().UnixNano(), rand.Intn(1000000), rand.Intn(1000000))
+}
+
+func StartStacks() {
+	if stackStarted {
+		return
+	}
+	go func() {
+		stackStarted = true
+		defer func() {
+			stackStarted = false
+		}()
+		for {
+			select {
+			case <-stackStopChan:
+				return
+			default:
+			}
+			poped := stacks.MustPop()
+			if poped == nil {
+				time.Sleep(time.Millisecond * 10)
+				continue
+			}
+			val := poped.(logTransfer)
+			if val.handlerFunc != nil {
+				val.handlerFunc(val.colors, val.logStr)
+			}
+		}
+	}()
+}
+
+func StopStacks() {
+	if !stackStarted {
+		return
+	}
+	stackStopChan <- 1
+}

vendor/github.com/mattn/go-colorable/.travis.yml

@@ -1,9 +0,0 @@
-language: go
-go:
-  - tip
-
-before_install:
-  - go get github.com/mattn/goveralls
-  - go get golang.org/x/tools/cmd/cover
-script:
-  - $HOME/gopath/bin/goveralls -repotoken xnXqRGwgW3SXIguzxf90ZSK1GPYZPaGrw

vendor/github.com/mattn/go-colorable/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016 Yasuhiro Matsumoto
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

vendor/github.com/mattn/go-colorable/README.md

@@ -1,48 +0,0 @@
-# go-colorable
-
-[![Godoc Reference](https://godoc.org/github.com/mattn/go-colorable?status.svg)](http://godoc.org/github.com/mattn/go-colorable)
-[![Build Status](https://travis-ci.org/mattn/go-colorable.svg?branch=master)](https://travis-ci.org/mattn/go-colorable)
-[![Coverage Status](https://coveralls.io/repos/github/mattn/go-colorable/badge.svg?branch=master)](https://coveralls.io/github/mattn/go-colorable?branch=master)
-[![Go Report Card](https://goreportcard.com/badge/mattn/go-colorable)](https://goreportcard.com/report/mattn/go-colorable)
-
-Colorable writer for windows.
-
-For example, most of logger packages doesn't show colors on windows. (I know we can do it with ansicon. But I don't want.)
-This package is possible to handle escape sequence for ansi color on windows.
-
-## Too Bad!
-
-![](https://raw.githubusercontent.com/mattn/go-colorable/gh-pages/bad.png)
-
-
-## So Good!
-
-![](https://raw.githubusercontent.com/mattn/go-colorable/gh-pages/good.png)
-
-## Usage
-
-```go
-logrus.SetFormatter(&logrus.TextFormatter{ForceColors: true})
-logrus.SetOutput(colorable.NewColorableStdout())
-
-logrus.Info("succeeded")
-logrus.Warn("not correct")
-logrus.Error("something error")
-logrus.Fatal("panic")
-```
-
-You can compile above code on non-windows OSs.
-
-## Installation
-
-```
-$ go get github.com/mattn/go-colorable
-```
-
-# License
-
-MIT
-
-# Author
-
-Yasuhiro Matsumoto (a.k.a mattn)

vendor/github.com/mattn/go-colorable/_example/escape-seq/main.go

@@ -1,16 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"fmt"
-
-	"github.com/mattn/go-colorable"
-)
-
-func main() {
-	stdOut := bufio.NewWriter(colorable.NewColorableStdout())
-
-	fmt.Fprint(stdOut, "\x1B[3GMove to 3rd Column\n")
-	fmt.Fprint(stdOut, "\x1B[1;2HMove to 2nd Column on 1st Line\n")
-	stdOut.Flush()
-}

vendor/github.com/mattn/go-colorable/_example/logrus/main.go

@@ -1,16 +0,0 @@
-package main
-
-import (
-	"github.com/mattn/go-colorable"
-	"github.com/sirupsen/logrus"
-)
-
-func main() {
-	logrus.SetFormatter(&logrus.TextFormatter{ForceColors: true})
-	logrus.SetOutput(colorable.NewColorableStdout())
-
-	logrus.Info("succeeded")
-	logrus.Warn("not correct")
-	logrus.Error("something error")
-	logrus.Fatal("panic")
-}

vendor/github.com/mattn/go-colorable/_example/title/main.go

@@ -1,14 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	. "github.com/mattn/go-colorable"
-)
-
-func main() {
-	out := NewColorableStdout()
-	fmt.Fprint(out, "\x1B]0;TITLE Changed\007(See title and hit any key)")
-	var c [1]byte
-	os.Stdin.Read(c[:])
-}

vendor/github.com/mattn/go-colorable/colorable_appengine.go

@@ -1,29 +0,0 @@
-// +build appengine
-
-package colorable
-
-import (
-	"io"
-	"os"
-
-	_ "github.com/mattn/go-isatty"
-)
-
-// NewColorable return new instance of Writer which handle escape sequence.
-func NewColorable(file *os.File) io.Writer {
-	if file == nil {
-		panic("nil passed instead of *os.File to NewColorable()")
-	}
-
-	return file
-}
-
-// NewColorableStdout return new instance of Writer which handle escape sequence for stdout.
-func NewColorableStdout() io.Writer {
-	return os.Stdout
-}
-
-// NewColorableStderr return new instance of Writer which handle escape sequence for stderr.
-func NewColorableStderr() io.Writer {
-	return os.Stderr
-}

vendor/github.com/mattn/go-colorable/colorable_others.go

@@ -1,30 +0,0 @@
-// +build !windows
-// +build !appengine
-
-package colorable
-
-import (
-	"io"
-	"os"
-
-	_ "github.com/mattn/go-isatty"
-)
-
-// NewColorable return new instance of Writer which handle escape sequence.
-func NewColorable(file *os.File) io.Writer {
-	if file == nil {
-		panic("nil passed instead of *os.File to NewColorable()")
-	}
-
-	return file
-}
-
-// NewColorableStdout return new instance of Writer which handle escape sequence for stdout.
-func NewColorableStdout() io.Writer {
-	return os.Stdout
-}
-
-// NewColorableStderr return new instance of Writer which handle escape sequence for stderr.
-func NewColorableStderr() io.Writer {
-	return os.Stderr
-}

vendor/github.com/mattn/go-colorable/colorable_test.go

@@ -1,83 +0,0 @@
-package colorable
-
-import (
-	"bytes"
-	"os"
-	"runtime"
-	"testing"
-)
-
-// checkEncoding checks that colorable is output encoding agnostic as long as
-// the encoding is a superset of ASCII. This implies that one byte not part of
-// an ANSI sequence must give exactly one byte in output
-func checkEncoding(t *testing.T, data []byte) {
-	// Send non-UTF8 data to colorable
-	b := bytes.NewBuffer(make([]byte, 0, 10))
-	if b.Len() != 0 {
-		t.FailNow()
-	}
-	// TODO move colorable wrapping outside the test
-	c := NewNonColorable(b)
-	c.Write(data)
-	if b.Len() != len(data) {
-		t.Fatalf("%d bytes expected, got %d", len(data), b.Len())
-	}
-}
-
-func TestEncoding(t *testing.T) {
-	checkEncoding(t, []byte{})      // Empty
-	checkEncoding(t, []byte(`abc`)) // "abc"
-	checkEncoding(t, []byte(`é`))   // "é" in UTF-8
-	checkEncoding(t, []byte{233})   // 'é' in Latin-1
-}
-
-func TestNonColorable(t *testing.T) {
-	var buf bytes.Buffer
-	want := "hello"
-	NewNonColorable(&buf).Write([]byte("\x1b[0m" + want + "\x1b[2J"))
-	got := buf.String()
-	if got != "hello" {
-		t.Fatalf("want %q but %q", want, got)
-	}
-
-	buf.Reset()
-	NewNonColorable(&buf).Write([]byte("\x1b["))
-	got = buf.String()
-	if got != "" {
-		t.Fatalf("want %q but %q", "", got)
-	}
-}
-
-func TestNonColorableNil(t *testing.T) {
-	paniced := false
-	func() {
-		defer func() {
-			recover()
-			paniced = true
-		}()
-		NewNonColorable(nil)
-		NewColorable(nil)
-	}()
-
-	if !paniced {
-		t.Fatalf("should panic")
-	}
-}
-
-func TestColorable(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skipf("skip this test on windows")
-	}
-	_, ok := NewColorableStdout().(*os.File)
-	if !ok {
-		t.Fatalf("should os.Stdout on UNIX")
-	}
-	_, ok = NewColorableStderr().(*os.File)
-	if !ok {
-		t.Fatalf("should os.Stdout on UNIX")
-	}
-	_, ok = NewColorable(os.Stdout).(*os.File)
-	if !ok {
-		t.Fatalf("should os.Stdout on UNIX")
-	}
-}

vendor/github.com/mattn/go-colorable/colorable_windows.go

@@ -1,884 +0,0 @@
-// +build windows
-// +build !appengine
-
-package colorable
-
-import (
-	"bytes"
-	"io"
-	"math"
-	"os"
-	"strconv"
-	"strings"
-	"syscall"
-	"unsafe"
-
-	"github.com/mattn/go-isatty"
-)
-
-const (
-	foregroundBlue      = 0x1
-	foregroundGreen     = 0x2
-	foregroundRed       = 0x4
-	foregroundIntensity = 0x8
-	foregroundMask      = (foregroundRed | foregroundBlue | foregroundGreen | foregroundIntensity)
-	backgroundBlue      = 0x10
-	backgroundGreen     = 0x20
-	backgroundRed       = 0x40
-	backgroundIntensity = 0x80
-	backgroundMask      = (backgroundRed | backgroundBlue | backgroundGreen | backgroundIntensity)
-)
-
-type wchar uint16
-type short int16
-type dword uint32
-type word uint16
-
-type coord struct {
-	x short
-	y short
-}
-
-type smallRect struct {
-	left   short
-	top    short
-	right  short
-	bottom short
-}
-
-type consoleScreenBufferInfo struct {
-	size              coord
-	cursorPosition    coord
-	attributes        word
-	window            smallRect
-	maximumWindowSize coord
-}
-
-type consoleCursorInfo struct {
-	size    dword
-	visible int32
-}
-
-var (
-	kernel32                       = syscall.NewLazyDLL("kernel32.dll")
-	procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo")
-	procSetConsoleTextAttribute    = kernel32.NewProc("SetConsoleTextAttribute")
-	procSetConsoleCursorPosition   = kernel32.NewProc("SetConsoleCursorPosition")
-	procFillConsoleOutputCharacter = kernel32.NewProc("FillConsoleOutputCharacterW")
-	procFillConsoleOutputAttribute = kernel32.NewProc("FillConsoleOutputAttribute")
-	procGetConsoleCursorInfo       = kernel32.NewProc("GetConsoleCursorInfo")
-	procSetConsoleCursorInfo       = kernel32.NewProc("SetConsoleCursorInfo")
-	procSetConsoleTitle            = kernel32.NewProc("SetConsoleTitleW")
-)
-
-// Writer provide colorable Writer to the console
-type Writer struct {
-	out     io.Writer
-	handle  syscall.Handle
-	oldattr word
-	oldpos  coord
-}
-
-// NewColorable return new instance of Writer which handle escape sequence from File.
-func NewColorable(file *os.File) io.Writer {
-	if file == nil {
-		panic("nil passed instead of *os.File to NewColorable()")
-	}
-
-	if isatty.IsTerminal(file.Fd()) {
-		var csbi consoleScreenBufferInfo
-		handle := syscall.Handle(file.Fd())
-		procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
-		return &Writer{out: file, handle: handle, oldattr: csbi.attributes, oldpos: coord{0, 0}}
-	}
-	return file
-}
-
-// NewColorableStdout return new instance of Writer which handle escape sequence for stdout.
-func NewColorableStdout() io.Writer {
-	return NewColorable(os.Stdout)
-}
-
-// NewColorableStderr return new instance of Writer which handle escape sequence for stderr.
-func NewColorableStderr() io.Writer {
-	return NewColorable(os.Stderr)
-}
-
-var color256 = map[int]int{
-	0:   0x000000,
-	1:   0x800000,
-	2:   0x008000,
-	3:   0x808000,
-	4:   0x000080,
-	5:   0x800080,
-	6:   0x008080,
-	7:   0xc0c0c0,
-	8:   0x808080,
-	9:   0xff0000,
-	10:  0x00ff00,
-	11:  0xffff00,
-	12:  0x0000ff,
-	13:  0xff00ff,
-	14:  0x00ffff,
-	15:  0xffffff,
-	16:  0x000000,
-	17:  0x00005f,
-	18:  0x000087,
-	19:  0x0000af,
-	20:  0x0000d7,
-	21:  0x0000ff,
-	22:  0x005f00,
-	23:  0x005f5f,
-	24:  0x005f87,
-	25:  0x005faf,
-	26:  0x005fd7,
-	27:  0x005fff,
-	28:  0x008700,
-	29:  0x00875f,
-	30:  0x008787,
-	31:  0x0087af,
-	32:  0x0087d7,
-	33:  0x0087ff,
-	34:  0x00af00,
-	35:  0x00af5f,
-	36:  0x00af87,
-	37:  0x00afaf,
-	38:  0x00afd7,
-	39:  0x00afff,
-	40:  0x00d700,
-	41:  0x00d75f,
-	42:  0x00d787,
-	43:  0x00d7af,
-	44:  0x00d7d7,
-	45:  0x00d7ff,
-	46:  0x00ff00,
-	47:  0x00ff5f,
-	48:  0x00ff87,
-	49:  0x00ffaf,
-	50:  0x00ffd7,
-	51:  0x00ffff,
-	52:  0x5f0000,
-	53:  0x5f005f,
-	54:  0x5f0087,
-	55:  0x5f00af,
-	56:  0x5f00d7,
-	57:  0x5f00ff,
-	58:  0x5f5f00,
-	59:  0x5f5f5f,
-	60:  0x5f5f87,
-	61:  0x5f5faf,
-	62:  0x5f5fd7,
-	63:  0x5f5fff,
-	64:  0x5f8700,
-	65:  0x5f875f,
-	66:  0x5f8787,
-	67:  0x5f87af,
-	68:  0x5f87d7,
-	69:  0x5f87ff,
-	70:  0x5faf00,
-	71:  0x5faf5f,
-	72:  0x5faf87,
-	73:  0x5fafaf,
-	74:  0x5fafd7,
-	75:  0x5fafff,
-	76:  0x5fd700,
-	77:  0x5fd75f,
-	78:  0x5fd787,
-	79:  0x5fd7af,
-	80:  0x5fd7d7,
-	81:  0x5fd7ff,
-	82:  0x5fff00,
-	83:  0x5fff5f,
-	84:  0x5fff87,
-	85:  0x5fffaf,
-	86:  0x5fffd7,
-	87:  0x5fffff,
-	88:  0x870000,
-	89:  0x87005f,
-	90:  0x870087,
-	91:  0x8700af,
-	92:  0x8700d7,
-	93:  0x8700ff,
-	94:  0x875f00,
-	95:  0x875f5f,
-	96:  0x875f87,
-	97:  0x875faf,
-	98:  0x875fd7,
-	99:  0x875fff,
-	100: 0x878700,
-	101: 0x87875f,
-	102: 0x878787,
-	103: 0x8787af,
-	104: 0x8787d7,
-	105: 0x8787ff,
-	106: 0x87af00,
-	107: 0x87af5f,
-	108: 0x87af87,
-	109: 0x87afaf,
-	110: 0x87afd7,
-	111: 0x87afff,
-	112: 0x87d700,
-	113: 0x87d75f,
-	114: 0x87d787,
-	115: 0x87d7af,
-	116: 0x87d7d7,
-	117: 0x87d7ff,
-	118: 0x87ff00,
-	119: 0x87ff5f,
-	120: 0x87ff87,
-	121: 0x87ffaf,
-	122: 0x87ffd7,
-	123: 0x87ffff,
-	124: 0xaf0000,
-	125: 0xaf005f,
-	126: 0xaf0087,
-	127: 0xaf00af,
-	128: 0xaf00d7,
-	129: 0xaf00ff,
-	130: 0xaf5f00,
-	131: 0xaf5f5f,
-	132: 0xaf5f87,
-	133: 0xaf5faf,
-	134: 0xaf5fd7,
-	135: 0xaf5fff,
-	136: 0xaf8700,
-	137: 0xaf875f,
-	138: 0xaf8787,
-	139: 0xaf87af,
-	140: 0xaf87d7,
-	141: 0xaf87ff,
-	142: 0xafaf00,
-	143: 0xafaf5f,
-	144: 0xafaf87,
-	145: 0xafafaf,
-	146: 0xafafd7,
-	147: 0xafafff,
-	148: 0xafd700,
-	149: 0xafd75f,
-	150: 0xafd787,
-	151: 0xafd7af,
-	152: 0xafd7d7,
-	153: 0xafd7ff,
-	154: 0xafff00,
-	155: 0xafff5f,
-	156: 0xafff87,
-	157: 0xafffaf,
-	158: 0xafffd7,
-	159: 0xafffff,
-	160: 0xd70000,
-	161: 0xd7005f,
-	162: 0xd70087,
-	163: 0xd700af,
-	164: 0xd700d7,
-	165: 0xd700ff,
-	166: 0xd75f00,
-	167: 0xd75f5f,
-	168: 0xd75f87,
-	169: 0xd75faf,
-	170: 0xd75fd7,
-	171: 0xd75fff,
-	172: 0xd78700,
-	173: 0xd7875f,
-	174: 0xd78787,
-	175: 0xd787af,
-	176: 0xd787d7,
-	177: 0xd787ff,
-	178: 0xd7af00,
-	179: 0xd7af5f,
-	180: 0xd7af87,
-	181: 0xd7afaf,
-	182: 0xd7afd7,
-	183: 0xd7afff,
-	184: 0xd7d700,
-	185: 0xd7d75f,
-	186: 0xd7d787,
-	187: 0xd7d7af,
-	188: 0xd7d7d7,
-	189: 0xd7d7ff,
-	190: 0xd7ff00,
-	191: 0xd7ff5f,
-	192: 0xd7ff87,
-	193: 0xd7ffaf,
-	194: 0xd7ffd7,
-	195: 0xd7ffff,
-	196: 0xff0000,
-	197: 0xff005f,
-	198: 0xff0087,
-	199: 0xff00af,
-	200: 0xff00d7,
-	201: 0xff00ff,
-	202: 0xff5f00,
-	203: 0xff5f5f,
-	204: 0xff5f87,
-	205: 0xff5faf,
-	206: 0xff5fd7,
-	207: 0xff5fff,
-	208: 0xff8700,
-	209: 0xff875f,
-	210: 0xff8787,
-	211: 0xff87af,
-	212: 0xff87d7,
-	213: 0xff87ff,
-	214: 0xffaf00,
-	215: 0xffaf5f,
-	216: 0xffaf87,
-	217: 0xffafaf,
-	218: 0xffafd7,
-	219: 0xffafff,
-	220: 0xffd700,
-	221: 0xffd75f,
-	222: 0xffd787,
-	223: 0xffd7af,
-	224: 0xffd7d7,
-	225: 0xffd7ff,
-	226: 0xffff00,
-	227: 0xffff5f,
-	228: 0xffff87,
-	229: 0xffffaf,
-	230: 0xffffd7,
-	231: 0xffffff,
-	232: 0x080808,
-	233: 0x121212,
-	234: 0x1c1c1c,
-	235: 0x262626,
-	236: 0x303030,
-	237: 0x3a3a3a,
-	238: 0x444444,
-	239: 0x4e4e4e,
-	240: 0x585858,
-	241: 0x626262,
-	242: 0x6c6c6c,
-	243: 0x767676,
-	244: 0x808080,
-	245: 0x8a8a8a,
-	246: 0x949494,
-	247: 0x9e9e9e,
-	248: 0xa8a8a8,
-	249: 0xb2b2b2,
-	250: 0xbcbcbc,
-	251: 0xc6c6c6,
-	252: 0xd0d0d0,
-	253: 0xdadada,
-	254: 0xe4e4e4,
-	255: 0xeeeeee,
-}
-
-// `\033]0;TITLESTR\007`
-func doTitleSequence(er *bytes.Reader) error {
-	var c byte
-	var err error
-
-	c, err = er.ReadByte()
-	if err != nil {
-		return err
-	}
-	if c != '0' && c != '2' {
-		return nil
-	}
-	c, err = er.ReadByte()
-	if err != nil {
-		return err
-	}
-	if c != ';' {
-		return nil
-	}
-	title := make([]byte, 0, 80)
-	for {
-		c, err = er.ReadByte()
-		if err != nil {
-			return err
-		}
-		if c == 0x07 || c == '\n' {
-			break
-		}
-		title = append(title, c)
-	}
-	if len(title) > 0 {
-		title8, err := syscall.UTF16PtrFromString(string(title))
-		if err == nil {
-			procSetConsoleTitle.Call(uintptr(unsafe.Pointer(title8)))
-		}
-	}
-	return nil
-}
-
-// Write write data on console
-func (w *Writer) Write(data []byte) (n int, err error) {
-	var csbi consoleScreenBufferInfo
-	procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-
-	er := bytes.NewReader(data)
-	var bw [1]byte
-loop:
-	for {
-		c1, err := er.ReadByte()
-		if err != nil {
-			break loop
-		}
-		if c1 != 0x1b {
-			bw[0] = c1
-			w.out.Write(bw[:])
-			continue
-		}
-		c2, err := er.ReadByte()
-		if err != nil {
-			break loop
-		}
-
-		if c2 == ']' {
-			if err := doTitleSequence(er); err != nil {
-				break loop
-			}
-			continue
-		}
-		if c2 != 0x5b {
-			continue
-		}
-
-		var buf bytes.Buffer
-		var m byte
-		for {
-			c, err := er.ReadByte()
-			if err != nil {
-				break loop
-			}
-			if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '@' {
-				m = c
-				break
-			}
-			buf.Write([]byte(string(c)))
-		}
-
-		switch m {
-		case 'A':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.y -= short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'B':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.y += short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'C':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.x += short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'D':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.x -= short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'E':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.x = 0
-			csbi.cursorPosition.y += short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'F':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.x = 0
-			csbi.cursorPosition.y -= short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'G':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.x = short(n - 1)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'H', 'f':
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			if buf.Len() > 0 {
-				token := strings.Split(buf.String(), ";")
-				switch len(token) {
-				case 1:
-					n1, err := strconv.Atoi(token[0])
-					if err != nil {
-						continue
-					}
-					csbi.cursorPosition.y = short(n1 - 1)
-				case 2:
-					n1, err := strconv.Atoi(token[0])
-					if err != nil {
-						continue
-					}
-					n2, err := strconv.Atoi(token[1])
-					if err != nil {
-						continue
-					}
-					csbi.cursorPosition.x = short(n2 - 1)
-					csbi.cursorPosition.y = short(n1 - 1)
-				}
-			} else {
-				csbi.cursorPosition.y = 0
-			}
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'J':
-			n := 0
-			if buf.Len() > 0 {
-				n, err = strconv.Atoi(buf.String())
-				if err != nil {
-					continue
-				}
-			}
-			var count, written dword
-			var cursor coord
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			switch n {
-			case 0:
-				cursor = coord{x: csbi.cursorPosition.x, y: csbi.cursorPosition.y}
-				count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.size.y-csbi.cursorPosition.y)*csbi.size.x)
-			case 1:
-				cursor = coord{x: csbi.window.left, y: csbi.window.top}
-				count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.window.top-csbi.cursorPosition.y)*csbi.size.x)
-			case 2:
-				cursor = coord{x: csbi.window.left, y: csbi.window.top}
-				count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.size.y-csbi.cursorPosition.y)*csbi.size.x)
-			}
-			procFillConsoleOutputCharacter.Call(uintptr(w.handle), uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
-			procFillConsoleOutputAttribute.Call(uintptr(w.handle), uintptr(csbi.attributes), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
-		case 'K':
-			n := 0
-			if buf.Len() > 0 {
-				n, err = strconv.Atoi(buf.String())
-				if err != nil {
-					continue
-				}
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			var cursor coord
-			var count, written dword
-			switch n {
-			case 0:
-				cursor = coord{x: csbi.cursorPosition.x + 1, y: csbi.cursorPosition.y}
-				count = dword(csbi.size.x - csbi.cursorPosition.x - 1)
-			case 1:
-				cursor = coord{x: csbi.window.left, y: csbi.window.top + csbi.cursorPosition.y}
-				count = dword(csbi.size.x - csbi.cursorPosition.x)
-			case 2:
-				cursor = coord{x: csbi.window.left, y: csbi.window.top + csbi.cursorPosition.y}
-				count = dword(csbi.size.x)
-			}
-			procFillConsoleOutputCharacter.Call(uintptr(w.handle), uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
-			procFillConsoleOutputAttribute.Call(uintptr(w.handle), uintptr(csbi.attributes), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
-		case 'm':
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			attr := csbi.attributes
-			cs := buf.String()
-			if cs == "" {
-				procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(w.oldattr))
-				continue
-			}
-			token := strings.Split(cs, ";")
-			for i := 0; i < len(token); i++ {
-				ns := token[i]
-				if n, err = strconv.Atoi(ns); err == nil {
-					switch {
-					case n == 0 || n == 100:
-						attr = w.oldattr
-					case 1 <= n && n <= 5:
-						attr |= foregroundIntensity
-					case n == 7:
-						attr = ((attr & foregroundMask) << 4) | ((attr & backgroundMask) >> 4)
-					case n == 22 || n == 25:
-						attr |= foregroundIntensity
-					case n == 27:
-						attr = ((attr & foregroundMask) << 4) | ((attr & backgroundMask) >> 4)
-					case 30 <= n && n <= 37:
-						attr &= backgroundMask
-						if (n-30)&1 != 0 {
-							attr |= foregroundRed
-						}
-						if (n-30)&2 != 0 {
-							attr |= foregroundGreen
-						}
-						if (n-30)&4 != 0 {
-							attr |= foregroundBlue
-						}
-					case n == 38: // set foreground color.
-						if i < len(token)-2 && (token[i+1] == "5" || token[i+1] == "05") {
-							if n256, err := strconv.Atoi(token[i+2]); err == nil {
-								if n256foreAttr == nil {
-									n256setup()
-								}
-								attr &= backgroundMask
-								attr |= n256foreAttr[n256]
-								i += 2
-							}
-						} else {
-							attr = attr & (w.oldattr & backgroundMask)
-						}
-					case n == 39: // reset foreground color.
-						attr &= backgroundMask
-						attr |= w.oldattr & foregroundMask
-					case 40 <= n && n <= 47:
-						attr &= foregroundMask
-						if (n-40)&1 != 0 {
-							attr |= backgroundRed
-						}
-						if (n-40)&2 != 0 {
-							attr |= backgroundGreen
-						}
-						if (n-40)&4 != 0 {
-							attr |= backgroundBlue
-						}
-					case n == 48: // set background color.
-						if i < len(token)-2 && token[i+1] == "5" {
-							if n256, err := strconv.Atoi(token[i+2]); err == nil {
-								if n256backAttr == nil {
-									n256setup()
-								}
-								attr &= foregroundMask
-								attr |= n256backAttr[n256]
-								i += 2
-							}
-						} else {
-							attr = attr & (w.oldattr & foregroundMask)
-						}
-					case n == 49: // reset foreground color.
-						attr &= foregroundMask
-						attr |= w.oldattr & backgroundMask
-					case 90 <= n && n <= 97:
-						attr = (attr & backgroundMask)
-						attr |= foregroundIntensity
-						if (n-90)&1 != 0 {
-							attr |= foregroundRed
-						}
-						if (n-90)&2 != 0 {
-							attr |= foregroundGreen
-						}
-						if (n-90)&4 != 0 {
-							attr |= foregroundBlue
-						}
-					case 100 <= n && n <= 107:
-						attr = (attr & foregroundMask)
-						attr |= backgroundIntensity
-						if (n-100)&1 != 0 {
-							attr |= backgroundRed
-						}
-						if (n-100)&2 != 0 {
-							attr |= backgroundGreen
-						}
-						if (n-100)&4 != 0 {
-							attr |= backgroundBlue
-						}
-					}
-					procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(attr))
-				}
-			}
-		case 'h':
-			var ci consoleCursorInfo
-			cs := buf.String()
-			if cs == "5>" {
-				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-				ci.visible = 0
-				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-			} else if cs == "?25" {
-				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-				ci.visible = 1
-				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-			}
-		case 'l':
-			var ci consoleCursorInfo
-			cs := buf.String()
-			if cs == "5>" {
-				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-				ci.visible = 1
-				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-			} else if cs == "?25" {
-				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-				ci.visible = 0
-				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-			}
-		case 's':
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			w.oldpos = csbi.cursorPosition
-		case 'u':
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&w.oldpos)))
-		}
-	}
-
-	return len(data), nil
-}
-
-type consoleColor struct {
-	rgb       int
-	red       bool
-	green     bool
-	blue      bool
-	intensity bool
-}
-
-func (c consoleColor) foregroundAttr() (attr word) {
-	if c.red {
-		attr |= foregroundRed
-	}
-	if c.green {
-		attr |= foregroundGreen
-	}
-	if c.blue {
-		attr |= foregroundBlue
-	}
-	if c.intensity {
-		attr |= foregroundIntensity
-	}
-	return
-}
-
-func (c consoleColor) backgroundAttr() (attr word) {
-	if c.red {
-		attr |= backgroundRed
-	}
-	if c.green {
-		attr |= backgroundGreen
-	}
-	if c.blue {
-		attr |= backgroundBlue
-	}
-	if c.intensity {
-		attr |= backgroundIntensity
-	}
-	return
-}
-
-var color16 = []consoleColor{
-	{0x000000, false, false, false, false},
-	{0x000080, false, false, true, false},
-	{0x008000, false, true, false, false},
-	{0x008080, false, true, true, false},
-	{0x800000, true, false, false, false},
-	{0x800080, true, false, true, false},
-	{0x808000, true, true, false, false},
-	{0xc0c0c0, true, true, true, false},
-	{0x808080, false, false, false, true},
-	{0x0000ff, false, false, true, true},
-	{0x00ff00, false, true, false, true},
-	{0x00ffff, false, true, true, true},
-	{0xff0000, true, false, false, true},
-	{0xff00ff, true, false, true, true},
-	{0xffff00, true, true, false, true},
-	{0xffffff, true, true, true, true},
-}
-
-type hsv struct {
-	h, s, v float32
-}
-
-func (a hsv) dist(b hsv) float32 {
-	dh := a.h - b.h
-	switch {
-	case dh > 0.5:
-		dh = 1 - dh
-	case dh < -0.5:
-		dh = -1 - dh
-	}
-	ds := a.s - b.s
-	dv := a.v - b.v
-	return float32(math.Sqrt(float64(dh*dh + ds*ds + dv*dv)))
-}
-
-func toHSV(rgb int) hsv {
-	r, g, b := float32((rgb&0xFF0000)>>16)/256.0,
-		float32((rgb&0x00FF00)>>8)/256.0,
-		float32(rgb&0x0000FF)/256.0
-	min, max := minmax3f(r, g, b)
-	h := max - min
-	if h > 0 {
-		if max == r {
-			h = (g - b) / h
-			if h < 0 {
-				h += 6
-			}
-		} else if max == g {
-			h = 2 + (b-r)/h
-		} else {
-			h = 4 + (r-g)/h
-		}
-	}
-	h /= 6.0
-	s := max - min
-	if max != 0 {
-		s /= max
-	}
-	v := max
-	return hsv{h: h, s: s, v: v}
-}
-
-type hsvTable []hsv
-
-func toHSVTable(rgbTable []consoleColor) hsvTable {
-	t := make(hsvTable, len(rgbTable))
-	for i, c := range rgbTable {
-		t[i] = toHSV(c.rgb)
-	}
-	return t
-}
-
-func (t hsvTable) find(rgb int) consoleColor {
-	hsv := toHSV(rgb)
-	n := 7
-	l := float32(5.0)
-	for i, p := range t {
-		d := hsv.dist(p)
-		if d < l {
-			l, n = d, i
-		}
-	}
-	return color16[n]
-}
-
-func minmax3f(a, b, c float32) (min, max float32) {
-	if a < b {
-		if b < c {
-			return a, c
-		} else if a < c {
-			return a, b
-		} else {
-			return c, b
-		}
-	} else {
-		if a < c {
-			return b, c
-		} else if b < c {
-			return b, a
-		} else {
-			return c, a
-		}
-	}
-}
-
-var n256foreAttr []word
-var n256backAttr []word
-
-func n256setup() {
-	n256foreAttr = make([]word, 256)
-	n256backAttr = make([]word, 256)
-	t := toHSVTable(color16)
-	for i, rgb := range color256 {
-		c := t.find(rgb)
-		n256foreAttr[i] = c.foregroundAttr()
-		n256backAttr[i] = c.backgroundAttr()
-	}
-}

vendor/github.com/mattn/go-colorable/noncolorable.go

@@ -1,55 +0,0 @@
-package colorable
-
-import (
-	"bytes"
-	"io"
-)
-
-// NonColorable hold writer but remove escape sequence.
-type NonColorable struct {
-	out io.Writer
-}
-
-// NewNonColorable return new instance of Writer which remove escape sequence from Writer.
-func NewNonColorable(w io.Writer) io.Writer {
-	return &NonColorable{out: w}
-}
-
-// Write write data on console
-func (w *NonColorable) Write(data []byte) (n int, err error) {
-	er := bytes.NewReader(data)
-	var bw [1]byte
-loop:
-	for {
-		c1, err := er.ReadByte()
-		if err != nil {
-			break loop
-		}
-		if c1 != 0x1b {
-			bw[0] = c1
-			w.out.Write(bw[:])
-			continue
-		}
-		c2, err := er.ReadByte()
-		if err != nil {
-			break loop
-		}
-		if c2 != 0x5b {
-			continue
-		}
-
-		var buf bytes.Buffer
-		for {
-			c, err := er.ReadByte()
-			if err != nil {
-				break loop
-			}
-			if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '@' {
-				break
-			}
-			buf.Write([]byte(string(c)))
-		}
-	}
-
-	return len(data), nil
-}

vendor/github.com/mattn/go-isatty/.travis.yml

@@ -1,9 +0,0 @@
-language: go
-go:
-  - tip
-
-before_install:
-  - go get github.com/mattn/goveralls
-  - go get golang.org/x/tools/cmd/cover
-script:
-  - $HOME/gopath/bin/goveralls -repotoken 3gHdORO5k5ziZcWMBxnd9LrMZaJs8m9x5

vendor/github.com/mattn/go-isatty/LICENSE

@@ -1,9 +0,0 @@
-Copyright (c) Yasuhiro MATSUMOTO <mattn.jp@gmail.com>
-
-MIT License (Expat)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/mattn/go-isatty/README.md

@@ -1,50 +0,0 @@
-# go-isatty
-
-[![Godoc Reference](https://godoc.org/github.com/mattn/go-isatty?status.svg)](http://godoc.org/github.com/mattn/go-isatty)
-[![Build Status](https://travis-ci.org/mattn/go-isatty.svg?branch=master)](https://travis-ci.org/mattn/go-isatty)
-[![Coverage Status](https://coveralls.io/repos/github/mattn/go-isatty/badge.svg?branch=master)](https://coveralls.io/github/mattn/go-isatty?branch=master)
-[![Go Report Card](https://goreportcard.com/badge/mattn/go-isatty)](https://goreportcard.com/report/mattn/go-isatty)
-
-isatty for golang
-
-## Usage
-
-```go
-package main
-
-import (
-	"fmt"
-	"github.com/mattn/go-isatty"
-	"os"
-)
-
-func main() {
-	if isatty.IsTerminal(os.Stdout.Fd()) {
-		fmt.Println("Is Terminal")
-	} else if isatty.IsCygwinTerminal(os.Stdout.Fd()) {
-		fmt.Println("Is Cygwin/MSYS2 Terminal")
-	} else {
-		fmt.Println("Is Not Terminal")
-	}
-}
-```
-
-## Installation
-
-```
-$ go get github.com/mattn/go-isatty
-```
-
-## License
-
-MIT
-
-## Author
-
-Yasuhiro Matsumoto (a.k.a mattn)
-
-## Thanks
-
-* k-takata: base idea for IsCygwinTerminal
-
-    https://github.com/k-takata/go-iscygpty

vendor/github.com/mattn/go-isatty/doc.go

@@ -1,2 +0,0 @@
-// Package isatty implements interface to isatty
-package isatty

vendor/github.com/mattn/go-isatty/example_test.go

@@ -1,18 +0,0 @@
-package isatty_test
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/mattn/go-isatty"
-)
-
-func Example() {
-	if isatty.IsTerminal(os.Stdout.Fd()) {
-		fmt.Println("Is Terminal")
-	} else if isatty.IsCygwinTerminal(os.Stdout.Fd()) {
-		fmt.Println("Is Cygwin/MSYS2 Terminal")
-	} else {
-		fmt.Println("Is Not Terminal")
-	}
-}

vendor/github.com/mattn/go-isatty/isatty_appengine.go

@@ -1,15 +0,0 @@
-// +build appengine
-
-package isatty
-
-// IsTerminal returns true if the file descriptor is terminal which
-// is always false on on appengine classic which is a sandboxed PaaS.
-func IsTerminal(fd uintptr) bool {
-	return false
-}
-
-// IsCygwinTerminal() return true if the file descriptor is a cygwin or msys2
-// terminal. This is also always false on this environment.
-func IsCygwinTerminal(fd uintptr) bool {
-	return false
-}

vendor/github.com/mattn/go-isatty/isatty_bsd.go

@@ -1,18 +0,0 @@
-// +build darwin freebsd openbsd netbsd dragonfly
-// +build !appengine
-
-package isatty
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-const ioctlReadTermios = syscall.TIOCGETA
-
-// IsTerminal return true if the file descriptor is terminal.
-func IsTerminal(fd uintptr) bool {
-	var termios syscall.Termios
-	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
-	return err == 0
-}

vendor/github.com/mattn/go-isatty/isatty_linux.go

@@ -1,18 +0,0 @@
-// +build linux
-// +build !appengine,!ppc64,!ppc64le
-
-package isatty
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-const ioctlReadTermios = syscall.TCGETS
-
-// IsTerminal return true if the file descriptor is terminal.
-func IsTerminal(fd uintptr) bool {
-	var termios syscall.Termios
-	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
-	return err == 0
-}

vendor/github.com/mattn/go-isatty/isatty_linux_ppc64x.go

@@ -1,19 +0,0 @@
-// +build linux
-// +build ppc64 ppc64le
-
-package isatty
-
-import (
-	"unsafe"
-
-	syscall "golang.org/x/sys/unix"
-)
-
-const ioctlReadTermios = syscall.TCGETS
-
-// IsTerminal return true if the file descriptor is terminal.
-func IsTerminal(fd uintptr) bool {
-	var termios syscall.Termios
-	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
-	return err == 0
-}

vendor/github.com/mattn/go-isatty/isatty_others.go

@@ -1,10 +0,0 @@
-// +build !windows
-// +build !appengine
-
-package isatty
-
-// IsCygwinTerminal() return true if the file descriptor is a cygwin or msys2
-// terminal. This is also always false on this environment.
-func IsCygwinTerminal(fd uintptr) bool {
-	return false
-}

vendor/github.com/mattn/go-isatty/isatty_others_test.go

@@ -1,19 +0,0 @@
-// +build !windows
-
-package isatty
-
-import (
-	"os"
-	"testing"
-)
-
-func TestTerminal(t *testing.T) {
-	// test for non-panic
-	IsTerminal(os.Stdout.Fd())
-}
-
-func TestCygwinPipeName(t *testing.T) {
-	if IsCygwinTerminal(os.Stdout.Fd()) {
-		t.Fatal("should be false always")
-	}
-}

vendor/github.com/mattn/go-isatty/isatty_solaris.go

@@ -1,16 +0,0 @@
-// +build solaris
-// +build !appengine
-
-package isatty
-
-import (
-	"golang.org/x/sys/unix"
-)
-
-// IsTerminal returns true if the given file descriptor is a terminal.
-// see: http://src.illumos.org/source/xref/illumos-gate/usr/src/lib/libbc/libc/gen/common/isatty.c
-func IsTerminal(fd uintptr) bool {
-	var termio unix.Termio
-	err := unix.IoctlSetTermio(int(fd), unix.TCGETA, &termio)
-	return err == nil
-}

vendor/github.com/mattn/go-isatty/isatty_windows.go

@@ -1,94 +0,0 @@
-// +build windows
-// +build !appengine
-
-package isatty
-
-import (
-	"strings"
-	"syscall"
-	"unicode/utf16"
-	"unsafe"
-)
-
-const (
-	fileNameInfo uintptr = 2
-	fileTypePipe         = 3
-)
-
-var (
-	kernel32                         = syscall.NewLazyDLL("kernel32.dll")
-	procGetConsoleMode               = kernel32.NewProc("GetConsoleMode")
-	procGetFileInformationByHandleEx = kernel32.NewProc("GetFileInformationByHandleEx")
-	procGetFileType                  = kernel32.NewProc("GetFileType")
-)
-
-func init() {
-	// Check if GetFileInformationByHandleEx is available.
-	if procGetFileInformationByHandleEx.Find() != nil {
-		procGetFileInformationByHandleEx = nil
-	}
-}
-
-// IsTerminal return true if the file descriptor is terminal.
-func IsTerminal(fd uintptr) bool {
-	var st uint32
-	r, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, fd, uintptr(unsafe.Pointer(&st)), 0)
-	return r != 0 && e == 0
-}
-
-// Check pipe name is used for cygwin/msys2 pty.
-// Cygwin/MSYS2 PTY has a name like:
-//   \{cygwin,msys}-XXXXXXXXXXXXXXXX-ptyN-{from,to}-master
-func isCygwinPipeName(name string) bool {
-	token := strings.Split(name, "-")
-	if len(token) < 5 {
-		return false
-	}
-
-	if token[0] != `\msys` && token[0] != `\cygwin` {
-		return false
-	}
-
-	if token[1] == "" {
-		return false
-	}
-
-	if !strings.HasPrefix(token[2], "pty") {
-		return false
-	}
-
-	if token[3] != `from` && token[3] != `to` {
-		return false
-	}
-
-	if token[4] != "master" {
-		return false
-	}
-
-	return true
-}
-
-// IsCygwinTerminal() return true if the file descriptor is a cygwin or msys2
-// terminal.
-func IsCygwinTerminal(fd uintptr) bool {
-	if procGetFileInformationByHandleEx == nil {
-		return false
-	}
-
-	// Cygwin/msys's pty is a pipe.
-	ft, _, e := syscall.Syscall(procGetFileType.Addr(), 1, fd, 0, 0)
-	if ft != fileTypePipe || e != 0 {
-		return false
-	}
-
-	var buf [2 + syscall.MAX_PATH]uint16
-	r, _, e := syscall.Syscall6(procGetFileInformationByHandleEx.Addr(),
-		4, fd, fileNameInfo, uintptr(unsafe.Pointer(&buf)),
-		uintptr(len(buf)*2), 0, 0)
-	if r == 0 || e != 0 {
-		return false
-	}
-
-	l := *(*uint32)(unsafe.Pointer(&buf))
-	return isCygwinPipeName(string(utf16.Decode(buf[2 : 2+l/2])))
-}

vendor/github.com/mattn/go-isatty/isatty_windows_test.go

@@ -1,35 +0,0 @@
-// +build windows
-
-package isatty
-
-import (
-	"testing"
-)
-
-func TestCygwinPipeName(t *testing.T) {
-	tests := []struct {
-		name   string
-		result bool
-	}{
-		{``, false},
-		{`\msys-`, false},
-		{`\cygwin-----`, false},
-		{`\msys-x-PTY5-pty1-from-master`, false},
-		{`\cygwin-x-PTY5-from-master`, false},
-		{`\cygwin-x-pty2-from-toaster`, false},
-		{`\cygwin--pty2-from-master`, false},
-		{`\\cygwin-x-pty2-from-master`, false},
-		{`\cygwin-x-pty2-from-master-`, true}, // for the feature
-		{`\cygwin-e022582115c10879-pty4-from-master`, true},
-		{`\msys-e022582115c10879-pty4-to-master`, true},
-		{`\cygwin-e022582115c10879-pty4-to-master`, true},
-	}
-
-	for _, test := range tests {
-		want := test.result
-		got := isCygwinPipeName(test.name)
-		if want != got {
-			t.Fatalf("isatty(%q): got %v, want %v:", test.name, got, want)
-		}
-	}
-}

vendor/golang.org/x/sys/.gitattributes

@@ -1,10 +0,0 @@
-# Treat all files in this repo as binary, with no git magic updating
-# line endings. Windows users contributing to Go will need to use a
-# modern version of git and editors capable of LF line endings.
-#
-# We'll prevent accidental CRLF line endings from entering the repo
-# via the git-review gofmt checks.
-#
-# See golang.org/issue/9281
-
-* -text

vendor/golang.org/x/sys/.gitignore

@@ -1,2 +0,0 @@
-# Add no patterns to .hgignore except for files generated by the build.
-last-change

vendor/golang.org/x/sys/AUTHORS

@@ -1,3 +0,0 @@
-# This source code refers to The Go Authors for copyright purposes.
-# The master list of authors is in the main Go distribution,
-# visible at http://tip.golang.org/AUTHORS.

vendor/golang.org/x/sys/CONTRIBUTING.md

@@ -1,31 +0,0 @@
-# Contributing to Go
-
-Go is an open source project.
-
-It is the work of hundreds of contributors. We appreciate your help!
-
-
-## Filing issues
-
-When [filing an issue](https://golang.org/issue/new), make sure to answer these five questions:
-
-1. What version of Go are you using (`go version`)?
-2. What operating system and processor architecture are you using?
-3. What did you do?
-4. What did you expect to see?
-5. What did you see instead?
-
-General questions should go to the [golang-nuts mailing list](https://groups.google.com/group/golang-nuts) instead of the issue tracker.
-The gophers there will answer or ask you to file an issue if you've tripped over a bug.
-
-## Contributing code
-
-Please read the [Contribution Guidelines](https://golang.org/doc/contribute.html)
-before sending patches.
-
-**We do not accept GitHub pull requests**
-(we use [Gerrit](https://code.google.com/p/gerrit/) instead for code review).
-
-Unless otherwise noted, the Go source files are distributed under
-the BSD-style license found in the LICENSE file.
-

vendor/golang.org/x/sys/CONTRIBUTORS

@@ -1,3 +0,0 @@
-# This source code was written by the Go contributors.
-# The master list of contributors is in the main Go distribution,
-# visible at http://tip.golang.org/CONTRIBUTORS.

vendor/golang.org/x/sys/LICENSE

@@ -1,27 +0,0 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/golang.org/x/sys/PATENTS

@@ -1,22 +0,0 @@
-Additional IP Rights Grant (Patents)
-
-"This implementation" means the copyrightable works distributed by
-Google as part of the Go project.
-
-Google hereby grants to You a perpetual, worldwide, non-exclusive,
-no-charge, royalty-free, irrevocable (except as stated in this section)
-patent license to make, have made, use, offer to sell, sell, import,
-transfer and otherwise run, modify and propagate the contents of this
-implementation of Go, where such license applies only to those patent
-claims, both currently owned or controlled by Google and acquired in
-the future, licensable by Google that are necessarily infringed by this
-implementation of Go.  This grant does not include claims that would be
-infringed only as a consequence of further modification of this
-implementation.  If you or your agent or exclusive licensee institute or
-order or agree to the institution of patent litigation against any
-entity (including a cross-claim or counterclaim in a lawsuit) alleging
-that this implementation of Go or any code incorporated within this
-implementation of Go constitutes direct or contributory patent
-infringement, or inducement of patent infringement, then any patent
-rights granted to you under this License for this implementation of Go
-shall terminate as of the date such litigation is filed.

vendor/golang.org/x/sys/README.md

@@ -1,18 +0,0 @@
-# sys
-
-This repository holds supplemental Go packages for low-level interactions with
-the operating system.
-
-## Download/Install
-
-The easiest way to install is to run `go get -u golang.org/x/sys`. You can
-also manually git clone the repository to `$GOPATH/src/golang.org/x/sys`.
-
-## Report Issues / Send Patches
-
-This repository uses Gerrit for code changes. To learn how to submit changes to
-this repository, see https://golang.org/doc/contribute.html.
-
-The main issue tracker for the sys repository is located at
-https://github.com/golang/go/issues. Prefix your issue with "x/sys:" in the
-subject line, so it is easy to find.

vendor/golang.org/x/sys/codereview.cfg

@@ -1 +0,0 @@
-issuerepo: golang/go

vendor/golang.org/x/sys/plan9/asm.s

@@ -1,8 +0,0 @@
-// Copyright 2014 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.
-
-#include "textflag.h"
-
-TEXT ·use(SB),NOSPLIT,$0
-	RET

vendor/golang.org/x/sys/plan9/asm_plan9_386.s

@@ -1,30 +0,0 @@
-// Copyright 2009 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.
-
-#include "textflag.h"
-
-//
-// System call support for 386, Plan 9
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-32
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-44
-	JMP	syscall·Syscall6(SB)
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-	JMP	syscall·RawSyscall(SB)
-
-TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
-	JMP	syscall·RawSyscall6(SB)
-
-TEXT ·seek(SB),NOSPLIT,$0-36
-	JMP	syscall·seek(SB)
-
-TEXT ·exit(SB),NOSPLIT,$4-4
-	JMP	syscall·exit(SB)

vendor/golang.org/x/sys/plan9/asm_plan9_amd64.s

@@ -1,30 +0,0 @@
-// Copyright 2009 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.
-
-#include "textflag.h"
-
-//
-// System call support for amd64, Plan 9
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-64
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-88
-	JMP	syscall·Syscall6(SB)
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-56
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·RawSyscall6(SB)
-
-TEXT ·seek(SB),NOSPLIT,$0-56
-	JMP	syscall·seek(SB)
-
-TEXT ·exit(SB),NOSPLIT,$8-8
-	JMP	syscall·exit(SB)

vendor/golang.org/x/sys/plan9/asm_plan9_arm.s

@@ -1,25 +0,0 @@
-// Copyright 2009 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.
-
-#include "textflag.h"
-
-// System call support for plan9 on arm
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT ·Syscall(SB),NOSPLIT,$0-32
-	JMP	syscall·Syscall(SB)
-
-TEXT ·Syscall6(SB),NOSPLIT,$0-44
-	JMP	syscall·Syscall6(SB)
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-	JMP	syscall·RawSyscall(SB)
-
-TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
-	JMP	syscall·RawSyscall6(SB)
-
-TEXT ·seek(SB),NOSPLIT,$0-36
-	JMP	syscall·exit(SB)

vendor/golang.org/x/sys/plan9/const_plan9.go

@@ -1,70 +0,0 @@
-package plan9
-
-// Plan 9 Constants
-
-// Open modes
-const (
-	O_RDONLY  = 0
-	O_WRONLY  = 1
-	O_RDWR    = 2
-	O_TRUNC   = 16
-	O_CLOEXEC = 32
-	O_EXCL    = 0x1000
-)
-
-// Rfork flags
-const (
-	RFNAMEG  = 1 << 0
-	RFENVG   = 1 << 1
-	RFFDG    = 1 << 2
-	RFNOTEG  = 1 << 3
-	RFPROC   = 1 << 4
-	RFMEM    = 1 << 5
-	RFNOWAIT = 1 << 6
-	RFCNAMEG = 1 << 10
-	RFCENVG  = 1 << 11
-	RFCFDG   = 1 << 12
-	RFREND   = 1 << 13
-	RFNOMNT  = 1 << 14
-)
-
-// Qid.Type bits
-const (
-	QTDIR    = 0x80
-	QTAPPEND = 0x40
-	QTEXCL   = 0x20
-	QTMOUNT  = 0x10
-	QTAUTH   = 0x08
-	QTTMP    = 0x04
-	QTFILE   = 0x00
-)
-
-// Dir.Mode bits
-const (
-	DMDIR    = 0x80000000
-	DMAPPEND = 0x40000000
-	DMEXCL   = 0x20000000
-	DMMOUNT  = 0x10000000
-	DMAUTH   = 0x08000000
-	DMTMP    = 0x04000000
-	DMREAD   = 0x4
-	DMWRITE  = 0x2
-	DMEXEC   = 0x1
-)
-
-const (
-	STATMAX    = 65535
-	ERRMAX     = 128
-	STATFIXLEN = 49
-)
-
-// Mount and bind flags
-const (
-	MREPL   = 0x0000
-	MBEFORE = 0x0001
-	MAFTER  = 0x0002
-	MORDER  = 0x0003
-	MCREATE = 0x0004
-	MCACHE  = 0x0010
-	MMASK   = 0x0017
-)

vendor/golang.org/x/sys/plan9/dir_plan9.go

@@ -1,212 +0,0 @@
-// Copyright 2012 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.
-
-// Plan 9 directory marshalling. See intro(5).
-
-package plan9
-
-import "errors"
-
-var (
-	ErrShortStat = errors.New("stat buffer too short")
-	ErrBadStat   = errors.New("malformed stat buffer")
-	ErrBadName   = errors.New("bad character in file name")
-)
-
-// A Qid represents a 9P server's unique identification for a file.
-type Qid struct {
-	Path uint64 // the file server's unique identification for the file
-	Vers uint32 // version number for given Path
-	Type uint8  // the type of the file (plan9.QTDIR for example)
-}
-
-// A Dir contains the metadata for a file.
-type Dir struct {
-	// system-modified data
-	Type uint16 // server type
-	Dev  uint32 // server subtype
-
-	// file data
-	Qid    Qid    // unique id from server
-	Mode   uint32 // permissions
-	Atime  uint32 // last read time
-	Mtime  uint32 // last write time
-	Length int64  // file length
-	Name   string // last element of path
-	Uid    string // owner name
-	Gid    string // group name
-	Muid   string // last modifier name
-}
-
-var nullDir = Dir{
-	Type: ^uint16(0),
-	Dev:  ^uint32(0),
-	Qid: Qid{
-		Path: ^uint64(0),
-		Vers: ^uint32(0),
-		Type: ^uint8(0),
-	},
-	Mode:   ^uint32(0),
-	Atime:  ^uint32(0),
-	Mtime:  ^uint32(0),
-	Length: ^int64(0),
-}
-
-// Null assigns special "don't touch" values to members of d to
-// avoid modifying them during plan9.Wstat.
-func (d *Dir) Null() { *d = nullDir }
-
-// Marshal encodes a 9P stat message corresponding to d into b
-//
-// If there isn't enough space in b for a stat message, ErrShortStat is returned.
-func (d *Dir) Marshal(b []byte) (n int, err error) {
-	n = STATFIXLEN + len(d.Name) + len(d.Uid) + len(d.Gid) + len(d.Muid)
-	if n > len(b) {
-		return n, ErrShortStat
-	}
-
-	for _, c := range d.Name {
-		if c == '/' {
-			return n, ErrBadName
-		}
-	}
-
-	b = pbit16(b, uint16(n)-2)
-	b = pbit16(b, d.Type)
-	b = pbit32(b, d.Dev)
-	b = pbit8(b, d.Qid.Type)
-	b = pbit32(b, d.Qid.Vers)
-	b = pbit64(b, d.Qid.Path)
-	b = pbit32(b, d.Mode)
-	b = pbit32(b, d.Atime)
-	b = pbit32(b, d.Mtime)
-	b = pbit64(b, uint64(d.Length))
-	b = pstring(b, d.Name)
-	b = pstring(b, d.Uid)
-	b = pstring(b, d.Gid)
-	b = pstring(b, d.Muid)
-
-	return n, nil
-}
-
-// UnmarshalDir decodes a single 9P stat message from b and returns the resulting Dir.
-//
-// If b is too small to hold a valid stat message, ErrShortStat is returned.
-//
-// If the stat message itself is invalid, ErrBadStat is returned.
-func UnmarshalDir(b []byte) (*Dir, error) {
-	if len(b) < STATFIXLEN {
-		return nil, ErrShortStat
-	}
-	size, buf := gbit16(b)
-	if len(b) != int(size)+2 {
-		return nil, ErrBadStat
-	}
-	b = buf
-
-	var d Dir
-	d.Type, b = gbit16(b)
-	d.Dev, b = gbit32(b)
-	d.Qid.Type, b = gbit8(b)
-	d.Qid.Vers, b = gbit32(b)
-	d.Qid.Path, b = gbit64(b)
-	d.Mode, b = gbit32(b)
-	d.Atime, b = gbit32(b)
-	d.Mtime, b = gbit32(b)
-
-	n, b := gbit64(b)
-	d.Length = int64(n)
-
-	var ok bool
-	if d.Name, b, ok = gstring(b); !ok {
-		return nil, ErrBadStat
-	}
-	if d.Uid, b, ok = gstring(b); !ok {
-		return nil, ErrBadStat
-	}
-	if d.Gid, b, ok = gstring(b); !ok {
-		return nil, ErrBadStat
-	}
-	if d.Muid, b, ok = gstring(b); !ok {
-		return nil, ErrBadStat
-	}
-
-	return &d, nil
-}
-
-// pbit8 copies the 8-bit number v to b and returns the remaining slice of b.
-func pbit8(b []byte, v uint8) []byte {
-	b[0] = byte(v)
-	return b[1:]
-}
-
-// pbit16 copies the 16-bit number v to b in little-endian order and returns the remaining slice of b.
-func pbit16(b []byte, v uint16) []byte {
-	b[0] = byte(v)
-	b[1] = byte(v >> 8)
-	return b[2:]
-}
-
-// pbit32 copies the 32-bit number v to b in little-endian order and returns the remaining slice of b.
-func pbit32(b []byte, v uint32) []byte {
-	b[0] = byte(v)
-	b[1] = byte(v >> 8)
-	b[2] = byte(v >> 16)
-	b[3] = byte(v >> 24)
-	return b[4:]
-}
-
-// pbit64 copies the 64-bit number v to b in little-endian order and returns the remaining slice of b.
-func pbit64(b []byte, v uint64) []byte {
-	b[0] = byte(v)
-	b[1] = byte(v >> 8)
-	b[2] = byte(v >> 16)
-	b[3] = byte(v >> 24)
-	b[4] = byte(v >> 32)
-	b[5] = byte(v >> 40)
-	b[6] = byte(v >> 48)
-	b[7] = byte(v >> 56)
-	return b[8:]
-}
-
-// pstring copies the string s to b, prepending it with a 16-bit length in little-endian order, and
-// returning the remaining slice of b..
-func pstring(b []byte, s string) []byte {
-	b = pbit16(b, uint16(len(s)))
-	n := copy(b, s)
-	return b[n:]
-}
-
-// gbit8 reads an 8-bit number from b and returns it with the remaining slice of b.
-func gbit8(b []byte) (uint8, []byte) {
-	return uint8(b[0]), b[1:]
-}
-
-// gbit16 reads a 16-bit number in little-endian order from b and returns it with the remaining slice of b.
-func gbit16(b []byte) (uint16, []byte) {
-	return uint16(b[0]) | uint16(b[1])<<8, b[2:]
-}
-
-// gbit32 reads a 32-bit number in little-endian order from b and returns it with the remaining slice of b.
-func gbit32(b []byte) (uint32, []byte) {
-	return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24, b[4:]
-}
-
-// gbit64 reads a 64-bit number in little-endian order from b and returns it with the remaining slice of b.
-func gbit64(b []byte) (uint64, []byte) {
-	lo := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
-	hi := uint32(b[4]) | uint32(b[5])<<8 | uint32(b[6])<<16 | uint32(b[7])<<24
-	return uint64(lo) | uint64(hi)<<32, b[8:]
-}
-
-// gstring reads a string from b, prefixed with a 16-bit length in little-endian order.
-// It returns the string with the remaining slice of b and a boolean. If the length is
-// greater than the number of bytes in b, the boolean will be false.
-func gstring(b []byte) (string, []byte, bool) {
-	n, b := gbit16(b)
-	if int(n) > len(b) {
-		return "", b, false
-	}
-	return string(b[:n]), b[n:], true
-}

vendor/golang.org/x/sys/plan9/env_plan9.go

@@ -1,31 +0,0 @@
-// Copyright 2011 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.
-
-// Plan 9 environment variables.
-
-package plan9
-
-import (
-	"syscall"
-)
-
-func Getenv(key string) (value string, found bool) {
-	return syscall.Getenv(key)
-}
-
-func Setenv(key, value string) error {
-	return syscall.Setenv(key, value)
-}
-
-func Clearenv() {
-	syscall.Clearenv()
-}
-
-func Environ() []string {
-	return syscall.Environ()
-}
-
-func Unsetenv(key string) error {
-	return syscall.Unsetenv(key)
-}

vendor/golang.org/x/sys/plan9/errors_plan9.go

@@ -1,50 +0,0 @@
-// Copyright 2011 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 plan9
-
-import "syscall"
-
-// Constants
-const (
-	// Invented values to support what package os expects.
-	O_CREAT    = 0x02000
-	O_APPEND   = 0x00400
-	O_NOCTTY   = 0x00000
-	O_NONBLOCK = 0x00000
-	O_SYNC     = 0x00000
-	O_ASYNC    = 0x00000
-
-	S_IFMT   = 0x1f000
-	S_IFIFO  = 0x1000
-	S_IFCHR  = 0x2000
-	S_IFDIR  = 0x4000
-	S_IFBLK  = 0x6000
-	S_IFREG  = 0x8000
-	S_IFLNK  = 0xa000
-	S_IFSOCK = 0xc000
-)
-
-// Errors
-var (
-	EINVAL       = syscall.NewError("bad arg in system call")
-	ENOTDIR      = syscall.NewError("not a directory")
-	EISDIR       = syscall.NewError("file is a directory")
-	ENOENT       = syscall.NewError("file does not exist")
-	EEXIST       = syscall.NewError("file already exists")
-	EMFILE       = syscall.NewError("no free file descriptors")
-	EIO          = syscall.NewError("i/o error")
-	ENAMETOOLONG = syscall.NewError("file name too long")
-	EINTR        = syscall.NewError("interrupted")
-	EPERM        = syscall.NewError("permission denied")
-	EBUSY        = syscall.NewError("no free devices")
-	ETIMEDOUT    = syscall.NewError("connection timed out")
-	EPLAN9       = syscall.NewError("not supported by plan 9")
-
-	// The following errors do not correspond to any
-	// Plan 9 system messages. Invented to support
-	// what package os and others expect.
-	EACCES       = syscall.NewError("access permission denied")
-	EAFNOSUPPORT = syscall.NewError("address family not supported by protocol")
-)

vendor/golang.org/x/sys/plan9/mkall.sh

@@ -1,138 +0,0 @@
-#!/usr/bin/env bash
-# Copyright 2009 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.
-
-# The plan9 package provides access to the raw system call
-# interface of the underlying operating system.  Porting Go to
-# a new architecture/operating system combination requires
-# some manual effort, though there are tools that automate
-# much of the process.  The auto-generated files have names
-# beginning with z.
-#
-# This script runs or (given -n) prints suggested commands to generate z files
-# for the current system.  Running those commands is not automatic.
-# This script is documentation more than anything else.
-#
-# * asm_${GOOS}_${GOARCH}.s
-#
-# This hand-written assembly file implements system call dispatch.
-# There are three entry points:
-#
-# 	func Syscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr);
-# 	func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr);
-# 	func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr);
-#
-# The first and second are the standard ones; they differ only in
-# how many arguments can be passed to the kernel.
-# The third is for low-level use by the ForkExec wrapper;
-# unlike the first two, it does not call into the scheduler to
-# let it know that a system call is running.
-#
-# * syscall_${GOOS}.go
-#
-# This hand-written Go file implements system calls that need
-# special handling and lists "//sys" comments giving prototypes
-# for ones that can be auto-generated.  Mksyscall reads those
-# comments to generate the stubs.
-#
-# * syscall_${GOOS}_${GOARCH}.go
-#
-# Same as syscall_${GOOS}.go except that it contains code specific
-# to ${GOOS} on one particular architecture.
-#
-# * types_${GOOS}.c
-#
-# This hand-written C file includes standard C headers and then
-# creates typedef or enum names beginning with a dollar sign
-# (use of $ in variable names is a gcc extension).  The hardest
-# part about preparing this file is figuring out which headers to
-# include and which symbols need to be #defined to get the
-# actual data structures that pass through to the kernel system calls.
-# Some C libraries present alternate versions for binary compatibility
-# and translate them on the way in and out of system calls, but
-# there is almost always a #define that can get the real ones.
-# See types_darwin.c and types_linux.c for examples.
-#
-# * zerror_${GOOS}_${GOARCH}.go
-#
-# This machine-generated file defines the system's error numbers,
-# error strings, and signal numbers.  The generator is "mkerrors.sh".
-# Usually no arguments are needed, but mkerrors.sh will pass its
-# arguments on to godefs.
-#
-# * zsyscall_${GOOS}_${GOARCH}.go
-#
-# Generated by mksyscall.pl; see syscall_${GOOS}.go above.
-#
-# * zsysnum_${GOOS}_${GOARCH}.go
-#
-# Generated by mksysnum_${GOOS}.
-#
-# * ztypes_${GOOS}_${GOARCH}.go
-#
-# Generated by godefs; see types_${GOOS}.c above.
-
-GOOSARCH="${GOOS}_${GOARCH}"
-
-# defaults
-mksyscall="./mksyscall.pl"
-mkerrors="./mkerrors.sh"
-zerrors="zerrors_$GOOSARCH.go"
-mksysctl=""
-zsysctl="zsysctl_$GOOSARCH.go"
-mksysnum=
-mktypes=
-run="sh"
-
-case "$1" in
--syscalls)
-	for i in zsyscall*go
-	do
-		sed 1q $i | sed 's;^// ;;' | sh > _$i && gofmt < _$i > $i
-		rm _$i
-	done
-	exit 0
-	;;
--n)
-	run="cat"
-	shift
-esac
-
-case "$#" in
-0)
-	;;
-*)
-	echo 'usage: mkall.sh [-n]' 1>&2
-	exit 2
-esac
-
-case "$GOOSARCH" in
-_* | *_ | _)
-	echo 'undefined $GOOS_$GOARCH:' "$GOOSARCH" 1>&2
-	exit 1
-	;;
-plan9_386)
-	mkerrors=
-	mksyscall="./mksyscall.pl -l32 -plan9"
-	mksysnum="./mksysnum_plan9.sh /n/sources/plan9/sys/src/libc/9syscall/sys.h"
-	mktypes="XXX"
-	;;
-*)
-	echo 'unrecognized $GOOS_$GOARCH: ' "$GOOSARCH" 1>&2
-	exit 1
-	;;
-esac
-
-(
-	if [ -n "$mkerrors" ]; then echo "$mkerrors |gofmt >$zerrors"; fi
-	case "$GOOS" in
-	plan9)
-		syscall_goos="syscall_$GOOS.go"
-		if [ -n "$mksyscall" ]; then echo "$mksyscall $syscall_goos syscall_$GOOSARCH.go |gofmt >zsyscall_$GOOSARCH.go"; fi
-		;;
-	esac
-	if [ -n "$mksysctl" ]; then echo "$mksysctl |gofmt >$zsysctl"; fi
-	if [ -n "$mksysnum" ]; then echo "$mksysnum |gofmt >zsysnum_$GOOSARCH.go"; fi
-	if [ -n "$mktypes" ]; then echo "$mktypes types_$GOOS.go |gofmt >ztypes_$GOOSARCH.go"; fi
-) | $run

vendor/golang.org/x/sys/plan9/mkerrors.sh

@@ -1,246 +0,0 @@
-#!/usr/bin/env bash
-# Copyright 2009 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.
-
-# Generate Go code listing errors and other #defined constant
-# values (ENAMETOOLONG etc.), by asking the preprocessor
-# about the definitions.
-
-unset LANG
-export LC_ALL=C
-export LC_CTYPE=C
-
-CC=${CC:-gcc}
-
-uname=$(uname)
-
-includes='
-#include <sys/types.h>
-#include <sys/file.h>
-#include <fcntl.h>
-#include <dirent.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <netinet/ip.h>
-#include <netinet/ip6.h>
-#include <netinet/tcp.h>
-#include <errno.h>
-#include <sys/signal.h>
-#include <signal.h>
-#include <sys/resource.h>
-'
-
-ccflags="$@"
-
-# Write go tool cgo -godefs input.
-(
-	echo package plan9
-	echo
-	echo '/*'
-	indirect="includes_$(uname)"
-	echo "${!indirect} $includes"
-	echo '*/'
-	echo 'import "C"'
-	echo
-	echo 'const ('
-
-	# The gcc command line prints all the #defines
-	# it encounters while processing the input
-	echo "${!indirect} $includes" | $CC -x c - -E -dM $ccflags |
-	awk '
-		$1 != "#define" || $2 ~ /\(/ || $3 == "" {next}
-
-		$2 ~ /^E([ABCD]X|[BIS]P|[SD]I|S|FL)$/ {next}  # 386 registers
-		$2 ~ /^(SIGEV_|SIGSTKSZ|SIGRT(MIN|MAX))/ {next}
-		$2 ~ /^(SCM_SRCRT)$/ {next}
-		$2 ~ /^(MAP_FAILED)$/ {next}
-
-		$2 !~ /^ETH_/ &&
-		$2 !~ /^EPROC_/ &&
-		$2 !~ /^EQUIV_/ &&
-		$2 !~ /^EXPR_/ &&
-		$2 ~ /^E[A-Z0-9_]+$/ ||
-		$2 ~ /^B[0-9_]+$/ ||
-		$2 ~ /^V[A-Z0-9]+$/ ||
-		$2 ~ /^CS[A-Z0-9]/ ||
-		$2 ~ /^I(SIG|CANON|CRNL|EXTEN|MAXBEL|STRIP|UTF8)$/ ||
-		$2 ~ /^IGN/ ||
-		$2 ~ /^IX(ON|ANY|OFF)$/ ||
-		$2 ~ /^IN(LCR|PCK)$/ ||
-		$2 ~ /(^FLU?SH)|(FLU?SH$)/ ||
-		$2 ~ /^C(LOCAL|READ)$/ ||
-		$2 == "BRKINT" ||
-		$2 == "HUPCL" ||
-		$2 == "PENDIN" ||
-		$2 == "TOSTOP" ||
-		$2 ~ /^PAR/ ||
-		$2 ~ /^SIG[^_]/ ||
-		$2 ~ /^O[CNPFP][A-Z]+[^_][A-Z]+$/ ||
-		$2 ~ /^IN_/ ||
-		$2 ~ /^LOCK_(SH|EX|NB|UN)$/ ||
-		$2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|ICMP6|TCP|EVFILT|NOTE|EV|SHUT|PROT|MAP|PACKET|MSG|SCM|MCL|DT|MADV|PR)_/ ||
-		$2 == "ICMPV6_FILTER" ||
-		$2 == "SOMAXCONN" ||
-		$2 == "NAME_MAX" ||
-		$2 == "IFNAMSIZ" ||
-		$2 ~ /^CTL_(MAXNAME|NET|QUERY)$/ ||
-		$2 ~ /^SYSCTL_VERS/ ||
-		$2 ~ /^(MS|MNT)_/ ||
-		$2 ~ /^TUN(SET|GET|ATTACH|DETACH)/ ||
-		$2 ~ /^(O|F|FD|NAME|S|PTRACE|PT)_/ ||
-		$2 ~ /^LINUX_REBOOT_CMD_/ ||
-		$2 ~ /^LINUX_REBOOT_MAGIC[12]$/ ||
-		$2 !~ "NLA_TYPE_MASK" &&
-		$2 ~ /^(NETLINK|NLM|NLMSG|NLA|IFA|IFAN|RT|RTCF|RTN|RTPROT|RTNH|ARPHRD|ETH_P)_/ ||
-		$2 ~ /^SIOC/ ||
-		$2 ~ /^TIOC/ ||
-		$2 !~ "RTF_BITS" &&
-		$2 ~ /^(IFF|IFT|NET_RT|RTM|RTF|RTV|RTA|RTAX)_/ ||
-		$2 ~ /^BIOC/ ||
-		$2 ~ /^RUSAGE_(SELF|CHILDREN|THREAD)/ ||
-		$2 ~ /^RLIMIT_(AS|CORE|CPU|DATA|FSIZE|NOFILE|STACK)|RLIM_INFINITY/ ||
-		$2 ~ /^PRIO_(PROCESS|PGRP|USER)/ ||
-		$2 ~ /^CLONE_[A-Z_]+/ ||
-		$2 !~ /^(BPF_TIMEVAL)$/ &&
-		$2 ~ /^(BPF|DLT)_/ ||
-		$2 !~ "WMESGLEN" &&
-		$2 ~ /^W[A-Z0-9]+$/ {printf("\t%s = C.%s\n", $2, $2)}
-		$2 ~ /^__WCOREFLAG$/ {next}
-		$2 ~ /^__W[A-Z0-9]+$/ {printf("\t%s = C.%s\n", substr($2,3), $2)}
-
-		{next}
-	' | sort
-
-	echo ')'
-) >_const.go
-
-# Pull out the error names for later.
-errors=$(
-	echo '#include <errno.h>' | $CC -x c - -E -dM $ccflags |
-	awk '$1=="#define" && $2 ~ /^E[A-Z0-9_]+$/ { print $2 }' |
-	sort
-)
-
-# Pull out the signal names for later.
-signals=$(
-	echo '#include <signal.h>' | $CC -x c - -E -dM $ccflags |
-	awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print $2 }' |
-	egrep -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT)' |
-	sort
-)
-
-# Again, writing regexps to a file.
-echo '#include <errno.h>' | $CC -x c - -E -dM $ccflags |
-	awk '$1=="#define" && $2 ~ /^E[A-Z0-9_]+$/ { print "^\t" $2 "[ \t]*=" }' |
-	sort >_error.grep
-echo '#include <signal.h>' | $CC -x c - -E -dM $ccflags |
-	awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print "^\t" $2 "[ \t]*=" }' |
-	egrep -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT)' |
-	sort >_signal.grep
-
-echo '// mkerrors.sh' "$@"
-echo '// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT'
-echo
-go tool cgo -godefs -- "$@" _const.go >_error.out
-cat _error.out | grep -vf _error.grep | grep -vf _signal.grep
-echo
-echo '// Errors'
-echo 'const ('
-cat _error.out | grep -f _error.grep | sed 's/=\(.*\)/= Errno(\1)/'
-echo ')'
-
-echo
-echo '// Signals'
-echo 'const ('
-cat _error.out | grep -f _signal.grep | sed 's/=\(.*\)/= Signal(\1)/'
-echo ')'
-
-# Run C program to print error and syscall strings.
-(
-	echo -E "
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <ctype.h>
-#include <string.h>
-#include <signal.h>
-
-#define nelem(x) (sizeof(x)/sizeof((x)[0]))
-
-enum { A = 'A', Z = 'Z', a = 'a', z = 'z' }; // avoid need for single quotes below
-
-int errors[] = {
-"
-	for i in $errors
-	do
-		echo -E '	'$i,
-	done
-
-	echo -E "
-};
-
-int signals[] = {
-"
-	for i in $signals
-	do
-		echo -E '	'$i,
-	done
-
-	# Use -E because on some systems bash builtin interprets \n itself.
-	echo -E '
-};
-
-static int
-intcmp(const void *a, const void *b)
-{
-	return *(int*)a - *(int*)b;
-}
-
-int
-main(void)
-{
-	int i, j, e;
-	char buf[1024], *p;
-
-	printf("\n\n// Error table\n");
-	printf("var errors = [...]string {\n");
-	qsort(errors, nelem(errors), sizeof errors[0], intcmp);
-	for(i=0; i<nelem(errors); i++) {
-		e = errors[i];
-		if(i > 0 && errors[i-1] == e)
-			continue;
-		strcpy(buf, strerror(e));
-		// lowercase first letter: Bad -> bad, but STREAM -> STREAM.
-		if(A <= buf[0] && buf[0] <= Z && a <= buf[1] && buf[1] <= z)
-			buf[0] += a - A;
-		printf("\t%d: \"%s\",\n", e, buf);
-	}
-	printf("}\n\n");
-	
-	printf("\n\n// Signal table\n");
-	printf("var signals = [...]string {\n");
-	qsort(signals, nelem(signals), sizeof signals[0], intcmp);
-	for(i=0; i<nelem(signals); i++) {
-		e = signals[i];
-		if(i > 0 && signals[i-1] == e)
-			continue;
-		strcpy(buf, strsignal(e));
-		// lowercase first letter: Bad -> bad, but STREAM -> STREAM.
-		if(A <= buf[0] && buf[0] <= Z && a <= buf[1] && buf[1] <= z)
-			buf[0] += a - A;
-		// cut trailing : number.
-		p = strrchr(buf, ":"[0]);
-		if(p)
-			*p = '\0';
-		printf("\t%d: \"%s\",\n", e, buf);
-	}
-	printf("}\n\n");
-
-	return 0;
-}
-
-'
-) >_errors.c
-
-$CC $ccflags -o _errors _errors.c && $GORUN ./_errors && rm -f _errors.c _errors _const.go _error.grep _signal.grep _error.out

vendor/golang.org/x/sys/plan9/mksyscall.pl

@@ -1,319 +0,0 @@
-#!/usr/bin/env perl
-# Copyright 2009 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.
-
-# This program reads a file containing function prototypes
-# (like syscall_plan9.go) and generates system call bodies.
-# The prototypes are marked by lines beginning with "//sys"
-# and read like func declarations if //sys is replaced by func, but:
-#	* The parameter lists must give a name for each argument.
-#	  This includes return parameters.
-#	* The parameter lists must give a type for each argument:
-#	  the (x, y, z int) shorthand is not allowed.
-#	* If the return parameter is an error number, it must be named errno.
-
-# A line beginning with //sysnb is like //sys, except that the
-# goroutine will not be suspended during the execution of the system
-# call.  This must only be used for system calls which can never
-# block, as otherwise the system call could cause all goroutines to
-# hang.
-
-use strict;
-
-my $cmdline = "mksyscall.pl " . join(' ', @ARGV);
-my $errors = 0;
-my $_32bit = "";
-my $plan9 = 0;
-my $openbsd = 0;
-my $netbsd = 0;
-my $dragonfly = 0;
-my $nacl = 0;
-my $arm = 0; # 64-bit value should use (even, odd)-pair
-
-if($ARGV[0] eq "-b32") {
-	$_32bit = "big-endian";
-	shift;
-} elsif($ARGV[0] eq "-l32") {
-	$_32bit = "little-endian";
-	shift;
-}
-if($ARGV[0] eq "-plan9") {
-	$plan9 = 1;
-	shift;
-}
-if($ARGV[0] eq "-openbsd") {
-	$openbsd = 1;
-	shift;
-}
-if($ARGV[0] eq "-netbsd") {
-	$netbsd = 1;
-	shift;
-}
-if($ARGV[0] eq "-dragonfly") {
-	$dragonfly = 1;
-	shift;
-}
-if($ARGV[0] eq "-nacl") {
-	$nacl = 1;
-	shift;
-}
-if($ARGV[0] eq "-arm") {
-	$arm = 1;
-	shift;
-}
-
-if($ARGV[0] =~ /^-/) {
-	print STDERR "usage: mksyscall.pl [-b32 | -l32] [file ...]\n";
-	exit 1;
-}
-
-sub parseparamlist($) {
-	my ($list) = @_;
-	$list =~ s/^\s*//;
-	$list =~ s/\s*$//;
-	if($list eq "") {
-		return ();
-	}
-	return split(/\s*,\s*/, $list);
-}
-
-sub parseparam($) {
-	my ($p) = @_;
-	if($p !~ /^(\S*) (\S*)$/) {
-		print STDERR "$ARGV:$.: malformed parameter: $p\n";
-		$errors = 1;
-		return ("xx", "int");
-	}
-	return ($1, $2);
-}
-
-my $text = "";
-while(<>) {
-	chomp;
-	s/\s+/ /g;
-	s/^\s+//;
-	s/\s+$//;
-	my $nonblock = /^\/\/sysnb /;
-	next if !/^\/\/sys / && !$nonblock;
-
-	# Line must be of the form
-	#	func Open(path string, mode int, perm int) (fd int, errno error)
-	# Split into name, in params, out params.
-	if(!/^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*((?i)SYS_[A-Z0-9_]+))?$/) {
-		print STDERR "$ARGV:$.: malformed //sys declaration\n";
-		$errors = 1;
-		next;
-	}
-	my ($func, $in, $out, $sysname) = ($2, $3, $4, $5);
-
-	# Split argument lists on comma.
-	my @in = parseparamlist($in);
-	my @out = parseparamlist($out);
-
-	# Try in vain to keep people from editing this file.
-	# The theory is that they jump into the middle of the file
-	# without reading the header.
-	$text .= "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n";
-
-	# Go function header.
-	my $out_decl = @out ? sprintf(" (%s)", join(', ', @out)) : "";
-	$text .= sprintf "func %s(%s)%s {\n", $func, join(', ', @in), $out_decl;
-
-	# Check if err return available
-	my $errvar = "";
-	foreach my $p (@out) {
-		my ($name, $type) = parseparam($p);
-		if($type eq "error") {
-			$errvar = $name;
-			last;
-		}
-	}
-
-	# Prepare arguments to Syscall.
-	my @args = ();
-	my @uses = ();
-	my $n = 0;
-	foreach my $p (@in) {
-		my ($name, $type) = parseparam($p);
-		if($type =~ /^\*/) {
-			push @args, "uintptr(unsafe.Pointer($name))";
-		} elsif($type eq "string" && $errvar ne "") {
-			$text .= "\tvar _p$n *byte\n";
-			$text .= "\t_p$n, $errvar = BytePtrFromString($name)\n";
-			$text .= "\tif $errvar != nil {\n\t\treturn\n\t}\n";
-			push @args, "uintptr(unsafe.Pointer(_p$n))";
-			push @uses, "use(unsafe.Pointer(_p$n))";
-			$n++;
-		} elsif($type eq "string") {
-			print STDERR "$ARGV:$.: $func uses string arguments, but has no error return\n";
-			$text .= "\tvar _p$n *byte\n";
-			$text .= "\t_p$n, _ = BytePtrFromString($name)\n";
-			push @args, "uintptr(unsafe.Pointer(_p$n))";
-			push @uses, "use(unsafe.Pointer(_p$n))";
-			$n++;
-		} elsif($type =~ /^\[\](.*)/) {
-			# Convert slice into pointer, length.
-			# Have to be careful not to take address of &a[0] if len == 0:
-			# pass dummy pointer in that case.
-			# Used to pass nil, but some OSes or simulators reject write(fd, nil, 0).
-			$text .= "\tvar _p$n unsafe.Pointer\n";
-			$text .= "\tif len($name) > 0 {\n\t\t_p$n = unsafe.Pointer(\&${name}[0])\n\t}";
-			$text .= " else {\n\t\t_p$n = unsafe.Pointer(&_zero)\n\t}";
-			$text .= "\n";
-			push @args, "uintptr(_p$n)", "uintptr(len($name))";
-			$n++;
-		} elsif($type eq "int64" && ($openbsd || $netbsd)) {
-			push @args, "0";
-			if($_32bit eq "big-endian") {
-				push @args, "uintptr($name>>32)", "uintptr($name)";
-			} elsif($_32bit eq "little-endian") {
-				push @args, "uintptr($name)", "uintptr($name>>32)";
-			} else {
-				push @args, "uintptr($name)";
-			}
-		} elsif($type eq "int64" && $dragonfly) {
-			if ($func !~ /^extp(read|write)/i) {
-				push @args, "0";
-			}
-			if($_32bit eq "big-endian") {
-				push @args, "uintptr($name>>32)", "uintptr($name)";
-			} elsif($_32bit eq "little-endian") {
-				push @args, "uintptr($name)", "uintptr($name>>32)";
-			} else {
-				push @args, "uintptr($name)";
-			}
-		} elsif($type eq "int64" && $_32bit ne "") {
-			if(@args % 2 && $arm) {
-				# arm abi specifies 64-bit argument uses 
-				# (even, odd) pair
-				push @args, "0"
-			}
-			if($_32bit eq "big-endian") {
-				push @args, "uintptr($name>>32)", "uintptr($name)";
-			} else {
-				push @args, "uintptr($name)", "uintptr($name>>32)";
-			}
-		} else {
-			push @args, "uintptr($name)";
-		}
-	}
-
-	# Determine which form to use; pad args with zeros.
-	my $asm = "Syscall";
-	if ($nonblock) {
-		$asm = "RawSyscall";
-	}
-	if(@args <= 3) {
-		while(@args < 3) {
-			push @args, "0";
-		}
-	} elsif(@args <= 6) {
-		$asm .= "6";
-		while(@args < 6) {
-			push @args, "0";
-		}
-	} elsif(@args <= 9) {
-		$asm .= "9";
-		while(@args < 9) {
-			push @args, "0";
-		}
-	} else {
-		print STDERR "$ARGV:$.: too many arguments to system call\n";
-	}
-
-	# System call number.
-	if($sysname eq "") {
-		$sysname = "SYS_$func";
-		$sysname =~ s/([a-z])([A-Z])/${1}_$2/g;	# turn FooBar into Foo_Bar
-		$sysname =~ y/a-z/A-Z/;
-		if($nacl) {
-			$sysname =~ y/A-Z/a-z/;
-		}
-	}
-
-	# Actual call.
-	my $args = join(', ', @args);
-	my $call = "$asm($sysname, $args)";
-
-	# Assign return values.
-	my $body = "";
-	my @ret = ("_", "_", "_");
-	my $do_errno = 0;
-	for(my $i=0; $i<@out; $i++) {
-		my $p = $out[$i];
-		my ($name, $type) = parseparam($p);
-		my $reg = "";
-		if($name eq "err" && !$plan9) {
-			$reg = "e1";
-			$ret[2] = $reg;
-			$do_errno = 1;
-		} elsif($name eq "err" && $plan9) {
-			$ret[0] = "r0";
-			$ret[2] = "e1";
-			next;
-		} else {
-			$reg = sprintf("r%d", $i);
-			$ret[$i] = $reg;
-		}
-		if($type eq "bool") {
-			$reg = "$reg != 0";
-		}
-		if($type eq "int64" && $_32bit ne "") {
-			# 64-bit number in r1:r0 or r0:r1.
-			if($i+2 > @out) {
-				print STDERR "$ARGV:$.: not enough registers for int64 return\n";
-			}
-			if($_32bit eq "big-endian") {
-				$reg = sprintf("int64(r%d)<<32 | int64(r%d)", $i, $i+1);
-			} else {
-				$reg = sprintf("int64(r%d)<<32 | int64(r%d)", $i+1, $i);
-			}
-			$ret[$i] = sprintf("r%d", $i);
-			$ret[$i+1] = sprintf("r%d", $i+1);
-		}
-		if($reg ne "e1" || $plan9) {
-			$body .= "\t$name = $type($reg)\n";
-		}
-	}
-	if ($ret[0] eq "_" && $ret[1] eq "_" && $ret[2] eq "_") {
-		$text .= "\t$call\n";
-	} else {
-		$text .= "\t$ret[0], $ret[1], $ret[2] := $call\n";
-	}
-	foreach my $use (@uses) {
-		$text .= "\t$use\n";
-	}
-	$text .= $body;
-	
-	if ($plan9 && $ret[2] eq "e1") {
-		$text .= "\tif int32(r0) == -1 {\n";
-		$text .= "\t\terr = e1\n";
-		$text .= "\t}\n";
-	} elsif ($do_errno) {
-		$text .= "\tif e1 != 0 {\n";
-		$text .= "\t\terr = e1\n";
-		$text .= "\t}\n";
-	}
-	$text .= "\treturn\n";
-	$text .= "}\n\n";
-}
-
-chomp $text;
-chomp $text;
-
-if($errors) {
-	exit 1;
-}
-
-print <<EOF;
-// $cmdline
-// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
-
-package plan9
-
-import "unsafe"
-
-$text
-EOF
-exit 0;

vendor/golang.org/x/sys/plan9/mksysnum_plan9.sh

@@ -1,23 +0,0 @@
-#!/bin/sh
-# Copyright 2009 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.
-
-COMMAND="mksysnum_plan9.sh $@"
-
-cat <<EOF
-// $COMMAND
-// MACHINE GENERATED BY THE ABOVE COMMAND; DO NOT EDIT
-
-package plan9
-
-const(
-EOF
-
-SP='[ 	]' # space or tab
-sed "s/^#define${SP}\\([A-Z0-9_][A-Z0-9_]*\\)${SP}${SP}*\\([0-9][0-9]*\\)/SYS_\\1=\\2/g" \
-	< $1 | grep -v SYS__
-
-cat <<EOF
-)
-EOF

vendor/golang.org/x/sys/plan9/pwd_go15_plan9.go

@@ -1,21 +0,0 @@
-// 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.
-
-// +build go1.5
-
-package plan9
-
-import "syscall"
-
-func fixwd() {
-	syscall.Fixwd()
-}
-
-func Getwd() (wd string, err error) {
-	return syscall.Getwd()
-}
-
-func Chdir(path string) error {
-	return syscall.Chdir(path)
-}

vendor/golang.org/x/sys/plan9/pwd_plan9.go

@@ -1,23 +0,0 @@
-// 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.
-
-// +build !go1.5
-
-package plan9
-
-func fixwd() {
-}
-
-func Getwd() (wd string, err error) {
-	fd, err := open(".", O_RDONLY)
-	if err != nil {
-		return "", err
-	}
-	defer Close(fd)
-	return Fd2path(fd)
-}
-
-func Chdir(path string) error {
-	return chdir(path)
-}

vendor/golang.org/x/sys/plan9/race.go

@@ -1,30 +0,0 @@
-// Copyright 2012 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.
-
-// +build plan9,race
-
-package plan9
-
-import (
-	"runtime"
-	"unsafe"
-)
-
-const raceenabled = true
-
-func raceAcquire(addr unsafe.Pointer) {
-	runtime.RaceAcquire(addr)
-}
-
-func raceReleaseMerge(addr unsafe.Pointer) {
-	runtime.RaceReleaseMerge(addr)
-}
-
-func raceReadRange(addr unsafe.Pointer, len int) {
-	runtime.RaceReadRange(addr, len)
-}
-
-func raceWriteRange(addr unsafe.Pointer, len int) {
-	runtime.RaceWriteRange(addr, len)
-}

vendor/golang.org/x/sys/plan9/race0.go

@@ -1,25 +0,0 @@
-// Copyright 2012 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.
-
-// +build plan9,!race
-
-package plan9
-
-import (
-	"unsafe"
-)
-
-const raceenabled = false
-
-func raceAcquire(addr unsafe.Pointer) {
-}
-
-func raceReleaseMerge(addr unsafe.Pointer) {
-}
-
-func raceReadRange(addr unsafe.Pointer, len int) {
-}
-
-func raceWriteRange(addr unsafe.Pointer, len int) {
-}

vendor/golang.org/x/sys/plan9/str.go

@@ -1,22 +0,0 @@
-// Copyright 2009 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.
-
-// +build plan9
-
-package plan9
-
-func itoa(val int) string { // do it here rather than with fmt to avoid dependency
-	if val < 0 {
-		return "-" + itoa(-val)
-	}
-	var buf [32]byte // big enough for int64
-	i := len(buf) - 1
-	for val >= 10 {
-		buf[i] = byte(val%10 + '0')
-		i--
-		val /= 10
-	}
-	buf[i] = byte(val + '0')
-	return string(buf[i:])
-}

vendor/golang.org/x/sys/plan9/syscall.go

@@ -1,74 +0,0 @@
-// Copyright 2009 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.
-
-// +build plan9
-
-// Package plan9 contains an interface to the low-level operating system
-// primitives. OS details vary depending on the underlying system, and
-// by default, godoc will display the OS-specific documentation for the current
-// system. If you want godoc to display documentation for another
-// system, set $GOOS and $GOARCH to the desired system. For example, if
-// you want to view documentation for freebsd/arm on linux/amd64, set $GOOS
-// to freebsd and $GOARCH to arm.
-// The primary use of this package is inside other packages that provide a more
-// portable interface to the system, such as "os", "time" and "net".  Use
-// those packages rather than this one if you can.
-// For details of the functions and data types in this package consult
-// the manuals for the appropriate operating system.
-// These calls return err == nil to indicate success; otherwise
-// err represents an operating system error describing the failure and
-// holds a value of type syscall.ErrorString.
-package plan9 // import "golang.org/x/sys/plan9"
-
-import "unsafe"
-
-// ByteSliceFromString returns a NUL-terminated slice of bytes
-// containing the text of s. If s contains a NUL byte at any
-// location, it returns (nil, EINVAL).
-func ByteSliceFromString(s string) ([]byte, error) {
-	for i := 0; i < len(s); i++ {
-		if s[i] == 0 {
-			return nil, EINVAL
-		}
-	}
-	a := make([]byte, len(s)+1)
-	copy(a, s)
-	return a, nil
-}
-
-// BytePtrFromString returns a pointer to a NUL-terminated array of
-// bytes containing the text of s. If s contains a NUL byte at any
-// location, it returns (nil, EINVAL).
-func BytePtrFromString(s string) (*byte, error) {
-	a, err := ByteSliceFromString(s)
-	if err != nil {
-		return nil, err
-	}
-	return &a[0], nil
-}
-
-// Single-word zero for use when we need a valid pointer to 0 bytes.
-// See mksyscall.pl.
-var _zero uintptr
-
-func (ts *Timespec) Unix() (sec int64, nsec int64) {
-	return int64(ts.Sec), int64(ts.Nsec)
-}
-
-func (tv *Timeval) Unix() (sec int64, nsec int64) {
-	return int64(tv.Sec), int64(tv.Usec) * 1000
-}
-
-func (ts *Timespec) Nano() int64 {
-	return int64(ts.Sec)*1e9 + int64(ts.Nsec)
-}
-
-func (tv *Timeval) Nano() int64 {
-	return int64(tv.Sec)*1e9 + int64(tv.Usec)*1000
-}
-
-// use is a no-op, but the compiler cannot see that it is.
-// Calling use(p) ensures that p is kept live until that point.
-//go:noescape
-func use(p unsafe.Pointer)

vendor/golang.org/x/sys/plan9/syscall_plan9.go

@@ -1,349 +0,0 @@
-// Copyright 2011 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.
-
-// Plan 9 system calls.
-// This file is compiled as ordinary Go code,
-// but it is also input to mksyscall,
-// which parses the //sys lines and generates system call stubs.
-// Note that sometimes we use a lowercase //sys name and
-// wrap it in our own nicer implementation.
-
-package plan9
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-// A Note is a string describing a process note.
-// It implements the os.Signal interface.
-type Note string
-
-func (n Note) Signal() {}
-
-func (n Note) String() string {
-	return string(n)
-}
-
-var (
-	Stdin  = 0
-	Stdout = 1
-	Stderr = 2
-)
-
-// For testing: clients can set this flag to force
-// creation of IPv6 sockets to return EAFNOSUPPORT.
-var SocketDisableIPv6 bool
-
-func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.ErrorString)
-func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.ErrorString)
-func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr)
-func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr)
-
-func atoi(b []byte) (n uint) {
-	n = 0
-	for i := 0; i < len(b); i++ {
-		n = n*10 + uint(b[i]-'0')
-	}
-	return
-}
-
-func cstring(s []byte) string {
-	for i := range s {
-		if s[i] == 0 {
-			return string(s[0:i])
-		}
-	}
-	return string(s)
-}
-
-func errstr() string {
-	var buf [ERRMAX]byte
-
-	RawSyscall(SYS_ERRSTR, uintptr(unsafe.Pointer(&buf[0])), uintptr(len(buf)), 0)
-
-	buf[len(buf)-1] = 0
-	return cstring(buf[:])
-}
-
-// Implemented in assembly to import from runtime.
-func exit(code int)
-
-func Exit(code int) { exit(code) }
-
-func readnum(path string) (uint, error) {
-	var b [12]byte
-
-	fd, e := Open(path, O_RDONLY)
-	if e != nil {
-		return 0, e
-	}
-	defer Close(fd)
-
-	n, e := Pread(fd, b[:], 0)
-
-	if e != nil {
-		return 0, e
-	}
-
-	m := 0
-	for ; m < n && b[m] == ' '; m++ {
-	}
-
-	return atoi(b[m : n-1]), nil
-}
-
-func Getpid() (pid int) {
-	n, _ := readnum("#c/pid")
-	return int(n)
-}
-
-func Getppid() (ppid int) {
-	n, _ := readnum("#c/ppid")
-	return int(n)
-}
-
-func Read(fd int, p []byte) (n int, err error) {
-	return Pread(fd, p, -1)
-}
-
-func Write(fd int, p []byte) (n int, err error) {
-	return Pwrite(fd, p, -1)
-}
-
-var ioSync int64
-
-//sys	fd2path(fd int, buf []byte) (err error)
-func Fd2path(fd int) (path string, err error) {
-	var buf [512]byte
-
-	e := fd2path(fd, buf[:])
-	if e != nil {
-		return "", e
-	}
-	return cstring(buf[:]), nil
-}
-
-//sys	pipe(p *[2]int32) (err error)
-func Pipe(p []int) (err error) {
-	if len(p) != 2 {
-		return syscall.ErrorString("bad arg in system call")
-	}
-	var pp [2]int32
-	err = pipe(&pp)
-	p[0] = int(pp[0])
-	p[1] = int(pp[1])
-	return
-}
-
-// Underlying system call writes to newoffset via pointer.
-// Implemented in assembly to avoid allocation.
-func seek(placeholder uintptr, fd int, offset int64, whence int) (newoffset int64, err string)
-
-func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
-	newoffset, e := seek(0, fd, offset, whence)
-
-	if newoffset == -1 {
-		err = syscall.ErrorString(e)
-	}
-	return
-}
-
-func Mkdir(path string, mode uint32) (err error) {
-	fd, err := Create(path, O_RDONLY, DMDIR|mode)
-
-	if fd != -1 {
-		Close(fd)
-	}
-
-	return
-}
-
-type Waitmsg struct {
-	Pid  int
-	Time [3]uint32
-	Msg  string
-}
-
-func (w Waitmsg) Exited() bool   { return true }
-func (w Waitmsg) Signaled() bool { return false }
-
-func (w Waitmsg) ExitStatus() int {
-	if len(w.Msg) == 0 {
-		// a normal exit returns no message
-		return 0
-	}
-	return 1
-}
-
-//sys	await(s []byte) (n int, err error)
-func Await(w *Waitmsg) (err error) {
-	var buf [512]byte
-	var f [5][]byte
-
-	n, err := await(buf[:])
-
-	if err != nil || w == nil {
-		return
-	}
-
-	nf := 0
-	p := 0
-	for i := 0; i < n && nf < len(f)-1; i++ {
-		if buf[i] == ' ' {
-			f[nf] = buf[p:i]
-			p = i + 1
-			nf++
-		}
-	}
-	f[nf] = buf[p:]
-	nf++
-
-	if nf != len(f) {
-		return syscall.ErrorString("invalid wait message")
-	}
-	w.Pid = int(atoi(f[0]))
-	w.Time[0] = uint32(atoi(f[1]))
-	w.Time[1] = uint32(atoi(f[2]))
-	w.Time[2] = uint32(atoi(f[3]))
-	w.Msg = cstring(f[4])
-	if w.Msg == "''" {
-		// await() returns '' for no error
-		w.Msg = ""
-	}
-	return
-}
-
-func Unmount(name, old string) (err error) {
-	fixwd()
-	oldp, err := BytePtrFromString(old)
-	if err != nil {
-		return err
-	}
-	oldptr := uintptr(unsafe.Pointer(oldp))
-
-	var r0 uintptr
-	var e syscall.ErrorString
-
-	// bind(2) man page: If name is zero, everything bound or mounted upon old is unbound or unmounted.
-	if name == "" {
-		r0, _, e = Syscall(SYS_UNMOUNT, _zero, oldptr, 0)
-	} else {
-		namep, err := BytePtrFromString(name)
-		if err != nil {
-			return err
-		}
-		r0, _, e = Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(namep)), oldptr, 0)
-	}
-
-	if int32(r0) == -1 {
-		err = e
-	}
-	return
-}
-
-func Fchdir(fd int) (err error) {
-	path, err := Fd2path(fd)
-
-	if err != nil {
-		return
-	}
-
-	return Chdir(path)
-}
-
-type Timespec struct {
-	Sec  int32
-	Nsec int32
-}
-
-type Timeval struct {
-	Sec  int32
-	Usec int32
-}
-
-func NsecToTimeval(nsec int64) (tv Timeval) {
-	nsec += 999 // round up to microsecond
-	tv.Usec = int32(nsec % 1e9 / 1e3)
-	tv.Sec = int32(nsec / 1e9)
-	return
-}
-
-func nsec() int64 {
-	var scratch int64
-
-	r0, _, _ := Syscall(SYS_NSEC, uintptr(unsafe.Pointer(&scratch)), 0, 0)
-	// TODO(aram): remove hack after I fix _nsec in the pc64 kernel.
-	if r0 == 0 {
-		return scratch
-	}
-	return int64(r0)
-}
-
-func Gettimeofday(tv *Timeval) error {
-	nsec := nsec()
-	*tv = NsecToTimeval(nsec)
-	return nil
-}
-
-func Getpagesize() int { return 0x1000 }
-
-func Getegid() (egid int) { return -1 }
-func Geteuid() (euid int) { return -1 }
-func Getgid() (gid int)   { return -1 }
-func Getuid() (uid int)   { return -1 }
-
-func Getgroups() (gids []int, err error) {
-	return make([]int, 0), nil
-}
-
-//sys	open(path string, mode int) (fd int, err error)
-func Open(path string, mode int) (fd int, err error) {
-	fixwd()
-	return open(path, mode)
-}
-
-//sys	create(path string, mode int, perm uint32) (fd int, err error)
-func Create(path string, mode int, perm uint32) (fd int, err error) {
-	fixwd()
-	return create(path, mode, perm)
-}
-
-//sys	remove(path string) (err error)
-func Remove(path string) error {
-	fixwd()
-	return remove(path)
-}
-
-//sys	stat(path string, edir []byte) (n int, err error)
-func Stat(path string, edir []byte) (n int, err error) {
-	fixwd()
-	return stat(path, edir)
-}
-
-//sys	bind(name string, old string, flag int) (err error)
-func Bind(name string, old string, flag int) (err error) {
-	fixwd()
-	return bind(name, old, flag)
-}
-
-//sys	mount(fd int, afd int, old string, flag int, aname string) (err error)
-func Mount(fd int, afd int, old string, flag int, aname string) (err error) {
-	fixwd()
-	return mount(fd, afd, old, flag, aname)
-}
-
-//sys	wstat(path string, edir []byte) (err error)
-func Wstat(path string, edir []byte) (err error) {
-	fixwd()
-	return wstat(path, edir)
-}
-
-//sys	chdir(path string) (err error)
-//sys	Dup(oldfd int, newfd int) (fd int, err error)
-//sys	Pread(fd int, p []byte, offset int64) (n int, err error)
-//sys	Pwrite(fd int, p []byte, offset int64) (n int, err error)
-//sys	Close(fd int) (err error)
-//sys	Fstat(fd int, edir []byte) (n int, err error)
-//sys	Fwstat(fd int, edir []byte) (err error)

vendor/golang.org/x/sys/plan9/syscall_test.go

@@ -1,33 +0,0 @@
-// Copyright 2013 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.
-
-// +build plan9
-
-package plan9_test
-
-import (
-	"testing"
-
-	"golang.org/x/sys/plan9"
-)
-
-func testSetGetenv(t *testing.T, key, value string) {
-	err := plan9.Setenv(key, value)
-	if err != nil {
-		t.Fatalf("Setenv failed to set %q: %v", value, err)
-	}
-	newvalue, found := plan9.Getenv(key)
-	if !found {
-		t.Fatalf("Getenv failed to find %v variable (want value %q)", key, value)
-	}
-	if newvalue != value {
-		t.Fatalf("Getenv(%v) = %q; want %q", key, newvalue, value)
-	}
-}
-
-func TestEnv(t *testing.T) {
-	testSetGetenv(t, "TESTENV", "AVALUE")
-	// make sure TESTENV gets set to "", not deleted
-	testSetGetenv(t, "TESTENV", "")
-}

vendor/golang.org/x/sys/plan9/zsyscall_plan9_386.go

@@ -1,292 +0,0 @@
-// mksyscall.pl -l32 -plan9 syscall_plan9.go
-// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
-
-package plan9
-
-import "unsafe"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func fd2path(fd int, buf []byte) (err error) {
-	var _p0 unsafe.Pointer
-	if len(buf) > 0 {
-		_p0 = unsafe.Pointer(&buf[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_FD2PATH, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func pipe(p *[2]int32) (err error) {
-	r0, _, e1 := Syscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func await(s []byte) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(s) > 0 {
-		_p0 = unsafe.Pointer(&s[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_AWAIT, uintptr(_p0), uintptr(len(s)), 0)
-	n = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func open(path string, mode int) (fd int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
-	use(unsafe.Pointer(_p0))
-	fd = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func create(path string, mode int, perm uint32) (fd int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(SYS_CREATE, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
-	use(unsafe.Pointer(_p0))
-	fd = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func remove(path string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(SYS_REMOVE, uintptr(unsafe.Pointer(_p0)), 0, 0)
-	use(unsafe.Pointer(_p0))
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func stat(path string, edir []byte) (n int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 unsafe.Pointer
-	if len(edir) > 0 {
-		_p1 = unsafe.Pointer(&edir[0])
-	} else {
-		_p1 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
-	use(unsafe.Pointer(_p0))
-	n = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func bind(name string, old string, flag int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(name)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(old)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(SYS_BIND, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flag))
-	use(unsafe.Pointer(_p0))
-	use(unsafe.Pointer(_p1))
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func mount(fd int, afd int, old string, flag int, aname string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(old)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(aname)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall6(SYS_MOUNT, uintptr(fd), uintptr(afd), uintptr(unsafe.Pointer(_p0)), uintptr(flag), uintptr(unsafe.Pointer(_p1)), 0)
-	use(unsafe.Pointer(_p0))
-	use(unsafe.Pointer(_p1))
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func wstat(path string, edir []byte) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 unsafe.Pointer
-	if len(edir) > 0 {
-		_p1 = unsafe.Pointer(&edir[0])
-	} else {
-		_p1 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_WSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
-	use(unsafe.Pointer(_p0))
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func chdir(path string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
-	use(unsafe.Pointer(_p0))
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Dup(oldfd int, newfd int) (fd int, err error) {
-	r0, _, e1 := Syscall(SYS_DUP, uintptr(oldfd), uintptr(newfd), 0)
-	fd = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Pread(fd int, p []byte, offset int64) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(p) > 0 {
-		_p0 = unsafe.Pointer(&p[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
-	n = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(p) > 0 {
-		_p0 = unsafe.Pointer(&p[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
-	n = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Close(fd int) (err error) {
-	r0, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fstat(fd int, edir []byte) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(edir) > 0 {
-		_p0 = unsafe.Pointer(&edir[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
-	n = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fwstat(fd int, edir []byte) (err error) {
-	var _p0 unsafe.Pointer
-	if len(edir) > 0 {
-		_p0 = unsafe.Pointer(&edir[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_FWSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}

vendor/golang.org/x/sys/plan9/zsyscall_plan9_amd64.go

@@ -1,292 +0,0 @@
-// mksyscall.pl -l32 -plan9 syscall_plan9.go
-// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
-
-package plan9
-
-import "unsafe"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func fd2path(fd int, buf []byte) (err error) {
-	var _p0 unsafe.Pointer
-	if len(buf) > 0 {
-		_p0 = unsafe.Pointer(&buf[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_FD2PATH, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func pipe(p *[2]int32) (err error) {
-	r0, _, e1 := Syscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func await(s []byte) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(s) > 0 {
-		_p0 = unsafe.Pointer(&s[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_AWAIT, uintptr(_p0), uintptr(len(s)), 0)
-	n = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func open(path string, mode int) (fd int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
-	use(unsafe.Pointer(_p0))
-	fd = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func create(path string, mode int, perm uint32) (fd int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(SYS_CREATE, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
-	use(unsafe.Pointer(_p0))
-	fd = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func remove(path string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(SYS_REMOVE, uintptr(unsafe.Pointer(_p0)), 0, 0)
-	use(unsafe.Pointer(_p0))
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func stat(path string, edir []byte) (n int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 unsafe.Pointer
-	if len(edir) > 0 {
-		_p1 = unsafe.Pointer(&edir[0])
-	} else {
-		_p1 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
-	use(unsafe.Pointer(_p0))
-	n = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func bind(name string, old string, flag int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(name)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(old)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(SYS_BIND, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flag))
-	use(unsafe.Pointer(_p0))
-	use(unsafe.Pointer(_p1))
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func mount(fd int, afd int, old string, flag int, aname string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(old)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(aname)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall6(SYS_MOUNT, uintptr(fd), uintptr(afd), uintptr(unsafe.Pointer(_p0)), uintptr(flag), uintptr(unsafe.Pointer(_p1)), 0)
-	use(unsafe.Pointer(_p0))
-	use(unsafe.Pointer(_p1))
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func wstat(path string, edir []byte) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 unsafe.Pointer
-	if len(edir) > 0 {
-		_p1 = unsafe.Pointer(&edir[0])
-	} else {
-		_p1 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_WSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
-	use(unsafe.Pointer(_p0))
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func chdir(path string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
-	use(unsafe.Pointer(_p0))
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Dup(oldfd int, newfd int) (fd int, err error) {
-	r0, _, e1 := Syscall(SYS_DUP, uintptr(oldfd), uintptr(newfd), 0)
-	fd = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Pread(fd int, p []byte, offset int64) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(p) > 0 {
-		_p0 = unsafe.Pointer(&p[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
-	n = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(p) > 0 {
-		_p0 = unsafe.Pointer(&p[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
-	n = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Close(fd int) (err error) {
-	r0, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fstat(fd int, edir []byte) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(edir) > 0 {
-		_p0 = unsafe.Pointer(&edir[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
-	n = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fwstat(fd int, edir []byte) (err error) {
-	var _p0 unsafe.Pointer
-	if len(edir) > 0 {
-		_p0 = unsafe.Pointer(&edir[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_FWSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}

vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm.go

@@ -1,284 +0,0 @@
-// mksyscall.pl -l32 -plan9 -tags plan9,arm syscall_plan9.go
-// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
-
-// +build plan9,arm
-
-package plan9
-
-import "unsafe"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func fd2path(fd int, buf []byte) (err error) {
-	var _p0 unsafe.Pointer
-	if len(buf) > 0 {
-		_p0 = unsafe.Pointer(&buf[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_FD2PATH, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func pipe(p *[2]int32) (err error) {
-	r0, _, e1 := Syscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func await(s []byte) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(s) > 0 {
-		_p0 = unsafe.Pointer(&s[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_AWAIT, uintptr(_p0), uintptr(len(s)), 0)
-	n = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func open(path string, mode int) (fd int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
-	fd = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func create(path string, mode int, perm uint32) (fd int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(SYS_CREATE, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
-	fd = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func remove(path string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(SYS_REMOVE, uintptr(unsafe.Pointer(_p0)), 0, 0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func stat(path string, edir []byte) (n int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 unsafe.Pointer
-	if len(edir) > 0 {
-		_p1 = unsafe.Pointer(&edir[0])
-	} else {
-		_p1 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
-	n = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func bind(name string, old string, flag int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(name)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(old)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(SYS_BIND, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flag))
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func mount(fd int, afd int, old string, flag int, aname string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(old)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(aname)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall6(SYS_MOUNT, uintptr(fd), uintptr(afd), uintptr(unsafe.Pointer(_p0)), uintptr(flag), uintptr(unsafe.Pointer(_p1)), 0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func wstat(path string, edir []byte) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 unsafe.Pointer
-	if len(edir) > 0 {
-		_p1 = unsafe.Pointer(&edir[0])
-	} else {
-		_p1 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_WSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func chdir(path string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Dup(oldfd int, newfd int) (fd int, err error) {
-	r0, _, e1 := Syscall(SYS_DUP, uintptr(oldfd), uintptr(newfd), 0)
-	fd = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Pread(fd int, p []byte, offset int64) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(p) > 0 {
-		_p0 = unsafe.Pointer(&p[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
-	n = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(p) > 0 {
-		_p0 = unsafe.Pointer(&p[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
-	n = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Close(fd int) (err error) {
-	r0, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fstat(fd int, edir []byte) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(edir) > 0 {
-		_p0 = unsafe.Pointer(&edir[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
-	n = int(r0)
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fwstat(fd int, edir []byte) (err error) {
-	var _p0 unsafe.Pointer
-	if len(edir) > 0 {
-		_p0 = unsafe.Pointer(&edir[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_FWSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
-	if int32(r0) == -1 {
-		err = e1
-	}
-	return
-}

vendor/golang.org/x/sys/plan9/zsysnum_plan9.go

@@ -1,49 +0,0 @@
-// mksysnum_plan9.sh /opt/plan9/sys/src/libc/9syscall/sys.h
-// MACHINE GENERATED BY THE ABOVE COMMAND; DO NOT EDIT
-
-package plan9
-
-const (
-	SYS_SYSR1       = 0
-	SYS_BIND        = 2
-	SYS_CHDIR       = 3
-	SYS_CLOSE       = 4
-	SYS_DUP         = 5
-	SYS_ALARM       = 6
-	SYS_EXEC        = 7
-	SYS_EXITS       = 8
-	SYS_FAUTH       = 10
-	SYS_SEGBRK      = 12
-	SYS_OPEN        = 14
-	SYS_OSEEK       = 16
-	SYS_SLEEP       = 17
-	SYS_RFORK       = 19
-	SYS_PIPE        = 21
-	SYS_CREATE      = 22
-	SYS_FD2PATH     = 23
-	SYS_BRK_        = 24
-	SYS_REMOVE      = 25
-	SYS_NOTIFY      = 28
-	SYS_NOTED       = 29
-	SYS_SEGATTACH   = 30
-	SYS_SEGDETACH   = 31
-	SYS_SEGFREE     = 32
-	SYS_SEGFLUSH    = 33
-	SYS_RENDEZVOUS  = 34
-	SYS_UNMOUNT     = 35
-	SYS_SEMACQUIRE  = 37
-	SYS_SEMRELEASE  = 38
-	SYS_SEEK        = 39
-	SYS_FVERSION    = 40
-	SYS_ERRSTR      = 41
-	SYS_STAT        = 42
-	SYS_FSTAT       = 43
-	SYS_WSTAT       = 44
-	SYS_FWSTAT      = 45
-	SYS_MOUNT       = 46
-	SYS_AWAIT       = 47
-	SYS_PREAD       = 50
-	SYS_PWRITE      = 51
-	SYS_TSEMACQUIRE = 52
-	SYS_NSEC        = 53
-)

vendor/golang.org/x/sys/unix/.gitignore

@@ -1,2 +0,0 @@
-_obj/
-unix.test

vendor/golang.org/x/sys/unix/README.md

@@ -1,173 +0,0 @@
-# Building `sys/unix`
-
-The sys/unix package provides access to the raw system call interface of the
-underlying operating system. See: https://godoc.org/golang.org/x/sys/unix
-
-Porting Go to a new architecture/OS combination or adding syscalls, types, or
-constants to an existing architecture/OS pair requires some manual effort;
-however, there are tools that automate much of the process.
-
-## Build Systems
-
-There are currently two ways we generate the necessary files. We are currently
-migrating the build system to use containers so the builds are reproducible.
-This is being done on an OS-by-OS basis. Please update this documentation as
-components of the build system change.
-
-### Old Build System (currently for `GOOS != "Linux" || GOARCH == "sparc64"`)
-
-The old build system generates the Go files based on the C header files
-present on your system. This means that files
-for a given GOOS/GOARCH pair must be generated on a system with that OS and
-architecture. This also means that the generated code can differ from system
-to system, based on differences in the header files.
-
-To avoid this, if you are using the old build system, only generate the Go
-files on an installation with unmodified header files. It is also important to
-keep track of which version of the OS the files were generated from (ex.
-Darwin 14 vs Darwin 15). This makes it easier to track the progress of changes
-and have each OS upgrade correspond to a single change.
-
-To build the files for your current OS and architecture, make sure GOOS and
-GOARCH are set correctly and run `mkall.sh`. This will generate the files for
-your specific system. Running `mkall.sh -n` shows the commands that will be run.
-
-Requirements: bash, perl, go
-
-### New Build System (currently for `GOOS == "Linux" && GOARCH != "sparc64"`)
-
-The new build system uses a Docker container to generate the go files directly
-from source checkouts of the kernel and various system libraries. This means
-that on any platform that supports Docker, all the files using the new build
-system can be generated at once, and generated files will not change based on
-what the person running the scripts has installed on their computer.
-
-The OS specific files for the new build system are located in the `${GOOS}`
-directory, and the build is coordinated by the `${GOOS}/mkall.go` program. When
-the kernel or system library updates, modify the Dockerfile at
-`${GOOS}/Dockerfile` to checkout the new release of the source.
-
-To build all the files under the new build system, you must be on an amd64/Linux
-system and have your GOOS and GOARCH set accordingly. Running `mkall.sh` will
-then generate all of the files for all of the GOOS/GOARCH pairs in the new build
-system. Running `mkall.sh -n` shows the commands that will be run.
-
-Requirements: bash, perl, go, docker
-
-## Component files
-
-This section describes the various files used in the code generation process.
-It also contains instructions on how to modify these files to add a new
-architecture/OS or to add additional syscalls, types, or constants. Note that
-if you are using the new build system, the scripts cannot be called normally.
-They must be called from within the docker container.
-
-### asm files
-
-The hand-written assembly file at `asm_${GOOS}_${GOARCH}.s` implements system
-call dispatch. There are three entry points:
-```
-  func Syscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr)
-  func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr)
-  func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr)
-```
-The first and second are the standard ones; they differ only in how many
-arguments can be passed to the kernel. The third is for low-level use by the
-ForkExec wrapper. Unlike the first two, it does not call into the scheduler to
-let it know that a system call is running.
-
-When porting Go to an new architecture/OS, this file must be implemented for
-each GOOS/GOARCH pair.
-
-### mksysnum
-
-Mksysnum is a script located at `${GOOS}/mksysnum.pl` (or `mksysnum_${GOOS}.pl`
-for the old system). This script takes in a list of header files containing the
-syscall number declarations and parses them to produce the corresponding list of
-Go numeric constants. See `zsysnum_${GOOS}_${GOARCH}.go` for the generated
-constants.
-
-Adding new syscall numbers is mostly done by running the build on a sufficiently
-new installation of the target OS (or updating the source checkouts for the
-new build system). However, depending on the OS, you make need to update the
-parsing in mksysnum.
-
-### mksyscall.pl
-
-The `syscall.go`, `syscall_${GOOS}.go`, `syscall_${GOOS}_${GOARCH}.go` are
-hand-written Go files which implement system calls (for unix, the specific OS,
-or the specific OS/Architecture pair respectively) that need special handling
-and list `//sys` comments giving prototypes for ones that can be generated.
-
-The mksyscall.pl script takes the `//sys` and `//sysnb` comments and converts
-them into syscalls. This requires the name of the prototype in the comment to
-match a syscall number in the `zsysnum_${GOOS}_${GOARCH}.go` file. The function
-prototype can be exported (capitalized) or not.
-
-Adding a new syscall often just requires adding a new `//sys` function prototype
-with the desired arguments and a capitalized name so it is exported. However, if
-you want the interface to the syscall to be different, often one will make an
-unexported `//sys` prototype, an then write a custom wrapper in
-`syscall_${GOOS}.go`.
-
-### types files
-
-For each OS, there is a hand-written Go file at `${GOOS}/types.go` (or
-`types_${GOOS}.go` on the old system). This file includes standard C headers and
-creates Go type aliases to the corresponding C types. The file is then fed
-through godef to get the Go compatible definitions. Finally, the generated code
-is fed though mkpost.go to format the code correctly and remove any hidden or
-private identifiers. This cleaned-up code is written to
-`ztypes_${GOOS}_${GOARCH}.go`.
-
-The hardest part about preparing this file is figuring out which headers to
-include and which symbols need to be `#define`d to get the actual data
-structures that pass through to the kernel system calls. Some C libraries
-preset alternate versions for binary compatibility and translate them on the
-way in and out of system calls, but there is almost always a `#define` that can
-get the real ones.
-See `types_darwin.go` and `linux/types.go` for examples.
-
-To add a new type, add in the necessary include statement at the top of the
-file (if it is not already there) and add in a type alias line. Note that if
-your type is significantly different on different architectures, you may need
-some `#if/#elif` macros in your include statements.
-
-### mkerrors.sh
-
-This script is used to generate the system's various constants. This doesn't
-just include the error numbers and error strings, but also the signal numbers
-an a wide variety of miscellaneous constants. The constants come from the list
-of include files in the `includes_${uname}` variable. A regex then picks out
-the desired `#define` statements, and generates the corresponding Go constants.
-The error numbers and strings are generated from `#include <errno.h>`, and the
-signal numbers and strings are generated from `#include <signal.h>`. All of
-these constants are written to `zerrors_${GOOS}_${GOARCH}.go` via a C program,
-`_errors.c`, which prints out all the constants.
-
-To add a constant, add the header that includes it to the appropriate variable.
-Then, edit the regex (if necessary) to match the desired constant. Avoid making
-the regex too broad to avoid matching unintended constants.
-
-
-## Generated files
-
-### `zerror_${GOOS}_${GOARCH}.go`
-
-A file containing all of the system's generated error numbers, error strings,
-signal numbers, and constants. Generated by `mkerrors.sh` (see above).
-
-### `zsyscall_${GOOS}_${GOARCH}.go`
-
-A file containing all the generated syscalls for a specific GOOS and GOARCH.
-Generated by `mksyscall.pl` (see above).
-
-### `zsysnum_${GOOS}_${GOARCH}.go`
-
-A list of numeric constants for all the syscall number of the specific GOOS
-and GOARCH. Generated by mksysnum (see above).
-
-### `ztypes_${GOOS}_${GOARCH}.go`
-
-A file containing Go types for passing into (or returning from) syscalls.
-Generated by godefs and the types file (see above).

vendor/golang.org/x/sys/unix/affinity_linux.go

@@ -1,124 +0,0 @@
-// Copyright 2018 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.
-
-// CPU affinity functions
-
-package unix
-
-import (
-	"unsafe"
-)
-
-const cpuSetSize = _CPU_SETSIZE / _NCPUBITS
-
-// CPUSet represents a CPU affinity mask.
-type CPUSet [cpuSetSize]cpuMask
-
-func schedAffinity(trap uintptr, pid int, set *CPUSet) error {
-	_, _, e := RawSyscall(trap, uintptr(pid), uintptr(unsafe.Sizeof(*set)), uintptr(unsafe.Pointer(set)))
-	if e != 0 {
-		return errnoErr(e)
-	}
-	return nil
-}
-
-// SchedGetaffinity gets the CPU affinity mask of the thread specified by pid.
-// If pid is 0 the calling thread is used.
-func SchedGetaffinity(pid int, set *CPUSet) error {
-	return schedAffinity(SYS_SCHED_GETAFFINITY, pid, set)
-}
-
-// SchedSetaffinity sets the CPU affinity mask of the thread specified by pid.
-// If pid is 0 the calling thread is used.
-func SchedSetaffinity(pid int, set *CPUSet) error {
-	return schedAffinity(SYS_SCHED_SETAFFINITY, pid, set)
-}
-
-// Zero clears the set s, so that it contains no CPUs.
-func (s *CPUSet) Zero() {
-	for i := range s {
-		s[i] = 0
-	}
-}
-
-func cpuBitsIndex(cpu int) int {
-	return cpu / _NCPUBITS
-}
-
-func cpuBitsMask(cpu int) cpuMask {
-	return cpuMask(1 << (uint(cpu) % _NCPUBITS))
-}
-
-// Set adds cpu to the set s.
-func (s *CPUSet) Set(cpu int) {
-	i := cpuBitsIndex(cpu)
-	if i < len(s) {
-		s[i] |= cpuBitsMask(cpu)
-	}
-}
-
-// Clear removes cpu from the set s.
-func (s *CPUSet) Clear(cpu int) {
-	i := cpuBitsIndex(cpu)
-	if i < len(s) {
-		s[i] &^= cpuBitsMask(cpu)
-	}
-}
-
-// IsSet reports whether cpu is in the set s.
-func (s *CPUSet) IsSet(cpu int) bool {
-	i := cpuBitsIndex(cpu)
-	if i < len(s) {
-		return s[i]&cpuBitsMask(cpu) != 0
-	}
-	return false
-}
-
-// Count returns the number of CPUs in the set s.
-func (s *CPUSet) Count() int {
-	c := 0
-	for _, b := range s {
-		c += onesCount64(uint64(b))
-	}
-	return c
-}
-
-// onesCount64 is a copy of Go 1.9's math/bits.OnesCount64.
-// Once this package can require Go 1.9, we can delete this
-// and update the caller to use bits.OnesCount64.
-func onesCount64(x uint64) int {
-	const m0 = 0x5555555555555555 // 01010101 ...
-	const m1 = 0x3333333333333333 // 00110011 ...
-	const m2 = 0x0f0f0f0f0f0f0f0f // 00001111 ...
-	const m3 = 0x00ff00ff00ff00ff // etc.
-	const m4 = 0x0000ffff0000ffff
-
-	// Implementation: Parallel summing of adjacent bits.
-	// See "Hacker's Delight", Chap. 5: Counting Bits.
-	// The following pattern shows the general approach:
-	//
-	//   x = x>>1&(m0&m) + x&(m0&m)
-	//   x = x>>2&(m1&m) + x&(m1&m)
-	//   x = x>>4&(m2&m) + x&(m2&m)
-	//   x = x>>8&(m3&m) + x&(m3&m)
-	//   x = x>>16&(m4&m) + x&(m4&m)
-	//   x = x>>32&(m5&m) + x&(m5&m)
-	//   return int(x)
-	//
-	// Masking (& operations) can be left away when there's no
-	// danger that a field's sum will carry over into the next
-	// field: Since the result cannot be > 64, 8 bits is enough
-	// and we can ignore the masks for the shifts by 8 and up.
-	// Per "Hacker's Delight", the first line can be simplified
-	// more, but it saves at best one instruction, so we leave
-	// it alone for clarity.
-	const m = 1<<64 - 1
-	x = x>>1&(m0&m) + x&(m0&m)
-	x = x>>2&(m1&m) + x&(m1&m)
-	x = (x>>4 + x) & (m2 & m)
-	x += x >> 8
-	x += x >> 16
-	x += x >> 32
-	return int(x) & (1<<7 - 1)
-}

vendor/golang.org/x/sys/unix/asm_darwin_386.s

@@ -1,29 +0,0 @@
-// Copyright 2009 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System call support for 386, Darwin
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-28
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	JMP	syscall·Syscall9(SB)
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	JMP	syscall·RawSyscall6(SB)

vendor/golang.org/x/sys/unix/asm_darwin_amd64.s

@@ -1,29 +0,0 @@
-// Copyright 2009 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System call support for AMD64, Darwin
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-56
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-104
-	JMP	syscall·Syscall9(SB)
-
-TEXT	·RawSyscall(SB),NOSPLIT,$0-56
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·RawSyscall6(SB)

vendor/golang.org/x/sys/unix/asm_darwin_arm.s

@@ -1,30 +0,0 @@
-// 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.
-
-// +build !gccgo
-// +build arm,darwin
-
-#include "textflag.h"
-
-//
-// System call support for ARM, Darwin
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-28
-	B	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	B	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	B	syscall·Syscall9(SB)
-
-TEXT	·RawSyscall(SB),NOSPLIT,$0-28
-	B	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	B	syscall·RawSyscall6(SB)

vendor/golang.org/x/sys/unix/asm_darwin_arm64.s

@@ -1,30 +0,0 @@
-// 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.
-
-// +build !gccgo
-// +build arm64,darwin
-
-#include "textflag.h"
-
-//
-// System call support for AMD64, Darwin
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-56
-	B	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	B	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-104
-	B	syscall·Syscall9(SB)
-
-TEXT	·RawSyscall(SB),NOSPLIT,$0-56
-	B	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	B	syscall·RawSyscall6(SB)

vendor/golang.org/x/sys/unix/asm_dragonfly_amd64.s

@@ -1,29 +0,0 @@
-// Copyright 2009 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System call support for AMD64, DragonFly
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-64
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-88
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-112
-	JMP	syscall·Syscall9(SB)
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-64
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-88
-	JMP	syscall·RawSyscall6(SB)

vendor/golang.org/x/sys/unix/asm_freebsd_386.s

@@ -1,29 +0,0 @@
-// Copyright 2009 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System call support for 386, FreeBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-28
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	JMP	syscall·Syscall9(SB)
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	JMP	syscall·RawSyscall6(SB)

vendor/golang.org/x/sys/unix/asm_freebsd_amd64.s

@@ -1,29 +0,0 @@
-// Copyright 2009 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System call support for AMD64, FreeBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-56
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-104
-	JMP	syscall·Syscall9(SB)
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-56
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·RawSyscall6(SB)

vendor/golang.org/x/sys/unix/asm_freebsd_arm.s

@@ -1,29 +0,0 @@
-// Copyright 2012 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System call support for ARM, FreeBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-28
-	B	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	B	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	B	syscall·Syscall9(SB)
-
-TEXT	·RawSyscall(SB),NOSPLIT,$0-28
-	B	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	B	syscall·RawSyscall6(SB)

vendor/golang.org/x/sys/unix/asm_linux_386.s

@@ -1,65 +0,0 @@
-// Copyright 2009 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System calls for 386, Linux
-//
-
-// See ../runtime/sys_linux_386.s for the reason why we always use int 0x80
-// instead of the glibc-specific "CALL 0x10(GS)".
-#define INVOKE_SYSCALL	INT	$0x80
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT ·Syscall(SB),NOSPLIT,$0-28
-	JMP	syscall·Syscall(SB)
-
-TEXT ·Syscall6(SB),NOSPLIT,$0-40
-	JMP	syscall·Syscall6(SB)
-
-TEXT ·SyscallNoError(SB),NOSPLIT,$0-24
-	CALL	runtime·entersyscall(SB)
-	MOVL	trap+0(FP), AX  // syscall entry
-	MOVL	a1+4(FP), BX
-	MOVL	a2+8(FP), CX
-	MOVL	a3+12(FP), DX
-	MOVL	$0, SI
-	MOVL	$0, DI
-	INVOKE_SYSCALL
-	MOVL	AX, r1+16(FP)
-	MOVL	DX, r2+20(FP)
-	CALL	runtime·exitsyscall(SB)
-	RET
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-	JMP	syscall·RawSyscall(SB)
-
-TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
-	JMP	syscall·RawSyscall6(SB)
-
-TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24
-	MOVL	trap+0(FP), AX  // syscall entry
-	MOVL	a1+4(FP), BX
-	MOVL	a2+8(FP), CX
-	MOVL	a3+12(FP), DX
-	MOVL	$0, SI
-	MOVL	$0, DI
-	INVOKE_SYSCALL
-	MOVL	AX, r1+16(FP)
-	MOVL	DX, r2+20(FP)
-	RET
-
-TEXT ·socketcall(SB),NOSPLIT,$0-36
-	JMP	syscall·socketcall(SB)
-
-TEXT ·rawsocketcall(SB),NOSPLIT,$0-36
-	JMP	syscall·rawsocketcall(SB)
-
-TEXT ·seek(SB),NOSPLIT,$0-28
-	JMP	syscall·seek(SB)

vendor/golang.org/x/sys/unix/asm_linux_amd64.s

@@ -1,57 +0,0 @@
-// Copyright 2009 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System calls for AMD64, Linux
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT ·Syscall(SB),NOSPLIT,$0-56
-	JMP	syscall·Syscall(SB)
-
-TEXT ·Syscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·Syscall6(SB)
-
-TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
-	CALL	runtime·entersyscall(SB)
-	MOVQ	a1+8(FP), DI
-	MOVQ	a2+16(FP), SI
-	MOVQ	a3+24(FP), DX
-	MOVQ	$0, R10
-	MOVQ	$0, R8
-	MOVQ	$0, R9
-	MOVQ	trap+0(FP), AX	// syscall entry
-	SYSCALL
-	MOVQ	AX, r1+32(FP)
-	MOVQ	DX, r2+40(FP)
-	CALL	runtime·exitsyscall(SB)
-	RET
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-56
-	JMP	syscall·RawSyscall(SB)
-
-TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·RawSyscall6(SB)
-
-TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
-	MOVQ	a1+8(FP), DI
-	MOVQ	a2+16(FP), SI
-	MOVQ	a3+24(FP), DX
-	MOVQ	$0, R10
-	MOVQ	$0, R8
-	MOVQ	$0, R9
-	MOVQ	trap+0(FP), AX	// syscall entry
-	SYSCALL
-	MOVQ	AX, r1+32(FP)
-	MOVQ	DX, r2+40(FP)
-	RET
-
-TEXT ·gettimeofday(SB),NOSPLIT,$0-16
-	JMP	syscall·gettimeofday(SB)

vendor/golang.org/x/sys/unix/asm_linux_arm.s

@@ -1,56 +0,0 @@
-// Copyright 2009 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System calls for arm, Linux
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT ·Syscall(SB),NOSPLIT,$0-28
-	B	syscall·Syscall(SB)
-
-TEXT ·Syscall6(SB),NOSPLIT,$0-40
-	B	syscall·Syscall6(SB)
-
-TEXT ·SyscallNoError(SB),NOSPLIT,$0-24
-	BL	runtime·entersyscall(SB)
-	MOVW	trap+0(FP), R7
-	MOVW	a1+4(FP), R0
-	MOVW	a2+8(FP), R1
-	MOVW	a3+12(FP), R2
-	MOVW	$0, R3
-	MOVW	$0, R4
-	MOVW	$0, R5
-	SWI	$0
-	MOVW	R0, r1+16(FP)
-	MOVW	$0, R0
-	MOVW	R0, r2+20(FP)
-	BL	runtime·exitsyscall(SB)
-	RET
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-	B	syscall·RawSyscall(SB)
-
-TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
-	B	syscall·RawSyscall6(SB)
-
-TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24
-	MOVW	trap+0(FP), R7	// syscall entry
-	MOVW	a1+4(FP), R0
-	MOVW	a2+8(FP), R1
-	MOVW	a3+12(FP), R2
-	SWI	$0
-	MOVW	R0, r1+16(FP)
-	MOVW	$0, R0
-	MOVW	R0, r2+20(FP)
-	RET
-
-TEXT ·seek(SB),NOSPLIT,$0-28
-	B	syscall·seek(SB)

vendor/golang.org/x/sys/unix/asm_linux_arm64.s

@@ -1,52 +0,0 @@
-// 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.
-
-// +build linux
-// +build arm64
-// +build !gccgo
-
-#include "textflag.h"
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT ·Syscall(SB),NOSPLIT,$0-56
-	B	syscall·Syscall(SB)
-
-TEXT ·Syscall6(SB),NOSPLIT,$0-80
-	B	syscall·Syscall6(SB)
-
-TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
-	BL	runtime·entersyscall(SB)
-	MOVD	a1+8(FP), R0
-	MOVD	a2+16(FP), R1
-	MOVD	a3+24(FP), R2
-	MOVD	$0, R3
-	MOVD	$0, R4
-	MOVD	$0, R5
-	MOVD	trap+0(FP), R8	// syscall entry
-	SVC
-	MOVD	R0, r1+32(FP)	// r1
-	MOVD	R1, r2+40(FP)	// r2
-	BL	runtime·exitsyscall(SB)
-	RET
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-56
-	B	syscall·RawSyscall(SB)
-
-TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
-	B	syscall·RawSyscall6(SB)
-
-TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
-	MOVD	a1+8(FP), R0
-	MOVD	a2+16(FP), R1
-	MOVD	a3+24(FP), R2
-	MOVD	$0, R3
-	MOVD	$0, R4
-	MOVD	$0, R5
-	MOVD	trap+0(FP), R8	// syscall entry
-	SVC
-	MOVD	R0, r1+32(FP)
-	MOVD	R1, r2+40(FP)
-	RET

vendor/golang.org/x/sys/unix/asm_linux_mips64x.s

@@ -1,56 +0,0 @@
-// 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.
-
-// +build linux
-// +build mips64 mips64le
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System calls for mips64, Linux
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT ·Syscall(SB),NOSPLIT,$0-56
-	JMP	syscall·Syscall(SB)
-
-TEXT ·Syscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·Syscall6(SB)
-
-TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
-	JAL	runtime·entersyscall(SB)
-	MOVV	a1+8(FP), R4
-	MOVV	a2+16(FP), R5
-	MOVV	a3+24(FP), R6
-	MOVV	R0, R7
-	MOVV	R0, R8
-	MOVV	R0, R9
-	MOVV	trap+0(FP), R2	// syscall entry
-	SYSCALL
-	MOVV	R2, r1+32(FP)
-	MOVV	R3, r2+40(FP)
-	JAL	runtime·exitsyscall(SB)
-	RET
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-56
-	JMP	syscall·RawSyscall(SB)
-
-TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·RawSyscall6(SB)
-
-TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
-	MOVV	a1+8(FP), R4
-	MOVV	a2+16(FP), R5
-	MOVV	a3+24(FP), R6
-	MOVV	R0, R7
-	MOVV	R0, R8
-	MOVV	R0, R9
-	MOVV	trap+0(FP), R2	// syscall entry
-	SYSCALL
-	MOVV	R2, r1+32(FP)
-	MOVV	R3, r2+40(FP)
-	RET

vendor/golang.org/x/sys/unix/asm_linux_mipsx.s

@@ -1,54 +0,0 @@
-// Copyright 2016 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.
-
-// +build linux
-// +build mips mipsle
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System calls for mips, Linux
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT ·Syscall(SB),NOSPLIT,$0-28
-	JMP syscall·Syscall(SB)
-
-TEXT ·Syscall6(SB),NOSPLIT,$0-40
-	JMP syscall·Syscall6(SB)
-
-TEXT ·Syscall9(SB),NOSPLIT,$0-52
-	JMP syscall·Syscall9(SB)
-
-TEXT ·SyscallNoError(SB),NOSPLIT,$0-24
-	JAL	runtime·entersyscall(SB)
-	MOVW	a1+4(FP), R4
-	MOVW	a2+8(FP), R5
-	MOVW	a3+12(FP), R6
-	MOVW	R0, R7
-	MOVW	trap+0(FP), R2	// syscall entry
-	SYSCALL
-	MOVW	R2, r1+16(FP)	// r1
-	MOVW	R3, r2+20(FP)	// r2
-	JAL	runtime·exitsyscall(SB)
-	RET
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-	JMP syscall·RawSyscall(SB)
-
-TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
-	JMP syscall·RawSyscall6(SB)
-
-TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24
-	MOVW	a1+4(FP), R4
-	MOVW	a2+8(FP), R5
-	MOVW	a3+12(FP), R6
-	MOVW	trap+0(FP), R2	// syscall entry
-	SYSCALL
-	MOVW	R2, r1+16(FP)
-	MOVW	R3, r2+20(FP)
-	RET

vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s

@@ -1,56 +0,0 @@
-// Copyright 2014 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.
-
-// +build linux
-// +build ppc64 ppc64le
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System calls for ppc64, Linux
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT ·Syscall(SB),NOSPLIT,$0-56
-	BR	syscall·Syscall(SB)
-
-TEXT ·Syscall6(SB),NOSPLIT,$0-80
-	BR	syscall·Syscall6(SB)
-
-TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
-	BL	runtime·entersyscall(SB)
-	MOVD	a1+8(FP), R3
-	MOVD	a2+16(FP), R4
-	MOVD	a3+24(FP), R5
-	MOVD	R0, R6
-	MOVD	R0, R7
-	MOVD	R0, R8
-	MOVD	trap+0(FP), R9	// syscall entry
-	SYSCALL R9
-	MOVD	R3, r1+32(FP)
-	MOVD	R4, r2+40(FP)
-	BL	runtime·exitsyscall(SB)
-	RET
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-56
-	BR	syscall·RawSyscall(SB)
-
-TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
-	BR	syscall·RawSyscall6(SB)
-
-TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
-	MOVD	a1+8(FP), R3
-	MOVD	a2+16(FP), R4
-	MOVD	a3+24(FP), R5
-	MOVD	R0, R6
-	MOVD	R0, R7
-	MOVD	R0, R8
-	MOVD	trap+0(FP), R9	// syscall entry
-	SYSCALL R9
-	MOVD	R3, r1+32(FP)
-	MOVD	R4, r2+40(FP)
-	RET

vendor/golang.org/x/sys/unix/asm_linux_s390x.s

@@ -1,56 +0,0 @@
-// Copyright 2016 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.
-
-// +build s390x
-// +build linux
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System calls for s390x, Linux
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT ·Syscall(SB),NOSPLIT,$0-56
-	BR	syscall·Syscall(SB)
-
-TEXT ·Syscall6(SB),NOSPLIT,$0-80
-	BR	syscall·Syscall6(SB)
-
-TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
-	BL	runtime·entersyscall(SB)
-	MOVD	a1+8(FP), R2
-	MOVD	a2+16(FP), R3
-	MOVD	a3+24(FP), R4
-	MOVD	$0, R5
-	MOVD	$0, R6
-	MOVD	$0, R7
-	MOVD	trap+0(FP), R1	// syscall entry
-	SYSCALL
-	MOVD	R2, r1+32(FP)
-	MOVD	R3, r2+40(FP)
-	BL	runtime·exitsyscall(SB)
-	RET
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-56
-	BR	syscall·RawSyscall(SB)
-
-TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
-	BR	syscall·RawSyscall6(SB)
-
-TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
-	MOVD	a1+8(FP), R2
-	MOVD	a2+16(FP), R3
-	MOVD	a3+24(FP), R4
-	MOVD	$0, R5
-	MOVD	$0, R6
-	MOVD	$0, R7
-	MOVD	trap+0(FP), R1	// syscall entry
-	SYSCALL
-	MOVD	R2, r1+32(FP)
-	MOVD	R3, r2+40(FP)
-	RET

vendor/golang.org/x/sys/unix/asm_netbsd_386.s

@@ -1,29 +0,0 @@
-// Copyright 2009 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System call support for 386, NetBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-28
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	JMP	syscall·Syscall9(SB)
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	JMP	syscall·RawSyscall6(SB)

vendor/golang.org/x/sys/unix/asm_netbsd_amd64.s

@@ -1,29 +0,0 @@
-// Copyright 2009 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System call support for AMD64, NetBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-56
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-104
-	JMP	syscall·Syscall9(SB)
-
-TEXT	·RawSyscall(SB),NOSPLIT,$0-56
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·RawSyscall6(SB)

vendor/golang.org/x/sys/unix/asm_netbsd_arm.s

@@ -1,29 +0,0 @@
-// Copyright 2013 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System call support for ARM, NetBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-28
-	B	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	B	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	B	syscall·Syscall9(SB)
-
-TEXT	·RawSyscall(SB),NOSPLIT,$0-28
-	B	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	B	syscall·RawSyscall6(SB)

vendor/golang.org/x/sys/unix/asm_openbsd_386.s

@@ -1,29 +0,0 @@
-// Copyright 2009 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System call support for 386, OpenBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-28
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	JMP	syscall·Syscall9(SB)
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	JMP	syscall·RawSyscall6(SB)

vendor/golang.org/x/sys/unix/asm_openbsd_amd64.s

@@ -1,29 +0,0 @@
-// Copyright 2009 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System call support for AMD64, OpenBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-56
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-104
-	JMP	syscall·Syscall9(SB)
-
-TEXT	·RawSyscall(SB),NOSPLIT,$0-56
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·RawSyscall6(SB)

vendor/golang.org/x/sys/unix/asm_openbsd_arm.s

@@ -1,29 +0,0 @@
-// Copyright 2017 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System call support for ARM, OpenBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-28
-	B	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	B	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	B	syscall·Syscall9(SB)
-
-TEXT	·RawSyscall(SB),NOSPLIT,$0-28
-	B	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	B	syscall·RawSyscall6(SB)

vendor/golang.org/x/sys/unix/asm_solaris_amd64.s

@@ -1,17 +0,0 @@
-// Copyright 2014 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System calls for amd64, Solaris are implemented in runtime/syscall_solaris.go
-//
-
-TEXT ·sysvicall6(SB),NOSPLIT,$0-88
-	JMP	syscall·sysvicall6(SB)
-
-TEXT ·rawSysvicall6(SB),NOSPLIT,$0-88
-	JMP	syscall·rawSysvicall6(SB)

vendor/golang.org/x/sys/unix/bluetooth_linux.go

@@ -1,35 +0,0 @@
-// Copyright 2016 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.
-
-// Bluetooth sockets and messages
-
-package unix
-
-// Bluetooth Protocols
-const (
-	BTPROTO_L2CAP  = 0
-	BTPROTO_HCI    = 1
-	BTPROTO_SCO    = 2
-	BTPROTO_RFCOMM = 3
-	BTPROTO_BNEP   = 4
-	BTPROTO_CMTP   = 5
-	BTPROTO_HIDP   = 6
-	BTPROTO_AVDTP  = 7
-)
-
-const (
-	HCI_CHANNEL_RAW     = 0
-	HCI_CHANNEL_USER    = 1
-	HCI_CHANNEL_MONITOR = 2
-	HCI_CHANNEL_CONTROL = 3
-)
-
-// Socketoption Level
-const (
-	SOL_BLUETOOTH = 0x112
-	SOL_HCI       = 0x0
-	SOL_L2CAP     = 0x6
-	SOL_RFCOMM    = 0x12
-	SOL_SCO       = 0x11
-)

vendor/golang.org/x/sys/unix/cap_freebsd.go

@@ -1,195 +0,0 @@
-// Copyright 2017 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.
-
-// +build freebsd
-
-package unix
-
-import (
-	errorspkg "errors"
-	"fmt"
-)
-
-// Go implementation of C mostly found in /usr/src/sys/kern/subr_capability.c
-
-const (
-	// This is the version of CapRights this package understands. See C implementation for parallels.
-	capRightsGoVersion = CAP_RIGHTS_VERSION_00
-	capArSizeMin       = CAP_RIGHTS_VERSION_00 + 2
-	capArSizeMax       = capRightsGoVersion + 2
-)
-
-var (
-	bit2idx = []int{
-		-1, 0, 1, -1, 2, -1, -1, -1, 3, -1, -1, -1, -1, -1, -1, -1,
-		4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	}
-)
-
-func capidxbit(right uint64) int {
-	return int((right >> 57) & 0x1f)
-}
-
-func rightToIndex(right uint64) (int, error) {
-	idx := capidxbit(right)
-	if idx < 0 || idx >= len(bit2idx) {
-		return -2, fmt.Errorf("index for right 0x%x out of range", right)
-	}
-	return bit2idx[idx], nil
-}
-
-func caprver(right uint64) int {
-	return int(right >> 62)
-}
-
-func capver(rights *CapRights) int {
-	return caprver(rights.Rights[0])
-}
-
-func caparsize(rights *CapRights) int {
-	return capver(rights) + 2
-}
-
-// CapRightsSet sets the permissions in setrights in rights.
-func CapRightsSet(rights *CapRights, setrights []uint64) error {
-	// This is essentially a copy of cap_rights_vset()
-	if capver(rights) != CAP_RIGHTS_VERSION_00 {
-		return fmt.Errorf("bad rights version %d", capver(rights))
-	}
-
-	n := caparsize(rights)
-	if n < capArSizeMin || n > capArSizeMax {
-		return errorspkg.New("bad rights size")
-	}
-
-	for _, right := range setrights {
-		if caprver(right) != CAP_RIGHTS_VERSION_00 {
-			return errorspkg.New("bad right version")
-		}
-		i, err := rightToIndex(right)
-		if err != nil {
-			return err
-		}
-		if i >= n {
-			return errorspkg.New("index overflow")
-		}
-		if capidxbit(rights.Rights[i]) != capidxbit(right) {
-			return errorspkg.New("index mismatch")
-		}
-		rights.Rights[i] |= right
-		if capidxbit(rights.Rights[i]) != capidxbit(right) {
-			return errorspkg.New("index mismatch (after assign)")
-		}
-	}
-
-	return nil
-}
-
-// CapRightsClear clears the permissions in clearrights from rights.
-func CapRightsClear(rights *CapRights, clearrights []uint64) error {
-	// This is essentially a copy of cap_rights_vclear()
-	if capver(rights) != CAP_RIGHTS_VERSION_00 {
-		return fmt.Errorf("bad rights version %d", capver(rights))
-	}
-
-	n := caparsize(rights)
-	if n < capArSizeMin || n > capArSizeMax {
-		return errorspkg.New("bad rights size")
-	}
-
-	for _, right := range clearrights {
-		if caprver(right) != CAP_RIGHTS_VERSION_00 {
-			return errorspkg.New("bad right version")
-		}
-		i, err := rightToIndex(right)
-		if err != nil {
-			return err
-		}
-		if i >= n {
-			return errorspkg.New("index overflow")
-		}
-		if capidxbit(rights.Rights[i]) != capidxbit(right) {
-			return errorspkg.New("index mismatch")
-		}
-		rights.Rights[i] &= ^(right & 0x01FFFFFFFFFFFFFF)
-		if capidxbit(rights.Rights[i]) != capidxbit(right) {
-			return errorspkg.New("index mismatch (after assign)")
-		}
-	}
-
-	return nil
-}
-
-// CapRightsIsSet checks whether all the permissions in setrights are present in rights.
-func CapRightsIsSet(rights *CapRights, setrights []uint64) (bool, error) {
-	// This is essentially a copy of cap_rights_is_vset()
-	if capver(rights) != CAP_RIGHTS_VERSION_00 {
-		return false, fmt.Errorf("bad rights version %d", capver(rights))
-	}
-
-	n := caparsize(rights)
-	if n < capArSizeMin || n > capArSizeMax {
-		return false, errorspkg.New("bad rights size")
-	}
-
-	for _, right := range setrights {
-		if caprver(right) != CAP_RIGHTS_VERSION_00 {
-			return false, errorspkg.New("bad right version")
-		}
-		i, err := rightToIndex(right)
-		if err != nil {
-			return false, err
-		}
-		if i >= n {
-			return false, errorspkg.New("index overflow")
-		}
-		if capidxbit(rights.Rights[i]) != capidxbit(right) {
-			return false, errorspkg.New("index mismatch")
-		}
-		if (rights.Rights[i] & right) != right {
-			return false, nil
-		}
-	}
-
-	return true, nil
-}
-
-func capright(idx uint64, bit uint64) uint64 {
-	return ((1 << (57 + idx)) | bit)
-}
-
-// CapRightsInit returns a pointer to an initialised CapRights structure filled with rights.
-// See man cap_rights_init(3) and rights(4).
-func CapRightsInit(rights []uint64) (*CapRights, error) {
-	var r CapRights
-	r.Rights[0] = (capRightsGoVersion << 62) | capright(0, 0)
-	r.Rights[1] = capright(1, 0)
-
-	err := CapRightsSet(&r, rights)
-	if err != nil {
-		return nil, err
-	}
-	return &r, nil
-}
-
-// CapRightsLimit reduces the operations permitted on fd to at most those contained in rights.
-// The capability rights on fd can never be increased by CapRightsLimit.
-// See man cap_rights_limit(2) and rights(4).
-func CapRightsLimit(fd uintptr, rights *CapRights) error {
-	return capRightsLimit(int(fd), rights)
-}
-
-// CapRightsGet returns a CapRights structure containing the operations permitted on fd.
-// See man cap_rights_get(3) and rights(4).
-func CapRightsGet(fd uintptr) (*CapRights, error) {
-	r, err := CapRightsInit(nil)
-	if err != nil {
-		return nil, err
-	}
-	err = capRightsGet(capRightsGoVersion, int(fd), r)
-	if err != nil {
-		return nil, err
-	}
-	return r, nil
-}

vendor/golang.org/x/sys/unix/constants.go

@@ -1,13 +0,0 @@
-// 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.
-
-// +build darwin dragonfly freebsd linux netbsd openbsd solaris
-
-package unix
-
-const (
-	R_OK = 0x4
-	W_OK = 0x2
-	X_OK = 0x1
-)

vendor/golang.org/x/sys/unix/creds_test.go

@@ -1,152 +0,0 @@
-// Copyright 2012 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.
-
-// +build linux
-
-package unix_test
-
-import (
-	"bytes"
-	"go/build"
-	"net"
-	"os"
-	"syscall"
-	"testing"
-
-	"golang.org/x/sys/unix"
-)
-
-// TestSCMCredentials tests the sending and receiving of credentials
-// (PID, UID, GID) in an ancillary message between two UNIX
-// sockets. The SO_PASSCRED socket option is enabled on the sending
-// socket for this to work.
-func TestSCMCredentials(t *testing.T) {
-	socketTypeTests := []struct {
-		socketType int
-		dataLen    int
-	}{
-		{
-			unix.SOCK_STREAM,
-			1,
-		}, {
-			unix.SOCK_DGRAM,
-			0,
-		},
-	}
-
-	for _, tt := range socketTypeTests {
-		if tt.socketType == unix.SOCK_DGRAM && !atLeast1p10() {
-			t.Log("skipping DGRAM test on pre-1.10")
-			continue
-		}
-
-		fds, err := unix.Socketpair(unix.AF_LOCAL, tt.socketType, 0)
-		if err != nil {
-			t.Fatalf("Socketpair: %v", err)
-		}
-		defer unix.Close(fds[0])
-		defer unix.Close(fds[1])
-
-		err = unix.SetsockoptInt(fds[0], unix.SOL_SOCKET, unix.SO_PASSCRED, 1)
-		if err != nil {
-			t.Fatalf("SetsockoptInt: %v", err)
-		}
-
-		srvFile := os.NewFile(uintptr(fds[0]), "server")
-		defer srvFile.Close()
-		srv, err := net.FileConn(srvFile)
-		if err != nil {
-			t.Errorf("FileConn: %v", err)
-			return
-		}
-		defer srv.Close()
-
-		cliFile := os.NewFile(uintptr(fds[1]), "client")
-		defer cliFile.Close()
-		cli, err := net.FileConn(cliFile)
-		if err != nil {
-			t.Errorf("FileConn: %v", err)
-			return
-		}
-		defer cli.Close()
-
-		var ucred unix.Ucred
-		if os.Getuid() != 0 {
-			ucred.Pid = int32(os.Getpid())
-			ucred.Uid = 0
-			ucred.Gid = 0
-			oob := unix.UnixCredentials(&ucred)
-			_, _, err := cli.(*net.UnixConn).WriteMsgUnix(nil, oob, nil)
-			if op, ok := err.(*net.OpError); ok {
-				err = op.Err
-			}
-			if sys, ok := err.(*os.SyscallError); ok {
-				err = sys.Err
-			}
-			if err != syscall.EPERM {
-				t.Fatalf("WriteMsgUnix failed with %v, want EPERM", err)
-			}
-		}
-
-		ucred.Pid = int32(os.Getpid())
-		ucred.Uid = uint32(os.Getuid())
-		ucred.Gid = uint32(os.Getgid())
-		oob := unix.UnixCredentials(&ucred)
-
-		// On SOCK_STREAM, this is internally going to send a dummy byte
-		n, oobn, err := cli.(*net.UnixConn).WriteMsgUnix(nil, oob, nil)
-		if err != nil {
-			t.Fatalf("WriteMsgUnix: %v", err)
-		}
-		if n != 0 {
-			t.Fatalf("WriteMsgUnix n = %d, want 0", n)
-		}
-		if oobn != len(oob) {
-			t.Fatalf("WriteMsgUnix oobn = %d, want %d", oobn, len(oob))
-		}
-
-		oob2 := make([]byte, 10*len(oob))
-		n, oobn2, flags, _, err := srv.(*net.UnixConn).ReadMsgUnix(nil, oob2)
-		if err != nil {
-			t.Fatalf("ReadMsgUnix: %v", err)
-		}
-		if flags != 0 {
-			t.Fatalf("ReadMsgUnix flags = 0x%x, want 0", flags)
-		}
-		if n != tt.dataLen {
-			t.Fatalf("ReadMsgUnix n = %d, want %d", n, tt.dataLen)
-		}
-		if oobn2 != oobn {
-			// without SO_PASSCRED set on the socket, ReadMsgUnix will
-			// return zero oob bytes
-			t.Fatalf("ReadMsgUnix oobn = %d, want %d", oobn2, oobn)
-		}
-		oob2 = oob2[:oobn2]
-		if !bytes.Equal(oob, oob2) {
-			t.Fatal("ReadMsgUnix oob bytes don't match")
-		}
-
-		scm, err := unix.ParseSocketControlMessage(oob2)
-		if err != nil {
-			t.Fatalf("ParseSocketControlMessage: %v", err)
-		}
-		newUcred, err := unix.ParseUnixCredentials(&scm[0])
-		if err != nil {
-			t.Fatalf("ParseUnixCredentials: %v", err)
-		}
-		if *newUcred != ucred {
-			t.Fatalf("ParseUnixCredentials = %+v, want %+v", newUcred, ucred)
-		}
-	}
-}
-
-// atLeast1p10 reports whether we are running on Go 1.10 or later.
-func atLeast1p10() bool {
-	for _, ver := range build.Default.ReleaseTags {
-		if ver == "go1.10" {
-			return true
-		}
-	}
-	return false
-}

vendor/golang.org/x/sys/unix/dev_darwin.go

@@ -1,24 +0,0 @@
-// Copyright 2017 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.
-
-// Functions to access/create device major and minor numbers matching the
-// encoding used in Darwin's sys/types.h header.
-
-package unix
-
-// Major returns the major component of a Darwin device number.
-func Major(dev uint64) uint32 {
-	return uint32((dev >> 24) & 0xff)
-}
-
-// Minor returns the minor component of a Darwin device number.
-func Minor(dev uint64) uint32 {
-	return uint32(dev & 0xffffff)
-}
-
-// Mkdev returns a Darwin device number generated from the given major and minor
-// components.
-func Mkdev(major, minor uint32) uint64 {
-	return (uint64(major) << 24) | uint64(minor)
-}

vendor/golang.org/x/sys/unix/dev_darwin_test.go

@@ -1,51 +0,0 @@
-// Copyright 2017 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.
-
-// +build go1.7
-
-package unix_test
-
-import (
-	"fmt"
-	"testing"
-
-	"golang.org/x/sys/unix"
-)
-
-func TestDevices(t *testing.T) {
-	testCases := []struct {
-		path  string
-		major uint32
-		minor uint32
-	}{
-		// Most of the device major/minor numbers on Darwin are
-		// dynamically generated by devfs. These are some well-known
-		// static numbers.
-		{"/dev/ttyp0", 4, 0},
-		{"/dev/ttys0", 4, 48},
-		{"/dev/ptyp0", 5, 0},
-		{"/dev/ptyr0", 5, 32},
-	}
-	for _, tc := range testCases {
-		t.Run(fmt.Sprintf("%s %v:%v", tc.path, tc.major, tc.minor), func(t *testing.T) {
-			var stat unix.Stat_t
-			err := unix.Stat(tc.path, &stat)
-			if err != nil {
-				t.Errorf("failed to stat device: %v", err)
-				return
-			}
-
-			dev := uint64(stat.Rdev)
-			if unix.Major(dev) != tc.major {
-				t.Errorf("for %s Major(%#x) == %d, want %d", tc.path, dev, unix.Major(dev), tc.major)
-			}
-			if unix.Minor(dev) != tc.minor {
-				t.Errorf("for %s Minor(%#x) == %d, want %d", tc.path, dev, unix.Minor(dev), tc.minor)
-			}
-			if unix.Mkdev(tc.major, tc.minor) != dev {
-				t.Errorf("for %s Mkdev(%d, %d) == %#x, want %#x", tc.path, tc.major, tc.minor, unix.Mkdev(tc.major, tc.minor), dev)
-			}
-		})
-	}
-}

vendor/golang.org/x/sys/unix/dev_dragonfly.go

@@ -1,30 +0,0 @@
-// Copyright 2017 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.
-
-// Functions to access/create device major and minor numbers matching the
-// encoding used in Dragonfly's sys/types.h header.
-//
-// The information below is extracted and adapted from sys/types.h:
-//
-// Minor gives a cookie instead of an index since in order to avoid changing the
-// meanings of bits 0-15 or wasting time and space shifting bits 16-31 for
-// devices that don't use them.
-
-package unix
-
-// Major returns the major component of a DragonFlyBSD device number.
-func Major(dev uint64) uint32 {
-	return uint32((dev >> 8) & 0xff)
-}
-
-// Minor returns the minor component of a DragonFlyBSD device number.
-func Minor(dev uint64) uint32 {
-	return uint32(dev & 0xffff00ff)
-}
-
-// Mkdev returns a DragonFlyBSD device number generated from the given major and
-// minor components.
-func Mkdev(major, minor uint32) uint64 {
-	return (uint64(major) << 8) | uint64(minor)
-}

vendor/golang.org/x/sys/unix/dev_dragonfly_test.go

@@ -1,50 +0,0 @@
-// Copyright 2017 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.
-
-// +build go1.7
-
-package unix_test
-
-import (
-	"fmt"
-	"testing"
-
-	"golang.org/x/sys/unix"
-)
-
-func TestDevices(t *testing.T) {
-	testCases := []struct {
-		path  string
-		major uint32
-		minor uint32
-	}{
-		// Minor is a cookie instead of an index on DragonFlyBSD
-		{"/dev/null", 10, 0x00000002},
-		{"/dev/random", 10, 0x00000003},
-		{"/dev/urandom", 10, 0x00000004},
-		{"/dev/zero", 10, 0x0000000c},
-		{"/dev/bpf", 15, 0xffff00ff},
-	}
-	for _, tc := range testCases {
-		t.Run(fmt.Sprintf("%s %v:%v", tc.path, tc.major, tc.minor), func(t *testing.T) {
-			var stat unix.Stat_t
-			err := unix.Stat(tc.path, &stat)
-			if err != nil {
-				t.Errorf("failed to stat device: %v", err)
-				return
-			}
-
-			dev := uint64(stat.Rdev)
-			if unix.Major(dev) != tc.major {
-				t.Errorf("for %s Major(%#x) == %d, want %d", tc.path, dev, unix.Major(dev), tc.major)
-			}
-			if unix.Minor(dev) != tc.minor {
-				t.Errorf("for %s Minor(%#x) == %d, want %d", tc.path, dev, unix.Minor(dev), tc.minor)
-			}
-			if unix.Mkdev(tc.major, tc.minor) != dev {
-				t.Errorf("for %s Mkdev(%d, %d) == %#x, want %#x", tc.path, tc.major, tc.minor, unix.Mkdev(tc.major, tc.minor), dev)
-			}
-		})
-	}
-}

vendor/golang.org/x/sys/unix/dev_freebsd.go

@@ -1,30 +0,0 @@
-// Copyright 2017 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.
-
-// Functions to access/create device major and minor numbers matching the
-// encoding used in FreeBSD's sys/types.h header.
-//
-// The information below is extracted and adapted from sys/types.h:
-//
-// Minor gives a cookie instead of an index since in order to avoid changing the
-// meanings of bits 0-15 or wasting time and space shifting bits 16-31 for
-// devices that don't use them.
-
-package unix
-
-// Major returns the major component of a FreeBSD device number.
-func Major(dev uint64) uint32 {
-	return uint32((dev >> 8) & 0xff)
-}
-
-// Minor returns the minor component of a FreeBSD device number.
-func Minor(dev uint64) uint32 {
-	return uint32(dev & 0xffff00ff)
-}
-
-// Mkdev returns a FreeBSD device number generated from the given major and
-// minor components.
-func Mkdev(major, minor uint32) uint64 {
-	return (uint64(major) << 8) | uint64(minor)
-}

vendor/golang.org/x/sys/unix/dev_linux.go

@@ -1,42 +0,0 @@
-// Copyright 2017 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.
-
-// Functions to access/create device major and minor numbers matching the
-// encoding used by the Linux kernel and glibc.
-//
-// The information below is extracted and adapted from bits/sysmacros.h in the
-// glibc sources:
-//
-// dev_t in glibc is 64-bit, with 32-bit major and minor numbers. glibc's
-// default encoding is MMMM Mmmm mmmM MMmm, where M is a hex digit of the major
-// number and m is a hex digit of the minor number. This is backward compatible
-// with legacy systems where dev_t is 16 bits wide, encoded as MMmm. It is also
-// backward compatible with the Linux kernel, which for some architectures uses
-// 32-bit dev_t, encoded as mmmM MMmm.
-
-package unix
-
-// Major returns the major component of a Linux device number.
-func Major(dev uint64) uint32 {
-	major := uint32((dev & 0x00000000000fff00) >> 8)
-	major |= uint32((dev & 0xfffff00000000000) >> 32)
-	return major
-}
-
-// Minor returns the minor component of a Linux device number.
-func Minor(dev uint64) uint32 {
-	minor := uint32((dev & 0x00000000000000ff) >> 0)
-	minor |= uint32((dev & 0x00000ffffff00000) >> 12)
-	return minor
-}
-
-// Mkdev returns a Linux device number generated from the given major and minor
-// components.
-func Mkdev(major, minor uint32) uint64 {
-	dev := (uint64(major) & 0x00000fff) << 8
-	dev |= (uint64(major) & 0xfffff000) << 32
-	dev |= (uint64(minor) & 0x000000ff) << 0
-	dev |= (uint64(minor) & 0xffffff00) << 12
-	return dev
-}