[chore]: Bump github.com/gin-contrib/gzip from 1.0.1 to 1.1.0 (#3639)

Bumps [github.com/gin-contrib/gzip](https://github.com/gin-contrib/gzip) from 1.0.1 to 1.1.0. - [Release notes](https://github.com/gin-contrib/gzip/releases) - [Changelog](https://github.com/gin-contrib/gzip/blob/master/.goreleaser.yaml) - [Commits](https://github.com/gin-contrib/gzip/compare/v1.0.1...v1.1.0) --- updated-dependencies: - dependency-name: github.com/gin-contrib/gzip dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
2025-11-04 08:02:26 -06:00 · 2025-01-14 13:10:39 +00:00 · 2025-01-14 13:10:39 +00:00 · 4d423102c1
commit 4d423102c1
parent 8cfae010a9
519 changed files with 156968 additions and 132058 deletions
--- a/vendor/github.com/bytedance/sonic/internal/encoder/ir/op.go
+++ b/vendor/github.com/bytedance/sonic/internal/encoder/ir/op.go
@ -0,0 +1,473 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ir
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"unsafe"
+
+	"github.com/bytedance/sonic/internal/encoder/vars"
+	"github.com/bytedance/sonic/internal/rt"
+)
+
+type Op uint8
+
+const (
+	OP_null Op = iota + 1
+	OP_empty_arr
+	OP_empty_obj
+	OP_bool
+	OP_i8
+	OP_i16
+	OP_i32
+	OP_i64
+	OP_u8
+	OP_u16
+	OP_u32
+	OP_u64
+	OP_f32
+	OP_f64
+	OP_str
+	OP_bin
+	OP_quote
+	OP_number
+	OP_eface
+	OP_iface
+	OP_byte
+	OP_text
+	OP_deref
+	OP_index
+	OP_load
+	OP_save
+	OP_drop
+	OP_drop_2
+	OP_recurse
+	OP_is_nil
+	OP_is_nil_p1
+	OP_is_zero_1
+	OP_is_zero_2
+	OP_is_zero_4
+	OP_is_zero_8
+	OP_is_zero_map
+	OP_goto
+	OP_map_iter
+	OP_map_stop
+	OP_map_check_key
+	OP_map_write_key
+	OP_map_value_next
+	OP_slice_len
+	OP_slice_next
+	OP_marshal
+	OP_marshal_p
+	OP_marshal_text
+	OP_marshal_text_p
+	OP_cond_set
+	OP_cond_testc
+)
+
+const (
+	_INT_SIZE = 32 << (^uint(0) >> 63)
+	_PTR_SIZE = 32 << (^uintptr(0) >> 63)
+	_PTR_BYTE = unsafe.Sizeof(uintptr(0))
+)
+
+const OpSize = unsafe.Sizeof(NewInsOp(0))
+
+var OpNames = [256]string{
+	OP_null:           "null",
+	OP_empty_arr:      "empty_arr",
+	OP_empty_obj:      "empty_obj",
+	OP_bool:           "bool",
+	OP_i8:             "i8",
+	OP_i16:            "i16",
+	OP_i32:            "i32",
+	OP_i64:            "i64",
+	OP_u8:             "u8",
+	OP_u16:            "u16",
+	OP_u32:            "u32",
+	OP_u64:            "u64",
+	OP_f32:            "f32",
+	OP_f64:            "f64",
+	OP_str:            "str",
+	OP_bin:            "bin",
+	OP_quote:          "quote",
+	OP_number:         "number",
+	OP_eface:          "eface",
+	OP_iface:          "iface",
+	OP_byte:           "byte",
+	OP_text:           "text",
+	OP_deref:          "deref",
+	OP_index:          "index",
+	OP_load:           "load",
+	OP_save:           "save",
+	OP_drop:           "drop",
+	OP_drop_2:         "drop_2",
+	OP_recurse:        "recurse",
+	OP_is_nil:         "is_nil",
+	OP_is_nil_p1:      "is_nil_p1",
+	OP_is_zero_1:      "is_zero_1",
+	OP_is_zero_2:      "is_zero_2",
+	OP_is_zero_4:      "is_zero_4",
+	OP_is_zero_8:      "is_zero_8",
+	OP_is_zero_map:    "is_zero_map",
+	OP_goto:           "goto",
+	OP_map_iter:       "map_iter",
+	OP_map_stop:       "map_stop",
+	OP_map_check_key:  "map_check_key",
+	OP_map_write_key:  "map_write_key",
+	OP_map_value_next: "map_value_next",
+	OP_slice_len:      "slice_len",
+	OP_slice_next:     "slice_next",
+	OP_marshal:        "marshal",
+	OP_marshal_p:      "marshal_p",
+	OP_marshal_text:   "marshal_text",
+	OP_marshal_text_p: "marshal_text_p",
+	OP_cond_set:       "cond_set",
+	OP_cond_testc:     "cond_testc",
+}
+
+func (self Op) String() string {
+	if ret := OpNames[self]; ret != "" {
+		return ret
+	} else {
+		return "<invalid>"
+	}
+}
+
+func OP_int() Op {
+	switch _INT_SIZE {
+	case 32:
+		return OP_i32
+	case 64:
+		return OP_i64
+	default:
+		panic("unsupported int size")
+	}
+}
+
+func OP_uint() Op {
+	switch _INT_SIZE {
+	case 32:
+		return OP_u32
+	case 64:
+		return OP_u64
+	default:
+		panic("unsupported uint size")
+	}
+}
+
+func OP_uintptr() Op {
+	switch _PTR_SIZE {
+	case 32:
+		return OP_u32
+	case 64:
+		return OP_u64
+	default:
+		panic("unsupported pointer size")
+	}
+}
+
+func OP_is_zero_ints() Op {
+	switch _INT_SIZE {
+	case 32:
+		return OP_is_zero_4
+	case 64:
+		return OP_is_zero_8
+	default:
+		panic("unsupported integer size")
+	}
+}
+
+type Instr struct {
+	o Op
+	u int            // union {op: 8, _: 8, vi: 48}, vi maybe int or len(str)
+	p unsafe.Pointer // maybe GoString.Ptr, or *GoType
+}
+
+func NewInsOp(op Op) Instr {
+	return Instr{o: op}
+}
+
+func NewInsVi(op Op, vi int) Instr {
+	return Instr{o: op, u: vi}
+}
+
+func NewInsVs(op Op, vs string) Instr {
+	return Instr{
+		o: op,
+		u: len(vs),
+		p: (*rt.GoString)(unsafe.Pointer(&vs)).Ptr,
+	}
+}
+
+func NewInsVt(op Op, vt reflect.Type) Instr {
+	return Instr{
+		o: op,
+		p: unsafe.Pointer(rt.UnpackType(vt)),
+	}
+}
+
+type typAndTab struct {
+	vt *rt.GoType
+	itab *rt.GoItab
+}
+
+func NewInsVtab(op Op, vt reflect.Type, itab *rt.GoItab) Instr {
+	return Instr{
+		o: op,
+		p: unsafe.Pointer(&typAndTab{
+			vt: rt.UnpackType(vt),
+			itab: itab,
+		}),
+	}
+}
+
+func NewInsVp(op Op, vt reflect.Type, pv bool) Instr {
+	i := 0
+	if pv {
+		i = 1
+	}
+	return Instr{
+		o: op,
+		u: i,
+		p: unsafe.Pointer(rt.UnpackType(vt)),
+	}
+}
+
+func (self Instr) Op() Op {
+	return Op(self.o)
+}
+
+func (self Instr) Vi() int {
+	return self.u
+}
+
+func (self Instr) Vf() uint8 {
+	return (*rt.GoType)(self.p).KindFlags
+}
+
+func (self Instr) Vs() (v string) {
+	(*rt.GoString)(unsafe.Pointer(&v)).Ptr = self.p
+	(*rt.GoString)(unsafe.Pointer(&v)).Len = self.Vi()
+	return
+}
+
+func (self Instr) Vk() reflect.Kind {
+	return (*rt.GoType)(self.p).Kind()
+}
+
+func (self Instr) Vt() reflect.Type {
+	return (*rt.GoType)(self.p).Pack()
+}
+
+func (self Instr) Vr() *rt.GoType {
+	return (*rt.GoType)(self.p)
+}
+
+func (self Instr) Vp() (vt reflect.Type, pv bool) {
+	return (*rt.GoType)(self.p).Pack(), self.u == 1
+}
+
+func (self Instr) Vtab() (vt *rt.GoType, itab *rt.GoItab) {
+	tt := (*typAndTab)(self.p)
+	return tt.vt, tt.itab
+}
+
+func (self Instr) Vp2() (vt *rt.GoType, pv bool) {
+	return (*rt.GoType)(self.p), self.u == 1
+}
+
+func (self Instr) I64() int64 {
+	return int64(self.Vi())
+}
+
+func (self Instr) Byte() byte {
+	return byte(self.Vi())
+}
+
+func (self Instr) Vlen() int {
+	return int((*rt.GoType)(self.p).Size)
+}
+
+func (self Instr) isBranch() bool {
+	switch self.Op() {
+	case OP_goto:
+		fallthrough
+	case OP_is_nil:
+		fallthrough
+	case OP_is_nil_p1:
+		fallthrough
+	case OP_is_zero_1:
+		fallthrough
+	case OP_is_zero_2:
+		fallthrough
+	case OP_is_zero_4:
+		fallthrough
+	case OP_is_zero_8:
+		fallthrough
+	case OP_map_check_key:
+		fallthrough
+	case OP_map_write_key:
+		fallthrough
+	case OP_slice_next:
+		fallthrough
+	case OP_cond_testc:
+		return true
+	default:
+		return false
+	}
+}
+
+func (self Instr) Disassemble() string {
+	switch self.Op() {
+	case OP_byte:
+		return fmt.Sprintf("%-18s%s", self.Op().String(), strconv.QuoteRune(rune(self.Vi())))
+	case OP_text:
+		return fmt.Sprintf("%-18s%s", self.Op().String(), strconv.Quote(self.Vs()))
+	case OP_index:
+		return fmt.Sprintf("%-18s%d", self.Op().String(), self.Vi())
+	case OP_recurse:
+		fallthrough
+	case OP_map_iter:
+		return fmt.Sprintf("%-18s%s", self.Op().String(), self.Vt())
+	case OP_marshal:
+		fallthrough
+	case OP_marshal_p:
+		fallthrough
+	case OP_marshal_text:
+		fallthrough
+	case OP_marshal_text_p:
+		vt, _ := self.Vtab()
+		return fmt.Sprintf("%-18s%s", self.Op().String(), vt.Pack())
+	case OP_goto:
+		fallthrough
+	case OP_is_nil:
+		fallthrough
+	case OP_is_nil_p1:
+		fallthrough
+	case OP_is_zero_1:
+		fallthrough
+	case OP_is_zero_2:
+		fallthrough
+	case OP_is_zero_4:
+		fallthrough
+	case OP_is_zero_8:
+		fallthrough
+	case OP_is_zero_map:
+		fallthrough
+	case OP_cond_testc:
+		fallthrough
+	case OP_map_check_key:
+		fallthrough
+	case OP_map_write_key:
+		return fmt.Sprintf("%-18sL_%d", self.Op().String(), self.Vi())
+	case OP_slice_next:
+		return fmt.Sprintf("%-18sL_%d, %s", self.Op().String(), self.Vi(), self.Vt())
+	default:
+		return fmt.Sprintf("%#v", self) 
+	}
+}
+
+type (
+	Program []Instr
+)
+
+func (self Program) PC() int {
+	return len(self)
+}
+
+func (self Program) Tag(n int) {
+	if n >= vars.MaxStack {
+		panic("type nesting too deep")
+	}
+}
+
+func (self Program) Pin(i int) {
+	v := &self[i]
+	v.u = self.PC()
+}
+
+func (self Program) Rel(v []int) {
+	for _, i := range v {
+		self.Pin(i)
+	}
+}
+
+func (self *Program) Add(op Op) {
+	*self = append(*self, NewInsOp(op))
+}
+
+func (self *Program) Key(op Op) {
+	*self = append(*self,
+		NewInsVi(OP_byte, '"'),
+		NewInsOp(op),
+		NewInsVi(OP_byte, '"'),
+	)
+}
+
+func (self *Program) Int(op Op, vi int) {
+	*self = append(*self, NewInsVi(op, vi))
+}
+
+func (self *Program) Str(op Op, vs string) {
+	*self = append(*self, NewInsVs(op, vs))
+}
+
+func (self *Program) Rtt(op Op, vt reflect.Type) {
+	*self = append(*self, NewInsVt(op, vt))
+}
+
+func (self *Program) Vp(op Op, vt reflect.Type, pv bool) {
+	*self = append(*self, NewInsVp(op, vt, pv))
+}
+
+func (self *Program) Vtab(op Op, vt reflect.Type, itab *rt.GoItab) {
+	*self = append(*self, NewInsVtab(op, vt, itab))
+}
+
+func (self Program) Disassemble() string {
+	nb := len(self)
+	tab := make([]bool, nb+1)
+	ret := make([]string, 0, nb+1)
+
+	/* prescan to get all the labels */
+	for _, ins := range self {
+		if ins.isBranch() {
+			tab[ins.Vi()] = true
+		}
+	}
+
+	/* disassemble each instruction */
+	for i, ins := range self {
+		if !tab[i] {
+			ret = append(ret, "\t"+ins.Disassemble())
+		} else {
+			ret = append(ret, fmt.Sprintf("L_%d:\n\t%s", i, ins.Disassemble()))
+		}
+	}
+
+	/* add the last label, if needed */
+	if tab[nb] {
+		ret = append(ret, fmt.Sprintf("L_%d:", nb))
+	}
+
+	/* add an "end" indicator, and join all the strings */
+	return strings.Join(append(ret, "\tend"), "\n")
+}