Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 bitfield.go // 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 }	5.45 KB	2025-05-25 12:27
📄 bitfield_test.go // 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 import ( "bytes" "fmt" "os" "testing" ) type myUint8 uint8 type test1 struct { // 28 bits foo uint16 `bitfield:",fob"` Bar int8 `bitfield:"5,baz"` Foo uint64 bar myUint8 `bitfield:"3"` Bool bool `bitfield:""` Baz int8 `bitfield:"3"` } type test2 struct { larger1 uint16 `bitfield:"32"` larger2 uint16 `bitfield:"32"` } type tooManyBits struct { u1 uint16 `bitfield:"12"` u2 uint16 `bitfield:"12"` u3 uint16 `bitfield:"12"` u4 uint16 `bitfield:"12"` u5 uint16 `bitfield:"12"` u6 uint16 `bitfield:"12"` } type just64 struct { foo uint64 `bitfield:""` } type toUint8 struct { foo bool `bitfield:""` } type toUint16 struct { foo int `bitfield:"9"` } type faultySize struct { foo uint64 `bitfield:"a"` } type faultyType struct { foo int `bitfield:"5"` } var ( maxed = test1{ foo: 0xffff, Bar: 0x1f, Foo: 0xffff, bar: 0x7, Bool: true, Baz: 0x7, } alternate1 = test1{ foo: 0xffff, bar: 0x7, Baz: 0x7, } alternate2 = test1{ Bar: 0x1f, Bool: true, } overflow = test1{ Bar: 0x3f, } negative = test1{ Bar: -1, } ) func TestPack(t testing.T) { testCases := []struct { desc string x interface{} nBits uint out uint64 ok bool }{ {"maxed out fields", maxed, 0, 0xfffffff0, true}, {"maxed using less bits", maxed, 28, 0x0fffffff, true}, {"alternate1", alternate1, 0, 0xffff0770, true}, {"alternate2", alternate2, 0, 0x0000f880, true}, {"just64", &just64{0x0f0f0f0f}, 00, 0xf0f0f0f, true}, {"just64", &just64{0x0f0f0f0f}, 64, 0xf0f0f0f, true}, {"just64", &just64{0xffffFFFF}, 64, 0xffffffff, true}, {"to uint8", &toUint8{true}, 0, 0x80, true}, {"to uint16", &toUint16{1}, 0, 0x0080, true}, // errors {"overflow", overflow, 0, 0, false}, {"too many bits", &tooManyBits{}, 0, 0, false}, {"fault size", &faultySize{}, 0, 0, false}, {"fault type", &faultyType{}, 0, 0, false}, {"negative", negative, 0, 0, false}, {"not enough bits", maxed, 27, 0, false}, } for _, tc := range testCases { t.Run(fmt.Sprintf("%T/%s", tc.x, tc.desc), func(t testing.T) { v, err := Pack(tc.x, &Config{NumBits: tc.nBits}) if ok := err == nil; v != tc.out \|\| ok != tc.ok { t.Errorf("got %#x, %v; want %#x, %v (%v)", v, ok, tc.out, tc.ok, err) } }) } } func TestRoundtrip(t testing.T) { testCases := []struct { x test1 }{ {maxed}, {alternate1}, {alternate2}, } for _, tc := range testCases { t.Run("", func(t testing.T) { v, err := Pack(tc.x, nil) if err != nil { t.Fatal(err) } want := tc.x want.Foo = 0 // not stored x := myInt(v) got := test1{ foo: x.fob(), Bar: x.baz(), bar: x.bar(), Bool: x.Bool(), Baz: x.Baz(), } if got != want { t.Errorf("\ngot %#v\nwant %#v (%#x)", got, want, v) } }) } } func TestGen(t testing.T) { testCases := []struct { desc string x interface{} config Config ok bool out string }{{ desc: "test1", x: &test1{}, ok: true, out: test1Gen, }, { desc: "test1 with options", x: &test1{}, config: &Config{Package: "bitfield", TypeName: "myInt"}, ok: true, out: mustRead("gen1_test.go"), }, { desc: "test1 with alternative bits", x: &test1{}, config: &Config{NumBits: 28, Package: "bitfield", TypeName: "myInt2"}, ok: true, out: mustRead("gen2_test.go"), }, { desc: "failure", x: &test1{}, config: &Config{NumBits: 27}, // Too few bits. ok: false, out: "", }} for _, tc := range testCases { t.Run(tc.desc, func(t testing.T) { w := &bytes.Buffer{} err := Gen(w, tc.x, tc.config) if ok := err == nil; ok != tc.ok { t.Fatalf("got %v; want %v (%v)", ok, tc.ok, err) } got := w.String() if got != tc.out { t.Errorf("got:\n%s\nwant:\n%s", got, tc.out) } }) } } const test1Gen = `type test1 uint32 func (t test1) fob() uint16 { return uint16((t >> 16) & 0xffff) } func (t test1) baz() int8 { return int8((t >> 11) & 0x1f) } func (t test1) bar() myUint8 { return myUint8((t >> 8) & 0x7) } func (t test1) Bool() bool { const bit = 1 << 7 return t&bit == bit } func (t test1) Baz() int8 { return int8((t >> 4) & 0x7) } ` func mustRead(filename string) string { b, err := os.ReadFile(filename) if err != nil { panic(err) } return string(b) }	4.41 KB	2025-05-25 12:27
📄 gen1_test.go // Code generated by golang.org/x/text/internal/gen/bitfield. DO NOT EDIT. package bitfield type myInt uint32 func (m myInt) fob() uint16 { return uint16((m >> 16) & 0xffff) } func (m myInt) baz() int8 { return int8((m >> 11) & 0x1f) } func (m myInt) bar() myUint8 { return myUint8((m >> 8) & 0x7) } func (m myInt) Bool() bool { const bit = 1 << 7 return m&bit == bit } func (m myInt) Baz() int8 { return int8((m >> 4) & 0x7) }	441 B	2025-05-25 12:27
📄 gen2_test.go // Code generated by golang.org/x/text/internal/gen/bitfield. DO NOT EDIT. package bitfield type myInt2 uint32 func (m myInt2) fob() uint16 { return uint16((m >> 12) & 0xffff) } func (m myInt2) baz() int8 { return int8((m >> 7) & 0x1f) } func (m myInt2) bar() myUint8 { return myUint8((m >> 4) & 0x7) } func (m myInt2) Bool() bool { const bit = 1 << 3 return m&bit == bit } func (m myInt2) Baz() int8 { return int8((m >> 0) & 0x7) }	446 B	2025-05-25 12:27

Terminal