mirror of
https://github.com/cwinfo/matterbridge.git
synced 2025-07-04 14:47:45 +00:00
Add vendor files for spf13/viper
This commit is contained in:
226
vendor/golang.org/x/text/internal/gen/bitfield/bitfield.go
generated
vendored
Normal file
226
vendor/golang.org/x/text/internal/gen/bitfield/bitfield.go
generated
vendored
Normal file
@ -0,0 +1,226 @@
|
||||
// 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
|
||||
}
|
Reference in New Issue
Block a user