From b1af8fd87760b34e3ff2fd3bda38f211815a0473 Mon Sep 17 00:00:00 2001
From: Terin Stock <terinjokes@gmail.com>
Date: Sun, 9 Mar 2025 17:47:56 +0100
Subject: [chore] remove vendor

---
 vendor/github.com/bytedance/sonic/ast/buffer.go | 470 ------------------------
 1 file changed, 470 deletions(-)
 delete mode 100644 vendor/github.com/bytedance/sonic/ast/buffer.go

(limited to 'vendor/github.com/bytedance/sonic/ast/buffer.go')

diff --git a/vendor/github.com/bytedance/sonic/ast/buffer.go b/vendor/github.com/bytedance/sonic/ast/buffer.go
deleted file mode 100644
index 04701ef5b..000000000
--- a/vendor/github.com/bytedance/sonic/ast/buffer.go
+++ /dev/null
@@ -1,470 +0,0 @@
-/**
- * Copyright 2023 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 ast
-
-import (
-	"sort"
-	"unsafe"
-
-	"github.com/bytedance/sonic/internal/caching"
-)
-
-type nodeChunk [_DEFAULT_NODE_CAP]Node
-
-type linkedNodes struct {
-    head   nodeChunk
-    tail   []*nodeChunk
-    size   int
-}
-
-func (self *linkedNodes) Cap() int {
-    if self == nil {
-        return 0
-    }
-    return (len(self.tail)+1)*_DEFAULT_NODE_CAP 
-}
-
-func (self *linkedNodes) Len() int {
-    if self == nil {
-        return 0
-    }
-    return self.size 
-}
-
-func (self *linkedNodes) At(i int) (*Node) {
-    if self == nil {
-        return nil
-    }
-    if i >= 0 && i<self.size && i < _DEFAULT_NODE_CAP {
-        return &self.head[i]
-    } else if i >= _DEFAULT_NODE_CAP && i<self.size  {
-        a, b := i/_DEFAULT_NODE_CAP-1, i%_DEFAULT_NODE_CAP
-        if a < len(self.tail) {
-            return &self.tail[a][b]
-        }
-    }
-    return nil
-}
-
-func (self *linkedNodes) MoveOne(source int,  target int) {
-    if source == target {
-        return
-    }
-    if source < 0 || source >= self.size || target < 0 || target >= self.size {
-        return
-    }
-    // reserve source
-    n := *self.At(source)
-    if source < target {
-        // move every element (source,target] one step back
-        for i:=source; i<target; i++ {
-            *self.At(i) = *self.At(i+1)
-        } 
-    } else {
-        // move every element [target,source) one step forward
-        for i:=source; i>target; i-- {
-            *self.At(i) = *self.At(i-1)
-        }
-    } 
-    // set target
-    *self.At(target) = n
-}
-
-func (self *linkedNodes) Pop() {
-    if self == nil || self.size == 0 {
-        return
-    }
-    self.Set(self.size-1, Node{})
-    self.size--
-}
-
-func (self *linkedNodes) Push(v Node) {
-    self.Set(self.size, v)
-}
-
-
-func (self *linkedNodes) Set(i int, v Node) {
-    if i < _DEFAULT_NODE_CAP {
-        self.head[i] = v
-        if self.size <= i {
-            self.size = i+1
-        }
-        return
-    }
-    a, b := i/_DEFAULT_NODE_CAP-1, i%_DEFAULT_NODE_CAP
-    if a < 0 {
-        self.head[b] = v
-    } else {
-        self.growTailLength(a+1)
-        var n = &self.tail[a]
-        if *n == nil {
-            *n = new(nodeChunk)
-        }
-        (*n)[b] = v
-    }
-    if self.size <= i {
-        self.size = i+1
-    }
-}
-
-func (self *linkedNodes) growTailLength(l int) {
-    if l <= len(self.tail) {
-        return
-    }
-    c := cap(self.tail)
-    for c < l {
-        c += 1 + c>>_APPEND_GROW_SHIFT
-    }
-    if c == cap(self.tail) {
-        self.tail = self.tail[:l]
-        return
-    }
-    tmp := make([]*nodeChunk, l, c)
-    copy(tmp, self.tail)
-    self.tail = tmp
-}
-
-func (self *linkedNodes) ToSlice(con []Node) {
-    if len(con) < self.size {
-        return
-    }
-    i := (self.size-1)
-    a, b := i/_DEFAULT_NODE_CAP-1, i%_DEFAULT_NODE_CAP
-    if a < 0 {
-        copy(con, self.head[:b+1])
-        return
-    } else {
-        copy(con, self.head[:])
-        con = con[_DEFAULT_NODE_CAP:]
-    }
-
-    for i:=0; i<a; i++ {
-        copy(con, self.tail[i][:])
-        con = con[_DEFAULT_NODE_CAP:]
-    }
-    copy(con, self.tail[a][:b+1])
-}
-
-func (self *linkedNodes) FromSlice(con []Node) {
-    self.size = len(con)
-    i := self.size-1
-    a, b := i/_DEFAULT_NODE_CAP-1, i%_DEFAULT_NODE_CAP
-    if a < 0 {
-        copy(self.head[:b+1], con)
-        return
-    } else {
-        copy(self.head[:], con)
-        con = con[_DEFAULT_NODE_CAP:]
-    }
-
-    if cap(self.tail) <= a {
-        c := (a+1) + (a+1)>>_APPEND_GROW_SHIFT
-        self.tail = make([]*nodeChunk, a+1, c)
-    }
-    self.tail = self.tail[:a+1]
-
-    for i:=0; i<a; i++ {
-        self.tail[i] = new(nodeChunk)
-        copy(self.tail[i][:], con)
-        con = con[_DEFAULT_NODE_CAP:]
-    }
-
-    self.tail[a] = new(nodeChunk)
-    copy(self.tail[a][:b+1], con)
-}
-
-type pairChunk [_DEFAULT_NODE_CAP]Pair
-
-type linkedPairs struct {
-    index map[uint64]int
-    head pairChunk
-    tail []*pairChunk
-    size int
-}
-
-func (self *linkedPairs) BuildIndex() {
-    if self.index == nil {
-        self.index = make(map[uint64]int, self.size)
-    }
-    for i:=0; i<self.size; i++ {
-        p := self.At(i)
-        self.index[p.hash] = i
-    }
-}
-
-func (self *linkedPairs) Cap() int {
-    if self == nil {
-        return 0
-    }
-    return (len(self.tail)+1)*_DEFAULT_NODE_CAP 
-}
-
-func (self *linkedPairs) Len() int {
-    if self == nil {
-        return 0
-    }
-    return self.size 
-}
-
-func (self *linkedPairs) At(i int) *Pair {
-    if self == nil {
-        return nil
-    }
-    if i >= 0 && i < _DEFAULT_NODE_CAP && i<self.size {
-        return &self.head[i]
-    } else if i >= _DEFAULT_NODE_CAP && i<self.size {
-        a, b := i/_DEFAULT_NODE_CAP-1, i%_DEFAULT_NODE_CAP
-        if a < len(self.tail) {
-            return &self.tail[a][b]
-        }
-    }
-    return nil
-}
-
-func (self *linkedPairs) Push(v Pair) {
-    self.Set(self.size, v)
-}
-
-func (self *linkedPairs) Pop() {
-    if self == nil || self.size == 0 {
-        return
-    }
-    self.Unset(self.size-1)
-    self.size--
-}
-
-func (self *linkedPairs) Unset(i int) {
-    if self.index != nil {
-        p := self.At(i)
-        delete(self.index, p.hash)
-    }
-    self.set(i, Pair{}) 
-}
-
-func (self *linkedPairs) Set(i int, v Pair) {
-    if self.index != nil {
-        h := v.hash
-        self.index[h] = i
-    }
-    self.set(i, v)
-}
-
-func (self *linkedPairs) set(i int, v Pair) {
-    if i < _DEFAULT_NODE_CAP {
-        self.head[i] = v
-        if self.size <= i {
-            self.size = i+1
-        }
-        return
-    }
-    a, b := i/_DEFAULT_NODE_CAP-1, i%_DEFAULT_NODE_CAP
-    if a < 0 {
-        self.head[b] = v
-    } else {
-        self.growTailLength(a+1)
-        var n = &self.tail[a]
-        if *n == nil {
-            *n = new(pairChunk)
-        }
-        (*n)[b] = v
-    }
-    if self.size <= i {
-        self.size = i+1
-    }
-}
-
-func (self *linkedPairs) growTailLength(l int) {
-    if l <= len(self.tail) {
-        return
-    }
-    c := cap(self.tail)
-    for c < l {
-        c += 1 + c>>_APPEND_GROW_SHIFT
-    }
-    if c == cap(self.tail) {
-        self.tail = self.tail[:l]
-        return
-    }
-    tmp := make([]*pairChunk, l, c)
-    copy(tmp, self.tail)
-    self.tail = tmp
-}
-
-// linear search
-func (self *linkedPairs) Get(key string) (*Pair, int) {
-    if self.index != nil {
-        // fast-path
-        i, ok := self.index[caching.StrHash(key)]
-        if ok {
-            n := self.At(i)
-            if n.Key == key {
-                return n, i
-            }
-            // hash conflicts
-            goto linear_search
-        } else {
-            return nil, -1
-        }
-    }
-linear_search:
-    for i:=0; i<self.size; i++ {
-        if n := self.At(i); n.Key == key {
-            return n, i
-        }
-    }
-    return nil, -1
-}
-
-func (self *linkedPairs) ToSlice(con []Pair) {
-    if len(con) < self.size {
-        return
-    }
-    i := self.size-1
-    a, b := i/_DEFAULT_NODE_CAP-1, i%_DEFAULT_NODE_CAP
-
-    if a < 0 {
-        copy(con, self.head[:b+1])
-        return
-    } else {
-        copy(con, self.head[:])
-        con = con[_DEFAULT_NODE_CAP:]
-    }
-
-    for i:=0; i<a; i++ {
-        copy(con, self.tail[i][:])
-        con = con[_DEFAULT_NODE_CAP:]
-    }
-    copy(con, self.tail[a][:b+1])
-}
-
-func (self *linkedPairs) ToMap(con map[string]Node) {
-    for i:=0; i<self.size; i++ {
-        n := self.At(i)
-        con[n.Key] = n.Value
-    }
-}
-
-func (self *linkedPairs) copyPairs(to []Pair, from []Pair, l int) {
-    copy(to, from)
-    if self.index != nil {
-        for i:=0; i<l; i++ {
-            // NOTICE: in case of user not pass hash, just cal it
-            h := caching.StrHash(from[i].Key)
-            from[i].hash = h
-            self.index[h] = i
-        }
-    }
-}
-
-func (self *linkedPairs) FromSlice(con []Pair) {
-    self.size = len(con)
-    i := self.size-1
-    a, b := i/_DEFAULT_NODE_CAP-1, i%_DEFAULT_NODE_CAP
-    if a < 0 {
-        self.copyPairs(self.head[:b+1], con, b+1)
-        return
-    } else {
-        self.copyPairs(self.head[:], con, len(self.head))
-        con = con[_DEFAULT_NODE_CAP:]
-    }
-
-    if cap(self.tail) <= a {
-        c := (a+1) + (a+1)>>_APPEND_GROW_SHIFT
-        self.tail = make([]*pairChunk, a+1, c)
-    }
-    self.tail = self.tail[:a+1]
-
-    for i:=0; i<a; i++ {
-        self.tail[i] = new(pairChunk)
-        self.copyPairs(self.tail[i][:], con, len(self.tail[i]))
-        con = con[_DEFAULT_NODE_CAP:]
-    }
-
-    self.tail[a] = new(pairChunk)
-    self.copyPairs(self.tail[a][:b+1], con, b+1)
-}
-
-func (self *linkedPairs) Less(i, j int) bool {
-    return lessFrom(self.At(i).Key, self.At(j).Key, 0)
-}
-
-func (self *linkedPairs) Swap(i, j int) {
-    a, b := self.At(i), self.At(j)
-    if self.index != nil {
-        self.index[a.hash] = j
-        self.index[b.hash] = i
-    }
-    *a, *b = *b, *a
-}
-
-func (self *linkedPairs) Sort() {
-    sort.Stable(self)
-}
-
-// Compare two strings from the pos d.
-func lessFrom(a, b string, d int) bool {
-    l := len(a)
-    if l > len(b) {
-        l = len(b)
-    }
-    for i := d; i < l; i++ {
-        if a[i] == b[i] {
-            continue
-        }
-        return a[i] < b[i]
-    }
-    return len(a) < len(b)
-}
-
-type parseObjectStack struct {
-    parser Parser
-    v      linkedPairs
-}
-
-type parseArrayStack struct {
-    parser Parser
-    v      linkedNodes
-}
-
-func newLazyArray(p *Parser) Node {
-    s := new(parseArrayStack)
-    s.parser = *p
-    return Node{
-        t: _V_ARRAY_LAZY,
-        p: unsafe.Pointer(s),
-    }
-}
-
-func newLazyObject(p *Parser) Node {
-    s := new(parseObjectStack)
-    s.parser = *p
-    return Node{
-        t: _V_OBJECT_LAZY,
-        p: unsafe.Pointer(s),
-    }
-}
-
-func (self *Node) getParserAndArrayStack() (*Parser, *parseArrayStack) {
-    stack := (*parseArrayStack)(self.p)
-    return &stack.parser, stack
-}
-
-func (self *Node) getParserAndObjectStack() (*Parser, *parseObjectStack) {
-    stack := (*parseObjectStack)(self.p)
-    return &stack.parser, stack
-}
-
-- 
cgit v1.2.3