Use mod vendor for vendored directory (backwards compatible)

1 files changed, 0 insertions, 226 deletions

diff --git a/vendor/golang.org/x/text/internal/gen/bitfield/bitfield.go b/vendor/golang.org/x/text/internal/gen/bitfield/bitfield.go
deleted file mode 100644
index a8d0a48d..00000000
--- a/vendor/golang.org/x/text/internal/gen/bitfield/bitfield.go
+++ /dev/null
@@ -1,226 +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.
-
-// Package bitfield converts annotated structs into integer values.
-//
-// Any field that is marked with a bitfield tag is compacted. The tag value has
-// two parts. The part before the comma determines the method name for a
-// generated type. If left blank the name of the field is used.
-// The part after the comma determines the number of bits to use for the
-// representation.
-package bitfield
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"reflect"
-	"strconv"
-	"strings"
-)
-
-// Config determines settings for packing and generation. If a Config is used,
-// the same Config should be used for packing and generation.
-type Config struct {
-	// NumBits fixes the maximum allowed bits for the integer representation.
-	// If NumBits is not 8, 16, 32, or 64, the actual underlying integer size
-	// will be the next largest available.
-	NumBits uint
-
-	// If Package is set, code generation will write a package clause.
-	Package string
-
-	// TypeName is the name for the generated type. By default it is the name
-	// of the type of the value passed to Gen.
-	TypeName string
-}
-
-var nullConfig = &Config{}
-
-// Pack packs annotated bit ranges of struct x in an integer.
-//
-// Only fields that have a "bitfield" tag are compacted.
-func Pack(x interface{}, c *Config) (packed uint64, err error) {
-	packed, _, err = pack(x, c)
-	return
-}
-
-func pack(x interface{}, c *Config) (packed uint64, nBit uint, err error) {
-	if c == nil {
-		c = nullConfig
-	}
-	nBits := c.NumBits
-	v := reflect.ValueOf(x)
-	v = reflect.Indirect(v)
-	t := v.Type()
-	pos := 64 - nBits
-	if nBits == 0 {
-		pos = 0
-	}
-	for i := 0; i < v.NumField(); i++ {
-		v := v.Field(i)
-		field := t.Field(i)
-		f, err := parseField(field)
-
-		if err != nil {
-			return 0, 0, err
-		}
-		if f.nBits == 0 {
-			continue
-		}
-		value := uint64(0)
-		switch v.Kind() {
-		case reflect.Bool:
-			if v.Bool() {
-				value = 1
-			}
-		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			value = v.Uint()
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			x := v.Int()
-			if x < 0 {
-				return 0, 0, fmt.Errorf("bitfield: negative value for field %q not allowed", field.Name)
-			}
-			value = uint64(x)
-		}
-		if value > (1<<f.nBits)-1 {
-			return 0, 0, fmt.Errorf("bitfield: value %#x of field %q does not fit in %d bits", value, field.Name, f.nBits)
-		}
-		shift := 64 - pos - f.nBits
-		if pos += f.nBits; pos > 64 {
-			return 0, 0, fmt.Errorf("bitfield: no more bits left for field %q", field.Name)
-		}
-		packed |= value << shift
-	}
-	if nBits == 0 {
-		nBits = posToBits(pos)
-		packed >>= (64 - nBits)
-	}
-	return packed, nBits, nil
-}
-
-type field struct {
-	name  string
-	value uint64
-	nBits uint
-}
-
-// parseField parses a tag of the form [<name>][:<nBits>][,<pos>[..<end>]]
-func parseField(field reflect.StructField) (f field, err error) {
-	s, ok := field.Tag.Lookup("bitfield")
-	if !ok {
-		return f, nil
-	}
-	switch field.Type.Kind() {
-	case reflect.Bool:
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-	default:
-		return f, fmt.Errorf("bitfield: field %q is not an integer or bool type", field.Name)
-	}
-	bits := s
-	f.name = ""
-
-	if i := strings.IndexByte(s, ','); i >= 0 {
-		bits = s[:i]
-		f.name = s[i+1:]
-	}
-	if bits != "" {
-		nBits, err := strconv.ParseUint(bits, 10, 8)
-		if err != nil {
-			return f, fmt.Errorf("bitfield: invalid bit size for field %q: %v", field.Name, err)
-		}
-		f.nBits = uint(nBits)
-	}
-	if f.nBits == 0 {
-		if field.Type.Kind() == reflect.Bool {
-			f.nBits = 1
-		} else {
-			f.nBits = uint(field.Type.Bits())
-		}
-	}
-	if f.name == "" {
-		f.name = field.Name
-	}
-	return f, err
-}
-
-func posToBits(pos uint) (bits uint) {
-	switch {
-	case pos <= 8:
-		bits = 8
-	case pos <= 16:
-		bits = 16
-	case pos <= 32:
-		bits = 32
-	case pos <= 64:
-		bits = 64
-	default:
-		panic("unreachable")
-	}
-	return bits
-}
-
-// Gen generates code for unpacking integers created with Pack.
-func Gen(w io.Writer, x interface{}, c *Config) error {
-	if c == nil {
-		c = nullConfig
-	}
-	_, nBits, err := pack(x, c)
-	if err != nil {
-		return err
-	}
-
-	t := reflect.TypeOf(x)
-	if t.Kind() == reflect.Ptr {
-		t = t.Elem()
-	}
-	if c.TypeName == "" {
-		c.TypeName = t.Name()
-	}
-	firstChar := []rune(c.TypeName)[0]
-
-	buf := &bytes.Buffer{}
-
-	print := func(w io.Writer, format string, args ...interface{}) {
-		if _, e := fmt.Fprintf(w, format+"\n", args...); e != nil && err == nil {
-			err = fmt.Errorf("bitfield: write failed: %v", err)
-		}
-	}
-
-	pos := uint(0)
-	for i := 0; i < t.NumField(); i++ {
-		field := t.Field(i)
-		f, _ := parseField(field)
-		if f.nBits == 0 {
-			continue
-		}
-		shift := nBits - pos - f.nBits
-		pos += f.nBits
-
-		retType := field.Type.Name()
-		print(buf, "\nfunc (%c %s) %s() %s {", firstChar, c.TypeName, f.name, retType)
-		if field.Type.Kind() == reflect.Bool {
-			print(buf, "\tconst bit = 1 << %d", shift)
-			print(buf, "\treturn %c&bit == bit", firstChar)
-		} else {
-			print(buf, "\treturn %s((%c >> %d) & %#x)", retType, firstChar, shift, (1<<f.nBits)-1)
-		}
-		print(buf, "}")
-	}
-
-	if c.Package != "" {
-		print(w, "// Code generated by golang.org/x/text/internal/gen/bitfield. DO NOT EDIT.\n")
-		print(w, "package %s\n", c.Package)
-	}
-
-	bits := posToBits(pos)
-
-	print(w, "type %s uint%d", c.TypeName, bits)
-
-	if _, err := io.Copy(w, buf); err != nil {
-		return fmt.Errorf("bitfield: write failed: %v", err)
-	}
-	return nil
-}