summaryrefslogtreecommitdiff
path: root/vendor/github.com/bytedance/sonic/ast/buffer.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/bytedance/sonic/ast/buffer.go')
-rw-r--r--vendor/github.com/bytedance/sonic/ast/buffer.go470
1 files changed, 0 insertions, 470 deletions
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
-}
-
generated by cgit v1.2.3 (git 2.46.0) at 2025-07-26 04:11:41 +0000