From f10991936317725d2262315ef46d21eb87e255f8 Mon Sep 17 00:00:00 2001 From: victor Date: Sat, 15 Aug 2026 12:05:47 +0200 Subject: [PATCH 01/29] Add dependencies for QR code generation --- go.mod | 1 + go.sum | 2 + vendor/modules.txt | 5 + vendor/rsc.io/qr/LICENSE | 27 + vendor/rsc.io/qr/README.md | 3 + vendor/rsc.io/qr/coding/qr.go | 815 +++++++++++++++++++++++ vendor/rsc.io/qr/gf256/gf256.go | 241 +++++++ vendor/rsc.io/qr/libqrencode/qrencode.go | 149 +++++ vendor/rsc.io/qr/png.go | 400 +++++++++++ vendor/rsc.io/qr/qr.go | 116 ++++ 10 files changed, 1759 insertions(+) create mode 100644 vendor/rsc.io/qr/LICENSE create mode 100644 vendor/rsc.io/qr/README.md create mode 100644 vendor/rsc.io/qr/coding/qr.go create mode 100644 vendor/rsc.io/qr/gf256/gf256.go create mode 100644 vendor/rsc.io/qr/libqrencode/qrencode.go create mode 100644 vendor/rsc.io/qr/png.go create mode 100644 vendor/rsc.io/qr/qr.go diff --git a/go.mod b/go.mod index 062b1b077ca..9d0aff0384a 100644 --- a/go.mod +++ b/go.mod @@ -45,6 +45,7 @@ require ( gopkg.in/natefinch/lumberjack.v2 v2.0.0 gopkg.in/yaml.v3 v3.0.1 nhooyr.io/websocket v1.8.7 + rsc.io/qr v0.2.0 zombiezen.com/go/capnproto2 v2.18.0+incompatible ) diff --git a/go.sum b/go.sum index 5462cb8582d..9523a0890aa 100644 --- a/go.sum +++ b/go.sum @@ -298,5 +298,7 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= nhooyr.io/websocket v1.8.7 h1:usjR2uOr/zjjkVMy0lW+PPohFok7PCow5sDjLgX4P4g= nhooyr.io/websocket v1.8.7/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0= +rsc.io/qr v0.2.0 h1:6vBLea5/NRMVTz8V66gipeLycZMl/+UlFmk8DvqQ6WY= +rsc.io/qr v0.2.0/go.mod h1:IF+uZjkb9fqyeF/4tlBoynqmQxUoPfWEKh921coOuXs= zombiezen.com/go/capnproto2 v2.18.0+incompatible h1:mwfXZniffG5mXokQGHUJWGnqIBggoPfT/CEwon9Yess= zombiezen.com/go/capnproto2 v2.18.0+incompatible/go.mod h1:XO5Pr2SbXgqZwn0m0Ru54QBqpOf4K5AYBO+8LAOBQEQ= diff --git a/vendor/modules.txt b/vendor/modules.txt index 943d0999119..8479bf4f4d4 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -497,6 +497,11 @@ nhooyr.io/websocket/internal/bpool nhooyr.io/websocket/internal/errd nhooyr.io/websocket/internal/wsjs nhooyr.io/websocket/internal/xsync +# rsc.io/qr v0.2.0 +## explicit +rsc.io/qr +rsc.io/qr/coding +rsc.io/qr/gf256 # zombiezen.com/go/capnproto2 v2.18.0+incompatible ## explicit zombiezen.com/go/capnproto2 diff --git a/vendor/rsc.io/qr/LICENSE b/vendor/rsc.io/qr/LICENSE new file mode 100644 index 00000000000..6a66aea5eaf --- /dev/null +++ b/vendor/rsc.io/qr/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2009 The Go Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/rsc.io/qr/README.md b/vendor/rsc.io/qr/README.md new file mode 100644 index 00000000000..0ba6214d7aa --- /dev/null +++ b/vendor/rsc.io/qr/README.md @@ -0,0 +1,3 @@ +Basic QR encoder. + +go get [-u] rsc.io/qr diff --git a/vendor/rsc.io/qr/coding/qr.go b/vendor/rsc.io/qr/coding/qr.go new file mode 100644 index 00000000000..bfc3ea4084d --- /dev/null +++ b/vendor/rsc.io/qr/coding/qr.go @@ -0,0 +1,815 @@ +// Copyright 2011 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 coding implements low-level QR coding details. +package coding // import "rsc.io/qr/coding" + +import ( + "fmt" + "strconv" + "strings" + + "rsc.io/qr/gf256" +) + +// Field is the field for QR error correction. +var Field = gf256.NewField(0x11d, 2) + +// A Version represents a QR version. +// The version specifies the size of the QR code: +// a QR code with version v has 4v+17 pixels on a side. +// Versions number from 1 to 40: the larger the version, +// the more information the code can store. +type Version int + +const MinVersion = 1 +const MaxVersion = 40 + +func (v Version) String() string { + return strconv.Itoa(int(v)) +} + +func (v Version) sizeClass() int { + if v <= 9 { + return 0 + } + if v <= 26 { + return 1 + } + return 2 +} + +// DataBytes returns the number of data bytes that can be +// stored in a QR code with the given version and level. +func (v Version) DataBytes(l Level) int { + vt := &vtab[v] + lev := &vt.level[l] + return vt.bytes - lev.nblock*lev.check +} + +// Encoding implements a QR data encoding scheme. +// The implementations--Numeric, Alphanumeric, and String--specify +// the character set and the mapping from UTF-8 to code bits. +// The more restrictive the mode, the fewer code bits are needed. +type Encoding interface { + Check() error + Bits(v Version) int + Encode(b *Bits, v Version) +} + +type Bits struct { + b []byte + nbit int +} + +func (b *Bits) Reset() { + b.b = b.b[:0] + b.nbit = 0 +} + +func (b *Bits) Bits() int { + return b.nbit +} + +func (b *Bits) Bytes() []byte { + if b.nbit%8 != 0 { + panic("fractional byte") + } + return b.b +} + +func (b *Bits) Append(p []byte) { + if b.nbit%8 != 0 { + panic("fractional byte") + } + b.b = append(b.b, p...) + b.nbit += 8 * len(p) +} + +func (b *Bits) Write(v uint, nbit int) { + for nbit > 0 { + n := nbit + if n > 8 { + n = 8 + } + if b.nbit%8 == 0 { + b.b = append(b.b, 0) + } else { + m := -b.nbit & 7 + if n > m { + n = m + } + } + b.nbit += n + sh := uint(nbit - n) + b.b[len(b.b)-1] |= uint8(v >> sh << uint(-b.nbit&7)) + v -= v >> sh << sh + nbit -= n + } +} + +// Num is the encoding for numeric data. +// The only valid characters are the decimal digits 0 through 9. +type Num string + +func (s Num) String() string { + return fmt.Sprintf("Num(%#q)", string(s)) +} + +func (s Num) Check() error { + for _, c := range s { + if c < '0' || '9' < c { + return fmt.Errorf("non-numeric string %#q", string(s)) + } + } + return nil +} + +var numLen = [3]int{10, 12, 14} + +func (s Num) Bits(v Version) int { + return 4 + numLen[v.sizeClass()] + (10*len(s)+2)/3 +} + +func (s Num) Encode(b *Bits, v Version) { + b.Write(1, 4) + b.Write(uint(len(s)), numLen[v.sizeClass()]) + var i int + for i = 0; i+3 <= len(s); i += 3 { + w := uint(s[i]-'0')*100 + uint(s[i+1]-'0')*10 + uint(s[i+2]-'0') + b.Write(w, 10) + } + switch len(s) - i { + case 1: + w := uint(s[i] - '0') + b.Write(w, 4) + case 2: + w := uint(s[i]-'0')*10 + uint(s[i+1]-'0') + b.Write(w, 7) + } +} + +// Alpha is the encoding for alphanumeric data. +// The valid characters are 0-9A-Z$%*+-./: and space. +type Alpha string + +const alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:" + +func (s Alpha) String() string { + return fmt.Sprintf("Alpha(%#q)", string(s)) +} + +func (s Alpha) Check() error { + for _, c := range s { + if strings.IndexRune(alphabet, c) < 0 { + return fmt.Errorf("non-alphanumeric string %#q", string(s)) + } + } + return nil +} + +var alphaLen = [3]int{9, 11, 13} + +func (s Alpha) Bits(v Version) int { + return 4 + alphaLen[v.sizeClass()] + (11*len(s)+1)/2 +} + +func (s Alpha) Encode(b *Bits, v Version) { + b.Write(2, 4) + b.Write(uint(len(s)), alphaLen[v.sizeClass()]) + var i int + for i = 0; i+2 <= len(s); i += 2 { + w := uint(strings.IndexRune(alphabet, rune(s[i])))*45 + + uint(strings.IndexRune(alphabet, rune(s[i+1]))) + b.Write(w, 11) + } + + if i < len(s) { + w := uint(strings.IndexRune(alphabet, rune(s[i]))) + b.Write(w, 6) + } +} + +// String is the encoding for 8-bit data. All bytes are valid. +type String string + +func (s String) String() string { + return fmt.Sprintf("String(%#q)", string(s)) +} + +func (s String) Check() error { + return nil +} + +var stringLen = [3]int{8, 16, 16} + +func (s String) Bits(v Version) int { + return 4 + stringLen[v.sizeClass()] + 8*len(s) +} + +func (s String) Encode(b *Bits, v Version) { + b.Write(4, 4) + b.Write(uint(len(s)), stringLen[v.sizeClass()]) + for i := 0; i < len(s); i++ { + b.Write(uint(s[i]), 8) + } +} + +// A Pixel describes a single pixel in a QR code. +type Pixel uint32 + +const ( + Black Pixel = 1 << iota + Invert +) + +func (p Pixel) Offset() uint { + return uint(p >> 6) +} + +func OffsetPixel(o uint) Pixel { + return Pixel(o << 6) +} + +func (r PixelRole) Pixel() Pixel { + return Pixel(r << 2) +} + +func (p Pixel) Role() PixelRole { + return PixelRole(p>>2) & 15 +} + +func (p Pixel) String() string { + s := p.Role().String() + if p&Black != 0 { + s += "+black" + } + if p&Invert != 0 { + s += "+invert" + } + s += "+" + strconv.FormatUint(uint64(p.Offset()), 10) + return s +} + +// A PixelRole describes the role of a QR pixel. +type PixelRole uint32 + +const ( + _ PixelRole = iota + Position // position squares (large) + Alignment // alignment squares (small) + Timing // timing strip between position squares + Format // format metadata + PVersion // version pattern + Unused // unused pixel + Data // data bit + Check // error correction check bit + Extra +) + +var roles = []string{ + "", + "position", + "alignment", + "timing", + "format", + "pversion", + "unused", + "data", + "check", + "extra", +} + +func (r PixelRole) String() string { + if Position <= r && r <= Check { + return roles[r] + } + return strconv.Itoa(int(r)) +} + +// A Level represents a QR error correction level. +// From least to most tolerant of errors, they are L, M, Q, H. +type Level int + +const ( + L Level = iota + M + Q + H +) + +func (l Level) String() string { + if L <= l && l <= H { + return "LMQH"[l : l+1] + } + return strconv.Itoa(int(l)) +} + +// A Code is a square pixel grid. +type Code struct { + Bitmap []byte // 1 is black, 0 is white + Size int // number of pixels on a side + Stride int // number of bytes per row +} + +func (c *Code) Black(x, y int) bool { + return 0 <= x && x < c.Size && 0 <= y && y < c.Size && + c.Bitmap[y*c.Stride+x/8]&(1<= pad { + break + } + b.Write(0x11, 8) + } + } +} + +func (b *Bits) AddCheckBytes(v Version, l Level) { + nd := v.DataBytes(l) + if b.nbit < nd*8 { + b.Pad(nd*8 - b.nbit) + } + if b.nbit != nd*8 { + panic("qr: too much data") + } + + dat := b.Bytes() + vt := &vtab[v] + lev := &vt.level[l] + db := nd / lev.nblock + extra := nd % lev.nblock + chk := make([]byte, lev.check) + rs := gf256.NewRSEncoder(Field, lev.check) + for i := 0; i < lev.nblock; i++ { + if i == lev.nblock-extra { + db++ + } + rs.ECC(dat[:db], chk) + b.Append(chk) + dat = dat[db:] + } + + if len(b.Bytes()) != vt.bytes { + panic("qr: internal error") + } +} + +func (p *Plan) Encode(text ...Encoding) (*Code, error) { + var b Bits + for _, t := range text { + if err := t.Check(); err != nil { + return nil, err + } + t.Encode(&b, p.Version) + } + if b.Bits() > p.DataBytes*8 { + return nil, fmt.Errorf("cannot encode %d bits into %d-bit code", b.Bits(), p.DataBytes*8) + } + b.AddCheckBytes(p.Version, p.Level) + bytes := b.Bytes() + + // Now we have the checksum bytes and the data bytes. + // Construct the actual code. + c := &Code{Size: len(p.Pixel), Stride: (len(p.Pixel) + 7) &^ 7} + c.Bitmap = make([]byte, c.Stride*c.Size) + crow := c.Bitmap + for _, row := range p.Pixel { + for x, pix := range row { + switch pix.Role() { + case Data, Check: + o := pix.Offset() + if bytes[o/8]&(1< 40 { + return nil, fmt.Errorf("invalid QR version %d", int(v)) + } + siz := 17 + int(v)*4 + m := grid(siz) + p.Pixel = m + + // Timing markers (overwritten by boxes). + const ti = 6 // timing is in row/column 6 (counting from 0) + for i := range m { + p := Timing.Pixel() + if i&1 == 0 { + p |= Black + } + m[i][ti] = p + m[ti][i] = p + } + + // Position boxes. + posBox(m, 0, 0) + posBox(m, siz-7, 0) + posBox(m, 0, siz-7) + + // Alignment boxes. + info := &vtab[v] + for x := 4; x+5 < siz; { + for y := 4; y+5 < siz; { + // don't overwrite timing markers + if (x < 7 && y < 7) || (x < 7 && y+5 >= siz-7) || (x+5 >= siz-7 && y < 7) { + } else { + alignBox(m, x, y) + } + if y == 4 { + y = info.apos + } else { + y += info.astride + } + } + if x == 4 { + x = info.apos + } else { + x += info.astride + } + } + + // Version pattern. + pat := vtab[v].pattern + if pat != 0 { + v := pat + for x := 0; x < 6; x++ { + for y := 0; y < 3; y++ { + p := PVersion.Pixel() + if v&1 != 0 { + p |= Black + } + m[siz-11+y][x] = p + m[x][siz-11+y] = p + v >>= 1 + } + } + } + + // One lonely black pixel + m[siz-8][8] = Unused.Pixel() | Black + + return p, nil +} + +// fplan adds the format pixels +func fplan(l Level, m Mask, p *Plan) error { + // Format pixels. + fb := uint32(l^1) << 13 // level: L=01, M=00, Q=11, H=10 + fb |= uint32(m) << 10 // mask + const formatPoly = 0x537 + rem := fb + for i := 14; i >= 10; i-- { + if rem&(1<>i)&1 == 1 { + pix |= Black + } + if (invert>>i)&1 == 1 { + pix ^= Invert | Black + } + // top left + switch { + case i < 6: + p.Pixel[i][8] = pix + case i < 8: + p.Pixel[i+1][8] = pix + case i < 9: + p.Pixel[8][7] = pix + default: + p.Pixel[8][14-i] = pix + } + // bottom right + switch { + case i < 8: + p.Pixel[8][siz-1-int(i)] = pix + default: + p.Pixel[siz-1-int(14-i)][8] = pix + } + } + return nil +} + +// lplan edits a version-only Plan to add information +// about the error correction levels. +func lplan(v Version, l Level, p *Plan) error { + p.Level = l + + nblock := vtab[v].level[l].nblock + ne := vtab[v].level[l].check + nde := (vtab[v].bytes - ne*nblock) / nblock + extra := (vtab[v].bytes - ne*nblock) % nblock + dataBits := (nde*nblock + extra) * 8 + checkBits := ne * nblock * 8 + + p.DataBytes = vtab[v].bytes - ne*nblock + p.CheckBytes = ne * nblock + p.Blocks = nblock + + // Make data + checksum pixels. + data := make([]Pixel, dataBits) + for i := range data { + data[i] = Data.Pixel() | OffsetPixel(uint(i)) + } + check := make([]Pixel, checkBits) + for i := range check { + check[i] = Check.Pixel() | OffsetPixel(uint(i+dataBits)) + } + + // Split into blocks. + dataList := make([][]Pixel, nblock) + checkList := make([][]Pixel, nblock) + for i := 0; i < nblock; i++ { + // The last few blocks have an extra data byte (8 pixels). + nd := nde + if i >= nblock-extra { + nd++ + } + dataList[i], data = data[0:nd*8], data[nd*8:] + checkList[i], check = check[0:ne*8], check[ne*8:] + } + if len(data) != 0 || len(check) != 0 { + panic("data/check math") + } + + // Build up bit sequence, taking first byte of each block, + // then second byte, and so on. Then checksums. + bits := make([]Pixel, dataBits+checkBits) + dst := bits + for i := 0; i < nde+1; i++ { + for _, b := range dataList { + if i*8 < len(b) { + copy(dst, b[i*8:(i+1)*8]) + dst = dst[8:] + } + } + } + for i := 0; i < ne; i++ { + for _, b := range checkList { + if i*8 < len(b) { + copy(dst, b[i*8:(i+1)*8]) + dst = dst[8:] + } + } + } + if len(dst) != 0 { + panic("dst math") + } + + // Sweep up pair of columns, + // then down, assigning to right then left pixel. + // Repeat. + // See Figure 2 of http://www.pclviewer.com/rs2/qrtopology.htm + siz := len(p.Pixel) + rem := make([]Pixel, 7) + for i := range rem { + rem[i] = Extra.Pixel() + } + src := append(bits, rem...) + for x := siz; x > 0; { + for y := siz - 1; y >= 0; y-- { + if p.Pixel[y][x-1].Role() == 0 { + p.Pixel[y][x-1], src = src[0], src[1:] + } + if p.Pixel[y][x-2].Role() == 0 { + p.Pixel[y][x-2], src = src[0], src[1:] + } + } + x -= 2 + if x == 7 { // vertical timing strip + x-- + } + for y := 0; y < siz; y++ { + if p.Pixel[y][x-1].Role() == 0 { + p.Pixel[y][x-1], src = src[0], src[1:] + } + if p.Pixel[y][x-2].Role() == 0 { + p.Pixel[y][x-2], src = src[0], src[1:] + } + } + x -= 2 + } + return nil +} + +// mplan edits a version+level-only Plan to add the mask. +func mplan(m Mask, p *Plan) error { + p.Mask = m + for y, row := range p.Pixel { + for x, pix := range row { + if r := pix.Role(); (r == Data || r == Check || r == Extra) && p.Mask.Invert(y, x) { + row[x] ^= Black | Invert + } + } + } + return nil +} + +// posBox draws a position (large) box at upper left x, y. +func posBox(m [][]Pixel, x, y int) { + pos := Position.Pixel() + // box + for dy := 0; dy < 7; dy++ { + for dx := 0; dx < 7; dx++ { + p := pos + if dx == 0 || dx == 6 || dy == 0 || dy == 6 || 2 <= dx && dx <= 4 && 2 <= dy && dy <= 4 { + p |= Black + } + m[y+dy][x+dx] = p + } + } + // white border + for dy := -1; dy < 8; dy++ { + if 0 <= y+dy && y+dy < len(m) { + if x > 0 { + m[y+dy][x-1] = pos + } + if x+7 < len(m) { + m[y+dy][x+7] = pos + } + } + } + for dx := -1; dx < 8; dx++ { + if 0 <= x+dx && x+dx < len(m) { + if y > 0 { + m[y-1][x+dx] = pos + } + if y+7 < len(m) { + m[y+7][x+dx] = pos + } + } + } +} + +// alignBox draw an alignment (small) box at upper left x, y. +func alignBox(m [][]Pixel, x, y int) { + // box + align := Alignment.Pixel() + for dy := 0; dy < 5; dy++ { + for dx := 0; dx < 5; dx++ { + p := align + if dx == 0 || dx == 4 || dy == 0 || dy == 4 || dx == 2 && dy == 2 { + p |= Black + } + m[y+dy][x+dx] = p + } + } +} diff --git a/vendor/rsc.io/qr/gf256/gf256.go b/vendor/rsc.io/qr/gf256/gf256.go new file mode 100644 index 00000000000..05e56455f64 --- /dev/null +++ b/vendor/rsc.io/qr/gf256/gf256.go @@ -0,0 +1,241 @@ +// Copyright 2010 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 gf256 implements arithmetic over the Galois Field GF(256). +package gf256 // import "rsc.io/qr/gf256" + +import "strconv" + +// A Field represents an instance of GF(256) defined by a specific polynomial. +type Field struct { + log [256]byte // log[0] is unused + exp [510]byte +} + +// NewField returns a new field corresponding to the polynomial poly +// and generator α. The Reed-Solomon encoding in QR codes uses +// polynomial 0x11d with generator 2. +// +// The choice of generator α only affects the Exp and Log operations. +func NewField(poly, α int) *Field { + if poly < 0x100 || poly >= 0x200 || reducible(poly) { + panic("gf256: invalid polynomial: " + strconv.Itoa(poly)) + } + + var f Field + x := 1 + for i := 0; i < 255; i++ { + if x == 1 && i != 0 { + panic("gf256: invalid generator " + strconv.Itoa(α) + + " for polynomial " + strconv.Itoa(poly)) + } + f.exp[i] = byte(x) + f.exp[i+255] = byte(x) + f.log[x] = byte(i) + x = mul(x, α, poly) + } + f.log[0] = 255 + for i := 0; i < 255; i++ { + if f.log[f.exp[i]] != byte(i) { + panic("bad log") + } + if f.log[f.exp[i+255]] != byte(i) { + panic("bad log") + } + } + for i := 1; i < 256; i++ { + if f.exp[f.log[i]] != byte(i) { + panic("bad log") + } + } + + return &f +} + +// nbit returns the number of significant in p. +func nbit(p int) uint { + n := uint(0) + for ; p > 0; p >>= 1 { + n++ + } + return n +} + +// polyDiv divides the polynomial p by q and returns the remainder. +func polyDiv(p, q int) int { + np := nbit(p) + nq := nbit(q) + for ; np >= nq; np-- { + if p&(1<<(np-1)) != 0 { + p ^= q << (np - nq) + } + } + return p +} + +// mul returns the product x*y mod poly, a GF(256) multiplication. +func mul(x, y, poly int) int { + z := 0 + for x > 0 { + if x&1 != 0 { + z ^= y + } + x >>= 1 + y <<= 1 + if y&0x100 != 0 { + y ^= poly + } + } + return z +} + +// reducible reports whether p is reducible. +func reducible(p int) bool { + // Multiplying n-bit * n-bit produces (2n-1)-bit, + // so if p is reducible, one of its factors must be + // of np/2+1 bits or fewer. + np := nbit(p) + for q := 2; q < 1<<(np/2+1); q++ { + if polyDiv(p, q) == 0 { + return true + } + } + return false +} + +// Add returns the sum of x and y in the field. +func (f *Field) Add(x, y byte) byte { + return x ^ y +} + +// Exp returns the base-α exponential of e in the field. +// If e < 0, Exp returns 0. +func (f *Field) Exp(e int) byte { + if e < 0 { + return 0 + } + return f.exp[e%255] +} + +// Log returns the base-α logarithm of x in the field. +// If x == 0, Log returns -1. +func (f *Field) Log(x byte) int { + if x == 0 { + return -1 + } + return int(f.log[x]) +} + +// Inv returns the multiplicative inverse of x in the field. +// If x == 0, Inv returns 0. +func (f *Field) Inv(x byte) byte { + if x == 0 { + return 0 + } + return f.exp[255-f.log[x]] +} + +// Mul returns the product of x and y in the field. +func (f *Field) Mul(x, y byte) byte { + if x == 0 || y == 0 { + return 0 + } + return f.exp[int(f.log[x])+int(f.log[y])] +} + +// An RSEncoder implements Reed-Solomon encoding +// over a given field using a given number of error correction bytes. +type RSEncoder struct { + f *Field + c int + gen []byte + lgen []byte + p []byte +} + +func (f *Field) gen(e int) (gen, lgen []byte) { + // p = 1 + p := make([]byte, e+1) + p[e] = 1 + + for i := 0; i < e; i++ { + // p *= (x + Exp(i)) + // p[j] = p[j]*Exp(i) + p[j+1]. + c := f.Exp(i) + for j := 0; j < e; j++ { + p[j] = f.Mul(p[j], c) ^ p[j+1] + } + p[e] = f.Mul(p[e], c) + } + + // lp = log p. + lp := make([]byte, e+1) + for i, c := range p { + if c == 0 { + lp[i] = 255 + } else { + lp[i] = byte(f.Log(c)) + } + } + + return p, lp +} + +// NewRSEncoder returns a new Reed-Solomon encoder +// over the given field and number of error correction bytes. +func NewRSEncoder(f *Field, c int) *RSEncoder { + gen, lgen := f.gen(c) + return &RSEncoder{f: f, c: c, gen: gen, lgen: lgen} +} + +// ECC writes to check the error correcting code bytes +// for data using the given Reed-Solomon parameters. +func (rs *RSEncoder) ECC(data []byte, check []byte) { + if len(check) < rs.c { + panic("gf256: invalid check byte length") + } + if rs.c == 0 { + return + } + + // The check bytes are the remainder after dividing + // data padded with c zeros by the generator polynomial. + + // p = data padded with c zeros. + var p []byte + n := len(data) + rs.c + if len(rs.p) >= n { + p = rs.p + } else { + p = make([]byte, n) + } + copy(p, data) + for i := len(data); i < len(p); i++ { + p[i] = 0 + } + + // Divide p by gen, leaving the remainder in p[len(data):]. + // p[0] is the most significant term in p, and + // gen[0] is the most significant term in the generator, + // which is always 1. + // To avoid repeated work, we store various values as + // lv, not v, where lv = log[v]. + f := rs.f + lgen := rs.lgen[1:] + for i := 0; i < len(data); i++ { + c := p[i] + if c == 0 { + continue + } + q := p[i+1:] + exp := f.exp[f.log[c]:] + for j, lg := range lgen { + if lg != 255 { // lgen uses 255 for log 0 + q[j] ^= exp[lg] + } + } + } + copy(check, p[len(data):]) + rs.p = p +} diff --git a/vendor/rsc.io/qr/libqrencode/qrencode.go b/vendor/rsc.io/qr/libqrencode/qrencode.go new file mode 100644 index 00000000000..f4ce3ffb666 --- /dev/null +++ b/vendor/rsc.io/qr/libqrencode/qrencode.go @@ -0,0 +1,149 @@ +// Copyright 2011 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 libqrencode wraps the C libqrencode library. +// The qr package (in this package's parent directory) +// does not use any C wrapping. This code is here only +// for use during that package's tests. +package libqrencode + +/* +#cgo LDFLAGS: -lqrencode +#include +*/ +import "C" + +import ( + "fmt" + "image" + "image/color" + "unsafe" +) + +type Version int + +type Mode int + +const ( + Numeric Mode = C.QR_MODE_NUM + Alphanumeric Mode = C.QR_MODE_AN + EightBit Mode = C.QR_MODE_8 +) + +type Level int + +const ( + L Level = C.QR_ECLEVEL_L + M Level = C.QR_ECLEVEL_M + Q Level = C.QR_ECLEVEL_Q + H Level = C.QR_ECLEVEL_H +) + +type Pixel int + +const ( + Black Pixel = 1 << iota + DataECC + Format + PVersion + Timing + Alignment + Finder + NonData +) + +type Code struct { + Version int + Width int + Pixel [][]Pixel + Scale int +} + +func (*Code) ColorModel() color.Model { + return color.RGBAModel +} + +func (c *Code) Bounds() image.Rectangle { + d := (c.Width + 8) * c.Scale + return image.Rect(0, 0, d, d) +} + +var ( + white color.Color = color.RGBA{0xFF, 0xFF, 0xFF, 0xFF} + black color.Color = color.RGBA{0x00, 0x00, 0x00, 0xFF} + blue color.Color = color.RGBA{0x00, 0x00, 0x80, 0xFF} + red color.Color = color.RGBA{0xFF, 0x40, 0x40, 0xFF} + yellow color.Color = color.RGBA{0xFF, 0xFF, 0x00, 0xFF} + gray color.Color = color.RGBA{0x80, 0x80, 0x80, 0xFF} + green color.Color = color.RGBA{0x22, 0x8B, 0x22, 0xFF} +) + +func (c *Code) At(x, y int) color.Color { + x = x/c.Scale - 4 + y = y/c.Scale - 4 + if 0 <= x && x < c.Width && 0 <= y && y < c.Width { + switch p := c.Pixel[y][x]; { + case p&Black == 0: + // nothing + case p&DataECC != 0: + return black + case p&Format != 0: + return blue + case p&PVersion != 0: + return red + case p&Timing != 0: + return yellow + case p&Alignment != 0: + return gray + case p&Finder != 0: + return green + } + } + return white +} + +type Chunk struct { + Mode Mode + Text string +} + +func Encode(version Version, level Level, mode Mode, text string) (*Code, error) { + return EncodeChunk(version, level, Chunk{mode, text}) +} + +func EncodeChunk(version Version, level Level, chunk ...Chunk) (*Code, error) { + qi, err := C.QRinput_new2(C.int(version), C.QRecLevel(level)) + if qi == nil { + return nil, fmt.Errorf("QRinput_new2: %v", err) + } + defer C.QRinput_free(qi) + for _, ch := range chunk { + data := []byte(ch.Text) + n, err := C.QRinput_append(qi, C.QRencodeMode(ch.Mode), C.int(len(data)), (*C.uchar)(&data[0])) + if n < 0 { + return nil, fmt.Errorf("QRinput_append %q: %v", data, err) + } + } + + qc, err := C.QRcode_encodeInput(qi) + if qc == nil { + return nil, fmt.Errorf("QRinput_encodeInput: %v", err) + } + + c := &Code{ + Version: int(qc.version), + Width: int(qc.width), + Scale: 16, + } + pix := make([]Pixel, c.Width*c.Width) + cdat := (*[1000 * 1000]byte)(unsafe.Pointer(qc.data))[:len(pix)] + for i := range pix { + pix[i] = Pixel(cdat[i]) + } + c.Pixel = make([][]Pixel, c.Width) + for i := range c.Pixel { + c.Pixel[i] = pix[i*c.Width : (i+1)*c.Width] + } + return c, nil +} diff --git a/vendor/rsc.io/qr/png.go b/vendor/rsc.io/qr/png.go new file mode 100644 index 00000000000..db49d057726 --- /dev/null +++ b/vendor/rsc.io/qr/png.go @@ -0,0 +1,400 @@ +// Copyright 2011 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 qr + +// PNG writer for QR codes. + +import ( + "bytes" + "encoding/binary" + "hash" + "hash/crc32" +) + +// PNG returns a PNG image displaying the code. +// +// PNG uses a custom encoder tailored to QR codes. +// Its compressed size is about 2x away from optimal, +// but it runs about 20x faster than calling png.Encode +// on c.Image(). +func (c *Code) PNG() []byte { + var p pngWriter + return p.encode(c) +} + +type pngWriter struct { + tmp [16]byte + wctmp [4]byte + buf bytes.Buffer + zlib bitWriter + crc hash.Hash32 +} + +var pngHeader = []byte("\x89PNG\r\n\x1a\n") + +func (w *pngWriter) encode(c *Code) []byte { + scale := c.Scale + siz := c.Size + + w.buf.Reset() + + // Header + w.buf.Write(pngHeader) + + // Header block + binary.BigEndian.PutUint32(w.tmp[0:4], uint32((siz+8)*scale)) + binary.BigEndian.PutUint32(w.tmp[4:8], uint32((siz+8)*scale)) + w.tmp[8] = 1 // 1-bit + w.tmp[9] = 0 // gray + w.tmp[10] = 0 + w.tmp[11] = 0 + w.tmp[12] = 0 + w.writeChunk("IHDR", w.tmp[:13]) + + // Comment + w.writeChunk("tEXt", comment) + + // Data + w.zlib.writeCode(c) + w.writeChunk("IDAT", w.zlib.bytes.Bytes()) + + // End + w.writeChunk("IEND", nil) + + return w.buf.Bytes() +} + +var comment = []byte("Software\x00QR-PNG http://qr.swtch.com/") + +func (w *pngWriter) writeChunk(name string, data []byte) { + if w.crc == nil { + w.crc = crc32.NewIEEE() + } + binary.BigEndian.PutUint32(w.wctmp[0:4], uint32(len(data))) + w.buf.Write(w.wctmp[0:4]) + w.crc.Reset() + copy(w.wctmp[0:4], name) + w.buf.Write(w.wctmp[0:4]) + w.crc.Write(w.wctmp[0:4]) + w.buf.Write(data) + w.crc.Write(data) + crc := w.crc.Sum32() + binary.BigEndian.PutUint32(w.wctmp[0:4], crc) + w.buf.Write(w.wctmp[0:4]) +} + +func (b *bitWriter) writeCode(c *Code) { + const ftNone = 0 + + b.adler32.Reset() + b.bytes.Reset() + b.nbit = 0 + + scale := c.Scale + siz := c.Size + + // zlib header + b.tmp[0] = 0x78 + b.tmp[1] = 0 + b.tmp[1] += uint8(31 - (uint16(b.tmp[0])<<8+uint16(b.tmp[1]))%31) + b.bytes.Write(b.tmp[0:2]) + + // Start flate block. + b.writeBits(1, 1, false) // final block + b.writeBits(1, 2, false) // compressed, fixed Huffman tables + + // White border. + // First row. + b.byte(ftNone) + n := (scale*(siz+8) + 7) / 8 + b.byte(255) + b.repeat(n-1, 1) + // 4*scale rows total. + b.repeat((4*scale-1)*(1+n), 1+n) + + for i := 0; i < 4*scale; i++ { + b.adler32.WriteNByte(ftNone, 1) + b.adler32.WriteNByte(255, n) + } + + row := make([]byte, 1+n) + for y := 0; y < siz; y++ { + row[0] = ftNone + j := 1 + var z uint8 + nz := 0 + for x := -4; x < siz+4; x++ { + // Raw data. + for i := 0; i < scale; i++ { + z <<= 1 + if !c.Black(x, y) { + z |= 1 + } + if nz++; nz == 8 { + row[j] = z + j++ + nz = 0 + } + } + } + if j < len(row) { + row[j] = z + } + for _, z := range row { + b.byte(z) + } + + // Scale-1 copies. + b.repeat((scale-1)*(1+n), 1+n) + + b.adler32.WriteN(row, scale) + } + + // White border. + // First row. + b.byte(ftNone) + b.byte(255) + b.repeat(n-1, 1) + // 4*scale rows total. + b.repeat((4*scale-1)*(1+n), 1+n) + + for i := 0; i < 4*scale; i++ { + b.adler32.WriteNByte(ftNone, 1) + b.adler32.WriteNByte(255, n) + } + + // End of block. + b.hcode(256) + b.flushBits() + + // adler32 + binary.BigEndian.PutUint32(b.tmp[0:], b.adler32.Sum32()) + b.bytes.Write(b.tmp[0:4]) +} + +// A bitWriter is a write buffer for bit-oriented data like deflate. +type bitWriter struct { + bytes bytes.Buffer + bit uint32 + nbit uint + + tmp [4]byte + adler32 adigest +} + +func (b *bitWriter) writeBits(bit uint32, nbit uint, rev bool) { + // reverse, for huffman codes + if rev { + br := uint32(0) + for i := uint(0); i < nbit; i++ { + br |= ((bit >> i) & 1) << (nbit - 1 - i) + } + bit = br + } + b.bit |= bit << b.nbit + b.nbit += nbit + for b.nbit >= 8 { + b.bytes.WriteByte(byte(b.bit)) + b.bit >>= 8 + b.nbit -= 8 + } +} + +func (b *bitWriter) flushBits() { + if b.nbit > 0 { + b.bytes.WriteByte(byte(b.bit)) + b.nbit = 0 + b.bit = 0 + } +} + +func (b *bitWriter) hcode(v int) { + /* + Lit Value Bits Codes + --------- ---- ----- + 0 - 143 8 00110000 through + 10111111 + 144 - 255 9 110010000 through + 111111111 + 256 - 279 7 0000000 through + 0010111 + 280 - 287 8 11000000 through + 11000111 + */ + switch { + case v <= 143: + b.writeBits(uint32(v)+0x30, 8, true) + case v <= 255: + b.writeBits(uint32(v-144)+0x190, 9, true) + case v <= 279: + b.writeBits(uint32(v-256)+0, 7, true) + case v <= 287: + b.writeBits(uint32(v-280)+0xc0, 8, true) + default: + panic("invalid hcode") + } +} + +func (b *bitWriter) byte(x byte) { + b.hcode(int(x)) +} + +func (b *bitWriter) codex(c int, val int, nx uint) { + b.hcode(c + val>>nx) + b.writeBits(uint32(val)&(1<= 258+3; n -= 258 { + b.repeat1(258, d) + } + if n > 258 { + // 258 < n < 258+3 + b.repeat1(10, d) + b.repeat1(n-10, d) + return + } + if n < 3 { + panic("invalid flate repeat") + } + b.repeat1(n, d) +} + +func (b *bitWriter) repeat1(n, d int) { + /* + Extra Extra Extra + Code Bits Length(s) Code Bits Lengths Code Bits Length(s) + ---- ---- ------ ---- ---- ------- ---- ---- ------- + 257 0 3 267 1 15,16 277 4 67-82 + 258 0 4 268 1 17,18 278 4 83-98 + 259 0 5 269 2 19-22 279 4 99-114 + 260 0 6 270 2 23-26 280 4 115-130 + 261 0 7 271 2 27-30 281 5 131-162 + 262 0 8 272 2 31-34 282 5 163-194 + 263 0 9 273 3 35-42 283 5 195-226 + 264 0 10 274 3 43-50 284 5 227-257 + 265 1 11,12 275 3 51-58 285 0 258 + 266 1 13,14 276 3 59-66 + */ + switch { + case n <= 10: + b.codex(257, n-3, 0) + case n <= 18: + b.codex(265, n-11, 1) + case n <= 34: + b.codex(269, n-19, 2) + case n <= 66: + b.codex(273, n-35, 3) + case n <= 130: + b.codex(277, n-67, 4) + case n <= 257: + b.codex(281, n-131, 5) + case n == 258: + b.hcode(285) + default: + panic("invalid repeat length") + } + + /* + Extra Extra Extra + Code Bits Dist Code Bits Dist Code Bits Distance + ---- ---- ---- ---- ---- ------ ---- ---- -------- + 0 0 1 10 4 33-48 20 9 1025-1536 + 1 0 2 11 4 49-64 21 9 1537-2048 + 2 0 3 12 5 65-96 22 10 2049-3072 + 3 0 4 13 5 97-128 23 10 3073-4096 + 4 1 5,6 14 6 129-192 24 11 4097-6144 + 5 1 7,8 15 6 193-256 25 11 6145-8192 + 6 2 9-12 16 7 257-384 26 12 8193-12288 + 7 2 13-16 17 7 385-512 27 12 12289-16384 + 8 3 17-24 18 8 513-768 28 13 16385-24576 + 9 3 25-32 19 8 769-1024 29 13 24577-32768 + */ + if d <= 4 { + b.writeBits(uint32(d-1), 5, true) + } else if d <= 32768 { + nbit := uint(16) + for d <= 1<<(nbit-1) { + nbit-- + } + v := uint32(d - 1) + v &^= 1 << (nbit - 1) // top bit is implicit + code := uint32(2*nbit - 2) // second bit is low bit of code + code |= v >> (nbit - 2) + v &^= 1 << (nbit - 2) + b.writeBits(code, 5, true) + // rest of bits follow + b.writeBits(uint32(v), nbit-2, false) + } else { + panic("invalid repeat distance") + } +} + +func (b *bitWriter) run(v byte, n int) { + if n == 0 { + return + } + b.byte(v) + if n-1 < 3 { + for i := 0; i < n-1; i++ { + b.byte(v) + } + } else { + b.repeat(n-1, 1) + } +} + +type adigest struct { + a, b uint32 +} + +func (d *adigest) Reset() { d.a, d.b = 1, 0 } + +const amod = 65521 + +func aupdate(a, b uint32, pi byte, n int) (aa, bb uint32) { + // TODO(rsc): 6g doesn't do magic multiplies for b %= amod, + // only for b = b%amod. + + // invariant: a, b < amod + if pi == 0 { + b += uint32(n%amod) * a + b = b % amod + return a, b + } + + // n times: + // a += pi + // b += a + // is same as + // b += n*a + n*(n+1)/2*pi + // a += n*pi + m := uint32(n) + b += (m % amod) * a + b = b % amod + b += (m * (m + 1) / 2) % amod * uint32(pi) + b = b % amod + a += (m % amod) * uint32(pi) + a = a % amod + return a, b +} + +func afinish(a, b uint32) uint32 { + return b<<16 | a +} + +func (d *adigest) WriteN(p []byte, n int) { + for i := 0; i < n; i++ { + for _, pi := range p { + d.a, d.b = aupdate(d.a, d.b, pi, 1) + } + } +} + +func (d *adigest) WriteNByte(pi byte, n int) { + d.a, d.b = aupdate(d.a, d.b, pi, n) +} + +func (d *adigest) Sum32() uint32 { return afinish(d.a, d.b) } diff --git a/vendor/rsc.io/qr/qr.go b/vendor/rsc.io/qr/qr.go new file mode 100644 index 00000000000..ace7e6f1d4a --- /dev/null +++ b/vendor/rsc.io/qr/qr.go @@ -0,0 +1,116 @@ +// Copyright 2011 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 qr encodes QR codes. +*/ +package qr // import "rsc.io/qr" + +import ( + "errors" + "image" + "image/color" + + "rsc.io/qr/coding" +) + +// A Level denotes a QR error correction level. +// From least to most tolerant of errors, they are L, M, Q, H. +type Level int + +const ( + L Level = iota // 20% redundant + M // 38% redundant + Q // 55% redundant + H // 65% redundant +) + +// Encode returns an encoding of text at the given error correction level. +func Encode(text string, level Level) (*Code, error) { + // Pick data encoding, smallest first. + // We could split the string and use different encodings + // but that seems like overkill for now. + var enc coding.Encoding + switch { + case coding.Num(text).Check() == nil: + enc = coding.Num(text) + case coding.Alpha(text).Check() == nil: + enc = coding.Alpha(text) + default: + enc = coding.String(text) + } + + // Pick size. + l := coding.Level(level) + var v coding.Version + for v = coding.MinVersion; ; v++ { + if v > coding.MaxVersion { + return nil, errors.New("text too long to encode as QR") + } + if enc.Bits(v) <= v.DataBytes(l)*8 { + break + } + } + + // Build and execute plan. + p, err := coding.NewPlan(v, l, 0) + if err != nil { + return nil, err + } + cc, err := p.Encode(enc) + if err != nil { + return nil, err + } + + // TODO: Pick appropriate mask. + + return &Code{cc.Bitmap, cc.Size, cc.Stride, 8}, nil +} + +// A Code is a square pixel grid. +// It implements image.Image and direct PNG encoding. +type Code struct { + Bitmap []byte // 1 is black, 0 is white + Size int // number of pixels on a side + Stride int // number of bytes per row + Scale int // number of image pixels per QR pixel +} + +// Black returns true if the pixel at (x,y) is black. +func (c *Code) Black(x, y int) bool { + return 0 <= x && x < c.Size && 0 <= y && y < c.Size && + c.Bitmap[y*c.Stride+x/8]&(1< Date: Sat, 15 Aug 2026 12:06:00 +0200 Subject: [PATCH 02/29] Implement QR code generation and display for quick tunnels --- cmd/cloudflared/tunnel/quick_tunnel.go | 93 ++++++++++++++-- cmd/cloudflared/tunnel/quick_tunnel_test.go | 111 ++++++++++++++++++++ 2 files changed, 196 insertions(+), 8 deletions(-) create mode 100644 cmd/cloudflared/tunnel/quick_tunnel_test.go diff --git a/cmd/cloudflared/tunnel/quick_tunnel.go b/cmd/cloudflared/tunnel/quick_tunnel.go index fdc38caf475..0cb8ef2cf2b 100644 --- a/cmd/cloudflared/tunnel/quick_tunnel.go +++ b/cmd/cloudflared/tunnel/quick_tunnel.go @@ -10,6 +10,7 @@ import ( "github.com/google/uuid" "github.com/pkg/errors" + "rsc.io/qr" "github.com/cloudflare/cloudflared/cmd/cloudflared/cliutil" "github.com/cloudflare/cloudflared/cmd/cloudflared/flags" @@ -18,6 +19,10 @@ import ( const httpTimeout = 15 * time.Second +// qrQuietZoneModules is the number of empty modules added around the rendered +// QR code. Four modules is the minimum quiet zone required by the QR spec. +const qrQuietZoneModules = 4 + const disclaimer = "Thank you for trying Cloudflare Tunnel. Doing so, without a Cloudflare account, is a quick way to experiment and try it out. However, be aware that these account-less Tunnels have no uptime guarantee, are subject to the Cloudflare Online Services Terms of Use (https://www.cloudflare.com/website-terms/), and Cloudflare reserves the right to investigate your use of Tunnels for violations of such terms. If you intend to use Tunnels in production you should use a pre-created named tunnel by following: https://developers.cloudflare.com/cloudflare-one/connections/connect-apps" // RunQuickTunnel requests a tunnel from the specified service. @@ -72,15 +77,21 @@ func RunQuickTunnel(sc *subcommandContext) error { TunnelID: tunnelID, } - url := data.Result.Hostname - if !strings.HasPrefix(url, "https://") { - url = "https://" + url - } + cliutil.LogTable(sc.log, quickTunnelURLDisplayLines(data.Result.Hostname)) - cliutil.LogTable(sc.log, []string{ - "Your quick Tunnel has been created! Visit it at (it may take some time to be reachable):", - url, - }) + quickTunnelQRLines, err := quickTunnelQRCodeLines(data.Result.Hostname) + if err != nil { + sc.log.Warn().Err(err).Msg("Failed to generate quick Tunnel QR code") + } else { + // Filter out the all-white quiet-zone rows so the terminal output + // stays compact while the QR code itself remains scannable. + for _, line := range quickTunnelQRLines { + if line != "" { + sc.log.Info().Msg(line) + } + } + sc.log.Info().Msg("") + } if !sc.c.IsSet(flags.Protocol) { _ = sc.c.Set(flags.Protocol, "quic") @@ -97,6 +108,72 @@ func RunQuickTunnel(sc *subcommandContext) error { ) } +func quickTunnelURLDisplayLines(hostname string) []string { + return []string{ + "Your quick Tunnel has been created! Visit it at (it may take some time to be reachable):", + normalizeQuickTunnelURL(hostname), + } +} + +func quickTunnelQRCodeLines(hostname string) ([]string, error) { + url := normalizeQuickTunnelURL(hostname) + code, err := qr.Encode(url, qr.L) + if err != nil { + return nil, errors.Wrap(err, "failed to create quick Tunnel QR code") + } + + return renderHalfBlockQRCode(code, qrQuietZoneModules), nil +} + +func renderHalfBlockQRCode(code *qr.Code, quietZone int) []string { + minX, minY, maxX, maxY := code.Size, code.Size, 0, 0 + for y := 0; y < code.Size; y++ { + for x := 0; x < code.Size; x++ { + if code.Black(x, y) { + minX = min(minX, x) + minY = min(minY, y) + maxX = max(maxX, x) + maxY = max(maxY, y) + } + } + } + + minX -= quietZone + minY -= quietZone + maxX += quietZone + maxY += quietZone + + lines := make([]string, 0, ((maxY-minY)+2)/2) + lineWidth := maxX - minX + 1 + for y := minY; y <= maxY; y += 2 { + var line strings.Builder + line.Grow(lineWidth) + for x := minX; x <= maxX; x++ { + top := code.Black(x, y) + bottom := y+1 <= maxY && code.Black(x, y+1) + switch { + case top && bottom: + line.WriteRune('█') + case top: + line.WriteRune('▀') + case bottom: + line.WriteRune('▄') + default: + line.WriteRune(' ') + } + } + lines = append(lines, line.String()) + } + return lines +} + +func normalizeQuickTunnelURL(hostname string) string { + if strings.HasPrefix(hostname, "https://") { + return hostname + } + return "https://" + hostname +} + type QuickTunnelResponse struct { Success bool Result QuickTunnel diff --git a/cmd/cloudflared/tunnel/quick_tunnel_test.go b/cmd/cloudflared/tunnel/quick_tunnel_test.go new file mode 100644 index 00000000000..19537c5b9b8 --- /dev/null +++ b/cmd/cloudflared/tunnel/quick_tunnel_test.go @@ -0,0 +1,111 @@ +package tunnel + +import ( + "strings" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "rsc.io/qr" +) + +func TestQuickTunnelURLDisplayLinesNormalizeURL(t *testing.T) { + t.Parallel() + + lines := quickTunnelURLDisplayLines("example.trycloudflare.com") + + require.Len(t, lines, 2) + assert.Equal(t, "Your quick Tunnel has been created! Visit it at (it may take some time to be reachable):", lines[0]) + assert.Equal(t, "https://example.trycloudflare.com", lines[1]) +} + +func TestQuickTunnelURLDisplayLinesPreserveHTTPSURL(t *testing.T) { + t.Parallel() + + lines := quickTunnelURLDisplayLines("https://example.trycloudflare.com") + + require.Len(t, lines, 2) + assert.Equal(t, "https://example.trycloudflare.com", lines[1]) +} + +func TestQuickTunnelQRCodeLinesUseCompactTerminalBlocks(t *testing.T) { + t.Parallel() + + lines, err := quickTunnelQRCodeLines("example.trycloudflare.com") + + require.NoError(t, err) + require.NotEmpty(t, lines) + qrOutput := strings.Join(lines, "\n") + assert.Contains(t, qrOutput, "▀") + assert.Contains(t, qrOutput, "▄") + assert.NotContains(t, qrOutput, "https://example.trycloudflare.com") +} + +func TestQuickTunnelQRCodeLinesKeepScanQuietZone(t *testing.T) { + t.Parallel() + + lines, err := quickTunnelQRCodeLines("example.trycloudflare.com") + + require.NoError(t, err) + require.Greater(t, len(lines), 4) + assert.Empty(t, strings.TrimSpace(lines[0])) + assert.Empty(t, strings.TrimSpace(lines[1])) + assert.Empty(t, strings.TrimSpace(lines[len(lines)-2])) + assert.Empty(t, strings.TrimSpace(lines[len(lines)-1])) + assert.NotEmpty(t, strings.TrimSpace(lines[2])) + for _, line := range lines[2 : len(lines)-2] { + assert.True(t, strings.HasPrefix(line, " ")) + } +} + +func TestQuickTunnelQRCodeLinesReturnsErrorForURLTooLong(t *testing.T) { + t.Parallel() + + // A URL longer than the largest QR version can encode. + longURL := strings.Repeat("a", 10000) + + _, err := quickTunnelQRCodeLines(longURL) + + require.Error(t, err) + assert.Contains(t, err.Error(), "failed to create quick Tunnel QR code") +} + +func TestRenderHalfBlockQRCodeMatchesSourceBitmap(t *testing.T) { + t.Parallel() + + url := "https://example.trycloudflare.com" + code, err := qr.Encode(url, qr.L) + require.NoError(t, err) + + quietZone := 2 + lines := renderHalfBlockQRCode(code, quietZone) + require.NotEmpty(t, lines) + + // Reconstruct a per-module bitmap from the half-block terminal output + // and compare it to the original QR code. + for row, line := range lines { + yTop := row*2 - quietZone + yBottom := yTop + 1 + col := 0 + for _, r := range line { + x := col - quietZone + switch r { + case '█': + assert.True(t, code.Black(x, yTop), "expected black at (%d,%d)", x, yTop) + assert.True(t, code.Black(x, yBottom), "expected black at (%d,%d)", x, yBottom) + case '▀': + assert.True(t, code.Black(x, yTop), "expected black at (%d,%d)", x, yTop) + assert.False(t, code.Black(x, yBottom), "expected white at (%d,%d)", x, yBottom) + case '▄': + assert.False(t, code.Black(x, yTop), "expected white at (%d,%d)", x, yTop) + assert.True(t, code.Black(x, yBottom), "expected black at (%d,%d)", x, yBottom) + case ' ': + assert.False(t, code.Black(x, yTop), "expected white at (%d,%d)", x, yTop) + assert.False(t, code.Black(x, yBottom), "expected white at (%d,%d)", x, yBottom) + default: + t.Fatalf("unexpected rune %q at row %d col %d", r, row, col) + } + col++ + } + } +} From d7ac7efd0394d69f48d210ebe515e0048214f423 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20=22Pisco=22=20Fernandes?= Date: Thu, 20 Aug 2026 10:37:18 +0100 Subject: [PATCH 03/29] chore: Update distrolesss images in amd64 --- Dockerfile | 2 +- Dockerfile.amd64 | 2 +- Dockerfile.fips.amd64 | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Dockerfile b/Dockerfile index 06e61cda9c3..4206ae345c7 100644 --- a/Dockerfile +++ b/Dockerfile @@ -20,7 +20,7 @@ COPY . . RUN make cloudflared # use a distroless base image with glibc -FROM gcr.io/distroless/base-debian13:nonroot@sha256:b78832f41c8128046807c24840ebee4f1c18ba7870eed423d8750c272c15e147 +FROM gcr.io/distroless/base-debian13:nonroot@sha256:97b9d04bed1c754b756c3c4b6a04915c22fb0b5d96a59944eb3bf78c26e6e157 LABEL org.opencontainers.image.source="https://github.com/cloudflare/cloudflared" diff --git a/Dockerfile.amd64 b/Dockerfile.amd64 index 52909933c0a..05d634b8ab0 100644 --- a/Dockerfile.amd64 +++ b/Dockerfile.amd64 @@ -15,7 +15,7 @@ COPY . . RUN GOOS=linux GOARCH=amd64 make cloudflared # use a distroless base image with glibc -FROM gcr.io/distroless/base-debian13:nonroot-amd64@sha256:ce2a20e0e277b7d913aa8bcfa098fc2a543dc08028f7393434963fa24b39ea81 +FROM gcr.io/distroless/base-debian13:nonroot-amd64@sha256:a9fb022501d14a340fa5f5edb4168c2d32f68c8c80ec3520064f5bf4cc0fa51c LABEL org.opencontainers.image.source="https://github.com/cloudflare/cloudflared" diff --git a/Dockerfile.fips.amd64 b/Dockerfile.fips.amd64 index f7129637f46..0081502e1dd 100644 --- a/Dockerfile.fips.amd64 +++ b/Dockerfile.fips.amd64 @@ -16,7 +16,7 @@ COPY . . RUN FIPS=true GOOS=linux GOARCH=amd64 make cloudflared # use a distroless base image with glibc -FROM gcr.io/distroless/base-debian13:nonroot-amd64@sha256:ce2a20e0e277b7d913aa8bcfa098fc2a543dc08028f7393434963fa24b39ea81 +FROM gcr.io/distroless/base-debian13:nonroot-amd64@sha256:a9fb022501d14a340fa5f5edb4168c2d32f68c8c80ec3520064f5bf4cc0fa51c LABEL org.opencontainers.image.source="https://github.com/cloudflare/cloudflared" From 4960a5c50a3a3f0dc540bc3db089ea9964ff2b36 Mon Sep 17 00:00:00 2001 From: Devin Carr Date: Wed, 26 Aug 2026 02:52:11 -0700 Subject: [PATCH 04/29] chore: bump gorilla/websocket for GO-2026-6278 https://pkg.go.dev/vuln/GO-2026-6278 Closes GO-2026 --- go.mod | 2 +- go.sum | 2 ++ vendor/github.com/gorilla/websocket/README.md | 6 ------ vendor/github.com/gorilla/websocket/client.go | 18 +++++++++++++++--- vendor/github.com/gorilla/websocket/conn.go | 8 ++++++++ vendor/github.com/gorilla/websocket/server.go | 4 ++-- vendor/github.com/gorilla/websocket/util.go | 15 +++++++++++++++ vendor/modules.txt | 2 +- 8 files changed, 44 insertions(+), 13 deletions(-) diff --git a/go.mod b/go.mod index 9d0aff0384a..c1e5b490e89 100644 --- a/go.mod +++ b/go.mod @@ -16,7 +16,7 @@ require ( github.com/gobwas/ws v1.2.1 github.com/google/gopacket v1.1.19 github.com/google/uuid v1.6.0 - github.com/gorilla/websocket v1.5.0 + github.com/gorilla/websocket v1.5.3 github.com/json-iterator/go v1.1.12 github.com/mattn/go-colorable v0.1.13 github.com/mitchellh/go-homedir v1.1.0 diff --git a/go.sum b/go.sum index 9523a0890aa..b8871713ff3 100644 --- a/go.sum +++ b/go.sum @@ -107,6 +107,8 @@ github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+ github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc= github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= +github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/grpc-ecosystem/grpc-gateway/v2 v2.28.0 h1:HWRh5R2+9EifMyIHV7ZV+MIZqgz+PMpZ14Jynv3O2Zs= github.com/grpc-ecosystem/grpc-gateway/v2 v2.28.0/go.mod h1:JfhWUomR1baixubs02l85lZYYOm7LV6om4ceouMv45c= github.com/ipostelnik/cli/v2 v2.3.1-0.20210324024421-b6ea8234fe3d h1:PRDnysJ9dF1vUMmEzBu6aHQeUluSQy4eWH3RsSSy/vI= diff --git a/vendor/github.com/gorilla/websocket/README.md b/vendor/github.com/gorilla/websocket/README.md index 2517a28715f..d33ed7fdd8f 100644 --- a/vendor/github.com/gorilla/websocket/README.md +++ b/vendor/github.com/gorilla/websocket/README.md @@ -7,12 +7,6 @@ Gorilla WebSocket is a [Go](http://golang.org/) implementation of the [WebSocket](http://www.rfc-editor.org/rfc/rfc6455.txt) protocol. ---- - -⚠️ **[The Gorilla WebSocket Package is looking for a new maintainer](https://github.com/gorilla/websocket/issues/370)** - ---- - ### Documentation * [API Reference](https://pkg.go.dev/github.com/gorilla/websocket?tab=doc) diff --git a/vendor/github.com/gorilla/websocket/client.go b/vendor/github.com/gorilla/websocket/client.go index 2efd83555d3..04fdafee18e 100644 --- a/vendor/github.com/gorilla/websocket/client.go +++ b/vendor/github.com/gorilla/websocket/client.go @@ -9,6 +9,7 @@ import ( "context" "crypto/tls" "errors" + "fmt" "io" "io/ioutil" "net" @@ -318,14 +319,14 @@ func (d *Dialer) DialContext(ctx context.Context, urlStr string, requestHeader h } netConn, err := netDial("tcp", hostPort) + if err != nil { + return nil, nil, err + } if trace != nil && trace.GotConn != nil { trace.GotConn(httptrace.GotConnInfo{ Conn: netConn, }) } - if err != nil { - return nil, nil, err - } defer func() { if netConn != nil { @@ -370,6 +371,17 @@ func (d *Dialer) DialContext(ctx context.Context, urlStr string, requestHeader h resp, err := http.ReadResponse(conn.br, req) if err != nil { + if d.TLSClientConfig != nil { + for _, proto := range d.TLSClientConfig.NextProtos { + if proto != "http/1.1" { + return nil, nil, fmt.Errorf( + "websocket: protocol %q was given but is not supported;"+ + "sharing tls.Config with net/http Transport can cause this error: %w", + proto, err, + ) + } + } + } return nil, nil, err } diff --git a/vendor/github.com/gorilla/websocket/conn.go b/vendor/github.com/gorilla/websocket/conn.go index 331eebc8500..5161ef81f62 100644 --- a/vendor/github.com/gorilla/websocket/conn.go +++ b/vendor/github.com/gorilla/websocket/conn.go @@ -1189,8 +1189,16 @@ func (c *Conn) SetPongHandler(h func(appData string) error) { c.handlePong = h } +// NetConn returns the underlying connection that is wrapped by c. +// Note that writing to or reading from this connection directly will corrupt the +// WebSocket connection. +func (c *Conn) NetConn() net.Conn { + return c.conn +} + // UnderlyingConn returns the internal net.Conn. This can be used to further // modifications to connection specific flags. +// Deprecated: Use the NetConn method. func (c *Conn) UnderlyingConn() net.Conn { return c.conn } diff --git a/vendor/github.com/gorilla/websocket/server.go b/vendor/github.com/gorilla/websocket/server.go index 24d53b38abe..bb335974321 100644 --- a/vendor/github.com/gorilla/websocket/server.go +++ b/vendor/github.com/gorilla/websocket/server.go @@ -154,8 +154,8 @@ func (u *Upgrader) Upgrade(w http.ResponseWriter, r *http.Request, responseHeade } challengeKey := r.Header.Get("Sec-Websocket-Key") - if challengeKey == "" { - return u.returnError(w, r, http.StatusBadRequest, "websocket: not a websocket handshake: 'Sec-WebSocket-Key' header is missing or blank") + if !isValidChallengeKey(challengeKey) { + return u.returnError(w, r, http.StatusBadRequest, "websocket: not a websocket handshake: 'Sec-WebSocket-Key' header must be Base64 encoded value of 16-byte in length") } subprotocol := u.selectSubprotocol(r, responseHeader) diff --git a/vendor/github.com/gorilla/websocket/util.go b/vendor/github.com/gorilla/websocket/util.go index 7bf2f66c674..31a5dee6462 100644 --- a/vendor/github.com/gorilla/websocket/util.go +++ b/vendor/github.com/gorilla/websocket/util.go @@ -281,3 +281,18 @@ headers: } return result } + +// isValidChallengeKey checks if the argument meets RFC6455 specification. +func isValidChallengeKey(s string) bool { + // From RFC6455: + // + // A |Sec-WebSocket-Key| header field with a base64-encoded (see + // Section 4 of [RFC4648]) value that, when decoded, is 16 bytes in + // length. + + if s == "" { + return false + } + decoded, err := base64.StdEncoding.DecodeString(s) + return err == nil && len(decoded) == 16 +} diff --git a/vendor/modules.txt b/vendor/modules.txt index 8479bf4f4d4..b3f06d957a4 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -109,7 +109,7 @@ github.com/google/gopacket/layers # github.com/google/uuid v1.6.0 ## explicit github.com/google/uuid -# github.com/gorilla/websocket v1.5.0 +# github.com/gorilla/websocket v1.5.3 ## explicit; go 1.12 github.com/gorilla/websocket # github.com/grpc-ecosystem/grpc-gateway/v2 v2.28.0 From a0309440cab55fc1993bf234a6b25a1e34668a76 Mon Sep 17 00:00:00 2001 From: Devin Carr Date: Tue, 25 Aug 2026 17:19:15 -0700 Subject: [PATCH 05/29] TUN-10725: Remove unused certificate configuration --- tlsconfig/{certreloader.go => origin_ca.go} | 73 +++----------- tlsconfig/tlsconfig.go | 102 -------------------- tlsconfig/tlsconfig_test.go | 79 +++------------ 3 files changed, 22 insertions(+), 232 deletions(-) rename tlsconfig/{certreloader.go => origin_ca.go} (66%) delete mode 100644 tlsconfig/tlsconfig.go diff --git a/tlsconfig/certreloader.go b/tlsconfig/origin_ca.go similarity index 66% rename from tlsconfig/certreloader.go rename to tlsconfig/origin_ca.go index def07013ba5..1716ea661ef 100644 --- a/tlsconfig/certreloader.go +++ b/tlsconfig/origin_ca.go @@ -1,3 +1,4 @@ +// Package tlsconfig builds base TLS configuration for edge and origin connections. package tlsconfig import ( @@ -6,9 +7,7 @@ import ( "fmt" "os" "runtime" - "sync" - "github.com/getsentry/sentry-go" "github.com/pkg/errors" "github.com/rs/zerolog" ) @@ -17,59 +16,6 @@ const ( OriginCAPoolFlag = "origin-ca-pool" ) -// CertReloader can load and reload a TLS certificate from a particular filepath. -// Hooks into tls.Config's GetCertificate to allow a TLS server to update its certificate without restarting. -type CertReloader struct { - sync.Mutex - certificate *tls.Certificate - certPath string - keyPath string -} - -// NewCertReloader makes a CertReloader. It loads the cert during initialization to make sure certPath and keyPath are valid -func NewCertReloader(certPath, keyPath string) (*CertReloader, error) { - cr := new(CertReloader) - cr.certPath = certPath - cr.keyPath = keyPath - if err := cr.LoadCert(); err != nil { - return nil, err - } - return cr, nil -} - -// Cert returns the TLS certificate most recently read by the CertReloader. -// This method works as a direct utility method for tls.Config#Cert. -func (cr *CertReloader) Cert(clientHello *tls.ClientHelloInfo) (*tls.Certificate, error) { - cr.Lock() - defer cr.Unlock() - return cr.certificate, nil -} - -// ClientCert returns the TLS certificate most recently read by the CertReloader. -// This method works as a direct utility method for tls.Config#ClientCert. -func (cr *CertReloader) ClientCert(certRequestInfo *tls.CertificateRequestInfo) (*tls.Certificate, error) { - cr.Lock() - defer cr.Unlock() - return cr.certificate, nil -} - -// LoadCert loads a TLS certificate from the CertReloader's specified filepath. -// Call this after writing a new certificate to the disk (e.g. after renewing a certificate) -func (cr *CertReloader) LoadCert() error { - cr.Lock() - defer cr.Unlock() - - cert, err := tls.LoadX509KeyPair(cr.certPath, cr.keyPath) - - // Keep the old certificate if there's a problem reading the new one. - if err != nil { - sentry.CaptureException(fmt.Errorf("error parsing X509 key pair: %v", err)) - return err - } - cr.certificate = &cert - return nil -} - func LoadOriginCA(originCAPoolFilename string, log *zerolog.Logger) (*x509.CertPool, error) { var originCustomCAPool []byte @@ -128,15 +74,18 @@ func LoadCustomOriginCA(originCAFilename string) (*x509.CertPool, error) { } func CreateTunnelConfig(caCert string, serverName string) (*tls.Config, error) { - var rootCAs []string + tlsConfig := &tls.Config{ServerName: serverName} if caCert != "" { - rootCAs = append(rootCAs, caCert) - } + caCertPEM, err := os.ReadFile(caCert) //nolint:gosec + if err != nil { + return nil, fmt.Errorf("read CA certificate %s: %w", caCert, err) + } - userConfig := &TLSParameters{RootCAs: rootCAs, ServerName: serverName} - tlsConfig, err := GetConfig(userConfig) - if err != nil { - return nil, err + rootCAPool := x509.NewCertPool() + if !rootCAPool.AppendCertsFromPEM(caCertPEM) { + return nil, fmt.Errorf("parse CA certificate %s", caCert) + } + tlsConfig.RootCAs = rootCAPool } if tlsConfig.RootCAs == nil { diff --git a/tlsconfig/tlsconfig.go b/tlsconfig/tlsconfig.go deleted file mode 100644 index 3e6cea203b6..00000000000 --- a/tlsconfig/tlsconfig.go +++ /dev/null @@ -1,102 +0,0 @@ -// Package tlsconfig provides convenience functions for configuring TLS connections from the -// command line. -package tlsconfig - -import ( - "crypto/tls" - "crypto/x509" - "os" - - "github.com/pkg/errors" -) - -// Config is the user provided parameters to create a tls.Config -type TLSParameters struct { - Cert string - Key string - GetCertificate *CertReloader - GetClientCertificate *CertReloader - ClientCAs []string - RootCAs []string - ServerName string - CurvePreferences []tls.CurveID - MinVersion uint16 // min tls version. If zero, TLS1.0 is defined as minimum. - MaxVersion uint16 // max tls version. If zero, last TLS version is used defined as limit (currently TLS1.3) -} - -// GetConfig returns a TLS configuration according to the Config set by the user. -func GetConfig(p *TLSParameters) (*tls.Config, error) { - tlsconfig := &tls.Config{} - if p.Cert != "" && p.Key != "" { - cert, err := tls.LoadX509KeyPair(p.Cert, p.Key) - if err != nil { - return nil, errors.Wrap(err, "Error parsing X509 key pair") - } - tlsconfig.Certificates = []tls.Certificate{cert} - // BuildNameToCertificate parses Certificates and builds NameToCertificate from common name - // and SAN fields of leaf certificates - tlsconfig.BuildNameToCertificate() - } - - if p.GetCertificate != nil { - // GetCertificate is called when client supplies SNI info or Certificates is empty. - // Order of retrieving certificate is GetCertificate, NameToCertificate and lastly first element of Certificates - tlsconfig.GetCertificate = p.GetCertificate.Cert - } - - if p.GetClientCertificate != nil { - // GetClientCertificate is called when using an HTTP client library and mTLS is required. - tlsconfig.GetClientCertificate = p.GetClientCertificate.ClientCert - } - - if len(p.ClientCAs) > 0 { - // set of root certificate authorities that servers use if required to verify a client certificate - // by the policy in ClientAuth - clientCAs, err := LoadCert(p.ClientCAs) - if err != nil { - return nil, errors.Wrap(err, "Error loading client CAs") - } - tlsconfig.ClientCAs = clientCAs - // server's policy for TLS Client Authentication. Default is no client cert - tlsconfig.ClientAuth = tls.RequireAndVerifyClientCert - } - - if len(p.RootCAs) > 0 { - rootCAs, err := LoadCert(p.RootCAs) - if err != nil { - return nil, errors.Wrap(err, "Error loading root CAs") - } - tlsconfig.RootCAs = rootCAs - } - - if p.ServerName != "" { - tlsconfig.ServerName = p.ServerName - } - - if len(p.CurvePreferences) > 0 { - tlsconfig.CurvePreferences = p.CurvePreferences - } else { - // Cloudflare optimize CurveP256 - tlsconfig.CurvePreferences = []tls.CurveID{tls.CurveP256} - } - - tlsconfig.MinVersion = p.MinVersion - tlsconfig.MaxVersion = p.MaxVersion - - return tlsconfig, nil -} - -// LoadCert creates a CertPool containing all certificates in a PEM-format file. -func LoadCert(certPaths []string) (*x509.CertPool, error) { - ca := x509.NewCertPool() - for _, certPath := range certPaths { - caCert, err := os.ReadFile(certPath) - if err != nil { - return nil, errors.Wrapf(err, "Error reading certificate %s", certPath) - } - if !ca.AppendCertsFromPEM(caCert) { - return nil, errors.Wrapf(err, "Error parsing certificate %s", certPath) - } - } - return ca, nil -} diff --git a/tlsconfig/tlsconfig_test.go b/tlsconfig/tlsconfig_test.go index 26eb1056d50..631bf07c985 100644 --- a/tlsconfig/tlsconfig_test.go +++ b/tlsconfig/tlsconfig_test.go @@ -1,82 +1,25 @@ package tlsconfig import ( - "crypto/tls" "testing" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) -// testcert.pem and testcert2.pem are Generated using `openssl req -newkey rsa:512 -nodes -x509 -days 3650` -const ( - testcertCommonName = "localhost" -) - -func TestGetFromEmptyConfig(t *testing.T) { - c := &TLSParameters{} - - tlsConfig, err := GetConfig(c) - assert.NoError(t, err) - assert.Empty(t, tlsConfig.Certificates) - - assert.Empty(t, tlsConfig.NameToCertificate) - - assert.Nil(t, tlsConfig.ClientCAs) - assert.Equal(t, tls.NoClientCert, tlsConfig.ClientAuth) - - assert.Nil(t, tlsConfig.RootCAs) - - assert.Len(t, tlsConfig.CurvePreferences, 1) - assert.Equal(t, tls.CurveP256, tlsConfig.CurvePreferences[0]) -} - -func TestGetConfig(t *testing.T) { - cert, err := tls.LoadX509KeyPair("testcert.pem", "testkey.pem") - assert.NoError(t, err) - - c := &TLSParameters{ - Cert: "testcert.pem", - Key: "testkey.pem", - ClientCAs: []string{"testcert.pem", "testcert2.pem"}, - RootCAs: []string{"testcert.pem", "testcert2.pem"}, - ServerName: "test", - CurvePreferences: []tls.CurveID{tls.CurveP384}, - } - tlsConfig, err := GetConfig(c) - assert.NoError(t, err) - assert.Len(t, tlsConfig.Certificates, 1) - assert.Equal(t, cert, tlsConfig.Certificates[0]) - - assert.Equal(t, cert, *tlsConfig.NameToCertificate[testcertCommonName]) - - assert.NotNil(t, tlsConfig.ClientCAs) - assert.Equal(t, tls.RequireAndVerifyClientCert, tlsConfig.ClientAuth) +func TestCreateTunnelConfig(t *testing.T) { + t.Parallel() + tlsConfig, err := CreateTunnelConfig("testcert.pem", "edge.example.com") + require.NoError(t, err) + assert.Equal(t, "edge.example.com", tlsConfig.ServerName) assert.NotNil(t, tlsConfig.RootCAs) - - assert.Len(t, tlsConfig.CurvePreferences, 1) - assert.Equal(t, tls.CurveP384, tlsConfig.CurvePreferences[0]) + assert.Empty(t, tlsConfig.CurvePreferences) } -func TestCertReloader(t *testing.T) { - expectedCert, err := tls.LoadX509KeyPair("testcert.pem", "testkey.pem") - assert.NoError(t, err) - - certReloader, err := NewCertReloader("testcert.pem", "testkey.pem") - assert.NoError(t, err) - - chi := &tls.ClientHelloInfo{ServerName: testcertCommonName} - cert, err := certReloader.Cert(chi) - assert.NoError(t, err) - assert.Equal(t, expectedCert, *cert) - - c := &TLSParameters{ - GetCertificate: certReloader, - } - tlsConfig, err := GetConfig(c) - assert.NoError(t, err) +func TestCreateTunnelConfigRequiresServerName(t *testing.T) { + t.Parallel() - cert, err = tlsConfig.GetCertificate(chi) - assert.NoError(t, err) - assert.Equal(t, expectedCert, *cert) + _, err := CreateTunnelConfig("testcert.pem", "") + assert.EqualError(t, err, "either ServerName or InsecureSkipVerify must be specified in the tls.Config") } From 7c4688a5f72a5618aa09b8a850ce18e9182f2809 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20=22Pisco=22=20Fernandes?= Date: Wed, 26 Aug 2026 15:25:17 +0100 Subject: [PATCH 06/29] VULN-142146: Update GitLab R2 token path (cloudflared-pkgs) to protected branches Closes VULN-142146 --- .ci/release.gitlab-ci.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.ci/release.gitlab-ci.yml b/.ci/release.gitlab-ci.yml index 89d687432e1..c45fd06e583 100644 --- a/.ci/release.gitlab-ci.yml +++ b/.ci/release.gitlab-ci.yml @@ -51,10 +51,10 @@ include: vault: gitlab/cloudflare/tun/cloudflared/_dev/cfd_github_api_key/data@kv file: false R2_CLIENT_ID: - vault: gitlab/cloudflare/tun/cloudflared/_dev/_terraform_atlantis/r2_api_token/client_id@kv + vault: gitlab/cloudflare/tun/cloudflared/_protected/true/_terraform_atlantis/r2_api_token/client_id@kv file: false R2_CLIENT_SECRET: - vault: gitlab/cloudflare/tun/cloudflared/_dev/_terraform_atlantis/r2_api_token/client_secret@kv + vault: gitlab/cloudflare/tun/cloudflared/_protected/true/_terraform_atlantis/r2_api_token/client_secret@kv file: false LINUX_SIGNING_PUBLIC_KEY: vault: gitlab/cloudflare/tun/cloudflared/_dev/gpg_v1/public_key@kv From f6debd2d4f0b177a730b5880a0581f7d7b47146c Mon Sep 17 00:00:00 2001 From: Devin Carr Date: Wed, 26 Aug 2026 13:30:40 -0700 Subject: [PATCH 07/29] TUN-10820: Remove test-only stdin reconnect control Remove the hidden stdin-control flag and ReconnectSignal plumbing used to force tunnel reconnections through stdin. Delete the associated component test and supervisor control implementation. Serve QUIC and HTTP/2 connections directly with the caller context instead of wrapping them in an additional errgroup for reconnect signals. Automatic reconnection after genuine transport failures remains unchanged. This removal should help simplify the supervisor loop a bit and make way for better improvements in this area. Closes TUN-10820 --- cmd/cloudflared/tunnel/cmd.go | 56 +------------------------- component-tests/test_reconnect.py | 51 ------------------------ supervisor/external_control.go | 21 ---------- supervisor/supervisor.go | 12 +----- supervisor/tunnel.go | 65 ++++--------------------------- 5 files changed, 9 insertions(+), 196 deletions(-) delete mode 100644 component-tests/test_reconnect.py delete mode 100644 supervisor/external_control.go diff --git a/cmd/cloudflared/tunnel/cmd.go b/cmd/cloudflared/tunnel/cmd.go index 6320d0d278b..4abd9bccad2 100644 --- a/cmd/cloudflared/tunnel/cmd.go +++ b/cmd/cloudflared/tunnel/cmd.go @@ -1,7 +1,6 @@ package tunnel import ( - "bufio" "context" "fmt" "net" @@ -9,7 +8,6 @@ import ( "os" "path/filepath" "runtime/trace" - "strings" "sync" "time" @@ -51,7 +49,6 @@ const ( //nolint:gosec // This is the Sentry DSN for cloudflared which is safe to be public sentryDSN = "https://56a9c9fa5c364ab28f34b14f35ea0f1b:3e8827f6f9f740738eb11138f7bebb68@sentry.io/189878" - LogFieldCommand = "command" LogFieldExpandedPath = "expandedPath" LogFieldPIDPathname = "pidPathname" LogFieldTmpTraceFilename = "tmpTraceFilename" @@ -147,7 +144,6 @@ var ( "compression-quality", "use-reconnect-token", "dial-edge-timeout", - "stdin-control", cfdflags.Name, cfdflags.Ui, "quick-service", @@ -502,19 +498,13 @@ func StartServer( errC <- metrics.ServeMetrics(metricsListener, ctx, metricsConfig, log) }() - reconnectCh := make(chan supervisor.ReconnectSignal, c.Int(cfdflags.HaConnections)) - if c.IsSet("stdin-control") { - log.Info().Msg("Enabling control through stdin") - go stdinControl(reconnectCh, log) - } - wg.Add(1) go func() { defer func() { wg.Done() log.Info().Msg("Tunnel server stopped") }() - errC <- supervisor.StartTunnelDaemon(ctx, tunnelConfig, orchestrator, connectedSignal, reconnectCh, graceShutdownC) + errC <- supervisor.StartTunnelDaemon(ctx, tunnelConfig, orchestrator, connectedSignal, graceShutdownC) }() gracePeriod, err := gracePeriod(c) @@ -849,13 +839,6 @@ func tunnelFlags(shouldHide bool) []cli.Flag { EnvVars: []string{"DIAL_EDGE_TIMEOUT"}, Hidden: true, }), - altsrc.NewBoolFlag(&cli.BoolFlag{ - Name: "stdin-control", - Usage: "Control the process using commands sent through stdin", - EnvVars: []string{"STDIN_CONTROL"}, - Hidden: true, - Value: false, - }), altsrc.NewStringFlag(&cli.StringFlag{ Name: cfdflags.Name, Aliases: []string{"n"}, @@ -1194,43 +1177,6 @@ func sshFlags(shouldHide bool) []cli.Flag { } } -func stdinControl(reconnectCh chan supervisor.ReconnectSignal, log *zerolog.Logger) { - helpStr := strings.Join([]string{ - "Supported command:", - "reconnect [delay]", - "- restarts one randomly chosen connection with optional delay before reconnect\n", - }, "\n") - - for { - scanner := bufio.NewScanner(os.Stdin) - for scanner.Scan() { - command := scanner.Text() - parts := strings.SplitN(command, " ", 2) - - switch parts[0] { - case "": - continue - case "reconnect": - var reconnect supervisor.ReconnectSignal - if len(parts) > 1 { - var err error - if reconnect.Delay, err = time.ParseDuration(parts[1]); err != nil { - log.Error().Msg(err.Error()) - continue - } - } - log.Info().Msgf("Sending %+v", reconnect) - reconnectCh <- reconnect - case "help": - log.Info().Msg(helpStr) - default: - log.Info().Str(LogFieldCommand, command).Msg("Unknown command") - log.Info().Msg(helpStr) - } - } - } -} - func nonSecretCliFlags(log *zerolog.Logger, cli *cli.Context, flagInclusionList []string) map[string]string { flagsNames := cli.FlagNames() flags := make(map[string]string, len(flagsNames)) diff --git a/component-tests/test_reconnect.py b/component-tests/test_reconnect.py deleted file mode 100644 index ece68bdc1c1..00000000000 --- a/component-tests/test_reconnect.py +++ /dev/null @@ -1,51 +0,0 @@ -#!/usr/bin/env python -import copy -import platform -from time import sleep - -import pytest -from flaky import flaky - -from conftest import CfdModes -from constants import protocols -from util import start_cloudflared, wait_tunnel_ready, check_tunnel_not_connected - - -@flaky(max_runs=3, min_passes=1) -class TestReconnect: - default_ha_conns = 1 - default_reconnect_secs = 15 - extra_config = { - "stdin-control": True, - } - - def _extra_config(self, protocol): - return { - "stdin-control": True, - "protocol": protocol, - } - - @pytest.mark.skipif(platform.system() == "Windows", reason=f"Currently buggy on Windows TUN-4584") - @pytest.mark.parametrize("protocol", protocols()) - def test_named_reconnect(self, tmp_path, component_tests_config, protocol): - config = component_tests_config(self._extra_config(protocol)) - with start_cloudflared(tmp_path, config, cfd_pre_args=["tunnel", "--ha-connections", "1"], new_process=True, allow_input=True, capture_output=False) as cloudflared: - # Repeat the test multiple times because some issues only occur after multiple reconnects - self.assert_reconnect(config, cloudflared, 5) - - def send_reconnect(self, cloudflared, secs): - # Although it is recommended to use the Popen.communicate method, we cannot - # use it because it blocks on reading stdout and stderr until EOF is reached - cloudflared.stdin.write(f"reconnect {secs}s\n".encode()) - cloudflared.stdin.flush() - - def assert_reconnect(self, config, cloudflared, repeat): - wait_tunnel_ready(tunnel_url=config.get_url(), - require_min_connections=self.default_ha_conns) - for _ in range(repeat): - for _ in range(self.default_ha_conns): - self.send_reconnect(cloudflared, self.default_reconnect_secs) - check_tunnel_not_connected() - sleep(self.default_reconnect_secs * 2) - wait_tunnel_ready(tunnel_url=config.get_url(), - require_min_connections=self.default_ha_conns) diff --git a/supervisor/external_control.go b/supervisor/external_control.go deleted file mode 100644 index f170cde252d..00000000000 --- a/supervisor/external_control.go +++ /dev/null @@ -1,21 +0,0 @@ -package supervisor - -import ( - "time" -) - -type ReconnectSignal struct { - // wait this many seconds before re-establish the connection - Delay time.Duration -} - -// Error allows us to use ReconnectSignal as a special error to force connection abort -func (r ReconnectSignal) Error() string { - return "reconnect signal" -} - -func (r ReconnectSignal) DelayBeforeReconnect() { - if r.Delay > 0 { - time.Sleep(r.Delay) - } -} diff --git a/supervisor/supervisor.go b/supervisor/supervisor.go index 5bd49749a49..317bed02b46 100644 --- a/supervisor/supervisor.go +++ b/supervisor/supervisor.go @@ -45,7 +45,6 @@ type Supervisor struct { log *ConnAwareLogger logTransport *zerolog.Logger - reconnectCh chan ReconnectSignal gracefulShutdownC <-chan struct{} } @@ -56,7 +55,7 @@ type tunnelError struct { err error } -func NewSupervisor(config *TunnelConfig, orchestrator *orchestration.Orchestrator, reconnectCh chan ReconnectSignal, gracefulShutdownC <-chan struct{}) (*Supervisor, error) { +func NewSupervisor(config *TunnelConfig, orchestrator *orchestration.Orchestrator, gracefulShutdownC <-chan struct{}) (*Supervisor, error) { isStaticEdge := len(config.EdgeAddrs) > 0 var err error @@ -89,7 +88,6 @@ func NewSupervisor(config *TunnelConfig, orchestrator *orchestration.Orchestrato edgeAddrHandler: edgeAddrHandler, edgeBindAddr: edgeBindAddr, tracker: tracker, - reconnectCh: reconnectCh, gracefulShutdownC: gracefulShutdownC, connAwareLogger: log, } @@ -104,7 +102,6 @@ func NewSupervisor(config *TunnelConfig, orchestrator *orchestration.Orchestrato tunnelsProtocolFallback: map[int]*protocolFallback{}, log: log, logTransport: config.LogTransport, - reconnectCh: reconnectCh, gracefulShutdownC: gracefulShutdownC, }, nil } @@ -157,13 +154,6 @@ func (s *Supervisor) Run( tunnelsActive-- s.log.ConnAwareLogger().Err(tunnelError.err).Int(connection.LogFieldConnIndex, tunnelError.index).Msg("Connection terminated") if tunnelError.err != nil && !shuttingDown { - switch tunnelError.err.(type) { - case ReconnectSignal: - // For tunnels that closed with reconnect signal, we reconnect immediately - go s.startTunnel(ctx, tunnelError.index, s.newConnectedTunnelSignal(tunnelError.index)) - tunnelsActive++ - continue - } // Make sure we don't continue if there is no more fallback allowed if _, retry := s.tunnelsProtocolFallback[tunnelError.index].GetMaxBackoffDuration(ctx); !retry { continue diff --git a/supervisor/tunnel.go b/supervisor/tunnel.go index 2a342b78c54..84c681d6607 100644 --- a/supervisor/tunnel.go +++ b/supervisor/tunnel.go @@ -15,7 +15,6 @@ import ( "github.com/pkg/errors" "github.com/quic-go/quic-go" "github.com/rs/zerolog" - "golang.org/x/sync/errgroup" "github.com/cloudflare/cloudflared/client" "github.com/cloudflare/cloudflared/connection" @@ -97,10 +96,9 @@ func StartTunnelDaemon( config *TunnelConfig, orchestrator *orchestration.Orchestrator, connectedSignal *signal.Signal, - reconnectCh chan ReconnectSignal, graceShutdownC <-chan struct{}, ) error { - s, err := NewSupervisor(config, orchestrator, reconnectCh, graceShutdownC) + s, err := NewSupervisor(config, orchestrator, graceShutdownC) if err != nil { return err } @@ -183,7 +181,6 @@ type EdgeTunnelServer struct { edgeAddrHandler EdgeAddrHandler edgeAddrs *edgediscovery.Edge edgeBindAddr net.IP - reconnectCh chan ReconnectSignal gracefulShutdownC <-chan struct{} tracker *tunnelstate.ConnTracker @@ -415,13 +412,6 @@ func (e *EdgeTunnelServer) serveTunnel( return err.Cause, !err.Permanent case *connection.EdgeQuicDialError: return err, false - case ReconnectSignal: - connLog.Logger().Info(). - IPAddr(connection.LogFieldIPAddress, addr.UDP.IP). - Uint8(connection.LogFieldConnIndex, connIndex). - Msgf("Restarting connection due to reconnect signal in %s", err.Delay) - err.DelayBeforeReconnect() - return err, true default: if err == context.Canceled { connLog.Logger().Debug().Err(err).Msgf("Serve tunnel error") @@ -541,22 +531,7 @@ func (e *EdgeTunnelServer) serveHTTP2( e.config.Log, ) - errGroup, serveCtx := errgroup.WithContext(ctx) - errGroup.Go(func() error { - return h2conn.Serve(serveCtx) - }) - - errGroup.Go(func() error { - err := listenReconnect(serveCtx, e.reconnectCh, e.gracefulShutdownC) - if err != nil { - // forcefully break the connection (this is only used for testing) - // errgroup will return context canceled for the h2conn.Serve - connLog.Logger().Debug().Msg("Forcefully breaking http2 connection") - } - return err - }) - - return errGroup.Wait() + return h2conn.Serve(ctx) } func (e *EdgeTunnelServer) serveQUIC( @@ -654,26 +629,11 @@ func (e *EdgeTunnelServer) serveQUIC( ) // Serve the TunnelConnection - errGroup, serveCtx := errgroup.WithContext(ctx) - errGroup.Go(func() error { - err := tunnelConn.Serve(serveCtx) - if err != nil { - connLogger.ConnAwareLogger().Err(err).Msg("failed to serve tunnel connection") - } - return err - }) - - errGroup.Go(func() error { - err := listenReconnect(serveCtx, e.reconnectCh, e.gracefulShutdownC) - if err != nil { - // forcefully break the connection (this is only used for testing) - // errgroup will return context canceled for the tunnelConn.Serve - connLogger.Logger().Debug().Msg("Forcefully breaking tunnel connection") - } - return err - }) - - return errGroup.Wait(), false + err = tunnelConn.Serve(ctx) + if err != nil { + connLogger.ConnAwareLogger().Err(err).Msg("failed to serve tunnel connection") + } + return err, false } // The reportErrorToSentry is an helper function that handles @@ -696,17 +656,6 @@ func (e *EdgeTunnelServer) reportErrorToSentry(err error, pqMode features.PostQu } } -func listenReconnect(ctx context.Context, reconnectCh <-chan ReconnectSignal, gracefulShutdownCh <-chan struct{}) error { - select { - case reconnect := <-reconnectCh: - return reconnect - case <-gracefulShutdownCh: - return nil - case <-ctx.Done(): - return nil - } -} - type connectedFuse struct { fuse *booleanFuse backoff *protocolFallback From b5f750edb6e9a65383db00f679e6bdb55ab7ae83 Mon Sep 17 00:00:00 2001 From: Devin Carr Date: Thu, 27 Aug 2026 08:38:54 -0700 Subject: [PATCH 08/29] chore: Clean up unused code Delete the unused tunnelsForHA implementations and stale edge discovery test mocks. Remove unpopulated metrics and simplify the stream copy path by dropping its permanently disabled debug implementation. --- connection/metrics.go | 31 +-------- connection/tunnelsforha.go | 50 -------------- edgediscovery/mocks_for_test.go | 118 -------------------------------- stream/stream.go | 50 +------------- supervisor/tunnelsforha.go | 50 -------------- 5 files changed, 4 insertions(+), 295 deletions(-) delete mode 100644 connection/tunnelsforha.go delete mode 100644 edgediscovery/mocks_for_test.go delete mode 100644 supervisor/tunnelsforha.go diff --git a/connection/metrics.go b/connection/metrics.go index 0801ebbc05e..b3e5657d933 100644 --- a/connection/metrics.go +++ b/connection/metrics.go @@ -9,7 +9,6 @@ import ( const ( MetricsNamespace = "cloudflared" TunnelSubsystem = "tunnel" - muxerSubsystem = "muxer" configSubsystem = "config" ) @@ -27,16 +26,14 @@ type tunnelMetrics struct { regSuccess *prometheus.CounterVec regFail *prometheus.CounterVec - rpcFail *prometheus.CounterVec - tunnelsHA tunnelsForHA userHostnamesCounts *prometheus.CounterVec localConfigMetrics *localConfigMetrics } +//nolint:promlinter // Preserve existing metric names for compatibility. func newLocalConfigMetrics() *localConfigMetrics { - pushesMetric := prometheus.NewCounter( prometheus.CounterOpts{ Namespace: MetricsNamespace, @@ -67,18 +64,9 @@ func newLocalConfigMetrics() *localConfigMetrics { } // Metrics that can be collected without asking the edge +// +//nolint:promlinter // Preserve existing metric names for compatibility. func initTunnelMetrics() *tunnelMetrics { - maxConcurrentRequestsPerTunnel := prometheus.NewGaugeVec( - prometheus.GaugeOpts{ - Namespace: MetricsNamespace, - Subsystem: TunnelSubsystem, - Name: "max_concurrent_requests_per_tunnel", - Help: "Largest number of concurrent requests proxied through each tunnel so far", - }, - []string{"connection_id"}, - ) - prometheus.MustRegister(maxConcurrentRequestsPerTunnel) - serverLocations := prometheus.NewGaugeVec( prometheus.GaugeOpts{ Namespace: MetricsNamespace, @@ -90,17 +78,6 @@ func initTunnelMetrics() *tunnelMetrics { ) prometheus.MustRegister(serverLocations) - rpcFail := prometheus.NewCounterVec( - prometheus.CounterOpts{ - Namespace: MetricsNamespace, - Subsystem: TunnelSubsystem, - Name: "tunnel_rpc_fail", - Help: "Count of RPC connection errors by type", - }, - []string{"error", "rpcName"}, - ) - prometheus.MustRegister(rpcFail) - registerFail := prometheus.NewCounterVec( prometheus.CounterOpts{ Namespace: MetricsNamespace, @@ -137,10 +114,8 @@ func initTunnelMetrics() *tunnelMetrics { return &tunnelMetrics{ serverLocations: serverLocations, oldServerLocations: make(map[string]string), - tunnelsHA: newTunnelsForHA(), regSuccess: registerSuccess, regFail: registerFail, - rpcFail: rpcFail, userHostnamesCounts: userHostnamesCounts, localConfigMetrics: newLocalConfigMetrics(), } diff --git a/connection/tunnelsforha.go b/connection/tunnelsforha.go deleted file mode 100644 index 49b36fa5897..00000000000 --- a/connection/tunnelsforha.go +++ /dev/null @@ -1,50 +0,0 @@ -package connection - -import ( - "fmt" - "sync" - - "github.com/prometheus/client_golang/prometheus" -) - -// tunnelsForHA maps this cloudflared instance's HA connections to the tunnel IDs they serve. -type tunnelsForHA struct { - sync.Mutex - metrics *prometheus.GaugeVec - entries map[uint8]string -} - -// NewTunnelsForHA initializes the Prometheus metrics etc for a tunnelsForHA. -func newTunnelsForHA() tunnelsForHA { - metrics := prometheus.NewGaugeVec( - prometheus.GaugeOpts{ - Name: "tunnel_ids", - Help: "The ID of all tunnels (and their corresponding HA connection ID) running in this instance of cloudflared.", - }, - []string{"tunnel_id", "ha_conn_id"}, - ) - prometheus.MustRegister(metrics) - - return tunnelsForHA{ - metrics: metrics, - entries: make(map[uint8]string), - } -} - -// Track a new tunnel ID, removing the disconnected tunnel (if any) and update metrics. -func (t *tunnelsForHA) AddTunnelID(haConn uint8, tunnelID string) { - t.Lock() - defer t.Unlock() - haStr := fmt.Sprintf("%v", haConn) - if oldTunnelID, ok := t.entries[haConn]; ok { - t.metrics.WithLabelValues(oldTunnelID, haStr).Dec() - } - t.entries[haConn] = tunnelID - t.metrics.WithLabelValues(tunnelID, haStr).Inc() -} - -func (t *tunnelsForHA) String() string { - t.Lock() - defer t.Unlock() - return fmt.Sprintf("%v", t.entries) -} diff --git a/edgediscovery/mocks_for_test.go b/edgediscovery/mocks_for_test.go deleted file mode 100644 index 2db110ae74f..00000000000 --- a/edgediscovery/mocks_for_test.go +++ /dev/null @@ -1,118 +0,0 @@ -package edgediscovery - -import ( - "fmt" - "math" - "math/rand" - "net" - "reflect" - "testing/quick" -) - -type mockAddrs struct { - // a set of synthetic SRV records - addrMap map[net.SRV][]*net.TCPAddr - // the total number of addresses, aggregated across addrMap. - // For the convenience of test code that would otherwise have to compute - // this by hand every time. - numAddrs int -} - -func newMockAddrs(port uint16, numRegions uint8, numAddrsPerRegion uint8) mockAddrs { - addrMap := make(map[net.SRV][]*net.TCPAddr) - numAddrs := 0 - - for r := uint8(0); r < numRegions; r++ { - var ( - srv = net.SRV{Target: fmt.Sprintf("test-region-%v.example.com", r), Port: port} - addrs []*net.TCPAddr - ) - for a := uint8(0); a < numAddrsPerRegion; a++ { - addrs = append(addrs, &net.TCPAddr{ - IP: net.ParseIP(fmt.Sprintf("10.0.%v.%v", r, a)), - Port: int(port), - }) - } - addrMap[srv] = addrs - numAddrs += len(addrs) - } - return mockAddrs{addrMap: addrMap, numAddrs: numAddrs} -} - -var _ quick.Generator = mockAddrs{} - -func (mockAddrs) Generate(rand *rand.Rand, size int) reflect.Value { - port := uint16(rand.Intn(math.MaxUint16)) - numRegions := uint8(1 + rand.Intn(10)) - numAddrsPerRegion := uint8(1 + rand.Intn(32)) - result := newMockAddrs(port, numRegions, numAddrsPerRegion) - return reflect.ValueOf(result) -} - -// Returns a function compatible with net.LookupSRV that will return the SRV -// records from mockAddrs. -func mockNetLookupSRV( - m mockAddrs, -) func(service, proto, name string) (cname string, addrs []*net.SRV, err error) { - var addrs []*net.SRV - for k := range m.addrMap { - addr := k - addrs = append(addrs, &addr) - // We can't just do - // addrs = append(addrs, &k) - // `k` will be reused by subsequent loop iterations, - // so all the copies of `&k` would point to the same location. - } - return func(_, _, _ string) (string, []*net.SRV, error) { - return "", addrs, nil - } -} - -// Returns a function compatible with net.LookupIP that translates the SRV records -// from mockAddrs into IP addresses, based on the TCP addresses in mockAddrs. -func mockNetLookupIP( - m mockAddrs, -) func(host string) ([]net.IP, error) { - return func(host string) ([]net.IP, error) { - for srv, tcpAddrs := range m.addrMap { - if srv.Target != host { - continue - } - result := make([]net.IP, len(tcpAddrs)) - for i, tcpAddr := range tcpAddrs { - result[i] = tcpAddr.IP - } - return result, nil - } - return nil, fmt.Errorf("No IPs for %v", host) - } -} - -type mockEdgeServiceDiscoverer struct { -} - -func (mr *mockEdgeServiceDiscoverer) Addr() (*net.TCPAddr, error) { - return &net.TCPAddr{ - IP: net.ParseIP("127.0.0.1"), - Port: 63102, - }, nil -} - -func (mr *mockEdgeServiceDiscoverer) AnyAddr() (*net.TCPAddr, error) { - return &net.TCPAddr{ - IP: net.ParseIP("127.0.0.1"), - Port: 63102, - }, nil -} - -func (mr *mockEdgeServiceDiscoverer) ReplaceAddr(addr *net.TCPAddr) {} - -func (mr *mockEdgeServiceDiscoverer) MarkAddrBad(addr *net.TCPAddr) {} - -func (mr *mockEdgeServiceDiscoverer) AvailableAddrs() int { - return 1 -} - -func (mr *mockEdgeServiceDiscoverer) Refresh() error { - return nil -} diff --git a/stream/stream.go b/stream/stream.go index 3b623241818..98ff27fc672 100644 --- a/stream/stream.go +++ b/stream/stream.go @@ -1,7 +1,6 @@ package stream import ( - "encoding/hex" "fmt" "io" "runtime/debug" @@ -130,56 +129,9 @@ func unidirectionalStream(dst WriterCloser, src Reader, dir string, status *bidi defer func() { _ = dst.CloseWrite() }() - _, err := copyData(dst, src, dir) + _, err := cfio.Copy(dst, src) if err != nil { log.Debug().Msgf("%s copy: %v", dir, err) } status.markUniStreamDone() } - -// when set to true, enables logging of content copied to/from origin and tunnel -const debugCopy = false - -func copyData(dst io.Writer, src io.Reader, dir string) (written int64, err error) { - if debugCopy { - // copyBuffer is based on stdio Copy implementation but shows copied data - copyBuffer := func(dst io.Writer, src io.Reader, dir string) (written int64, err error) { - var buf []byte - size := 32 * 1024 - buf = make([]byte, size) - for { - t := time.Now() - nr, er := src.Read(buf) - if nr > 0 { - fmt.Println(dir, t.UnixNano(), "\n"+hex.Dump(buf[0:nr])) - nw, ew := dst.Write(buf[0:nr]) - if nw < 0 || nr < nw { - nw = 0 - if ew == nil { - ew = errors.New("invalid write") - } - } - written += int64(nw) - if ew != nil { - err = ew - break - } - if nr != nw { - err = io.ErrShortWrite - break - } - } - if er != nil { - if er != io.EOF { - err = er - } - break - } - } - return written, err - } - return copyBuffer(dst, src, dir) - } else { - return cfio.Copy(dst, src) - } -} diff --git a/supervisor/tunnelsforha.go b/supervisor/tunnelsforha.go deleted file mode 100644 index 80704e38fa7..00000000000 --- a/supervisor/tunnelsforha.go +++ /dev/null @@ -1,50 +0,0 @@ -package supervisor - -import ( - "fmt" - "sync" - - "github.com/prometheus/client_golang/prometheus" -) - -// tunnelsForHA maps this cloudflared instance's HA connections to the tunnel IDs they serve. -type tunnelsForHA struct { - sync.Mutex - metrics *prometheus.GaugeVec - entries map[uint8]string -} - -// NewTunnelsForHA initializes the Prometheus metrics etc for a tunnelsForHA. -func NewTunnelsForHA() tunnelsForHA { - metrics := prometheus.NewGaugeVec( - prometheus.GaugeOpts{ - Name: "tunnel_ids", - Help: "The ID of all tunnels (and their corresponding HA connection ID) running in this instance of cloudflared.", - }, - []string{"tunnel_id", "ha_conn_id"}, - ) - prometheus.MustRegister(metrics) - - return tunnelsForHA{ - metrics: metrics, - entries: make(map[uint8]string), - } -} - -// Track a new tunnel ID, removing the disconnected tunnel (if any) and update metrics. -func (t *tunnelsForHA) AddTunnelID(haConn uint8, tunnelID string) { - t.Lock() - defer t.Unlock() - haStr := fmt.Sprintf("%v", haConn) - if oldTunnelID, ok := t.entries[haConn]; ok { - t.metrics.WithLabelValues(oldTunnelID, haStr).Dec() - } - t.entries[haConn] = tunnelID - t.metrics.WithLabelValues(tunnelID, haStr).Inc() -} - -func (t *tunnelsForHA) String() string { - t.Lock() - defer t.Unlock() - return fmt.Sprintf("%v", t.entries) -} From 0f9546b759ed2623634bb9e41dce6ba87a536530 Mon Sep 17 00:00:00 2001 From: Devin Carr Date: Wed, 26 Aug 2026 22:29:14 -0700 Subject: [PATCH 09/29] TUN-10822: Remove fetching protocol percentage from remote Stop fetching protocol rollout percentages from DNS TXT records. Remove the obsolete remote selector, percentage-fetching API, and related tests, and simplify protocol selector construction. --- cmd/cloudflared/tunnel/configuration.go | 3 +- connection/protocol.go | 157 +++--------------------- connection/protocol_test.go | 115 +++-------------- edgediscovery/protocol.go | 52 -------- edgediscovery/protocol_test.go | 12 -- supervisor/tunnel_test.go | 34 +---- 6 files changed, 32 insertions(+), 341 deletions(-) delete mode 100644 edgediscovery/protocol.go delete mode 100644 edgediscovery/protocol_test.go diff --git a/cmd/cloudflared/tunnel/configuration.go b/cmd/cloudflared/tunnel/configuration.go index f4f9a6747f6..cdae8339479 100644 --- a/cmd/cloudflared/tunnel/configuration.go +++ b/cmd/cloudflared/tunnel/configuration.go @@ -22,7 +22,6 @@ import ( "github.com/cloudflare/cloudflared/cmd/cloudflared/flags" "github.com/cloudflare/cloudflared/config" "github.com/cloudflare/cloudflared/connection" - "github.com/cloudflare/cloudflared/edgediscovery" "github.com/cloudflare/cloudflared/edgediscovery/allregions" "github.com/cloudflare/cloudflared/features" "github.com/cloudflare/cloudflared/ingress" @@ -146,7 +145,7 @@ func prepareTunnelConfig( return nil, nil, err } - protocolSelector, err := connection.NewProtocolSelector(transportProtocol, namedTunnel.Credentials.AccountTag, c.IsSet(TunnelTokenFlag), edgediscovery.ProtocolPercentage, connection.ResolveTTL, log) + protocolSelector, err := connection.NewProtocolSelector(transportProtocol, log) if err != nil { return nil, nil, err } diff --git a/connection/protocol.go b/connection/protocol.go index 72e9b765cb2..094bd5ec89d 100644 --- a/connection/protocol.go +++ b/connection/protocol.go @@ -2,17 +2,12 @@ package connection import ( "fmt" - "hash/fnv" - "sync" - "time" "github.com/rs/zerolog" - - "github.com/cloudflare/cloudflared/edgediscovery" ) const ( - AvailableProtocolFlagMessage = "Available protocols: 'auto' - automatically chooses the best protocol over time (the default; and also the recommended one); 'quic' - based on QUIC, relying on UDP egress to Cloudflare edge; 'http2' - using Go's HTTP2 library, relying on TCP egress to Cloudflare edge" + AvailableProtocolFlagMessage = "Available protocols: 'auto' - starts with QUIC and falls back to HTTP/2 (the default and recommended option); 'quic' - based on QUIC, relying on UDP egress to Cloudflare edge; 'http2' - using Go's HTTP2 library, relying on TCP egress to Cloudflare edge" // edgeH2muxTLSServerName is the server name to establish h2mux connection with edge (unused, but kept for legacy reference). _ = "cftunnel.com" // edgeH2TLSServerName is the server name to establish http2 connection with edge @@ -23,12 +18,9 @@ const ( probeTLSServerName = "probe.cftunnel.com" quicProtos = "argotunnel" AutoSelectFlag = "auto" - // SRV and TXT record resolution TTL - ResolveTTL = time.Hour ) -// ProtocolList represents a list of supported protocols for communication with the edge -// in order of precedence for remote percentage fetcher. +// ProtocolList represents the supported protocols for communication with the edge. var ProtocolList = []Protocol{QUIC, HTTP2} type Protocol int64 @@ -106,161 +98,40 @@ type ProtocolSelector interface { Fallback() (Protocol, bool) } -// staticProtocolSelector will not provide a different protocol for Fallback -type staticProtocolSelector struct { - current Protocol -} - -func (s *staticProtocolSelector) Current() Protocol { - return s.current -} - -func (s *staticProtocolSelector) Fallback() (Protocol, bool) { - return s.current, false -} - -// remoteProtocolSelector will fetch a list of remote protocols to provide for edge discovery -type remoteProtocolSelector struct { - lock sync.RWMutex - - current Protocol - - // protocolPool is desired protocols in the order of priority they should be picked in. - protocolPool []Protocol - - switchThreshold int32 - fetchFunc edgediscovery.PercentageFetcher - refreshAfter time.Time - ttl time.Duration - log *zerolog.Logger -} - -func newRemoteProtocolSelector( - current Protocol, - protocolPool []Protocol, - switchThreshold int32, - fetchFunc edgediscovery.PercentageFetcher, - ttl time.Duration, - log *zerolog.Logger, -) *remoteProtocolSelector { - return &remoteProtocolSelector{ - current: current, - protocolPool: protocolPool, - switchThreshold: switchThreshold, - fetchFunc: fetchFunc, - refreshAfter: time.Now().Add(ttl), - ttl: ttl, - log: log, - } +type protocolSelector struct { + current Protocol + allowFallback bool } -func (s *remoteProtocolSelector) Current() Protocol { - s.lock.Lock() - defer s.lock.Unlock() - if time.Now().Before(s.refreshAfter) { - return s.current - } - - protocol, err := getProtocol(s.protocolPool, s.fetchFunc, s.switchThreshold) - if err != nil { - s.log.Err(err).Msg("Failed to refresh protocol") - return s.current - } - s.current = protocol - - s.refreshAfter = time.Now().Add(s.ttl) +func (s *protocolSelector) Current() Protocol { return s.current } -func (s *remoteProtocolSelector) Fallback() (Protocol, bool) { - s.lock.RLock() - defer s.lock.RUnlock() - return s.current.fallback() -} - -func getProtocol(protocolPool []Protocol, fetchFunc edgediscovery.PercentageFetcher, switchThreshold int32) (Protocol, error) { - protocolPercentages, err := fetchFunc() - if err != nil { - return 0, err - } - for _, protocol := range protocolPool { - protocolPercentage := protocolPercentages.GetPercentage(protocol.String()) - if protocolPercentage > switchThreshold { - return protocol, nil - } - } - - // Default to first index in protocolPool list - return protocolPool[0], nil -} - -// defaultProtocolSelector will allow for a protocol to have a fallback -type defaultProtocolSelector struct { - lock sync.RWMutex - current Protocol -} - -func newDefaultProtocolSelector( - current Protocol, -) *defaultProtocolSelector { - return &defaultProtocolSelector{ - current: current, +func (s *protocolSelector) Fallback() (Protocol, bool) { + if !s.allowFallback { + return s.current, false } -} - -func (s *defaultProtocolSelector) Current() Protocol { - s.lock.Lock() - defer s.lock.Unlock() - return s.current -} - -func (s *defaultProtocolSelector) Fallback() (Protocol, bool) { - s.lock.RLock() - defer s.lock.RUnlock() return s.current.fallback() } +// NewProtocolSelector selects the configured edge transport protocol. func NewProtocolSelector( protocolFlag string, - accountTag string, - tunnelTokenProvided bool, - protocolFetcher edgediscovery.PercentageFetcher, - resolveTTL time.Duration, log *zerolog.Logger, ) (ProtocolSelector, error) { - threshold := switchThreshold(accountTag) - fetchedProtocol, err := getProtocol(ProtocolList, protocolFetcher, threshold) - log.Debug().Msgf("Fetched protocol: %s", fetchedProtocol) - if err != nil { - log.Warn().Msg("Unable to lookup protocol percentage.") - // Falling through here since 'auto' is handled in the switch and failing - // to do the protocol lookup isn't a failure since it can be triggered again - // after the TTL. - } - // If the user picks a protocol, then we stick to it no matter what. switch protocolFlag { case "h2mux": // Any users still requesting h2mux will be upgraded to http2 instead log.Warn().Msg("h2mux is no longer a supported protocol: upgrading edge connection to http2. Please remove '--protocol h2mux' from runtime arguments to remove this warning.") - return &staticProtocolSelector{current: HTTP2}, nil + return &protocolSelector{current: HTTP2}, nil case QUIC.String(): - return &staticProtocolSelector{current: QUIC}, nil + return &protocolSelector{current: QUIC}, nil case HTTP2.String(): - return &staticProtocolSelector{current: HTTP2}, nil + return &protocolSelector{current: HTTP2}, nil case AutoSelectFlag: - // When a --token is provided, we want to start with QUIC but have fallback to HTTP2 - if tunnelTokenProvided { - return newDefaultProtocolSelector(QUIC), nil - } - return newRemoteProtocolSelector(fetchedProtocol, ProtocolList, threshold, protocolFetcher, resolveTTL, log), nil + return &protocolSelector{current: QUIC, allowFallback: true}, nil } return nil, fmt.Errorf("unknown protocol %s, %s", protocolFlag, AvailableProtocolFlagMessage) } - -func switchThreshold(accountTag string) int32 { - h := fnv.New32a() - _, _ = h.Write([]byte(accountTag)) - return int32(h.Sum32() % 100) // nolint: gosec -} diff --git a/connection/protocol_test.go b/connection/protocol_test.go index ee0a18b10c1..4264e1c09ba 100644 --- a/connection/protocol_test.go +++ b/connection/protocol_test.go @@ -1,40 +1,22 @@ package connection import ( - "fmt" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - - "github.com/cloudflare/cloudflared/edgediscovery" -) - -const ( - testNoTTL = 0 - testAccountTag = "testAccountTag" ) -type dynamicMockFetcher struct { - protocolPercents edgediscovery.ProtocolPercents - err error -} - -func (dmf *dynamicMockFetcher) fetch() edgediscovery.PercentageFetcher { - return func() (edgediscovery.ProtocolPercents, error) { - return dmf.protocolPercents, dmf.err - } -} - func TestNewProtocolSelector(t *testing.T) { + t.Parallel() + tests := []struct { - name string - protocol string - tunnelTokenProvided bool - expectedProtocol Protocol - hasFallback bool - expectedFallback Protocol - wantErr bool + name string + protocol string + expectedProtocol Protocol + hasFallback bool + expectedFallback Protocol + wantErr bool }{ { name: "named tunnel with unknown protocol", @@ -51,6 +33,11 @@ func TestNewProtocolSelector(t *testing.T) { protocol: "http2", expectedProtocol: HTTP2, }, + { + name: "named tunnel with quic: no fallback", + protocol: "quic", + expectedProtocol: QUIC, + }, { name: "named tunnel with auto: quic", protocol: AutoSelectFlag, @@ -60,13 +47,10 @@ func TestNewProtocolSelector(t *testing.T) { }, } - fetcher := dynamicMockFetcher{ - protocolPercents: edgediscovery.ProtocolPercents{}, - } - for _, test := range tests { t.Run(test.name, func(t *testing.T) { - selector, err := NewProtocolSelector(test.protocol, testAccountTag, test.tunnelTokenProvided, fetcher.fetch(), ResolveTTL, &log) + t.Parallel() + selector, err := NewProtocolSelector(test.protocol, &log) if test.wantErr { assert.Error(t, err, "test %s failed", test.name) } else { @@ -82,75 +66,6 @@ func TestNewProtocolSelector(t *testing.T) { } } -func TestAutoProtocolSelectorRefresh(t *testing.T) { - fetcher := dynamicMockFetcher{} - selector, err := NewProtocolSelector(AutoSelectFlag, testAccountTag, false, fetcher.fetch(), testNoTTL, &log) - require.NoError(t, err) - assert.Equal(t, QUIC, selector.Current()) - - fetcher.protocolPercents = edgediscovery.ProtocolPercents{edgediscovery.ProtocolPercent{Protocol: "http2", Percentage: 100}} - assert.Equal(t, HTTP2, selector.Current()) - - fetcher.protocolPercents = edgediscovery.ProtocolPercents{edgediscovery.ProtocolPercent{Protocol: "http2", Percentage: 0}} - assert.Equal(t, QUIC, selector.Current()) - - fetcher.protocolPercents = edgediscovery.ProtocolPercents{edgediscovery.ProtocolPercent{Protocol: "http2", Percentage: 100}} - assert.Equal(t, HTTP2, selector.Current()) - - fetcher.err = fmt.Errorf("failed to fetch") - assert.Equal(t, HTTP2, selector.Current()) - - fetcher.protocolPercents = edgediscovery.ProtocolPercents{edgediscovery.ProtocolPercent{Protocol: "http2", Percentage: -1}} - fetcher.err = nil - assert.Equal(t, QUIC, selector.Current()) - - fetcher.protocolPercents = edgediscovery.ProtocolPercents{edgediscovery.ProtocolPercent{Protocol: "http2", Percentage: 0}} - assert.Equal(t, QUIC, selector.Current()) - - fetcher.protocolPercents = edgediscovery.ProtocolPercents{edgediscovery.ProtocolPercent{Protocol: "quic", Percentage: 100}} - assert.Equal(t, QUIC, selector.Current()) -} - -func TestHTTP2ProtocolSelectorRefresh(t *testing.T) { - fetcher := dynamicMockFetcher{} - // Since the user chooses http2 on purpose, we always stick to it. - selector, err := NewProtocolSelector(HTTP2.String(), testAccountTag, false, fetcher.fetch(), testNoTTL, &log) - require.NoError(t, err) - assert.Equal(t, HTTP2, selector.Current()) - - fetcher.protocolPercents = edgediscovery.ProtocolPercents{edgediscovery.ProtocolPercent{Protocol: "http2", Percentage: 100}} - assert.Equal(t, HTTP2, selector.Current()) - - fetcher.protocolPercents = edgediscovery.ProtocolPercents{edgediscovery.ProtocolPercent{Protocol: "http2", Percentage: 0}} - assert.Equal(t, HTTP2, selector.Current()) - - fetcher.err = fmt.Errorf("failed to fetch") - assert.Equal(t, HTTP2, selector.Current()) - - fetcher.protocolPercents = edgediscovery.ProtocolPercents{edgediscovery.ProtocolPercent{Protocol: "http2", Percentage: -1}} - fetcher.err = nil - assert.Equal(t, HTTP2, selector.Current()) - - fetcher.protocolPercents = edgediscovery.ProtocolPercents{edgediscovery.ProtocolPercent{Protocol: "http2", Percentage: 0}} - assert.Equal(t, HTTP2, selector.Current()) - - fetcher.protocolPercents = edgediscovery.ProtocolPercents{edgediscovery.ProtocolPercent{Protocol: "http2", Percentage: 100}} - assert.Equal(t, HTTP2, selector.Current()) - - fetcher.protocolPercents = edgediscovery.ProtocolPercents{edgediscovery.ProtocolPercent{Protocol: "http2", Percentage: -1}} - assert.Equal(t, HTTP2, selector.Current()) -} - -func TestAutoProtocolSelectorNoRefreshWithToken(t *testing.T) { - fetcher := dynamicMockFetcher{} - selector, err := NewProtocolSelector(AutoSelectFlag, testAccountTag, true, fetcher.fetch(), testNoTTL, &log) - require.NoError(t, err) - assert.Equal(t, QUIC, selector.Current()) - - fetcher.protocolPercents = edgediscovery.ProtocolPercents{edgediscovery.ProtocolPercent{Protocol: "http2", Percentage: 100}} - assert.Equal(t, QUIC, selector.Current()) -} - func TestProbeTLSSettings(t *testing.T) { tests := []struct { name string diff --git a/edgediscovery/protocol.go b/edgediscovery/protocol.go deleted file mode 100644 index 2427294b5d3..00000000000 --- a/edgediscovery/protocol.go +++ /dev/null @@ -1,52 +0,0 @@ -package edgediscovery - -import ( - "encoding/json" - "fmt" - "net" - "strings" -) - -const ( - protocolRecord = "protocol-v2.argotunnel.com" -) - -var ( - errNoProtocolRecord = fmt.Errorf("No TXT record found for %s to determine connection protocol", protocolRecord) -) - -type PercentageFetcher func() (ProtocolPercents, error) - -// ProtocolPercent represents a single Protocol Percentage combination. -type ProtocolPercent struct { - Protocol string `json:"protocol"` - Percentage int32 `json:"percentage"` -} - -// ProtocolPercents represents the preferred distribution ratio of protocols when protocol isn't specified. -type ProtocolPercents []ProtocolPercent - -// GetPercentage returns the threshold percentage of a single protocol. -func (p ProtocolPercents) GetPercentage(protocol string) int32 { - for _, protocolPercent := range p { - if strings.ToLower(protocolPercent.Protocol) == strings.ToLower(protocol) { - return protocolPercent.Percentage - } - } - return 0 -} - -// ProtocolPercentage returns the ratio of protocols and a specification ratio for their selection. -func ProtocolPercentage() (ProtocolPercents, error) { - records, err := net.LookupTXT(protocolRecord) - if err != nil { - return nil, err - } - if len(records) == 0 { - return nil, errNoProtocolRecord - } - - var protocolsWithPercent ProtocolPercents - err = json.Unmarshal([]byte(records[0]), &protocolsWithPercent) - return protocolsWithPercent, err -} diff --git a/edgediscovery/protocol_test.go b/edgediscovery/protocol_test.go deleted file mode 100644 index 37b9353f2e0..00000000000 --- a/edgediscovery/protocol_test.go +++ /dev/null @@ -1,12 +0,0 @@ -package edgediscovery - -import ( - "testing" - - "github.com/stretchr/testify/assert" -) - -func TestProtocolPercentage(t *testing.T) { - _, err := ProtocolPercentage() - assert.NoError(t, err) -} diff --git a/supervisor/tunnel_test.go b/supervisor/tunnel_test.go index 65cf336650a..390e6169510 100644 --- a/supervisor/tunnel_test.go +++ b/supervisor/tunnel_test.go @@ -10,21 +10,9 @@ import ( "github.com/stretchr/testify/require" "github.com/cloudflare/cloudflared/connection" - "github.com/cloudflare/cloudflared/edgediscovery" "github.com/cloudflare/cloudflared/retry" ) -type dynamicMockFetcher struct { - protocolPercents edgediscovery.ProtocolPercents - err error -} - -func (dmf *dynamicMockFetcher) fetch() edgediscovery.PercentageFetcher { - return func() (edgediscovery.ProtocolPercents, error) { - return dmf.protocolPercents, dmf.err - } -} - func immediateTimeAfter(time.Duration) <-chan time.Time { c := make(chan time.Time, 1) c <- time.Now() @@ -36,18 +24,7 @@ func TestWaitForBackoffFallback(t *testing.T) { backoff := retry.NewBackoff(maxRetries, 40*time.Millisecond, false) backoff.Clock.After = immediateTimeAfter log := zerolog.Nop() - resolveTTL := 10 * time.Second - mockFetcher := dynamicMockFetcher{ - protocolPercents: edgediscovery.ProtocolPercents{edgediscovery.ProtocolPercent{Protocol: "quic", Percentage: 100}}, - } - protocolSelector, err := connection.NewProtocolSelector( - "auto", - "", - false, - mockFetcher.fetch(), - resolveTTL, - &log, - ) + protocolSelector, err := connection.NewProtocolSelector("auto", &log) require.NoError(t, err) initProtocol := protocolSelector.Current() @@ -102,14 +79,7 @@ func TestWaitForBackoffFallback(t *testing.T) { // But if there is no fallback available, then we exhaust the retries despite the type of error. // The reason why there's no fallback available is because we pick a specific protocol instead of letting it be auto. - protocolSelector, err = connection.NewProtocolSelector( - "quic", - "", - false, - mockFetcher.fetch(), - resolveTTL, - &log, - ) + protocolSelector, err = connection.NewProtocolSelector("quic", &log) require.NoError(t, err) protoFallback = &protocolFallback{backoff, protocolSelector.Current(), false} for i := 0; i < int(maxRetries-1); i++ { From 1d914482baa3bacfcf92f6b542bb5c2cb790a85c Mon Sep 17 00:00:00 2001 From: Hugo Vicente Date: Fri, 28 Aug 2026 13:37:05 +0000 Subject: [PATCH 10/29] chore: Remove stale metrics timeout TODO Removes the stale metrics timeout TODO. Go 1.22+ already adjusts pprof write deadlines for the requested profile duration. Addresses: [#1733](https://github.com/cloudflare/cloudflared/issues/1733) --- metrics/metrics.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/metrics/metrics.go b/metrics/metrics.go index de6cad56f3a..abc62504970 100644 --- a/metrics/metrics.go +++ b/metrics/metrics.go @@ -149,8 +149,6 @@ func ServeMetrics( var wg sync.WaitGroup // Metrics port is privileged, so no need for further access control trace.AuthRequest = func(*http.Request) (bool, bool) { return true, true } - // TODO: parameterize ReadTimeout and WriteTimeout. The maximum time we can - // profile CPU usage depends on WriteTimeout h := newMetricsHandler(config, log) server := &http.Server{ ReadTimeout: 10 * time.Second, From 0f4b3abd537639e4041ee0e792500c1532ba854a Mon Sep 17 00:00:00 2001 From: Alessandro Frigerio Date: Fri, 28 Aug 2026 15:37:26 +0000 Subject: [PATCH 11/29] TUN-10798: Parse Quick Tunnel allowed mail rules ## Summary - extract the existing recipient-rule parser and validation helpers from the OTP PoC - normalize and deduplicate repeated or comma-separated exact email and `*@domain` rules - reject malformed addresses, wildcard domains, and empty rule sets - keep the implementation as dead code with no CLI flag, provisioning, auth handler, or transport wiring ## Testing - `make test` - `make lint` ## Jira - [TUN-10798](https://jira.cfdata.org/browse/TUN-10798) --- connection/quick_tunnel_auth_validation.go | 66 +++++++++++ .../quick_tunnel_auth_validation_test.go | 110 ++++++++++++++++++ 2 files changed, 176 insertions(+) create mode 100644 connection/quick_tunnel_auth_validation.go create mode 100644 connection/quick_tunnel_auth_validation_test.go diff --git a/connection/quick_tunnel_auth_validation.go b/connection/quick_tunnel_auth_validation.go new file mode 100644 index 00000000000..d04ba444c1b --- /dev/null +++ b/connection/quick_tunnel_auth_validation.go @@ -0,0 +1,66 @@ +package connection + +import ( + "fmt" + "net/mail" + "strings" + + "golang.org/x/net/idna" +) + +// validateQuickTunnelAllowedMail validates and normalizes exact email addresses and +// wildcard domains from one or more comma-separated values. +func validateQuickTunnelAllowedMail(values []string) (emails, wildcardDomains map[string]struct{}, err error) { + emails, wildcardDomains = make(map[string]struct{}), make(map[string]struct{}) + for i, rawEntry := range strings.Split(strings.Join(values, ","), ",") { + entry := normalizeQuickTunnelEmail(rawEntry) + domain, isWildcard := strings.CutPrefix(entry, "*@") + + switch { + case entry == "": + return nil, nil, fmt.Errorf("allowed mail rule %d is empty", i+1) + + case isWildcard: + if !isValidQuickTunnelEmailDomain(domain) { + return nil, nil, fmt.Errorf( + "allowed mail rule %q has an invalid wildcard domain", + rawEntry, + ) + } + wildcardDomains[domain] = struct{}{} + + default: + if !isValidQuickTunnelEmail(entry) { + return nil, nil, fmt.Errorf( + "allowed mail rule %q is not a valid email address", + rawEntry, + ) + } + emails[entry] = struct{}{} + } + } + + return emails, wildcardDomains, nil +} + +func isValidQuickTunnelEmail(email string) bool { + address, err := mail.ParseAddress(email) + // ParseAddress accepts mailbox forms such as John Smith , + // so require the input to be a bare email address. + if err != nil || address.Address != email { + return false + } + + _, domain, ok := strings.Cut(email, "@") + return ok && isValidQuickTunnelEmailDomain(domain) +} + +func isValidQuickTunnelEmailDomain(domain string) bool { + asciiDomain, err := idna.Registration.ToASCII(domain) + // IDNs must be supplied in their ASCII punycode representation. + return domain != "" && err == nil && asciiDomain == domain +} + +func normalizeQuickTunnelEmail(email string) string { + return strings.ToLower(strings.TrimSpace(email)) +} diff --git a/connection/quick_tunnel_auth_validation_test.go b/connection/quick_tunnel_auth_validation_test.go new file mode 100644 index 00000000000..6fa23eb6872 --- /dev/null +++ b/connection/quick_tunnel_auth_validation_test.go @@ -0,0 +1,110 @@ +package connection + +import ( + "strings" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestValidateQuickTunnelAllowedMail(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + values []string + expectedEmails []string + expectedDomains []string + }{ + {name: "multiple without spaces", values: []string{"one@example.com,two@example.com"}, expectedEmails: []string{"one@example.com", "two@example.com"}}, + {name: "multiple with consistent spaces", values: []string{"one@example.com, two@example.com"}, expectedEmails: []string{"one@example.com", "two@example.com"}}, + {name: "multiple with inconsistent spaces", values: []string{" one@Example.com,two@example.com , THREE@example.com "}, expectedEmails: []string{"one@example.com", "two@example.com", "three@example.com"}}, + {name: "single with leading spaces", values: []string{" user@example.com"}, expectedEmails: []string{"user@example.com"}}, + {name: "single with trailing spaces", values: []string{"user@example.com "}, expectedEmails: []string{"user@example.com"}}, + {name: "single with surrounding spaces", values: []string{" User@Example.com "}, expectedEmails: []string{"user@example.com"}}, + {name: "repeated flags", values: []string{"first@example.com", "second@example.net,*@Example.org"}, expectedEmails: []string{"first@example.com", "second@example.net"}, expectedDomains: []string{"example.org"}}, + {name: "deduplicated", values: []string{"User@example.com,user@example.com", "*@Example.org,*@example.org"}, expectedEmails: []string{"user@example.com"}, expectedDomains: []string{"example.org"}}, + {name: "punycode IDN", values: []string{"jim@something.xn--fiqs8s,*@xn--fiqs8s"}, expectedEmails: []string{"jim@something.xn--fiqs8s"}, expectedDomains: []string{"xn--fiqs8s"}}, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + t.Parallel() + + emails, domains, err := validateQuickTunnelAllowedMail(test.values) + require.NoError(t, err) + assert.Len(t, emails, len(test.expectedEmails)) + assert.Len(t, domains, len(test.expectedDomains)) + for _, email := range test.expectedEmails { + assert.Contains(t, emails, email) + } + for _, domain := range test.expectedDomains { + assert.Contains(t, domains, domain) + } + }) + } +} + +func TestValidateQuickTunnelAllowedMailRejectsMalformedEntries(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + values []string + }{ + {name: "empty"}, + {name: "blank", values: []string{" , "}}, + {name: "display name", values: []string{"User "}}, + {name: "missing wildcard at", values: []string{"*example.com"}}, + {name: "double at", values: []string{"user@@example.com"}}, + {name: "invalid exact domain", values: []string{"user@-example.com"}}, + {name: "empty wildcard domain", values: []string{"*@"}}, + {name: "empty domain label", values: []string{"*@example..com"}}, + {name: "leading domain hyphen", values: []string{"*@-example.com"}}, + {name: "trailing domain hyphen", values: []string{"*@example-.com"}}, + {name: "invalid domain character", values: []string{"*@exam_ple.com"}}, + {name: "unicode IDN", values: []string{"jim@something.\u4e2d\u56fd"}}, + {name: "long domain label", values: []string{"*@" + strings.Repeat("a", 64) + ".com"}}, + {name: "long domain", values: []string{"*@" + strings.Repeat("a.", 126) + "aa"}}, + {name: "domain path", values: []string{"*@example.com/path"}}, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + t.Parallel() + _, _, err := validateQuickTunnelAllowedMail(test.values) + require.Error(t, err) + }) + } +} + +func TestValidateQuickTunnelAllowedMailRejectsEmptyRuleWithoutLeakingValues(t *testing.T) { + t.Parallel() + + values := []string{"first@example.com,,second@example.com"} + _, _, err := validateQuickTunnelAllowedMail(values) + require.EqualError(t, err, "allowed mail rule 2 is empty") + assert.NotContains(t, err.Error(), "example.com") +} + +func TestValidateQuickTunnelAllowedMailReportsInvalidRule(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + values []string + expectedError string + }{ + {name: "email", values: []string{"first@example.com", "private@example.com/path"}, expectedError: `allowed mail rule "private@example.com/path" is not a valid email address`}, + {name: "wildcard", values: []string{"first@example.com", "*@example.com/path"}, expectedError: `allowed mail rule "*@example.com/path" has an invalid wildcard domain`}, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + t.Parallel() + _, _, err := validateQuickTunnelAllowedMail(test.values) + require.EqualError(t, err, test.expectedError) + }) + } +} From 47e98209e0a169bb7c861333fd57c5b0eeb94eaf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20=22Pisco=22=20Fernandes?= Date: Mon, 31 Aug 2026 10:48:10 +0100 Subject: [PATCH 12/29] Release 2026.8.3 --- RELEASE_NOTES | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/RELEASE_NOTES b/RELEASE_NOTES index 889f62d21b9..9f2045bf759 100644 --- a/RELEASE_NOTES +++ b/RELEASE_NOTES @@ -1,3 +1,14 @@ +2026.8.3 +- 2026-08-28 chore: Remove stale metrics timeout TODO +- 2026-08-28 TUN-10798: Parse Quick Tunnel allowed mail rules +- 2026-08-27 chore: Clean up unused code +- 2026-08-26 chore: bump gorilla/websocket for GO-2026-6278 +- 2026-08-26 VULN-142146: Update GitLab R2 token path (cloudflared-pkgs) to protected branches +- 2026-08-26 TUN-10820: Remove test-only stdin reconnect control +- 2026-08-26 TUN-10822: Remove fetching protocol percentage from remote +- 2026-08-25 TUN-10725: Remove unused certificate configuration +- 2026-08-20 chore: Update distrolesss images in amd64 + 2026.8.2 - 2026-08-14 VULN-141859: Revert path normalization From 06da2a0d7b4a4a65640e9f2e0b6074e31eee384e Mon Sep 17 00:00:00 2001 From: Alessandro Frigerio Date: Tue, 1 Sep 2026 16:56:12 +0000 Subject: [PATCH 13/29] fix(ci): use fresh clone for Windows jobs ## Problem Windows CI jobs frequently fail during the `get_sources` phase with hundreds of `Permission denied` warnings while GitLab tries to clean read-only files from `.cache/go/pkg/mod/` left by previous builds. The failure occurs before the build script runs. Example failed job: https://gitlab.cfdata.org/cloudflare/tun/cloudflared/-/jobs/40007572 ## Fix Set `GIT_STRATEGY: clone` on the shared `.windows-build-defaults` anchor so Windows jobs always start from a fresh clone, bypassing the broken cleanup. ## Related - MR !1927 (affected by this issue) --- .ci/windows.gitlab-ci.yml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/.ci/windows.gitlab-ci.yml b/.ci/windows.gitlab-ci.yml index f12ed4c42af..c2b68b0730c 100644 --- a/.ci/windows.gitlab-ci.yml +++ b/.ci/windows.gitlab-ci.yml @@ -5,6 +5,11 @@ include: ### Defaults for Windows Builds ### ################################### .windows-build-defaults: &windows-build-defaults + variables: + # Windows runners often leave read-only files in the Go module cache, + # causing GitLab's default fetch-and-clean strategy to fail with + # "Permission denied" during get_sources. Use a fresh clone instead. + GIT_STRATEGY: clone rules: - !reference [.default-rules, run-always] tags: From 0b152564ea2e6b0045065e83f6b789bb62c8d7b0 Mon Sep 17 00:00:00 2001 From: James Royal Date: Wed, 2 Sep 2026 13:04:04 -0500 Subject: [PATCH 14/29] AUTH-8883 Fix Access token lock self-deadlock during same-process reauth MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit cloudflared access tcp can fetch an Access token, receive a later Access 302 during WebSocket setup, remove the app token, and immediately fetch again in the same process. The token lock files were intentionally left on disk for stale-PID recovery, but that meant the second fetch saw the first fetch’s lock, recognized its own PID as alive, and waited until lock timeout. This change restores normal lock release without losing crash recovery. Lock acquisition now returns an ownership handle with a per-acquisition ID, and getToken() releases both app and org token locks on return. Release only removes the lock if PID, process start time, and acquisition agree. I tested this by manually building and running through a few scenarios on my local machine. So far I haven't seen any lockfiles get left behind and the normal CLI flows are working as expected. Closes AUTH-8883 --- token/lockfile_test.go | 36 +++++++++++-- token/token.go | 109 +++++++++++++++++++++++++++++--------- token/token_fetch_test.go | 103 +++++++++++++++++++++++++++++++++++ 3 files changed, 217 insertions(+), 31 deletions(-) create mode 100644 token/token_fetch_test.go diff --git a/token/lockfile_test.go b/token/lockfile_test.go index eec54276f7e..9fdf86843b8 100644 --- a/token/lockfile_test.go +++ b/token/lockfile_test.go @@ -6,6 +6,7 @@ import ( "path/filepath" "testing" + "github.com/rs/zerolog" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -78,11 +79,11 @@ func TestReadAuthURL_NotExists(t *testing.T) { assert.Empty(t, readAuthURL(tokenPath)) } -func TestTryCreateLockFile_Success(t *testing.T) { +func TestCreateLockFile_Success(t *testing.T) { dir := t.TempDir() path := filepath.Join(dir, "test.lock") - err := tryCreateLockFile(path) + _, err := createLockFile(path) require.NoError(t, err) // verify the file contains valid JSON with our PID @@ -92,16 +93,41 @@ func TestTryCreateLockFile_Success(t *testing.T) { require.NoError(t, json.Unmarshal(data, &content)) assert.Equal(t, int32(os.Getpid()), content.PID) // nolint: gosec assert.Positive(t, content.StartTime) + assert.NotEmpty(t, content.ID) } -func TestTryCreateLockFile_AlreadyExists(t *testing.T) { +func TestLockFileReleaseDoesNotRemoveDifferentAcquisition(t *testing.T) { + t.Parallel() + + dir := t.TempDir() + tokenPath := filepath.Join(dir, "test-token") + log := zerolog.Nop() + + firstLock, err := acquireLockFile(tokenPath, &log) + require.NoError(t, err) + + // Simulate a stale reclaim where another acquirer creates a new lock at the + // same path before the original holder returns and runs its deferred release. + require.NoError(t, os.Remove(tokenPath+".lock")) + secondLock, err := acquireLockFile(tokenPath, &log) + require.NoError(t, err) + + firstLock.release() + assert.FileExists(t, tokenPath+".lock") + + secondLock.release() + assert.NoFileExists(t, tokenPath+".lock") +} + +func TestCreateLockFile_AlreadyExists(t *testing.T) { dir := t.TempDir() path := filepath.Join(dir, "test.lock") - require.NoError(t, tryCreateLockFile(path)) + _, err := createLockFile(path) + require.NoError(t, err) // second create should fail with "already exists" - err := tryCreateLockFile(path) + _, err = createLockFile(path) require.Error(t, err) assert.True(t, os.IsExist(err)) } diff --git a/token/token.go b/token/token.go index b182fa2c760..ab6e9342dde 100644 --- a/token/token.go +++ b/token/token.go @@ -1,6 +1,8 @@ package token import ( + "crypto/rand" + "encoding/hex" "encoding/json" "fmt" "net/http" @@ -41,8 +43,15 @@ type AppInfo struct { // lockContent is the JSON structure written into lock files. type lockContent struct { - PID int32 `json:"pid"` - StartTime int64 `json:"start_time"` + PID int32 `json:"pid"` + StartTime int64 `json:"start_time"` + ID string `json:"id,omitempty"` +} + +type lockFile struct { + path string + content lockContent + log *zerolog.Logger } type jwtPayload struct { @@ -104,28 +113,28 @@ const ( // // On each iteration: // 1. Try to create the file atomically with O_CREATE|O_EXCL. -// If that succeeds, write our PID + start time and return nil. +// If that succeeds, write our PID + start time and return the lock. // 2. If the file already exists, read it and check whether the owning // process is still alive (PID exists and start time matches). // 3. If the owner is alive, sleep for lockRetryInterval and retry. // 4. If the owner is dead (stale lock), remove the file and immediately // retry the O_EXCL create. No sleep (the atomic create is the // tiebreaker if multiple processes race to reclaim). -func acquireLockFile(tokenPath string, log *zerolog.Logger) error { +func acquireLockFile(tokenPath string, log *zerolog.Logger) (*lockFile, error) { lockPath := tokenPath + ".lock" deadline := time.Now().Add(lockTimeout) lastURL := "" for { if time.Now().After(deadline) { - return fmt.Errorf("timed out waiting for lock file %s", lockPath) + return nil, fmt.Errorf("timed out waiting for lock file %s", lockPath) } - err := tryCreateLockFile(lockPath) + content, err := createLockFile(lockPath) if err == nil { log.Debug().Str("path", lockPath).Msg("lock file acquired") - return nil + return &lockFile{path: lockPath, content: content, log: log}, nil } if !os.IsExist(err) { - return errors.Wrapf(err, "failed to create lock file %s", lockPath) + return nil, errors.Wrapf(err, "failed to create lock file %s", lockPath) } // lock file exists, so check if the owner is still alive @@ -167,6 +176,37 @@ func acquireLockFile(tokenPath string, log *zerolog.Logger) error { } } +func (l *lockFile) release() { + if l == nil { + return + } + + data, err := os.ReadFile(l.path) // nolint: gosec + if err != nil { + if !os.IsNotExist(err) { + l.log.Debug().Err(err).Str("path", l.path).Msg("could not read lock file during release") + } + return + } + + var content lockContent + if err := json.Unmarshal(data, &content); err != nil { + l.log.Debug().Err(err).Str("path", l.path).Msg("could not parse lock file during release") + return + } + + if content.ID == "" || + content.ID != l.content.ID || + content.PID != l.content.PID || + content.StartTime != l.content.StartTime { + return + } + + if err := os.Remove(l.path); err != nil && !os.IsNotExist(err) { + l.log.Debug().Err(err).Str("path", l.path).Msg("could not remove lock file during release") + } +} + // readAuthURL reads the auth URL companion file for the given token path. // Returns the URL string, or empty string if the file doesn't exist or // can't be read. @@ -178,13 +218,10 @@ func readAuthURL(tokenPath string) string { return strings.TrimSpace(string(data)) } -// tryCreateLockFile atomically creates the lock file using O_CREATE|O_EXCL -// and writes the current process's PID and start time into it as JSON. -// The file is created with 0600 permissions (owner read/write only). -func tryCreateLockFile(path string) (retErr error) { +func createLockFile(path string) (content lockContent, retErr error) { f, err := os.OpenFile(path, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0600) // nolint: gosec if err != nil { - return err + return lockContent{}, err } defer func() { if retErr != nil { @@ -195,12 +232,16 @@ func tryCreateLockFile(path string) (retErr error) { retErr = f.Close() }() - content, err := newSelfLockContent() + content, err = newSelfLockContent() if err != nil { - return err + return lockContent{}, err + } + + if err := json.NewEncoder(f).Encode(content); err != nil { + return lockContent{}, err } - return json.NewEncoder(f).Encode(content) + return content, nil } // newSelfLockContent returns a lockContent describing the current process. @@ -214,7 +255,19 @@ func newSelfLockContent() (lockContent, error) { if err != nil { return lockContent{}, fmt.Errorf("failed to get own start time: %w", err) } - return lockContent{PID: pid, StartTime: ct}, nil + id, err := newLockID() + if err != nil { + return lockContent{}, err + } + return lockContent{PID: pid, StartTime: ct, ID: id}, nil +} + +func newLockID() (string, error) { + var b [16]byte + if _, err := rand.Read(b[:]); err != nil { + return "", fmt.Errorf("failed to generate lock ID: %w", err) + } + return hex.EncodeToString(b[:]), nil } // isLockFileStale reads the lock file and checks whether the owning process @@ -290,9 +343,11 @@ func getToken(appURL *url.URL, appInfo *AppInfo, useHostOnly bool, autoClose boo return "", errors.Wrap(err, "failed to generate app token file path") } - if err = acquireLockFile(appTokenPath, log); err != nil { + appTokenLock, err := acquireLockFile(appTokenPath, log) + if err != nil { return "", errors.Wrap(err, "failed to acquire app token lock") } + defer appTokenLock.release() // check to see if another process has gotten a token while we waited for the lock if token, err := GetAppTokenIfExists(appInfo); token != "" && err == nil { @@ -301,22 +356,24 @@ func getToken(appURL *url.URL, appInfo *AppInfo, useHostOnly bool, autoClose boo // If an app token couldn't be found on disk, check for an org token and attempt to exchange it for an app token. var orgTokenPath string - orgToken, err := GetOrgTokenIfExists(appInfo.AuthDomain) - if err != nil { + orgToken, orgTokenErr := GetOrgTokenIfExists(appInfo.AuthDomain) + if orgTokenErr != nil { orgTokenPath, err = generateOrgTokenFilePathFromURL(appInfo.AuthDomain) if err != nil { return "", errors.Wrap(err, "failed to generate org token file path") } - if err = acquireLockFile(orgTokenPath, log); err != nil { - return "", errors.Wrap(err, "failed to acquire org token lock") + orgTokenLock, orgLockErr := acquireLockFile(orgTokenPath, log) + if orgLockErr != nil { + return "", errors.Wrap(orgLockErr, "failed to acquire org token lock") } + defer orgTokenLock.release() // check if an org token has been created since the lock was acquired - orgToken, err = GetOrgTokenIfExists(appInfo.AuthDomain) + orgToken, orgTokenErr = GetOrgTokenIfExists(appInfo.AuthDomain) } - if err == nil { - if appToken, err := exchangeOrgToken(appURL, orgToken); err != nil { - log.Debug().Msgf("failed to exchange org token for app token: %s", err) + if orgTokenErr == nil { + if appToken, exchangeErr := exchangeOrgToken(appURL, orgToken); exchangeErr != nil { + log.Debug().Msgf("failed to exchange org token for app token: %s", exchangeErr) } else { // generate app path if err := os.WriteFile(appTokenPath, []byte(appToken), 0600); err != nil { // nolint: gosec diff --git a/token/token_fetch_test.go b/token/token_fetch_test.go new file mode 100644 index 00000000000..5d8d41876a1 --- /dev/null +++ b/token/token_fetch_test.go @@ -0,0 +1,103 @@ +package token + +import ( + "crypto/rand" + "crypto/rsa" + "encoding/json" + "net/http" + "net/http/httptest" + "net/url" + "os" + "testing" + "time" + + "github.com/go-jose/go-jose/v4" + "github.com/rs/zerolog" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestFetchTokenWithRedirectAllowsSameProcessReauthentication(t *testing.T) { + useTempHome(t) + + log := zerolog.Nop() + key, err := rsa.GenerateKey(rand.Reader, 2048) + require.NoError(t, err) + + appToken := signedAccessToken(t, key, "app-aud", time.Now().Add(time.Hour)) + orgToken := signedAccessToken(t, key, "org-aud", time.Now().Add(time.Hour)) + + appInfo := &AppInfo{ + AuthDomain: "auth.example.com", + AppAUD: "app-aud", + AppHostname: "app.example.com", + } + appTokenPath, err := GenerateAppTokenFilePathFromURL(appInfo.AppHostname, appInfo.AppAUD, keyName) + require.NoError(t, err) + + orgTokenPath, err := generateOrgTokenFilePathFromURL(appInfo.AuthDomain) + require.NoError(t, err) + require.NoError(t, os.WriteFile(orgTokenPath, []byte(orgToken), 0600)) + + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + http.SetCookie(w, &http.Cookie{ + Name: tokenCookie, + Value: appToken, + Expires: time.Now().Add(time.Hour), + Secure: true, + HttpOnly: true, + SameSite: http.SameSiteStrictMode, + }) + w.WriteHeader(http.StatusOK) + })) + t.Cleanup(server.Close) + + appURL, err := url.Parse(server.URL) + require.NoError(t, err) + + fetchedToken, err := FetchTokenWithRedirect(appURL, appInfo, false, false, &log) + require.NoError(t, err) + assert.Equal(t, appToken, fetchedToken) + assert.NoFileExists(t, appTokenPath+".lock") + + // This mirrors the WebSocket 302 retry path, which removes the app token + // before fetching a replacement in the same cloudflared process. + require.NoError(t, RemoveTokenIfExists(appInfo)) + + done := make(chan struct{}) + var retryToken string + var retryErr error + go func() { + defer close(done) + retryToken, retryErr = FetchTokenWithRedirect(appURL, appInfo, false, false, &log) + }() + + select { + case <-done: + require.NoError(t, retryErr) + assert.Equal(t, appToken, retryToken) + assert.NoFileExists(t, appTokenPath+".lock") + case <-time.After(500 * time.Millisecond): + t.Fatal("same-process token retry waited on a lock left behind by the first token fetch") + } +} + +func signedAccessToken(t *testing.T, key *rsa.PrivateKey, aud string, expiresAt time.Time) string { + t.Helper() + + signer, err := jose.NewSigner(jose.SigningKey{Algorithm: jose.RS256, Key: key}, (&jose.SignerOptions{}).WithType("JWT")) + require.NoError(t, err) + + payload, err := json.Marshal(map[string]any{ + "aud": aud, + "exp": expiresAt.Unix(), + }) + require.NoError(t, err) + + jws, err := signer.Sign(payload) + require.NoError(t, err) + + token, err := jws.CompactSerialize() + require.NoError(t, err) + return token +} From 323b4dc0bc14ab8701c89310a5b68af0a22e85f6 Mon Sep 17 00:00:00 2001 From: Devin Carr Date: Wed, 2 Sep 2026 16:21:50 -0700 Subject: [PATCH 15/29] TUN-10829: Remove vendoring Remove the tracked vendor directory and build cloudflared from the locked Go module graph instead. - Use read-only module mode for build, test, vet, formatting, and linting. - Configure CI and Docker builders to use Athens with public-proxy and VCS fallback. - Download modules in a separate Docker layer for reusable image builds. - Remove obsolete module checksums and add the missing shell interpreter to the FIPS verification script. Closes TUN-10829 --- .ci/linux.gitlab-ci.yml | 8 +- .ci/mac.gitlab-ci.yml | 11 +- .ci/scripts/fmt-check.sh | 2 +- .ci/scripts/mac/build.sh | 6 +- .ci/scripts/windows/builds.ps1 | 7 + .ci/scripts/windows/component-test.ps1 | 7 +- .ci/windows.gitlab-ci.yml | 11 +- .dockerignore | 16 + .gitignore | 1 + .gitlab-ci.yml | 4 + .golangci.yaml | 11 +- AGENTS.md | 6 +- Dockerfile | 6 +- Dockerfile.amd64 | 6 +- Dockerfile.arm64 | 6 +- Dockerfile.fips.amd64 | 6 +- Dockerfile.fips.arm64 | 6 +- Makefile | 10 +- check-fips.sh | 2 + go.sum | 2 - vendor/github.com/BurntSushi/toml/.gitignore | 2 - vendor/github.com/BurntSushi/toml/COPYING | 21 - vendor/github.com/BurntSushi/toml/README.md | 120 - vendor/github.com/BurntSushi/toml/decode.go | 602 - .../BurntSushi/toml/decode_go116.go | 19 - .../github.com/BurntSushi/toml/deprecated.go | 21 - vendor/github.com/BurntSushi/toml/doc.go | 13 - vendor/github.com/BurntSushi/toml/encode.go | 736 - vendor/github.com/BurntSushi/toml/error.go | 276 - .../github.com/BurntSushi/toml/internal/tz.go | 36 - vendor/github.com/BurntSushi/toml/lex.go | 1233 -- vendor/github.com/BurntSushi/toml/meta.go | 121 - vendor/github.com/BurntSushi/toml/parse.go | 781 - .../github.com/BurntSushi/toml/type_fields.go | 242 - .../github.com/BurntSushi/toml/type_toml.go | 70 - vendor/github.com/beorn7/perks/LICENSE | 20 - .../beorn7/perks/quantile/exampledata.txt | 2388 --- .../beorn7/perks/quantile/stream.go | 316 - .../github.com/cespare/xxhash/v2/LICENSE.txt | 22 - vendor/github.com/cespare/xxhash/v2/README.md | 74 - .../github.com/cespare/xxhash/v2/testall.sh | 10 - vendor/github.com/cespare/xxhash/v2/xxhash.go | 243 - .../cespare/xxhash/v2/xxhash_amd64.s | 209 - .../cespare/xxhash/v2/xxhash_arm64.s | 183 - .../cespare/xxhash/v2/xxhash_asm.go | 15 - .../cespare/xxhash/v2/xxhash_other.go | 76 - .../cespare/xxhash/v2/xxhash_safe.go | 16 - .../cespare/xxhash/v2/xxhash_unsafe.go | 58 - .../github.com/cloudflare/backoff/.travis.yml | 24 - vendor/github.com/cloudflare/backoff/LICENSE | 24 - .../github.com/cloudflare/backoff/README.md | 83 - .../github.com/cloudflare/backoff/backoff.go | 197 - vendor/github.com/coreos/go-oidc/v3/LICENSE | 202 - vendor/github.com/coreos/go-oidc/v3/NOTICE | 5 - .../github.com/coreos/go-oidc/v3/oidc/jose.go | 32 - .../github.com/coreos/go-oidc/v3/oidc/jwks.go | 263 - .../github.com/coreos/go-oidc/v3/oidc/oidc.go | 584 - .../coreos/go-oidc/v3/oidc/verify.go | 338 - .../github.com/coreos/go-systemd/v22/LICENSE | 191 - .../github.com/coreos/go-systemd/v22/NOTICE | 5 - .../coreos/go-systemd/v22/daemon/sdnotify.go | 84 - .../coreos/go-systemd/v22/daemon/watchdog.go | 73 - .../cpuguy83/go-md2man/v2/LICENSE.md | 21 - .../cpuguy83/go-md2man/v2/md2man/md2man.go | 14 - .../cpuguy83/go-md2man/v2/md2man/roff.go | 345 - vendor/github.com/davecgh/go-spew/LICENSE | 15 - .../github.com/davecgh/go-spew/spew/bypass.go | 145 - .../davecgh/go-spew/spew/bypasssafe.go | 38 - .../github.com/davecgh/go-spew/spew/common.go | 341 - .../github.com/davecgh/go-spew/spew/config.go | 306 - vendor/github.com/davecgh/go-spew/spew/doc.go | 211 - .../github.com/davecgh/go-spew/spew/dump.go | 509 - .../github.com/davecgh/go-spew/spew/format.go | 419 - .../github.com/davecgh/go-spew/spew/spew.go | 148 - .../github.com/ebitengine/purego/.gitignore | 1 - vendor/github.com/ebitengine/purego/LICENSE | 201 - vendor/github.com/ebitengine/purego/README.md | 119 - .../github.com/ebitengine/purego/abi_amd64.h | 99 - .../github.com/ebitengine/purego/abi_arm64.h | 39 - .../ebitengine/purego/abi_loong64.h | 60 - vendor/github.com/ebitengine/purego/cgo.go | 19 - .../github.com/ebitengine/purego/dlerror.go | 17 - vendor/github.com/ebitengine/purego/dlfcn.go | 99 - .../ebitengine/purego/dlfcn_android.go | 34 - .../ebitengine/purego/dlfcn_darwin.go | 20 - .../ebitengine/purego/dlfcn_freebsd.go | 14 - .../ebitengine/purego/dlfcn_linux.go | 16 - .../ebitengine/purego/dlfcn_netbsd.go | 15 - .../ebitengine/purego/dlfcn_nocgo_freebsd.go | 11 - .../ebitengine/purego/dlfcn_nocgo_linux.go | 19 - .../ebitengine/purego/dlfcn_nocgo_netbsd.go | 9 - .../ebitengine/purego/dlfcn_playground.go | 24 - .../ebitengine/purego/dlfcn_stubs.s | 22 - vendor/github.com/ebitengine/purego/func.go | 571 - vendor/github.com/ebitengine/purego/gen.go | 6 - .../ebitengine/purego/go_runtime.go | 13 - .../purego/internal/cgo/dlfcn_cgo_unix.go | 56 - .../ebitengine/purego/internal/cgo/empty.go | 6 - .../purego/internal/cgo/syscall_cgo_unix.go | 55 - .../purego/internal/fakecgo/abi_amd64.h | 99 - .../purego/internal/fakecgo/abi_arm64.h | 39 - .../purego/internal/fakecgo/abi_loong64.h | 60 - .../purego/internal/fakecgo/abi_ppc64x.h | 195 - .../purego/internal/fakecgo/asm_386.s | 29 - .../purego/internal/fakecgo/asm_amd64.s | 39 - .../purego/internal/fakecgo/asm_arm.s | 52 - .../purego/internal/fakecgo/asm_arm64.s | 36 - .../purego/internal/fakecgo/asm_loong64.s | 40 - .../purego/internal/fakecgo/asm_ppc64le.s | 82 - .../purego/internal/fakecgo/asm_riscv64.s | 78 - .../purego/internal/fakecgo/asm_s390x.s | 55 - .../purego/internal/fakecgo/callbacks.go | 93 - .../ebitengine/purego/internal/fakecgo/doc.go | 32 - .../purego/internal/fakecgo/fakecgo.go | 14 - .../purego/internal/fakecgo/freebsd.go | 27 - .../purego/internal/fakecgo/go_darwin.go | 88 - .../purego/internal/fakecgo/go_freebsd.go | 100 - .../purego/internal/fakecgo/go_libinit.go | 72 - .../purego/internal/fakecgo/go_linux.go | 100 - .../purego/internal/fakecgo/go_netbsd.go | 106 - .../purego/internal/fakecgo/go_setenv.go | 18 - .../purego/internal/fakecgo/go_util.go | 38 - .../purego/internal/fakecgo/iscgo.go | 19 - .../purego/internal/fakecgo/libcgo.go | 39 - .../purego/internal/fakecgo/libcgo_darwin.go | 26 - .../purego/internal/fakecgo/libcgo_freebsd.go | 20 - .../purego/internal/fakecgo/libcgo_linux.go | 20 - .../purego/internal/fakecgo/libcgo_netbsd.go | 26 - .../purego/internal/fakecgo/netbsd.go | 23 - .../purego/internal/fakecgo/setenv.go | 19 - .../purego/internal/fakecgo/trampolines_386.s | 107 - .../internal/fakecgo/trampolines_amd64.s | 107 - .../purego/internal/fakecgo/trampolines_arm.s | 81 - .../internal/fakecgo/trampolines_arm64.s | 84 - .../internal/fakecgo/trampolines_loong64.s | 88 - .../internal/fakecgo/trampolines_ppc64le.s | 227 - .../internal/fakecgo/trampolines_riscv64.s | 72 - .../purego/internal/fakecgo/zsymbols.go | 165 - .../internal/fakecgo/zsymbols_darwin.go | 59 - .../internal/fakecgo/zsymbols_freebsd.go | 48 - .../purego/internal/fakecgo/zsymbols_linux.go | 48 - .../internal/fakecgo/zsymbols_netbsd.go | 59 - .../internal/fakecgo/ztrampolines_darwin.s | 19 - .../internal/fakecgo/ztrampolines_freebsd.s | 16 - .../internal/fakecgo/ztrampolines_linux.s | 16 - .../internal/fakecgo/ztrampolines_netbsd.s | 19 - .../internal/fakecgo/ztrampolines_stubs.s | 55 - .../purego/internal/strings/strings.go | 40 - .../purego/internal/xreflect/reflect_go124.go | 15 - .../purego/internal/xreflect/reflect_go125.go | 12 - vendor/github.com/ebitengine/purego/is_ios.go | 13 - vendor/github.com/ebitengine/purego/nocgo.go | 25 - .../ebitengine/purego/struct_386.go | 41 - .../ebitengine/purego/struct_amd64.go | 286 - .../ebitengine/purego/struct_arm.go | 85 - .../ebitengine/purego/struct_arm64.go | 549 - .../ebitengine/purego/struct_loong64.go | 213 - .../ebitengine/purego/struct_ppc64le.go | 143 - .../ebitengine/purego/struct_riscv64.go | 143 - .../ebitengine/purego/struct_s390x.go | 143 - vendor/github.com/ebitengine/purego/sys_386.s | 147 - .../github.com/ebitengine/purego/sys_amd64.s | 170 - vendor/github.com/ebitengine/purego/sys_arm.s | 142 - .../github.com/ebitengine/purego/sys_arm64.s | 97 - .../ebitengine/purego/sys_loong64.s | 96 - .../ebitengine/purego/sys_ppc64le.s | 120 - .../ebitengine/purego/sys_riscv64.s | 101 - .../github.com/ebitengine/purego/sys_s390x.s | 114 - .../ebitengine/purego/sys_unix_386.s | 226 - .../ebitengine/purego/sys_unix_arm.s | 89 - .../ebitengine/purego/sys_unix_arm64.s | 70 - .../ebitengine/purego/sys_unix_loong64.s | 75 - .../ebitengine/purego/sys_unix_ppc64le.s | 114 - .../ebitengine/purego/sys_unix_riscv64.s | 79 - .../ebitengine/purego/sys_unix_s390x.s | 109 - .../github.com/ebitengine/purego/syscall.go | 83 - .../ebitengine/purego/syscall_32bit.go | 109 - .../ebitengine/purego/syscall_cgo_linux.go | 21 - .../ebitengine/purego/syscall_sysv.go | 320 - .../ebitengine/purego/syscall_sysv_others.go | 28 - .../purego/syscall_sysv_stackargs.go | 33 - .../ebitengine/purego/syscall_windows.go | 46 - .../ebitengine/purego/zcallback_386.s | 4014 ---- .../ebitengine/purego/zcallback_amd64.s | 2014 -- .../ebitengine/purego/zcallback_arm.s | 4014 ---- .../ebitengine/purego/zcallback_arm64.s | 4014 ---- .../ebitengine/purego/zcallback_loong64.s | 4014 ---- .../ebitengine/purego/zcallback_ppc64le.s | 4014 ---- .../ebitengine/purego/zcallback_riscv64.s | 4051 ---- .../ebitengine/purego/zcallback_s390x.s | 4015 ---- .../facebookgo/grace/gracenet/net.go | 252 - .../github.com/fortytw2/leaktest/.travis.yml | 16 - vendor/github.com/fortytw2/leaktest/LICENSE | 27 - vendor/github.com/fortytw2/leaktest/README.md | 64 - .../github.com/fortytw2/leaktest/leaktest.go | 153 - .../fsnotify/fsnotify/.editorconfig | 12 - .../fsnotify/fsnotify/.gitattributes | 1 - .../github.com/fsnotify/fsnotify/.gitignore | 6 - .../github.com/fsnotify/fsnotify/.travis.yml | 36 - vendor/github.com/fsnotify/fsnotify/AUTHORS | 52 - .../github.com/fsnotify/fsnotify/CHANGELOG.md | 317 - .../fsnotify/fsnotify/CONTRIBUTING.md | 77 - vendor/github.com/fsnotify/fsnotify/LICENSE | 28 - vendor/github.com/fsnotify/fsnotify/README.md | 130 - vendor/github.com/fsnotify/fsnotify/fen.go | 37 - .../github.com/fsnotify/fsnotify/fsnotify.go | 68 - .../github.com/fsnotify/fsnotify/inotify.go | 337 - .../fsnotify/fsnotify/inotify_poller.go | 187 - vendor/github.com/fsnotify/fsnotify/kqueue.go | 521 - .../fsnotify/fsnotify/open_mode_bsd.go | 11 - .../fsnotify/fsnotify/open_mode_darwin.go | 12 - .../github.com/fsnotify/fsnotify/windows.go | 561 - .../getsentry/sentry-go/.codecov.yml | 19 - .../github.com/getsentry/sentry-go/.craft.yml | 46 - .../getsentry/sentry-go/.gitattributes | 5 - .../github.com/getsentry/sentry-go/.gitignore | 17 - .../getsentry/sentry-go/.golangci.yml | 62 - .../getsentry/sentry-go/CHANGELOG.md | 1407 -- .../getsentry/sentry-go/CONTRIBUTING.md | 98 - vendor/github.com/getsentry/sentry-go/LICENSE | 21 - .../getsentry/sentry-go/MIGRATION.md | 3 - .../github.com/getsentry/sentry-go/Makefile | 93 - .../github.com/getsentry/sentry-go/README.md | 107 - .../getsentry/sentry-go/attribute/builder.go | 36 - .../sentry-go/attribute/rawhelpers.go | 49 - .../getsentry/sentry-go/attribute/value.go | 207 - .../getsentry/sentry-go/batch_processor.go | 136 - .../getsentry/sentry-go/check_in.go | 121 - .../github.com/getsentry/sentry-go/client.go | 948 - vendor/github.com/getsentry/sentry-go/doc.go | 6 - vendor/github.com/getsentry/sentry-go/dsn.go | 37 - .../sentry-go/dynamic_sampling_context.go | 154 - .../getsentry/sentry-go/exception.go | 129 - vendor/github.com/getsentry/sentry-go/hub.go | 448 - .../getsentry/sentry-go/integrations.go | 393 - .../getsentry/sentry-go/interfaces.go | 785 - .../sentry-go/internal/debug/transport.go | 79 - .../sentry-go/internal/debuglog/log.go | 35 - .../sentry-go/internal/http/transport.go | 542 - .../sentry-go/internal/otel/baggage/README.md | 12 - .../internal/otel/baggage/baggage.go | 604 - .../otel/baggage/internal/baggage/baggage.go | 45 - .../sentry-go/internal/protocol/dsn.go | 236 - .../sentry-go/internal/protocol/envelope.go | 225 - .../sentry-go/internal/protocol/interfaces.go | 56 - .../sentry-go/internal/protocol/log_batch.go | 48 - .../internal/protocol/metric_batch.go | 41 - .../sentry-go/internal/protocol/types.go | 15 - .../sentry-go/internal/protocol/uuid.go | 18 - .../sentry-go/internal/ratelimit/category.go | 109 - .../sentry-go/internal/ratelimit/deadline.go | 22 - .../sentry-go/internal/ratelimit/doc.go | 3 - .../sentry-go/internal/ratelimit/map.go | 64 - .../internal/ratelimit/rate_limits.go | 76 - .../internal/ratelimit/retry_after.go | 40 - .../internal/telemetry/bucketed_buffer.go | 398 - .../sentry-go/internal/telemetry/buffer.go | 42 - .../sentry-go/internal/telemetry/processor.go | 49 - .../internal/telemetry/ring_buffer.go | 378 - .../sentry-go/internal/telemetry/scheduler.go | 301 - .../internal/telemetry/trace_aware.go | 7 - .../getsentry/sentry-go/internal/util/map.go | 43 - .../getsentry/sentry-go/internal/util/util.go | 83 - vendor/github.com/getsentry/sentry-go/log.go | 333 - .../sentry-go/log_batch_processor.go | 32 - .../getsentry/sentry-go/log_fallback.go | 114 - .../sentry-go/metric_batch_processor.go | 32 - .../github.com/getsentry/sentry-go/metrics.go | 241 - .../github.com/getsentry/sentry-go/mocks.go | 79 - .../sentry-go/propagation_context.go | 74 - .../github.com/getsentry/sentry-go/scope.go | 578 - .../github.com/getsentry/sentry-go/sentry.go | 149 - .../getsentry/sentry-go/sourcereader.go | 70 - .../getsentry/sentry-go/span_recorder.go | 58 - .../getsentry/sentry-go/stacktrace.go | 407 - .../getsentry/sentry-go/traces_sampler.go | 19 - .../github.com/getsentry/sentry-go/tracing.go | 1079 - .../getsentry/sentry-go/transport.go | 811 - vendor/github.com/getsentry/sentry-go/util.go | 132 - vendor/github.com/go-chi/chi/v5/.gitignore | 3 - vendor/github.com/go-chi/chi/v5/CHANGELOG.md | 341 - .../github.com/go-chi/chi/v5/CONTRIBUTING.md | 31 - vendor/github.com/go-chi/chi/v5/LICENSE | 20 - vendor/github.com/go-chi/chi/v5/Makefile | 22 - vendor/github.com/go-chi/chi/v5/README.md | 572 - vendor/github.com/go-chi/chi/v5/SECURITY.md | 5 - vendor/github.com/go-chi/chi/v5/chain.go | 49 - vendor/github.com/go-chi/chi/v5/chi.go | 138 - vendor/github.com/go-chi/chi/v5/context.go | 166 - vendor/github.com/go-chi/chi/v5/mux.go | 532 - vendor/github.com/go-chi/chi/v5/tree.go | 885 - vendor/github.com/go-chi/cors/LICENSE | 21 - vendor/github.com/go-chi/cors/README.md | 39 - vendor/github.com/go-chi/cors/cors.go | 400 - vendor/github.com/go-chi/cors/utils.go | 70 - .../github.com/go-jose/go-jose/v4/.gitignore | 2 - .../go-jose/go-jose/v4/.golangci.yml | 53 - .../github.com/go-jose/go-jose/v4/.travis.yml | 33 - .../go-jose/go-jose/v4/CONTRIBUTING.md | 9 - vendor/github.com/go-jose/go-jose/v4/LICENSE | 202 - .../github.com/go-jose/go-jose/v4/README.md | 108 - .../github.com/go-jose/go-jose/v4/SECURITY.md | 13 - .../go-jose/go-jose/v4/asymmetric.go | 603 - .../go-jose/go-jose/v4/cipher/cbc_hmac.go | 196 - .../go-jose/go-jose/v4/cipher/concat_kdf.go | 75 - .../go-jose/go-jose/v4/cipher/ecdh_es.go | 86 - .../go-jose/go-jose/v4/cipher/key_wrap.go | 117 - .../github.com/go-jose/go-jose/v4/crypter.go | 595 - vendor/github.com/go-jose/go-jose/v4/doc.go | 25 - .../github.com/go-jose/go-jose/v4/encoding.go | 228 - .../go-jose/go-jose/v4/json/LICENSE | 27 - .../go-jose/go-jose/v4/json/README.md | 13 - .../go-jose/go-jose/v4/json/decode.go | 1216 -- .../go-jose/go-jose/v4/json/encode.go | 1197 -- .../go-jose/go-jose/v4/json/indent.go | 141 - .../go-jose/go-jose/v4/json/scanner.go | 623 - .../go-jose/go-jose/v4/json/stream.go | 484 - .../go-jose/go-jose/v4/json/tags.go | 44 - vendor/github.com/go-jose/go-jose/v4/jwe.go | 391 - vendor/github.com/go-jose/go-jose/v4/jwk.go | 848 - vendor/github.com/go-jose/go-jose/v4/jws.go | 470 - .../go-jose/go-jose/v4/jwt/builder.go | 315 - .../go-jose/go-jose/v4/jwt/claims.go | 130 - .../github.com/go-jose/go-jose/v4/jwt/doc.go | 20 - .../go-jose/go-jose/v4/jwt/errors.go | 53 - .../github.com/go-jose/go-jose/v4/jwt/jwt.go | 198 - .../go-jose/go-jose/v4/jwt/validation.go | 127 - .../github.com/go-jose/go-jose/v4/opaque.go | 147 - .../github.com/go-jose/go-jose/v4/shared.go | 560 - .../github.com/go-jose/go-jose/v4/signing.go | 523 - .../go-jose/go-jose/v4/symmetric.go | 532 - vendor/github.com/go-logr/logr/.golangci.yaml | 28 - vendor/github.com/go-logr/logr/CHANGELOG.md | 6 - .../github.com/go-logr/logr/CONTRIBUTING.md | 17 - vendor/github.com/go-logr/logr/LICENSE | 201 - vendor/github.com/go-logr/logr/README.md | 407 - vendor/github.com/go-logr/logr/SECURITY.md | 18 - vendor/github.com/go-logr/logr/context.go | 33 - .../github.com/go-logr/logr/context_noslog.go | 49 - .../github.com/go-logr/logr/context_slog.go | 83 - vendor/github.com/go-logr/logr/discard.go | 24 - vendor/github.com/go-logr/logr/funcr/funcr.go | 914 - .../github.com/go-logr/logr/funcr/slogsink.go | 105 - vendor/github.com/go-logr/logr/logr.go | 520 - vendor/github.com/go-logr/logr/sloghandler.go | 192 - vendor/github.com/go-logr/logr/slogr.go | 100 - vendor/github.com/go-logr/logr/slogsink.go | 120 - vendor/github.com/go-logr/stdr/LICENSE | 201 - vendor/github.com/go-logr/stdr/README.md | 6 - vendor/github.com/go-logr/stdr/stdr.go | 170 - vendor/github.com/go-ole/go-ole/.travis.yml | 8 - vendor/github.com/go-ole/go-ole/ChangeLog.md | 49 - vendor/github.com/go-ole/go-ole/LICENSE | 21 - vendor/github.com/go-ole/go-ole/README.md | 46 - vendor/github.com/go-ole/go-ole/appveyor.yml | 54 - vendor/github.com/go-ole/go-ole/com.go | 344 - vendor/github.com/go-ole/go-ole/com_func.go | 174 - vendor/github.com/go-ole/go-ole/connect.go | 192 - vendor/github.com/go-ole/go-ole/constants.go | 153 - vendor/github.com/go-ole/go-ole/error.go | 51 - vendor/github.com/go-ole/go-ole/error_func.go | 8 - .../github.com/go-ole/go-ole/error_windows.go | 24 - vendor/github.com/go-ole/go-ole/guid.go | 284 - .../go-ole/go-ole/iconnectionpoint.go | 20 - .../go-ole/go-ole/iconnectionpoint_func.go | 21 - .../go-ole/go-ole/iconnectionpoint_windows.go | 43 - .../go-ole/iconnectionpointcontainer.go | 17 - .../go-ole/iconnectionpointcontainer_func.go | 11 - .../iconnectionpointcontainer_windows.go | 25 - vendor/github.com/go-ole/go-ole/idispatch.go | 94 - .../go-ole/go-ole/idispatch_func.go | 19 - .../go-ole/go-ole/idispatch_windows.go | 202 - .../github.com/go-ole/go-ole/ienumvariant.go | 19 - .../go-ole/go-ole/ienumvariant_func.go | 19 - .../go-ole/go-ole/ienumvariant_windows.go | 63 - .../github.com/go-ole/go-ole/iinspectable.go | 18 - .../go-ole/go-ole/iinspectable_func.go | 15 - .../go-ole/go-ole/iinspectable_windows.go | 72 - .../go-ole/go-ole/iprovideclassinfo.go | 21 - .../go-ole/go-ole/iprovideclassinfo_func.go | 7 - .../go-ole/iprovideclassinfo_windows.go | 21 - vendor/github.com/go-ole/go-ole/itypeinfo.go | 34 - .../go-ole/go-ole/itypeinfo_func.go | 7 - .../go-ole/go-ole/itypeinfo_windows.go | 21 - vendor/github.com/go-ole/go-ole/iunknown.go | 57 - .../github.com/go-ole/go-ole/iunknown_func.go | 19 - .../go-ole/go-ole/iunknown_windows.go | 58 - vendor/github.com/go-ole/go-ole/ole.go | 190 - .../go-ole/go-ole/oleutil/connection.go | 100 - .../go-ole/go-ole/oleutil/connection_func.go | 10 - .../go-ole/oleutil/connection_windows.go | 58 - .../go-ole/go-ole/oleutil/go-get.go | 6 - .../go-ole/go-ole/oleutil/oleutil.go | 127 - vendor/github.com/go-ole/go-ole/safearray.go | 27 - .../go-ole/go-ole/safearray_func.go | 211 - .../go-ole/go-ole/safearray_windows.go | 337 - .../go-ole/go-ole/safearrayconversion.go | 140 - .../go-ole/go-ole/safearrayslices.go | 33 - vendor/github.com/go-ole/go-ole/utility.go | 101 - vendor/github.com/go-ole/go-ole/variables.go | 15 - vendor/github.com/go-ole/go-ole/variant.go | 105 - .../github.com/go-ole/go-ole/variant_386.go | 11 - .../github.com/go-ole/go-ole/variant_amd64.go | 12 - .../github.com/go-ole/go-ole/variant_arm.go | 11 - .../github.com/go-ole/go-ole/variant_arm64.go | 13 - .../go-ole/go-ole/variant_date_386.go | 22 - .../go-ole/go-ole/variant_date_amd64.go | 20 - .../go-ole/go-ole/variant_date_arm.go | 22 - .../go-ole/go-ole/variant_date_arm64.go | 23 - .../go-ole/go-ole/variant_ppc64le.go | 12 - .../github.com/go-ole/go-ole/variant_s390x.go | 12 - vendor/github.com/go-ole/go-ole/vt_string.go | 58 - vendor/github.com/go-ole/go-ole/winrt.go | 99 - vendor/github.com/go-ole/go-ole/winrt_doc.go | 36 - vendor/github.com/gobwas/httphead/LICENSE | 21 - vendor/github.com/gobwas/httphead/README.md | 63 - vendor/github.com/gobwas/httphead/cookie.go | 200 - vendor/github.com/gobwas/httphead/head.go | 275 - vendor/github.com/gobwas/httphead/httphead.go | 331 - vendor/github.com/gobwas/httphead/lexer.go | 360 - vendor/github.com/gobwas/httphead/octet.go | 83 - vendor/github.com/gobwas/httphead/option.go | 193 - vendor/github.com/gobwas/httphead/writer.go | 101 - vendor/github.com/gobwas/pool/LICENSE | 21 - vendor/github.com/gobwas/pool/README.md | 107 - vendor/github.com/gobwas/pool/generic.go | 87 - .../gobwas/pool/internal/pmath/pmath.go | 65 - vendor/github.com/gobwas/pool/option.go | 43 - .../github.com/gobwas/pool/pbufio/pbufio.go | 106 - .../gobwas/pool/pbufio/pbufio_go110.go | 13 - .../gobwas/pool/pbufio/pbufio_go19.go | 27 - .../github.com/gobwas/pool/pbytes/pbytes.go | 24 - vendor/github.com/gobwas/pool/pbytes/pool.go | 59 - .../gobwas/pool/pbytes/pool_sanitize.go | 121 - vendor/github.com/gobwas/pool/pool.go | 25 - vendor/github.com/gobwas/ws/.gitignore | 5 - vendor/github.com/gobwas/ws/LICENSE | 21 - vendor/github.com/gobwas/ws/Makefile | 54 - vendor/github.com/gobwas/ws/README.md | 541 - vendor/github.com/gobwas/ws/check.go | 145 - vendor/github.com/gobwas/ws/cipher.go | 61 - vendor/github.com/gobwas/ws/dialer.go | 566 - .../github.com/gobwas/ws/dialer_tls_go17.go | 35 - .../github.com/gobwas/ws/dialer_tls_go18.go | 10 - vendor/github.com/gobwas/ws/doc.go | 81 - vendor/github.com/gobwas/ws/errors.go | 59 - vendor/github.com/gobwas/ws/frame.go | 420 - vendor/github.com/gobwas/ws/http.go | 503 - vendor/github.com/gobwas/ws/nonce.go | 78 - vendor/github.com/gobwas/ws/read.go | 147 - vendor/github.com/gobwas/ws/server.go | 663 - vendor/github.com/gobwas/ws/util.go | 199 - vendor/github.com/gobwas/ws/util_purego.go | 12 - vendor/github.com/gobwas/ws/util_unsafe.go | 22 - vendor/github.com/gobwas/ws/write.go | 104 - vendor/github.com/gobwas/ws/wsutil/cipher.go | 72 - vendor/github.com/gobwas/ws/wsutil/dialer.go | 147 - .../github.com/gobwas/ws/wsutil/extenstion.go | 31 - vendor/github.com/gobwas/ws/wsutil/handler.go | 219 - vendor/github.com/gobwas/ws/wsutil/helper.go | 279 - vendor/github.com/gobwas/ws/wsutil/reader.go | 289 - .../github.com/gobwas/ws/wsutil/upgrader.go | 68 - vendor/github.com/gobwas/ws/wsutil/utf8.go | 140 - vendor/github.com/gobwas/ws/wsutil/writer.go | 599 - vendor/github.com/gobwas/ws/wsutil/wsutil.go | 57 - vendor/github.com/google/gopacket/.gitignore | 38 - .../google/gopacket/.travis.gofmt.sh | 7 - .../google/gopacket/.travis.golint.sh | 28 - .../google/gopacket/.travis.govet.sh | 10 - .../google/gopacket/.travis.install.sh | 9 - .../google/gopacket/.travis.script.sh | 10 - vendor/github.com/google/gopacket/.travis.yml | 57 - vendor/github.com/google/gopacket/AUTHORS | 54 - .../google/gopacket/CONTRIBUTING.md | 215 - vendor/github.com/google/gopacket/LICENSE | 28 - vendor/github.com/google/gopacket/README.md | 12 - vendor/github.com/google/gopacket/base.go | 178 - vendor/github.com/google/gopacket/decode.go | 157 - vendor/github.com/google/gopacket/doc.go | 432 - vendor/github.com/google/gopacket/flows.go | 236 - vendor/github.com/google/gopacket/gc | 288 - .../github.com/google/gopacket/layerclass.go | 107 - .../google/gopacket/layers/.lint_blacklist | 39 - .../github.com/google/gopacket/layers/arp.go | 118 - .../github.com/google/gopacket/layers/asf.go | 166 - .../gopacket/layers/asf_presencepong.go | 194 - .../github.com/google/gopacket/layers/base.go | 52 - .../github.com/google/gopacket/layers/bfd.go | 481 - .../github.com/google/gopacket/layers/cdp.go | 659 - .../github.com/google/gopacket/layers/ctp.go | 109 - .../google/gopacket/layers/dhcpv4.go | 592 - .../google/gopacket/layers/dhcpv6.go | 360 - .../google/gopacket/layers/dhcpv6_options.go | 621 - .../github.com/google/gopacket/layers/dns.go | 1098 - .../github.com/google/gopacket/layers/doc.go | 61 - .../google/gopacket/layers/dot11.go | 2118 -- .../google/gopacket/layers/dot1q.go | 75 - .../github.com/google/gopacket/layers/eap.go | 114 - .../google/gopacket/layers/eapol.go | 302 - .../google/gopacket/layers/endpoints.go | 97 - .../google/gopacket/layers/enums.go | 443 - .../google/gopacket/layers/enums_generated.go | 434 - .../google/gopacket/layers/erspan2.go | 86 - .../google/gopacket/layers/etherip.go | 45 - .../google/gopacket/layers/ethernet.go | 123 - .../github.com/google/gopacket/layers/fddi.go | 41 - .../google/gopacket/layers/fuzz_layer.go | 39 - .../google/gopacket/layers/gen_linted.sh | 3 - .../google/gopacket/layers/geneve.go | 121 - .../github.com/google/gopacket/layers/gre.go | 200 - .../github.com/google/gopacket/layers/gtp.go | 184 - .../google/gopacket/layers/iana_ports.go | 11351 ---------- .../google/gopacket/layers/icmp4.go | 267 - .../google/gopacket/layers/icmp6.go | 266 - .../google/gopacket/layers/icmp6msg.go | 578 - .../github.com/google/gopacket/layers/igmp.go | 355 - .../github.com/google/gopacket/layers/ip4.go | 325 - .../github.com/google/gopacket/layers/ip6.go | 722 - .../google/gopacket/layers/ipsec.go | 77 - .../google/gopacket/layers/layertypes.go | 223 - .../github.com/google/gopacket/layers/lcm.go | 218 - .../google/gopacket/layers/linux_sll.go | 98 - .../github.com/google/gopacket/layers/llc.go | 193 - .../github.com/google/gopacket/layers/lldp.go | 1603 -- .../google/gopacket/layers/loopback.go | 80 - .../google/gopacket/layers/mldv1.go | 182 - .../google/gopacket/layers/mldv2.go | 619 - .../google/gopacket/layers/modbustcp.go | 150 - .../github.com/google/gopacket/layers/mpls.go | 87 - .../github.com/google/gopacket/layers/ndp.go | 611 - .../github.com/google/gopacket/layers/ntp.go | 416 - .../github.com/google/gopacket/layers/ospf.go | 715 - .../google/gopacket/layers/pflog.go | 84 - .../google/gopacket/layers/ports.go | 156 - .../github.com/google/gopacket/layers/ppp.go | 88 - .../google/gopacket/layers/pppoe.go | 60 - .../google/gopacket/layers/prism.go | 146 - .../google/gopacket/layers/radiotap.go | 1076 - .../google/gopacket/layers/radius.go | 560 - .../github.com/google/gopacket/layers/rmcp.go | 170 - .../github.com/google/gopacket/layers/rudp.go | 93 - .../github.com/google/gopacket/layers/sctp.go | 746 - .../google/gopacket/layers/sflow.go | 2567 --- .../github.com/google/gopacket/layers/sip.go | 542 - .../github.com/google/gopacket/layers/stp.go | 27 - .../github.com/google/gopacket/layers/tcp.go | 341 - .../google/gopacket/layers/tcpip.go | 104 - .../google/gopacket/layers/test_creator.py | 103 - .../github.com/google/gopacket/layers/tls.go | 283 - .../google/gopacket/layers/tls_alert.go | 165 - .../google/gopacket/layers/tls_appdata.go | 34 - .../google/gopacket/layers/tls_cipherspec.go | 64 - .../google/gopacket/layers/tls_handshake.go | 28 - .../github.com/google/gopacket/layers/udp.go | 133 - .../google/gopacket/layers/udplite.go | 44 - .../github.com/google/gopacket/layers/usb.go | 292 - .../github.com/google/gopacket/layers/vrrp.go | 156 - .../google/gopacket/layers/vxlan.go | 123 - .../google/gopacket/layers_decoder.go | 101 - .../github.com/google/gopacket/layertype.go | 111 - vendor/github.com/google/gopacket/packet.go | 864 - vendor/github.com/google/gopacket/parser.go | 350 - vendor/github.com/google/gopacket/time.go | 72 - vendor/github.com/google/gopacket/writer.go | 232 - vendor/github.com/google/uuid/CHANGELOG.md | 41 - vendor/github.com/google/uuid/CONTRIBUTING.md | 26 - vendor/github.com/google/uuid/CONTRIBUTORS | 9 - vendor/github.com/google/uuid/LICENSE | 27 - vendor/github.com/google/uuid/README.md | 21 - vendor/github.com/google/uuid/dce.go | 80 - vendor/github.com/google/uuid/doc.go | 12 - vendor/github.com/google/uuid/hash.go | 59 - vendor/github.com/google/uuid/marshal.go | 38 - vendor/github.com/google/uuid/node.go | 90 - vendor/github.com/google/uuid/node_js.go | 12 - vendor/github.com/google/uuid/node_net.go | 33 - vendor/github.com/google/uuid/null.go | 118 - vendor/github.com/google/uuid/sql.go | 59 - vendor/github.com/google/uuid/time.go | 134 - vendor/github.com/google/uuid/util.go | 43 - vendor/github.com/google/uuid/uuid.go | 365 - vendor/github.com/google/uuid/version1.go | 44 - vendor/github.com/google/uuid/version4.go | 76 - vendor/github.com/google/uuid/version6.go | 56 - vendor/github.com/google/uuid/version7.go | 104 - .../github.com/gorilla/websocket/.gitignore | 25 - vendor/github.com/gorilla/websocket/AUTHORS | 9 - vendor/github.com/gorilla/websocket/LICENSE | 22 - vendor/github.com/gorilla/websocket/README.md | 33 - vendor/github.com/gorilla/websocket/client.go | 434 - .../gorilla/websocket/compression.go | 148 - vendor/github.com/gorilla/websocket/conn.go | 1238 -- vendor/github.com/gorilla/websocket/doc.go | 227 - vendor/github.com/gorilla/websocket/join.go | 42 - vendor/github.com/gorilla/websocket/json.go | 60 - vendor/github.com/gorilla/websocket/mask.go | 55 - .../github.com/gorilla/websocket/mask_safe.go | 16 - .../github.com/gorilla/websocket/prepared.go | 102 - vendor/github.com/gorilla/websocket/proxy.go | 77 - vendor/github.com/gorilla/websocket/server.go | 365 - .../gorilla/websocket/tls_handshake.go | 21 - .../gorilla/websocket/tls_handshake_116.go | 21 - vendor/github.com/gorilla/websocket/util.go | 298 - .../gorilla/websocket/x_net_proxy.go | 473 - .../grpc-ecosystem/grpc-gateway/v2/LICENSE | 27 - .../v2/internal/httprule/BUILD.bazel | 35 - .../v2/internal/httprule/compile.go | 121 - .../grpc-gateway/v2/internal/httprule/fuzz.go | 11 - .../v2/internal/httprule/parse.go | 368 - .../v2/internal/httprule/types.go | 60 - .../grpc-gateway/v2/runtime/BUILD.bazel | 98 - .../grpc-gateway/v2/runtime/context.go | 417 - .../grpc-gateway/v2/runtime/convert.go | 318 - .../grpc-gateway/v2/runtime/doc.go | 5 - .../grpc-gateway/v2/runtime/errors.go | 204 - .../grpc-gateway/v2/runtime/fieldmask.go | 168 - .../grpc-gateway/v2/runtime/handler.go | 253 - .../v2/runtime/marshal_httpbodyproto.go | 32 - .../grpc-gateway/v2/runtime/marshal_json.go | 50 - .../grpc-gateway/v2/runtime/marshal_jsonpb.go | 349 - .../grpc-gateway/v2/runtime/marshal_proto.go | 60 - .../grpc-gateway/v2/runtime/marshaler.go | 58 - .../v2/runtime/marshaler_registry.go | 109 - .../grpc-gateway/v2/runtime/mux.go | 564 - .../grpc-gateway/v2/runtime/pattern.go | 381 - .../grpc-gateway/v2/runtime/proto2_convert.go | 80 - .../grpc-gateway/v2/runtime/query.go | 378 - .../grpc-gateway/v2/utilities/BUILD.bazel | 31 - .../grpc-gateway/v2/utilities/doc.go | 2 - .../grpc-gateway/v2/utilities/pattern.go | 22 - .../v2/utilities/readerfactory.go | 19 - .../v2/utilities/string_array_flag.go | 33 - .../grpc-gateway/v2/utilities/trie.go | 174 - .../github.com/json-iterator/go/.codecov.yml | 3 - vendor/github.com/json-iterator/go/.gitignore | 4 - .../github.com/json-iterator/go/.travis.yml | 14 - vendor/github.com/json-iterator/go/Gopkg.lock | 21 - vendor/github.com/json-iterator/go/Gopkg.toml | 26 - vendor/github.com/json-iterator/go/LICENSE | 21 - vendor/github.com/json-iterator/go/README.md | 85 - vendor/github.com/json-iterator/go/adapter.go | 150 - vendor/github.com/json-iterator/go/any.go | 325 - .../github.com/json-iterator/go/any_array.go | 278 - .../github.com/json-iterator/go/any_bool.go | 137 - .../github.com/json-iterator/go/any_float.go | 83 - .../github.com/json-iterator/go/any_int32.go | 74 - .../github.com/json-iterator/go/any_int64.go | 74 - .../json-iterator/go/any_invalid.go | 82 - vendor/github.com/json-iterator/go/any_nil.go | 69 - .../github.com/json-iterator/go/any_number.go | 123 - .../github.com/json-iterator/go/any_object.go | 374 - vendor/github.com/json-iterator/go/any_str.go | 166 - .../github.com/json-iterator/go/any_uint32.go | 74 - .../github.com/json-iterator/go/any_uint64.go | 74 - vendor/github.com/json-iterator/go/build.sh | 12 - vendor/github.com/json-iterator/go/config.go | 375 - .../go/fuzzy_mode_convert_table.md | 7 - vendor/github.com/json-iterator/go/iter.go | 349 - .../github.com/json-iterator/go/iter_array.go | 64 - .../github.com/json-iterator/go/iter_float.go | 342 - .../github.com/json-iterator/go/iter_int.go | 346 - .../json-iterator/go/iter_object.go | 267 - .../github.com/json-iterator/go/iter_skip.go | 130 - .../json-iterator/go/iter_skip_sloppy.go | 163 - .../json-iterator/go/iter_skip_strict.go | 99 - .../github.com/json-iterator/go/iter_str.go | 215 - .../github.com/json-iterator/go/jsoniter.go | 18 - vendor/github.com/json-iterator/go/pool.go | 42 - vendor/github.com/json-iterator/go/reflect.go | 337 - .../json-iterator/go/reflect_array.go | 104 - .../json-iterator/go/reflect_dynamic.go | 70 - .../json-iterator/go/reflect_extension.go | 483 - .../json-iterator/go/reflect_json_number.go | 112 - .../go/reflect_json_raw_message.go | 76 - .../json-iterator/go/reflect_map.go | 346 - .../json-iterator/go/reflect_marshaler.go | 225 - .../json-iterator/go/reflect_native.go | 453 - .../json-iterator/go/reflect_optional.go | 129 - .../json-iterator/go/reflect_slice.go | 99 - .../go/reflect_struct_decoder.go | 1097 - .../go/reflect_struct_encoder.go | 211 - vendor/github.com/json-iterator/go/stream.go | 210 - .../json-iterator/go/stream_float.go | 111 - .../github.com/json-iterator/go/stream_int.go | 190 - .../github.com/json-iterator/go/stream_str.go | 372 - vendor/github.com/json-iterator/go/test.sh | 12 - vendor/github.com/klauspost/compress/LICENSE | 304 - .../klauspost/compress/flate/deflate.go | 1017 - .../klauspost/compress/flate/dict_decoder.go | 184 - .../klauspost/compress/flate/fast_encoder.go | 232 - .../compress/flate/huffman_bit_writer.go | 1183 -- .../klauspost/compress/flate/huffman_code.go | 417 - .../compress/flate/huffman_sortByFreq.go | 159 - .../compress/flate/huffman_sortByLiteral.go | 201 - .../klauspost/compress/flate/inflate.go | 865 - .../klauspost/compress/flate/inflate_gen.go | 1283 -- .../klauspost/compress/flate/level1.go | 215 - .../klauspost/compress/flate/level2.go | 214 - .../klauspost/compress/flate/level3.go | 241 - .../klauspost/compress/flate/level4.go | 221 - .../klauspost/compress/flate/level5.go | 708 - .../klauspost/compress/flate/level6.go | 325 - .../compress/flate/matchlen_generic.go | 34 - .../klauspost/compress/flate/regmask_amd64.go | 37 - .../klauspost/compress/flate/regmask_other.go | 40 - .../klauspost/compress/flate/stateless.go | 313 - .../klauspost/compress/flate/token.go | 379 - .../klauspost/compress/internal/le/le.go | 5 - .../compress/internal/le/unsafe_disabled.go | 42 - .../compress/internal/le/unsafe_enabled.go | 55 - vendor/github.com/lufia/plan9stats/.gitignore | 12 - vendor/github.com/lufia/plan9stats/LICENSE | 29 - vendor/github.com/lufia/plan9stats/README.md | 2 - vendor/github.com/lufia/plan9stats/cpu.go | 288 - vendor/github.com/lufia/plan9stats/doc.go | 2 - vendor/github.com/lufia/plan9stats/host.go | 303 - vendor/github.com/lufia/plan9stats/int.go | 31 - vendor/github.com/lufia/plan9stats/opts.go | 21 - vendor/github.com/lufia/plan9stats/stats.go | 88 - vendor/github.com/mattn/go-colorable/LICENSE | 21 - .../github.com/mattn/go-colorable/README.md | 48 - .../mattn/go-colorable/colorable_appengine.go | 38 - .../mattn/go-colorable/colorable_others.go | 38 - .../mattn/go-colorable/colorable_windows.go | 1047 - .../github.com/mattn/go-colorable/go.test.sh | 12 - .../mattn/go-colorable/noncolorable.go | 57 - vendor/github.com/mattn/go-isatty/LICENSE | 9 - vendor/github.com/mattn/go-isatty/README.md | 50 - vendor/github.com/mattn/go-isatty/doc.go | 2 - vendor/github.com/mattn/go-isatty/go.test.sh | 12 - .../github.com/mattn/go-isatty/isatty_bsd.go | 20 - .../mattn/go-isatty/isatty_others.go | 17 - .../mattn/go-isatty/isatty_plan9.go | 23 - .../mattn/go-isatty/isatty_solaris.go | 21 - .../mattn/go-isatty/isatty_tcgets.go | 20 - .../mattn/go-isatty/isatty_windows.go | 125 - .../github.com/mitchellh/go-homedir/LICENSE | 21 - .../github.com/mitchellh/go-homedir/README.md | 14 - .../mitchellh/go-homedir/homedir.go | 167 - .../modern-go/concurrent/.gitignore | 1 - .../modern-go/concurrent/.travis.yml | 14 - .../github.com/modern-go/concurrent/LICENSE | 201 - .../github.com/modern-go/concurrent/README.md | 49 - .../modern-go/concurrent/executor.go | 14 - .../modern-go/concurrent/go_above_19.go | 15 - .../modern-go/concurrent/go_below_19.go | 33 - vendor/github.com/modern-go/concurrent/log.go | 13 - .../github.com/modern-go/concurrent/test.sh | 12 - .../concurrent/unbounded_executor.go | 119 - .../github.com/modern-go/reflect2/.gitignore | 2 - .../github.com/modern-go/reflect2/.travis.yml | 15 - .../github.com/modern-go/reflect2/Gopkg.lock | 9 - .../github.com/modern-go/reflect2/Gopkg.toml | 31 - vendor/github.com/modern-go/reflect2/LICENSE | 201 - .../github.com/modern-go/reflect2/README.md | 71 - .../modern-go/reflect2/go_above_118.go | 23 - .../modern-go/reflect2/go_above_19.go | 17 - .../modern-go/reflect2/go_below_118.go | 21 - .../github.com/modern-go/reflect2/reflect2.go | 300 - .../modern-go/reflect2/reflect2_amd64.s | 0 .../modern-go/reflect2/reflect2_kind.go | 30 - .../modern-go/reflect2/relfect2_386.s | 0 .../modern-go/reflect2/relfect2_amd64p32.s | 0 .../modern-go/reflect2/relfect2_arm.s | 0 .../modern-go/reflect2/relfect2_arm64.s | 0 .../modern-go/reflect2/relfect2_mips64x.s | 0 .../modern-go/reflect2/relfect2_mipsx.s | 0 .../modern-go/reflect2/relfect2_ppc64x.s | 0 .../modern-go/reflect2/relfect2_s390x.s | 0 .../modern-go/reflect2/safe_field.go | 58 - .../github.com/modern-go/reflect2/safe_map.go | 101 - .../modern-go/reflect2/safe_slice.go | 92 - .../modern-go/reflect2/safe_struct.go | 29 - .../modern-go/reflect2/safe_type.go | 78 - .../github.com/modern-go/reflect2/type_map.go | 70 - .../modern-go/reflect2/unsafe_array.go | 65 - .../modern-go/reflect2/unsafe_eface.go | 59 - .../modern-go/reflect2/unsafe_field.go | 74 - .../modern-go/reflect2/unsafe_iface.go | 64 - .../modern-go/reflect2/unsafe_link.go | 76 - .../modern-go/reflect2/unsafe_map.go | 130 - .../modern-go/reflect2/unsafe_ptr.go | 46 - .../modern-go/reflect2/unsafe_slice.go | 177 - .../modern-go/reflect2/unsafe_struct.go | 59 - .../modern-go/reflect2/unsafe_type.go | 85 - vendor/github.com/munnerz/goautoneg/LICENSE | 31 - vendor/github.com/munnerz/goautoneg/Makefile | 13 - .../github.com/munnerz/goautoneg/README.txt | 67 - .../github.com/munnerz/goautoneg/autoneg.go | 189 - vendor/github.com/pkg/errors/.gitignore | 24 - vendor/github.com/pkg/errors/.travis.yml | 10 - vendor/github.com/pkg/errors/LICENSE | 23 - vendor/github.com/pkg/errors/Makefile | 44 - vendor/github.com/pkg/errors/README.md | 59 - vendor/github.com/pkg/errors/appveyor.yml | 32 - vendor/github.com/pkg/errors/errors.go | 288 - vendor/github.com/pkg/errors/go113.go | 38 - vendor/github.com/pkg/errors/stack.go | 177 - vendor/github.com/pmezard/go-difflib/LICENSE | 27 - .../pmezard/go-difflib/difflib/difflib.go | 772 - .../github.com/power-devops/perfstat/LICENSE | 23 - .../power-devops/perfstat/c_helpers.c | 159 - .../power-devops/perfstat/c_helpers.h | 58 - .../power-devops/perfstat/config.go | 19 - .../power-devops/perfstat/cpustat.go | 138 - .../power-devops/perfstat/diskstat.go | 138 - .../github.com/power-devops/perfstat/doc.go | 316 - .../power-devops/perfstat/fsstat.go | 32 - .../power-devops/perfstat/helpers.go | 819 - .../power-devops/perfstat/lparstat.go | 40 - .../power-devops/perfstat/lvmstat.go | 73 - .../power-devops/perfstat/memstat.go | 85 - .../power-devops/perfstat/netstat.go | 118 - .../power-devops/perfstat/procstat.go | 76 - .../power-devops/perfstat/sysconf.go | 196 - .../power-devops/perfstat/systemcfg.go | 662 - .../power-devops/perfstat/types_cpu.go | 186 - .../power-devops/perfstat/types_disk.go | 176 - .../power-devops/perfstat/types_fs.go | 195 - .../power-devops/perfstat/types_lpar.go | 129 - .../power-devops/perfstat/types_lvm.go | 31 - .../power-devops/perfstat/types_memory.go | 101 - .../power-devops/perfstat/types_network.go | 163 - .../power-devops/perfstat/types_process.go | 43 - .../power-devops/perfstat/uptime.go | 36 - .../prometheus/client_golang/LICENSE | 201 - .../prometheus/client_golang/NOTICE | 18 - .../internal/github.com/golang/gddo/LICENSE | 27 - .../golang/gddo/httputil/header/header.go | 145 - .../golang/gddo/httputil/negotiate.go | 36 - .../client_golang/prometheus/.gitignore | 1 - .../client_golang/prometheus/README.md | 1 - .../prometheus/build_info_collector.go | 38 - .../client_golang/prometheus/collector.go | 128 - .../client_golang/prometheus/collectorfunc.go | 30 - .../client_golang/prometheus/counter.go | 358 - .../client_golang/prometheus/desc.go | 210 - .../client_golang/prometheus/doc.go | 210 - .../prometheus/expvar_collector.go | 86 - .../client_golang/prometheus/fnv.go | 42 - .../client_golang/prometheus/gauge.go | 311 - .../client_golang/prometheus/get_pid.go | 26 - .../prometheus/get_pid_gopherjs.go | 23 - .../client_golang/prometheus/go_collector.go | 274 - .../prometheus/go_collector_go116.go | 122 - .../prometheus/go_collector_latest.go | 574 - .../client_golang/prometheus/histogram.go | 2056 -- .../prometheus/internal/almost_equal.go | 60 - .../prometheus/internal/difflib.go | 655 - .../internal/go_collector_options.go | 34 - .../prometheus/internal/go_runtime_metrics.go | 143 - .../prometheus/internal/metric.go | 101 - .../client_golang/prometheus/labels.go | 188 - .../client_golang/prometheus/metric.go | 265 - .../client_golang/prometheus/num_threads.go | 25 - .../prometheus/num_threads_gopherjs.go | 22 - .../client_golang/prometheus/observer.go | 64 - .../prometheus/process_collector.go | 180 - .../prometheus/process_collector_darwin.go | 130 - .../process_collector_mem_cgo_darwin.c | 84 - .../process_collector_mem_cgo_darwin.go | 51 - .../process_collector_mem_nocgo_darwin.go | 39 - .../process_collector_not_supported.go | 33 - .../process_collector_procfsenabled.go | 96 - .../prometheus/process_collector_windows.go | 125 - .../client_golang/prometheus/promauto/auto.go | 376 - .../prometheus/promhttp/delegator.go | 380 - .../client_golang/prometheus/promhttp/http.go | 492 - .../prometheus/promhttp/instrument_client.go | 249 - .../prometheus/promhttp/instrument_server.go | 576 - .../promhttp/internal/compression.go | 21 - .../prometheus/promhttp/option.go | 84 - .../client_golang/prometheus/registry.go | 1076 - .../client_golang/prometheus/summary.go | 830 - .../client_golang/prometheus/timer.go | 81 - .../client_golang/prometheus/untyped.go | 42 - .../client_golang/prometheus/value.go | 274 - .../client_golang/prometheus/vec.go | 709 - .../client_golang/prometheus/vnext.go | 23 - .../client_golang/prometheus/wrap.go | 214 - .../prometheus/client_model/LICENSE | 201 - .../github.com/prometheus/client_model/NOTICE | 5 - .../prometheus/client_model/go/metrics.pb.go | 1399 -- vendor/github.com/prometheus/common/LICENSE | 201 - vendor/github.com/prometheus/common/NOTICE | 5 - .../prometheus/common/expfmt/decode.go | 431 - .../prometheus/common/expfmt/encode.go | 198 - .../prometheus/common/expfmt/expfmt.go | 207 - .../prometheus/common/expfmt/fuzz.go | 37 - .../common/expfmt/openmetrics_create.go | 696 - .../prometheus/common/expfmt/text_create.go | 520 - .../prometheus/common/expfmt/text_parse.go | 901 - .../prometheus/common/model/alert.go | 162 - .../prometheus/common/model/fingerprinting.go | 105 - .../github.com/prometheus/common/model/fnv.go | 42 - .../prometheus/common/model/labels.go | 236 - .../prometheus/common/model/labelset.go | 158 - .../common/model/labelset_string.go | 43 - .../prometheus/common/model/metadata.go | 28 - .../prometheus/common/model/metric.go | 465 - .../prometheus/common/model/model.go | 16 - .../prometheus/common/model/signature.go | 142 - .../prometheus/common/model/silence.go | 107 - .../prometheus/common/model/time.go | 340 - .../prometheus/common/model/value.go | 364 - .../prometheus/common/model/value_float.go | 99 - .../common/model/value_histogram.go | 179 - .../prometheus/common/model/value_type.go | 83 - .../github.com/prometheus/procfs/.gitignore | 2 - .../prometheus/procfs/.golangci.yml | 22 - .../prometheus/procfs/CODE_OF_CONDUCT.md | 3 - .../prometheus/procfs/CONTRIBUTING.md | 121 - vendor/github.com/prometheus/procfs/LICENSE | 201 - .../prometheus/procfs/MAINTAINERS.md | 3 - vendor/github.com/prometheus/procfs/Makefile | 31 - .../prometheus/procfs/Makefile.common | 277 - vendor/github.com/prometheus/procfs/NOTICE | 7 - vendor/github.com/prometheus/procfs/README.md | 61 - .../github.com/prometheus/procfs/SECURITY.md | 6 - vendor/github.com/prometheus/procfs/arp.go | 116 - .../github.com/prometheus/procfs/buddyinfo.go | 85 - .../github.com/prometheus/procfs/cmdline.go | 30 - .../github.com/prometheus/procfs/cpuinfo.go | 519 - .../prometheus/procfs/cpuinfo_armx.go | 20 - .../prometheus/procfs/cpuinfo_loong64.go | 19 - .../prometheus/procfs/cpuinfo_mipsx.go | 20 - .../prometheus/procfs/cpuinfo_others.go | 19 - .../prometheus/procfs/cpuinfo_ppcx.go | 20 - .../prometheus/procfs/cpuinfo_riscvx.go | 20 - .../prometheus/procfs/cpuinfo_s390x.go | 19 - .../prometheus/procfs/cpuinfo_x86.go | 20 - vendor/github.com/prometheus/procfs/crypto.go | 154 - vendor/github.com/prometheus/procfs/doc.go | 44 - vendor/github.com/prometheus/procfs/fs.go | 50 - .../prometheus/procfs/fs_statfs_notype.go | 23 - .../prometheus/procfs/fs_statfs_type.go | 33 - .../github.com/prometheus/procfs/fscache.go | 422 - .../prometheus/procfs/internal/fs/fs.go | 55 - .../prometheus/procfs/internal/util/parse.go | 112 - .../procfs/internal/util/readfile.go | 37 - .../procfs/internal/util/sysreadfile.go | 50 - .../internal/util/sysreadfile_compat.go | 27 - .../procfs/internal/util/valueparser.go | 91 - vendor/github.com/prometheus/procfs/ipvs.go | 241 - .../prometheus/procfs/kernel_random.go | 63 - .../github.com/prometheus/procfs/loadavg.go | 62 - vendor/github.com/prometheus/procfs/mdstat.go | 276 - .../github.com/prometheus/procfs/meminfo.go | 389 - .../github.com/prometheus/procfs/mountinfo.go | 180 - .../prometheus/procfs/mountstats.go | 707 - .../prometheus/procfs/net_conntrackstat.go | 118 - .../github.com/prometheus/procfs/net_dev.go | 205 - .../prometheus/procfs/net_ip_socket.go | 248 - .../prometheus/procfs/net_protocols.go | 180 - .../github.com/prometheus/procfs/net_route.go | 143 - .../prometheus/procfs/net_sockstat.go | 162 - .../prometheus/procfs/net_softnet.go | 155 - .../github.com/prometheus/procfs/net_tcp.go | 64 - .../prometheus/procfs/net_tls_stat.go | 119 - .../github.com/prometheus/procfs/net_udp.go | 64 - .../github.com/prometheus/procfs/net_unix.go | 257 - .../prometheus/procfs/net_wireless.go | 182 - .../github.com/prometheus/procfs/net_xfrm.go | 189 - .../github.com/prometheus/procfs/netstat.go | 82 - vendor/github.com/prometheus/procfs/proc.go | 338 - .../prometheus/procfs/proc_cgroup.go | 98 - .../prometheus/procfs/proc_cgroups.go | 98 - .../prometheus/procfs/proc_environ.go | 37 - .../prometheus/procfs/proc_fdinfo.go | 138 - .../prometheus/procfs/proc_interrupts.go | 98 - .../github.com/prometheus/procfs/proc_io.go | 59 - .../prometheus/procfs/proc_limits.go | 160 - .../github.com/prometheus/procfs/proc_maps.go | 211 - .../prometheus/procfs/proc_netstat.go | 443 - .../github.com/prometheus/procfs/proc_ns.go | 68 - .../github.com/prometheus/procfs/proc_psi.go | 102 - .../prometheus/procfs/proc_smaps.go | 166 - .../github.com/prometheus/procfs/proc_snmp.go | 353 - .../prometheus/procfs/proc_snmp6.go | 381 - .../github.com/prometheus/procfs/proc_stat.go | 229 - .../prometheus/procfs/proc_status.go | 238 - .../github.com/prometheus/procfs/proc_sys.go | 51 - .../github.com/prometheus/procfs/schedstat.go | 121 - vendor/github.com/prometheus/procfs/slab.go | 151 - .../github.com/prometheus/procfs/softirqs.go | 160 - vendor/github.com/prometheus/procfs/stat.go | 258 - vendor/github.com/prometheus/procfs/swaps.go | 89 - vendor/github.com/prometheus/procfs/thread.go | 80 - vendor/github.com/prometheus/procfs/ttar | 413 - vendor/github.com/prometheus/procfs/vm.go | 212 - .../github.com/prometheus/procfs/zoneinfo.go | 196 - vendor/github.com/quic-go/quic-go/.gitignore | 18 - .../github.com/quic-go/quic-go/.golangci.yml | 109 - vendor/github.com/quic-go/quic-go/LICENSE | 21 - vendor/github.com/quic-go/quic-go/README.md | 61 - vendor/github.com/quic-go/quic-go/SECURITY.md | 14 - .../github.com/quic-go/quic-go/buffer_pool.go | 92 - vendor/github.com/quic-go/quic-go/client.go | 109 - .../github.com/quic-go/quic-go/closed_conn.go | 58 - vendor/github.com/quic-go/quic-go/codecov.yml | 19 - vendor/github.com/quic-go/quic-go/config.go | 129 - .../quic-go/quic-go/conn_id_generator.go | 212 - .../quic-go/quic-go/conn_id_manager.go | 321 - .../github.com/quic-go/quic-go/connection.go | 3159 --- .../quic-go/quic-go/connection_logging.go | 315 - .../quic-go/quic-go/crypto_stream.go | 249 - .../quic-go/quic-go/crypto_stream_manager.go | 73 - .../quic-go/quic-go/datagram_queue.go | 137 - vendor/github.com/quic-go/quic-go/errors.go | 105 - .../quic-go/quic-go/frame_sorter.go | 274 - vendor/github.com/quic-go/quic-go/framer.go | 295 - .../github.com/quic-go/quic-go/interface.go | 215 - .../internal/ackhandler/ack_eliciting.go | 33 - .../quic-go/internal/ackhandler/ecn.go | 340 - .../quic-go/internal/ackhandler/frame.go | 21 - .../quic-go/internal/ackhandler/interfaces.go | 39 - .../ackhandler/lost_packet_tracker.go | 73 - .../quic-go/internal/ackhandler/mockgen.go | 6 - .../quic-go/internal/ackhandler/packet.go | 60 - .../ackhandler/packet_number_generator.go | 84 - .../ackhandler/received_packet_handler.go | 119 - .../ackhandler/received_packet_history.go | 159 - .../ackhandler/received_packet_tracker.go | 228 - .../quic-go/internal/ackhandler/send_mode.go | 46 - .../ackhandler/sent_packet_handler.go | 1143 - .../ackhandler/sent_packet_history.go | 274 - .../quic-go/internal/congestion/bandwidth.go | 22 - .../quic-go/internal/congestion/clock.go | 20 - .../quic-go/internal/congestion/cubic.go | 214 - .../internal/congestion/cubic_sender.go | 330 - .../internal/congestion/hybrid_slow_start.go | 112 - .../quic-go/internal/congestion/interface.go | 27 - .../quic-go/internal/congestion/pacer.go | 110 - .../flowcontrol/base_flow_controller.go | 122 - .../flowcontrol/connection_flow_controller.go | 113 - .../quic-go/internal/flowcontrol/interface.go | 46 - .../flowcontrol/stream_flow_controller.go | 154 - .../quic-go/internal/handshake/aead.go | 90 - .../internal/handshake/cipher_suite.go | 110 - .../internal/handshake/crypto_setup.go | 720 - .../quic-go/internal/handshake/fake_conn.go | 21 - .../internal/handshake/header_protector.go | 134 - .../quic-go/internal/handshake/hkdf.go | 27 - .../internal/handshake/initial_aead.go | 71 - .../quic-go/internal/handshake/interface.go | 140 - .../quic-go/internal/handshake/retry.go | 66 - .../internal/handshake/session_ticket.go | 56 - .../quic-go/internal/handshake/tls_config.go | 39 - .../internal/handshake/token_generator.go | 126 - .../internal/handshake/token_protector.go | 74 - .../internal/handshake/updatable_aead.go | 372 - .../handshake/xor_nonce_aead_boring.go | 51 - .../handshake/xor_nonce_aead_noboring.go | 13 - .../quic-go/quic-go/internal/monotime/time.go | 90 - .../internal/protocol/connection_id.go | 116 - .../internal/protocol/encryption_level.go | 65 - .../quic-go/internal/protocol/key_phase.go | 36 - .../internal/protocol/packet_number.go | 57 - .../quic-go/internal/protocol/params.go | 169 - .../quic-go/internal/protocol/perspective.go | 26 - .../quic-go/internal/protocol/protocol.go | 159 - .../quic-go/internal/protocol/stream.go | 102 - .../quic-go/internal/protocol/version.go | 115 - .../quic-go/internal/qerr/error_codes.go | 87 - .../quic-go/quic-go/internal/qerr/errors.go | 134 - .../internal/utils/buffered_write_closer.go | 26 - .../quic-go/internal/utils/connstats.go | 14 - .../internal/utils/linkedlist/README.md | 6 - .../internal/utils/linkedlist/linkedlist.go | 264 - .../quic-go/quic-go/internal/utils/log.go | 131 - .../quic-go/quic-go/internal/utils/rand.go | 29 - .../internal/utils/ringbuffer/ringbuffer.go | 96 - .../quic-go/internal/utils/rtt_stats.go | 159 - .../quic-go/internal/wire/ack_frame.go | 298 - .../internal/wire/ack_frequency_frame.go | 65 - .../quic-go/internal/wire/ack_range.go | 14 - .../internal/wire/connection_close_frame.go | 75 - .../quic-go/internal/wire/crypto_frame.go | 97 - .../internal/wire/data_blocked_frame.go | 29 - .../quic-go/internal/wire/datagram_frame.go | 85 - .../quic-go/internal/wire/extended_header.go | 164 - .../quic-go/quic-go/internal/wire/frame.go | 33 - .../quic-go/internal/wire/frame_parser.go | 192 - .../quic-go/internal/wire/frame_type.go | 81 - .../internal/wire/handshake_done_frame.go | 17 - .../quic-go/quic-go/internal/wire/header.go | 302 - .../internal/wire/immediate_ack_frame.go | 18 - .../quic-go/quic-go/internal/wire/log.go | 74 - .../quic-go/internal/wire/max_data_frame.go | 33 - .../internal/wire/max_stream_data_frame.go | 43 - .../internal/wire/max_streams_frame.go | 50 - .../internal/wire/new_connection_id_frame.go | 80 - .../quic-go/internal/wire/new_token_frame.go | 43 - .../internal/wire/path_challenge_frame.go | 32 - .../internal/wire/path_response_frame.go | 32 - .../quic-go/internal/wire/ping_frame.go | 17 - .../quic-go/quic-go/internal/wire/pool.go | 33 - .../internal/wire/reset_stream_frame.go | 79 - .../wire/retire_connection_id_frame.go | 30 - .../quic-go/internal/wire/short_header.go | 62 - .../internal/wire/stop_sending_frame.go | 45 - .../wire/stream_data_blocked_frame.go | 42 - .../quic-go/internal/wire/stream_frame.go | 191 - .../internal/wire/streams_blocked_frame.go | 50 - .../internal/wire/transport_parameters.go | 583 - .../internal/wire/version_negotiation.go | 53 - vendor/github.com/quic-go/quic-go/mockgen.go | 47 - .../quic-go/quic-go/mtu_discoverer.go | 253 - vendor/github.com/quic-go/quic-go/oss-fuzz.sh | 42 - .../quic-go/quic-go/packet_packer.go | 1009 - .../quic-go/quic-go/packet_unpacker.go | 222 - .../quic-go/quic-go/path_manager.go | 206 - .../quic-go/quic-go/path_manager_outgoing.go | 314 - .../github.com/quic-go/quic-go/qlog/event.go | 849 - .../github.com/quic-go/quic-go/qlog/frame.go | 481 - .../quic-go/quic-go/qlog/packet_header.go | 96 - .../quic-go/quic-go/qlog/qlog_dir.go | 61 - .../github.com/quic-go/quic-go/qlog/types.go | 304 - .../quic-go/qlogwriter/jsontext/encoder.go | 324 - .../quic-go/quic-go/qlogwriter/trace.go | 124 - .../quic-go/quic-go/qlogwriter/writer.go | 229 - .../quic-go/quic-go/quicvarint/io.go | 98 - .../quic-go/quic-go/quicvarint/varint.go | 180 - .../quic-go/quic-go/receive_stream.go | 528 - .../quic-go/quic-go/retransmission_queue.go | 158 - .../github.com/quic-go/quic-go/send_conn.go | 127 - .../github.com/quic-go/quic-go/send_queue.go | 112 - .../github.com/quic-go/quic-go/send_stream.go | 767 - vendor/github.com/quic-go/quic-go/server.go | 1123 - vendor/github.com/quic-go/quic-go/sni.go | 136 - .../quic-go/quic-go/stateless_reset.go | 42 - vendor/github.com/quic-go/quic-go/stream.go | 234 - .../github.com/quic-go/quic-go/streams_map.go | 354 - .../quic-go/quic-go/streams_map_incoming.go | 209 - .../quic-go/quic-go/streams_map_outgoing.go | 246 - vendor/github.com/quic-go/quic-go/sys_conn.go | 143 - .../quic-go/quic-go/sys_conn_buffers.go | 68 - .../quic-go/quic-go/sys_conn_buffers_write.go | 70 - .../github.com/quic-go/quic-go/sys_conn_df.go | 22 - .../quic-go/quic-go/sys_conn_df_darwin.go | 92 - .../quic-go/quic-go/sys_conn_df_linux.go | 42 - .../quic-go/quic-go/sys_conn_df_windows.go | 52 - .../quic-go/quic-go/sys_conn_helper_darwin.go | 38 - .../quic-go/sys_conn_helper_freebsd.go | 33 - .../quic-go/quic-go/sys_conn_helper_linux.go | 156 - .../quic-go/sys_conn_helper_nonlinux.go | 10 - .../quic-go/quic-go/sys_conn_no_oob.go | 21 - .../quic-go/quic-go/sys_conn_oob.go | 338 - .../quic-go/quic-go/sys_conn_windows.go | 42 - .../github.com/quic-go/quic-go/token_store.go | 116 - .../github.com/quic-go/quic-go/transport.go | 852 - vendor/github.com/rs/zerolog/.gitignore | 25 - vendor/github.com/rs/zerolog/.travis.yml | 15 - vendor/github.com/rs/zerolog/CNAME | 1 - vendor/github.com/rs/zerolog/LICENSE | 21 - vendor/github.com/rs/zerolog/README.md | 618 - vendor/github.com/rs/zerolog/_config.yml | 1 - vendor/github.com/rs/zerolog/array.go | 233 - vendor/github.com/rs/zerolog/console.go | 397 - vendor/github.com/rs/zerolog/context.go | 439 - vendor/github.com/rs/zerolog/ctx.go | 48 - vendor/github.com/rs/zerolog/encoder.go | 56 - vendor/github.com/rs/zerolog/encoder_cbor.go | 35 - vendor/github.com/rs/zerolog/encoder_json.go | 32 - vendor/github.com/rs/zerolog/event.go | 736 - vendor/github.com/rs/zerolog/fields.go | 253 - vendor/github.com/rs/zerolog/globals.go | 114 - vendor/github.com/rs/zerolog/go112.go | 7 - vendor/github.com/rs/zerolog/hook.go | 64 - .../rs/zerolog/internal/cbor/README.md | 56 - .../rs/zerolog/internal/cbor/base.go | 11 - .../rs/zerolog/internal/cbor/cbor.go | 100 - .../rs/zerolog/internal/cbor/decode_stream.go | 614 - .../rs/zerolog/internal/cbor/string.go | 68 - .../rs/zerolog/internal/cbor/time.go | 93 - .../rs/zerolog/internal/cbor/types.go | 478 - .../rs/zerolog/internal/json/base.go | 11 - .../rs/zerolog/internal/json/bytes.go | 85 - .../rs/zerolog/internal/json/string.go | 121 - .../rs/zerolog/internal/json/time.go | 106 - .../rs/zerolog/internal/json/types.go | 406 - vendor/github.com/rs/zerolog/log.go | 440 - vendor/github.com/rs/zerolog/log/log.go | 130 - vendor/github.com/rs/zerolog/not_go112.go | 5 - vendor/github.com/rs/zerolog/pretty.png | Bin 144694 -> 0 bytes vendor/github.com/rs/zerolog/sampler.go | 134 - vendor/github.com/rs/zerolog/syslog.go | 58 - vendor/github.com/rs/zerolog/writer.go | 98 - .../russross/blackfriday/v2/.gitignore | 8 - .../russross/blackfriday/v2/.travis.yml | 17 - .../russross/blackfriday/v2/LICENSE.txt | 29 - .../russross/blackfriday/v2/README.md | 335 - .../russross/blackfriday/v2/block.go | 1612 -- .../github.com/russross/blackfriday/v2/doc.go | 46 - .../russross/blackfriday/v2/entities.go | 2236 -- .../github.com/russross/blackfriday/v2/esc.go | 70 - .../russross/blackfriday/v2/html.go | 952 - .../russross/blackfriday/v2/inline.go | 1228 -- .../russross/blackfriday/v2/markdown.go | 950 - .../russross/blackfriday/v2/node.go | 360 - .../russross/blackfriday/v2/smartypants.go | 457 - vendor/github.com/shirou/gopsutil/v4/LICENSE | 61 - .../shirou/gopsutil/v4/common/env.go | 25 - .../github.com/shirou/gopsutil/v4/cpu/cpu.go | 202 - .../shirou/gopsutil/v4/cpu/cpu_aix.go | 16 - .../shirou/gopsutil/v4/cpu/cpu_aix_cgo.go | 79 - .../shirou/gopsutil/v4/cpu/cpu_aix_nocgo.go | 157 - .../shirou/gopsutil/v4/cpu/cpu_darwin.go | 195 - .../gopsutil/v4/cpu/cpu_darwin_arm64.go | 83 - .../gopsutil/v4/cpu/cpu_darwin_fallback.go | 13 - .../shirou/gopsutil/v4/cpu/cpu_dragonfly.go | 162 - .../gopsutil/v4/cpu/cpu_dragonfly_amd64.go | 10 - .../shirou/gopsutil/v4/cpu/cpu_fallback.go | 31 - .../shirou/gopsutil/v4/cpu/cpu_freebsd.go | 174 - .../shirou/gopsutil/v4/cpu/cpu_freebsd_386.go | 10 - .../gopsutil/v4/cpu/cpu_freebsd_amd64.go | 10 - .../shirou/gopsutil/v4/cpu/cpu_freebsd_arm.go | 10 - .../gopsutil/v4/cpu/cpu_freebsd_arm64.go | 10 - .../shirou/gopsutil/v4/cpu/cpu_linux.go | 531 - .../shirou/gopsutil/v4/cpu/cpu_netbsd.go | 121 - .../gopsutil/v4/cpu/cpu_netbsd_amd64.go | 10 - .../shirou/gopsutil/v4/cpu/cpu_netbsd_arm.go | 10 - .../gopsutil/v4/cpu/cpu_netbsd_arm64.go | 10 - .../shirou/gopsutil/v4/cpu/cpu_openbsd.go | 139 - .../shirou/gopsutil/v4/cpu/cpu_openbsd_386.go | 11 - .../gopsutil/v4/cpu/cpu_openbsd_amd64.go | 11 - .../shirou/gopsutil/v4/cpu/cpu_openbsd_arm.go | 11 - .../gopsutil/v4/cpu/cpu_openbsd_arm64.go | 11 - .../gopsutil/v4/cpu/cpu_openbsd_riscv64.go | 11 - .../shirou/gopsutil/v4/cpu/cpu_plan9.go | 51 - .../shirou/gopsutil/v4/cpu/cpu_solaris.go | 267 - .../shirou/gopsutil/v4/cpu/cpu_windows.go | 477 - .../gopsutil/v4/internal/common/common.go | 475 - .../gopsutil/v4/internal/common/common_aix.go | 131 - .../v4/internal/common/common_darwin.go | 577 - .../v4/internal/common/common_freebsd.go | 65 - .../v4/internal/common/common_linux.go | 343 - .../v4/internal/common/common_netbsd.go | 49 - .../v4/internal/common/common_openbsd.go | 49 - .../v4/internal/common/common_unix.go | 42 - .../v4/internal/common/common_windows.go | 305 - .../gopsutil/v4/internal/common/endian.go | 11 - .../v4/internal/common/readlink_linux.go | 53 - .../gopsutil/v4/internal/common/sleep.go | 22 - .../gopsutil/v4/internal/common/warnings.go | 53 - .../shirou/gopsutil/v4/mem/ex_linux.go | 42 - .../shirou/gopsutil/v4/mem/ex_windows.go | 62 - .../github.com/shirou/gopsutil/v4/mem/mem.go | 122 - .../shirou/gopsutil/v4/mem/mem_aix.go | 22 - .../shirou/gopsutil/v4/mem/mem_aix_cgo.go | 51 - .../shirou/gopsutil/v4/mem/mem_aix_nocgo.go | 78 - .../shirou/gopsutil/v4/mem/mem_bsd.go | 87 - .../shirou/gopsutil/v4/mem/mem_darwin.go | 127 - .../shirou/gopsutil/v4/mem/mem_fallback.go | 34 - .../shirou/gopsutil/v4/mem/mem_freebsd.go | 168 - .../shirou/gopsutil/v4/mem/mem_linux.go | 524 - .../shirou/gopsutil/v4/mem/mem_netbsd.go | 87 - .../shirou/gopsutil/v4/mem/mem_openbsd.go | 103 - .../shirou/gopsutil/v4/mem/mem_openbsd_386.go | 38 - .../gopsutil/v4/mem/mem_openbsd_amd64.go | 33 - .../shirou/gopsutil/v4/mem/mem_openbsd_arm.go | 38 - .../gopsutil/v4/mem/mem_openbsd_arm64.go | 38 - .../gopsutil/v4/mem/mem_openbsd_riscv64.go | 38 - .../shirou/gopsutil/v4/mem/mem_plan9.go | 69 - .../shirou/gopsutil/v4/mem/mem_solaris.go | 211 - .../shirou/gopsutil/v4/mem/mem_windows.go | 189 - .../github.com/shirou/gopsutil/v4/net/net.go | 356 - .../shirou/gopsutil/v4/net/net_aix.go | 300 - .../shirou/gopsutil/v4/net/net_aix_cgo.go | 37 - .../shirou/gopsutil/v4/net/net_aix_nocgo.go | 95 - .../shirou/gopsutil/v4/net/net_darwin.go | 265 - .../shirou/gopsutil/v4/net/net_fallback.go | 71 - .../shirou/gopsutil/v4/net/net_freebsd.go | 108 - .../shirou/gopsutil/v4/net/net_linux.go | 817 - .../shirou/gopsutil/v4/net/net_openbsd.go | 339 - .../shirou/gopsutil/v4/net/net_solaris.go | 169 - .../shirou/gopsutil/v4/net/net_unix.go | 184 - .../shirou/gopsutil/v4/net/net_windows.go | 731 - .../shirou/gopsutil/v4/process/process.go | 645 - .../shirou/gopsutil/v4/process/process_bsd.go | 72 - .../gopsutil/v4/process/process_darwin.go | 523 - .../v4/process/process_darwin_amd64.go | 303 - .../v4/process/process_darwin_arm64.go | 279 - .../gopsutil/v4/process/process_fallback.go | 203 - .../gopsutil/v4/process/process_freebsd.go | 367 - .../v4/process/process_freebsd_386.go | 218 - .../v4/process/process_freebsd_amd64.go | 224 - .../v4/process/process_freebsd_arm.go | 218 - .../v4/process/process_freebsd_arm64.go | 226 - .../gopsutil/v4/process/process_linux.go | 1204 -- .../gopsutil/v4/process/process_openbsd.go | 401 - .../v4/process/process_openbsd_386.go | 203 - .../v4/process/process_openbsd_amd64.go | 202 - .../v4/process/process_openbsd_arm.go | 203 - .../v4/process/process_openbsd_arm64.go | 204 - .../v4/process/process_openbsd_riscv64.go | 205 - .../gopsutil/v4/process/process_plan9.go | 203 - .../gopsutil/v4/process/process_posix.go | 187 - .../gopsutil/v4/process/process_solaris.go | 304 - .../gopsutil/v4/process/process_windows.go | 1213 -- .../v4/process/process_windows_32bit.go | 104 - .../v4/process/process_windows_64bit.go | 77 - vendor/github.com/stretchr/testify/LICENSE | 21 - .../testify/assert/assertion_compare.go | 495 - .../testify/assert/assertion_format.go | 866 - .../testify/assert/assertion_format.go.tmpl | 5 - .../testify/assert/assertion_forward.go | 1723 -- .../testify/assert/assertion_forward.go.tmpl | 5 - .../testify/assert/assertion_order.go | 81 - .../stretchr/testify/assert/assertions.go | 2295 -- .../github.com/stretchr/testify/assert/doc.go | 50 - .../stretchr/testify/assert/errors.go | 10 - .../testify/assert/forward_assertions.go | 16 - .../testify/assert/http_assertions.go | 165 - .../testify/assert/yaml/yaml_custom.go | 24 - .../testify/assert/yaml/yaml_default.go | 36 - .../stretchr/testify/assert/yaml/yaml_fail.go | 17 - .../stretchr/testify/require/doc.go | 31 - .../testify/require/forward_requirements.go | 16 - .../stretchr/testify/require/require.go | 2180 -- .../stretchr/testify/require/require.go.tmpl | 6 - .../testify/require/require_forward.go | 1724 -- .../testify/require/require_forward.go.tmpl | 5 - .../stretchr/testify/require/requirements.go | 29 - .../tklauser/go-sysconf/.cirrus.yml | 23 - .../github.com/tklauser/go-sysconf/.gitignore | 1 - vendor/github.com/tklauser/go-sysconf/LICENSE | 29 - .../github.com/tklauser/go-sysconf/README.md | 46 - .../github.com/tklauser/go-sysconf/sysconf.go | 21 - .../tklauser/go-sysconf/sysconf_bsd.go | 37 - .../tklauser/go-sysconf/sysconf_darwin.go | 307 - .../tklauser/go-sysconf/sysconf_dragonfly.go | 220 - .../tklauser/go-sysconf/sysconf_freebsd.go | 226 - .../tklauser/go-sysconf/sysconf_generic.go | 45 - .../tklauser/go-sysconf/sysconf_linux.go | 353 - .../tklauser/go-sysconf/sysconf_netbsd.go | 246 - .../tklauser/go-sysconf/sysconf_openbsd.go | 271 - .../tklauser/go-sysconf/sysconf_posix.go | 82 - .../tklauser/go-sysconf/sysconf_solaris.go | 14 - .../go-sysconf/sysconf_unsupported.go | 16 - .../go-sysconf/zsysconf_defs_darwin.go | 252 - .../go-sysconf/zsysconf_defs_dragonfly.go | 227 - .../go-sysconf/zsysconf_defs_freebsd.go | 228 - .../go-sysconf/zsysconf_defs_linux.go | 146 - .../go-sysconf/zsysconf_defs_netbsd.go | 163 - .../go-sysconf/zsysconf_defs_openbsd.go | 262 - .../go-sysconf/zsysconf_defs_solaris.go | 138 - .../go-sysconf/zsysconf_values_freebsd_386.go | 11 - .../zsysconf_values_freebsd_amd64.go | 11 - .../go-sysconf/zsysconf_values_freebsd_arm.go | 11 - .../zsysconf_values_freebsd_arm64.go | 11 - .../zsysconf_values_freebsd_riscv64.go | 11 - .../go-sysconf/zsysconf_values_linux_386.go | 113 - .../go-sysconf/zsysconf_values_linux_amd64.go | 113 - .../go-sysconf/zsysconf_values_linux_arm.go | 113 - .../go-sysconf/zsysconf_values_linux_arm64.go | 113 - .../zsysconf_values_linux_loong64.go | 113 - .../go-sysconf/zsysconf_values_linux_mips.go | 113 - .../zsysconf_values_linux_mips64.go | 113 - .../zsysconf_values_linux_mips64le.go | 113 - .../zsysconf_values_linux_mipsle.go | 113 - .../go-sysconf/zsysconf_values_linux_ppc64.go | 113 - .../zsysconf_values_linux_ppc64le.go | 113 - .../zsysconf_values_linux_riscv64.go | 113 - .../go-sysconf/zsysconf_values_linux_s390x.go | 113 - .../go-sysconf/zsysconf_values_netbsd_386.go | 10 - .../zsysconf_values_netbsd_amd64.go | 10 - .../go-sysconf/zsysconf_values_netbsd_arm.go | 10 - .../zsysconf_values_netbsd_arm64.go | 10 - .../github.com/tklauser/numcpus/.cirrus.yml | 23 - vendor/github.com/tklauser/numcpus/LICENSE | 202 - vendor/github.com/tklauser/numcpus/README.md | 52 - vendor/github.com/tklauser/numcpus/numcpus.go | 98 - .../tklauser/numcpus/numcpus_bsd.go | 65 - .../tklauser/numcpus/numcpus_linux.go | 192 - .../numcpus/numcpus_list_unsupported.go | 33 - .../tklauser/numcpus/numcpus_solaris.go | 55 - .../tklauser/numcpus/numcpus_unsupported.go | 41 - .../tklauser/numcpus/numcpus_windows.go | 41 - vendor/github.com/urfave/cli/v2/.flake8 | 2 - vendor/github.com/urfave/cli/v2/.gitignore | 7 - .../urfave/cli/v2/CODE_OF_CONDUCT.md | 74 - vendor/github.com/urfave/cli/v2/LICENSE | 21 - vendor/github.com/urfave/cli/v2/README.md | 70 - .../cli/v2/altsrc/default_input_source.go | 6 - vendor/github.com/urfave/cli/v2/altsrc/fg.py | 45 - .../github.com/urfave/cli/v2/altsrc/flag.go | 304 - .../urfave/cli/v2/altsrc/flag_generated.go | 189 - .../cli/v2/altsrc/input_source_context.go | 25 - .../cli/v2/altsrc/json_source_context.go | 212 - .../urfave/cli/v2/altsrc/map_input_source.go | 255 - .../urfave/cli/v2/altsrc/toml_file_loader.go | 112 - .../urfave/cli/v2/altsrc/yaml_file_loader.go | 91 - vendor/github.com/urfave/cli/v2/app.go | 540 - vendor/github.com/urfave/cli/v2/args.go | 54 - vendor/github.com/urfave/cli/v2/category.go | 79 - vendor/github.com/urfave/cli/v2/cli.go | 23 - vendor/github.com/urfave/cli/v2/command.go | 301 - vendor/github.com/urfave/cli/v2/context.go | 319 - vendor/github.com/urfave/cli/v2/docs.go | 157 - vendor/github.com/urfave/cli/v2/errors.go | 141 - vendor/github.com/urfave/cli/v2/fish.go | 196 - vendor/github.com/urfave/cli/v2/flag.go | 392 - vendor/github.com/urfave/cli/v2/flag_bool.go | 102 - .../github.com/urfave/cli/v2/flag_duration.go | 101 - .../github.com/urfave/cli/v2/flag_float64.go | 102 - .../urfave/cli/v2/flag_float64_slice.go | 159 - .../github.com/urfave/cli/v2/flag_generic.go | 104 - vendor/github.com/urfave/cli/v2/flag_int.go | 102 - vendor/github.com/urfave/cli/v2/flag_int64.go | 101 - .../urfave/cli/v2/flag_int64_slice.go | 158 - .../urfave/cli/v2/flag_int_slice.go | 169 - vendor/github.com/urfave/cli/v2/flag_path.go | 90 - .../github.com/urfave/cli/v2/flag_string.go | 91 - .../urfave/cli/v2/flag_string_slice.go | 176 - .../urfave/cli/v2/flag_timestamp.go | 150 - vendor/github.com/urfave/cli/v2/flag_uint.go | 101 - .../github.com/urfave/cli/v2/flag_uint64.go | 101 - vendor/github.com/urfave/cli/v2/funcs.go | 44 - vendor/github.com/urfave/cli/v2/help.go | 386 - vendor/github.com/urfave/cli/v2/parse.go | 94 - vendor/github.com/urfave/cli/v2/sort.go | 29 - vendor/github.com/urfave/cli/v2/template.go | 120 - vendor/github.com/yusufpapurcu/wmi/LICENSE | 20 - vendor/github.com/yusufpapurcu/wmi/README.md | 6 - .../yusufpapurcu/wmi/swbemservices.go | 261 - vendor/github.com/yusufpapurcu/wmi/wmi.go | 603 - .../auto/sdk/CONTRIBUTING.md | 27 - vendor/go.opentelemetry.io/auto/sdk/LICENSE | 201 - .../auto/sdk/VERSIONING.md | 15 - vendor/go.opentelemetry.io/auto/sdk/doc.go | 14 - .../auto/sdk/internal/telemetry/attr.go | 58 - .../auto/sdk/internal/telemetry/doc.go | 8 - .../auto/sdk/internal/telemetry/id.go | 103 - .../auto/sdk/internal/telemetry/number.go | 67 - .../auto/sdk/internal/telemetry/resource.go | 66 - .../auto/sdk/internal/telemetry/scope.go | 67 - .../auto/sdk/internal/telemetry/span.go | 472 - .../auto/sdk/internal/telemetry/status.go | 42 - .../auto/sdk/internal/telemetry/traces.go | 189 - .../auto/sdk/internal/telemetry/value.go | 450 - vendor/go.opentelemetry.io/auto/sdk/limit.go | 94 - vendor/go.opentelemetry.io/auto/sdk/span.go | 447 - vendor/go.opentelemetry.io/auto/sdk/tracer.go | 141 - .../auto/sdk/tracer_provider.go | 33 - .../contrib/propagators/LICENSE | 201 - .../contrib/propagators/jaeger/context.go | 41 - .../contrib/propagators/jaeger/doc.go | 17 - .../propagators/jaeger/jaeger_propagator.go | 161 - .../go.opentelemetry.io/otel/.clomonitor.yml | 3 - .../go.opentelemetry.io/otel/.codespellignore | 11 - vendor/go.opentelemetry.io/otel/.codespellrc | 10 - .../go.opentelemetry.io/otel/.gitattributes | 3 - vendor/go.opentelemetry.io/otel/.gitignore | 15 - vendor/go.opentelemetry.io/otel/.golangci.yml | 283 - vendor/go.opentelemetry.io/otel/.lycheeignore | 13 - .../otel/.markdownlint.yaml | 29 - vendor/go.opentelemetry.io/otel/AGENTS.md | 109 - vendor/go.opentelemetry.io/otel/CHANGELOG.md | 3834 ---- vendor/go.opentelemetry.io/otel/CLAUDE.md | 3 - vendor/go.opentelemetry.io/otel/CODEOWNERS | 17 - .../go.opentelemetry.io/otel/CONTRIBUTING.md | 1234 -- vendor/go.opentelemetry.io/otel/LICENSE | 231 - vendor/go.opentelemetry.io/otel/Makefile | 338 - vendor/go.opentelemetry.io/otel/README.md | 115 - vendor/go.opentelemetry.io/otel/RELEASING.md | 220 - .../otel/SECURITY-INSIGHTS.yml | 203 - vendor/go.opentelemetry.io/otel/VERSIONING.md | 224 - .../otel/attribute/README.md | 3 - .../go.opentelemetry.io/otel/attribute/doc.go | 5 - .../otel/attribute/encoder.go | 137 - .../otel/attribute/filter.go | 49 - .../otel/attribute/hash.go | 130 - .../otel/attribute/internal/attribute.go | 75 - .../otel/attribute/internal/xxhash/xxhash.go | 64 - .../otel/attribute/iterator.go | 151 - .../go.opentelemetry.io/otel/attribute/key.go | 145 - .../go.opentelemetry.io/otel/attribute/kv.go | 85 - .../otel/attribute/rawhelpers.go | 37 - .../go.opentelemetry.io/otel/attribute/set.go | 436 - .../otel/attribute/type_string.go | 34 - .../otel/attribute/value.go | 1034 - .../otel/baggage/README.md | 3 - .../otel/baggage/baggage.go | 1097 - .../otel/baggage/context.go | 28 - .../go.opentelemetry.io/otel/baggage/doc.go | 9 - .../go.opentelemetry.io/otel/codes/README.md | 3 - .../go.opentelemetry.io/otel/codes/codes.go | 106 - vendor/go.opentelemetry.io/otel/codes/doc.go | 10 - .../otel/dependencies.Dockerfile | 4 - vendor/go.opentelemetry.io/otel/doc.go | 25 - .../go.opentelemetry.io/otel/error_handler.go | 27 - .../otel/exporters/otlp/otlptrace/LICENSE | 231 - .../otel/exporters/otlp/otlptrace/README.md | 3 - .../otel/exporters/otlp/otlptrace/clients.go | 43 - .../otel/exporters/otlp/otlptrace/doc.go | 10 - .../otel/exporters/otlp/otlptrace/exporter.go | 105 - .../internal/tracetransform/attribute.go | 151 - .../tracetransform/instrumentation.go | 21 - .../internal/tracetransform/resource.go | 18 - .../otlptrace/internal/tracetransform/span.go | 221 - .../otel/exporters/otlp/otlptrace/version.go | 9 - vendor/go.opentelemetry.io/otel/handler.go | 33 - .../otel/internal/baggage/baggage.go | 32 - .../otel/internal/baggage/context.go | 81 - .../internal/errorhandler/errorhandler.go | 96 - .../otel/internal/global/handler.go | 17 - .../otel/internal/global/instruments.go | 468 - .../otel/internal/global/internal_logging.go | 62 - .../otel/internal/global/meter.go | 625 - .../otel/internal/global/propagator.go | 71 - .../otel/internal/global/state.go | 169 - .../otel/internal/global/trace.go | 232 - .../otel/internal_logging.go | 15 - vendor/go.opentelemetry.io/otel/metric.go | 42 - .../go.opentelemetry.io/otel/metric/LICENSE | 231 - .../go.opentelemetry.io/otel/metric/README.md | 3 - .../otel/metric/asyncfloat64.go | 282 - .../otel/metric/asyncint64.go | 278 - .../go.opentelemetry.io/otel/metric/config.go | 118 - vendor/go.opentelemetry.io/otel/metric/doc.go | 204 - .../otel/metric/embedded/README.md | 3 - .../otel/metric/embedded/embedded.go | 243 - .../otel/metric/instrument.go | 403 - .../go.opentelemetry.io/otel/metric/meter.go | 340 - .../otel/metric/noop/README.md | 3 - .../otel/metric/noop/noop.go | 320 - .../otel/metric/syncfloat64.go | 286 - .../otel/metric/syncint64.go | 286 - .../go.opentelemetry.io/otel/propagation.go | 20 - .../otel/propagation/README.md | 3 - .../otel/propagation/baggage.go | 145 - .../otel/propagation/doc.go | 13 - .../otel/propagation/propagation.go | 168 - .../otel/propagation/trace_context.go | 155 - vendor/go.opentelemetry.io/otel/renovate.json | 35 - .../go.opentelemetry.io/otel/requirements.txt | 1 - vendor/go.opentelemetry.io/otel/sdk/LICENSE | 231 - vendor/go.opentelemetry.io/otel/sdk/README.md | 3 - .../otel/sdk/instrumentation/README.md | 3 - .../otel/sdk/instrumentation/doc.go | 13 - .../otel/sdk/instrumentation/library.go | 9 - .../otel/sdk/instrumentation/scope.go | 19 - .../otel/sdk/internal/x/README.md | 46 - .../otel/sdk/internal/x/features.go | 54 - .../otel/sdk/internal/x/x.go | 58 - .../otel/sdk/resource/README.md | 3 - .../otel/sdk/resource/auto.go | 92 - .../otel/sdk/resource/builtin.go | 116 - .../otel/sdk/resource/config.go | 203 - .../otel/sdk/resource/container.go | 89 - .../otel/sdk/resource/doc.go | 20 - .../otel/sdk/resource/env.go | 95 - .../otel/sdk/resource/host_id.go | 108 - .../otel/sdk/resource/host_id_bsd.go | 11 - .../otel/sdk/resource/host_id_darwin.go | 8 - .../otel/sdk/resource/host_id_exec.go | 21 - .../otel/sdk/resource/host_id_linux.go | 10 - .../otel/sdk/resource/host_id_readfile.go | 17 - .../otel/sdk/resource/host_id_unsupported.go | 18 - .../otel/sdk/resource/host_id_windows.go | 35 - .../otel/sdk/resource/os.go | 89 - .../otel/sdk/resource/os_release_darwin.go | 92 - .../otel/sdk/resource/os_release_unix.go | 142 - .../otel/sdk/resource/os_unix.go | 79 - .../otel/sdk/resource/os_unsupported.go | 14 - .../otel/sdk/resource/os_windows.go | 91 - .../otel/sdk/resource/process.go | 174 - .../otel/sdk/resource/resource.go | 324 - .../otel/sdk/trace/README.md | 3 - .../otel/sdk/trace/batch_span_processor.go | 445 - .../go.opentelemetry.io/otel/sdk/trace/doc.go | 13 - .../otel/sdk/trace/event.go | 26 - .../otel/sdk/trace/evictedqueue.go | 64 - .../otel/sdk/trace/id_generator.go | 69 - .../otel/sdk/trace/internal/env/env.go | 168 - .../internal/observ/batch_span_processor.go | 119 - .../otel/sdk/trace/internal/observ/doc.go | 6 - .../internal/observ/simple_span_processor.go | 98 - .../otel/sdk/trace/internal/observ/tracer.go | 231 - .../otel/sdk/trace/link.go | 23 - .../otel/sdk/trace/provider.go | 510 - .../otel/sdk/trace/sampler_env.go | 96 - .../otel/sdk/trace/sampling.go | 337 - .../otel/sdk/trace/simple_span_processor.go | 150 - .../otel/sdk/trace/snapshot.go | 133 - .../otel/sdk/trace/span.go | 1046 - .../otel/sdk/trace/span_exporter.go | 36 - .../otel/sdk/trace/span_limits.go | 116 - .../otel/sdk/trace/span_processor.go | 61 - .../otel/sdk/trace/tracer.go | 188 - .../go.opentelemetry.io/otel/sdk/version.go | 10 - .../otel/semconv/internal/http.go | 338 - .../otel/semconv/v1.37.0/MIGRATION.md | 41 - .../otel/semconv/v1.37.0/README.md | 3 - .../otel/semconv/v1.37.0/attribute_group.go | 15197 -------------- .../otel/semconv/v1.37.0/doc.go | 9 - .../otel/semconv/v1.37.0/error_type.go | 56 - .../otel/semconv/v1.37.0/exception.go | 9 - .../otel/semconv/v1.37.0/schema.go | 9 - .../otel/semconv/v1.41.0/MIGRATION.md | 17 - .../otel/semconv/v1.41.0/README.md | 3 - .../otel/semconv/v1.41.0/attribute_group.go | 17285 ---------------- .../otel/semconv/v1.41.0/doc.go | 11 - .../otel/semconv/v1.41.0/error_type.go | 83 - .../otel/semconv/v1.41.0/exception.go | 11 - .../otel/semconv/v1.41.0/otelconv/metric.go | 3234 --- .../otel/semconv/v1.41.0/schema.go | 11 - .../otel/semconv/v1.7.0/README.md | 3 - .../otel/semconv/v1.7.0/doc.go | 9 - .../otel/semconv/v1.7.0/exception.go | 9 - .../otel/semconv/v1.7.0/http.go | 103 - .../otel/semconv/v1.7.0/resource.go | 935 - .../otel/semconv/v1.7.0/schema.go | 9 - .../otel/semconv/v1.7.0/trace.go | 1547 -- vendor/go.opentelemetry.io/otel/trace.go | 36 - vendor/go.opentelemetry.io/otel/trace/LICENSE | 231 - .../go.opentelemetry.io/otel/trace/README.md | 3 - vendor/go.opentelemetry.io/otel/trace/auto.go | 678 - .../go.opentelemetry.io/otel/trace/config.go | 378 - .../go.opentelemetry.io/otel/trace/context.go | 50 - vendor/go.opentelemetry.io/otel/trace/doc.go | 119 - .../otel/trace/embedded/README.md | 3 - .../otel/trace/embedded/embedded.go | 45 - vendor/go.opentelemetry.io/otel/trace/hex.go | 38 - .../otel/trace/internal/telemetry/attr.go | 58 - .../otel/trace/internal/telemetry/doc.go | 8 - .../otel/trace/internal/telemetry/id.go | 103 - .../otel/trace/internal/telemetry/number.go | 67 - .../otel/trace/internal/telemetry/resource.go | 66 - .../otel/trace/internal/telemetry/scope.go | 67 - .../otel/trace/internal/telemetry/span.go | 472 - .../otel/trace/internal/telemetry/status.go | 42 - .../otel/trace/internal/telemetry/traces.go | 189 - .../otel/trace/internal/telemetry/value.go | 453 - .../otel/trace/nonrecording.go | 16 - vendor/go.opentelemetry.io/otel/trace/noop.go | 105 - .../otel/trace/noop/README.md | 3 - .../otel/trace/noop/noop.go | 112 - .../otel/trace/provider.go | 59 - vendor/go.opentelemetry.io/otel/trace/span.go | 181 - .../go.opentelemetry.io/otel/trace/trace.go | 389 - .../go.opentelemetry.io/otel/trace/tracer.go | 37 - .../otel/trace/tracestate.go | 333 - .../otel/verify_released_changelog.sh | 42 - vendor/go.opentelemetry.io/otel/version.go | 9 - vendor/go.opentelemetry.io/otel/versions.yaml | 73 - vendor/go.opentelemetry.io/proto/otlp/LICENSE | 201 - .../collector/trace/v1/trace_service.pb.go | 367 - .../collector/trace/v1/trace_service.pb.gw.go | 171 - .../trace/v1/trace_service_grpc.pb.go | 105 - .../proto/otlp/common/v1/common.pb.go | 808 - .../proto/otlp/resource/v1/resource.pb.go | 214 - .../proto/otlp/trace/v1/trace.pb.go | 1285 -- vendor/go.uber.org/automaxprocs/LICENSE | 19 - .../automaxprocs/internal/cgroups/cgroup.go | 79 - .../automaxprocs/internal/cgroups/cgroups.go | 118 - .../automaxprocs/internal/cgroups/cgroups2.go | 176 - .../automaxprocs/internal/cgroups/doc.go | 23 - .../automaxprocs/internal/cgroups/errors.go | 52 - .../internal/cgroups/mountpoint.go | 171 - .../automaxprocs/internal/cgroups/subsys.go | 103 - .../internal/runtime/cpu_quota_linux.go | 75 - .../internal/runtime/cpu_quota_unsupported.go | 31 - .../automaxprocs/internal/runtime/runtime.go | 40 - .../automaxprocs/maxprocs/maxprocs.go | 139 - .../automaxprocs/maxprocs/version.go | 24 - vendor/go.uber.org/mock/AUTHORS | 12 - vendor/go.uber.org/mock/LICENSE | 202 - vendor/go.uber.org/mock/gomock/call.go | 506 - vendor/go.uber.org/mock/gomock/callset.go | 164 - vendor/go.uber.org/mock/gomock/controller.go | 326 - vendor/go.uber.org/mock/gomock/doc.go | 60 - vendor/go.uber.org/mock/gomock/matchers.go | 447 - vendor/go.uber.org/mock/gomock/string.go | 36 - vendor/golang.org/x/crypto/LICENSE | 27 - vendor/golang.org/x/crypto/PATENTS | 22 - vendor/golang.org/x/crypto/blake2b/blake2b.go | 291 - .../x/crypto/blake2b/blake2bAVX2_amd64.go | 37 - .../x/crypto/blake2b/blake2bAVX2_amd64.s | 4559 ---- .../x/crypto/blake2b/blake2b_amd64.s | 1441 -- .../x/crypto/blake2b/blake2b_generic.go | 182 - .../x/crypto/blake2b/blake2b_ref.go | 11 - vendor/golang.org/x/crypto/blake2b/blake2x.go | 185 - .../golang.org/x/crypto/blake2b/register.go | 30 - vendor/golang.org/x/crypto/blowfish/block.go | 159 - vendor/golang.org/x/crypto/blowfish/cipher.go | 99 - vendor/golang.org/x/crypto/blowfish/const.go | 199 - .../x/crypto/chacha20/chacha_arm64.go | 16 - .../x/crypto/chacha20/chacha_arm64.s | 307 - .../x/crypto/chacha20/chacha_generic.go | 398 - .../x/crypto/chacha20/chacha_noasm.go | 13 - .../x/crypto/chacha20/chacha_ppc64x.go | 16 - .../x/crypto/chacha20/chacha_ppc64x.s | 501 - .../x/crypto/chacha20/chacha_s390x.go | 27 - .../x/crypto/chacha20/chacha_s390x.s | 224 - vendor/golang.org/x/crypto/chacha20/xor.go | 42 - .../chacha20poly1305/chacha20poly1305.go | 101 - .../chacha20poly1305_amd64.go | 92 - .../chacha20poly1305/chacha20poly1305_amd64.s | 5230 ----- .../chacha20poly1305_generic.go | 87 - .../chacha20poly1305_noasm.go | 15 - .../chacha20poly1305/fips140only_compat.go | 9 - .../chacha20poly1305/fips140only_go1.26.go | 11 - .../chacha20poly1305/xchacha20poly1305.go | 89 - vendor/golang.org/x/crypto/cryptobyte/asn1.go | 825 - .../x/crypto/cryptobyte/asn1/asn1.go | 46 - .../golang.org/x/crypto/cryptobyte/builder.go | 350 - .../golang.org/x/crypto/cryptobyte/string.go | 183 - .../x/crypto/curve25519/curve25519.go | 93 - vendor/golang.org/x/crypto/hkdf/hkdf.go | 100 - .../x/crypto/internal/alias/alias.go | 31 - .../x/crypto/internal/alias/alias_purego.go | 34 - .../x/crypto/internal/poly1305/mac_noasm.go | 9 - .../x/crypto/internal/poly1305/poly1305.go | 99 - .../x/crypto/internal/poly1305/sum_amd64.s | 93 - .../x/crypto/internal/poly1305/sum_asm.go | 47 - .../x/crypto/internal/poly1305/sum_generic.go | 312 - .../x/crypto/internal/poly1305/sum_loong64.s | 123 - .../x/crypto/internal/poly1305/sum_ppc64x.s | 187 - .../x/crypto/internal/poly1305/sum_s390x.go | 76 - .../x/crypto/internal/poly1305/sum_s390x.s | 503 - vendor/golang.org/x/crypto/nacl/box/box.go | 182 - .../x/crypto/nacl/secretbox/secretbox.go | 173 - .../x/crypto/salsa20/salsa/hsalsa20.go | 150 - .../x/crypto/salsa20/salsa/salsa208.go | 201 - .../x/crypto/salsa20/salsa/salsa20_amd64.go | 23 - .../x/crypto/salsa20/salsa/salsa20_amd64.s | 880 - .../x/crypto/salsa20/salsa/salsa20_noasm.go | 14 - .../x/crypto/salsa20/salsa/salsa20_ref.go | 233 - vendor/golang.org/x/crypto/ssh/buffer.go | 97 - vendor/golang.org/x/crypto/ssh/certs.go | 640 - vendor/golang.org/x/crypto/ssh/channel.go | 701 - vendor/golang.org/x/crypto/ssh/cipher.go | 789 - vendor/golang.org/x/crypto/ssh/client.go | 368 - vendor/golang.org/x/crypto/ssh/client_auth.go | 828 - vendor/golang.org/x/crypto/ssh/common.go | 727 - vendor/golang.org/x/crypto/ssh/connection.go | 163 - vendor/golang.org/x/crypto/ssh/control.go | 155 - vendor/golang.org/x/crypto/ssh/doc.go | 34 - vendor/golang.org/x/crypto/ssh/handshake.go | 847 - .../ssh/internal/bcrypt_pbkdf/bcrypt_pbkdf.go | 93 - vendor/golang.org/x/crypto/ssh/kex.go | 864 - vendor/golang.org/x/crypto/ssh/keys.go | 1916 -- vendor/golang.org/x/crypto/ssh/mac.go | 84 - vendor/golang.org/x/crypto/ssh/messages.go | 893 - vendor/golang.org/x/crypto/ssh/mlkem.go | 168 - vendor/golang.org/x/crypto/ssh/mux.go | 388 - vendor/golang.org/x/crypto/ssh/server.go | 1084 - vendor/golang.org/x/crypto/ssh/session.go | 650 - vendor/golang.org/x/crypto/ssh/ssh_gss.go | 145 - vendor/golang.org/x/crypto/ssh/streamlocal.go | 116 - vendor/golang.org/x/crypto/ssh/tcpip.go | 545 - vendor/golang.org/x/crypto/ssh/transport.go | 377 - vendor/golang.org/x/net/LICENSE | 27 - vendor/golang.org/x/net/PATENTS | 22 - vendor/golang.org/x/net/bpf/asm.go | 41 - vendor/golang.org/x/net/bpf/constants.go | 222 - vendor/golang.org/x/net/bpf/doc.go | 80 - vendor/golang.org/x/net/bpf/instructions.go | 726 - vendor/golang.org/x/net/bpf/setter.go | 10 - vendor/golang.org/x/net/bpf/vm.go | 150 - .../golang.org/x/net/bpf/vm_instructions.go | 182 - vendor/golang.org/x/net/context/context.go | 118 - vendor/golang.org/x/net/http/httpguts/guts.go | 50 - .../golang.org/x/net/http/httpguts/httplex.go | 347 - vendor/golang.org/x/net/http2/.gitignore | 2 - vendor/golang.org/x/net/http2/README.md | 19 - vendor/golang.org/x/net/http2/ascii.go | 53 - vendor/golang.org/x/net/http2/ciphers.go | 641 - .../x/net/http2/client_conn_pool.go | 301 - .../x/net/http2/client_priority_go126.go | 20 - .../x/net/http2/client_priority_go127.go | 13 - vendor/golang.org/x/net/http2/clientconn.go | 57 - vendor/golang.org/x/net/http2/config.go | 171 - vendor/golang.org/x/net/http2/config_go125.go | 15 - vendor/golang.org/x/net/http2/config_go126.go | 15 - vendor/golang.org/x/net/http2/databuffer.go | 149 - vendor/golang.org/x/net/http2/errors.go | 145 - vendor/golang.org/x/net/http2/flow.go | 120 - vendor/golang.org/x/net/http2/frame.go | 1871 -- vendor/golang.org/x/net/http2/gotrack.go | 181 - vendor/golang.org/x/net/http2/hpack/encode.go | 245 - vendor/golang.org/x/net/http2/hpack/hpack.go | 523 - .../golang.org/x/net/http2/hpack/huffman.go | 226 - .../x/net/http2/hpack/static_table.go | 188 - vendor/golang.org/x/net/http2/hpack/tables.go | 403 - vendor/golang.org/x/net/http2/http2.go | 415 - vendor/golang.org/x/net/http2/pipe.go | 184 - vendor/golang.org/x/net/http2/server.go | 3217 --- .../golang.org/x/net/http2/server_common.go | 221 - vendor/golang.org/x/net/http2/server_wrap.go | 217 - vendor/golang.org/x/net/http2/transport.go | 3036 --- .../x/net/http2/transport_common.go | 447 - .../golang.org/x/net/http2/transport_wrap.go | 392 - vendor/golang.org/x/net/http2/unencrypted.go | 32 - vendor/golang.org/x/net/http2/write.go | 381 - vendor/golang.org/x/net/http2/writesched.go | 252 - .../x/net/http2/writesched_common.go | 90 - .../net/http2/writesched_priority_rfc7540.go | 420 - .../net/http2/writesched_priority_rfc9218.go | 226 - .../x/net/http2/writesched_random.go | 81 - .../x/net/http2/writesched_roundrobin.go | 121 - vendor/golang.org/x/net/icmp/dstunreach.go | 59 - vendor/golang.org/x/net/icmp/echo.go | 173 - vendor/golang.org/x/net/icmp/endpoint.go | 113 - vendor/golang.org/x/net/icmp/extension.go | 170 - vendor/golang.org/x/net/icmp/helper_posix.go | 75 - vendor/golang.org/x/net/icmp/interface.go | 322 - vendor/golang.org/x/net/icmp/ipv4.go | 68 - vendor/golang.org/x/net/icmp/ipv6.go | 23 - vendor/golang.org/x/net/icmp/listen_posix.go | 105 - vendor/golang.org/x/net/icmp/listen_stub.go | 35 - vendor/golang.org/x/net/icmp/message.go | 162 - vendor/golang.org/x/net/icmp/messagebody.go | 52 - vendor/golang.org/x/net/icmp/mpls.go | 77 - vendor/golang.org/x/net/icmp/multipart.go | 129 - vendor/golang.org/x/net/icmp/packettoobig.go | 43 - vendor/golang.org/x/net/icmp/paramprob.go | 72 - vendor/golang.org/x/net/icmp/sys_freebsd.go | 11 - vendor/golang.org/x/net/icmp/timeexceeded.go | 57 - vendor/golang.org/x/net/idna/idna.go | 880 - vendor/golang.org/x/net/idna/punycode.go | 220 - vendor/golang.org/x/net/idna/tables15.0.0.go | 5144 ----- vendor/golang.org/x/net/idna/tables17.0.0.go | 5302 ----- vendor/golang.org/x/net/idna/trie.go | 51 - vendor/golang.org/x/net/idna/trieval.go | 119 - .../x/net/internal/httpcommon/ascii.go | 53 - .../x/net/internal/httpcommon/headermap.go | 115 - .../x/net/internal/httpcommon/request.go | 475 - .../x/net/internal/httpsfv/httpsfv.go | 665 - .../golang.org/x/net/internal/iana/const.go | 223 - .../x/net/internal/socket/cmsghdr.go | 11 - .../x/net/internal/socket/cmsghdr_bsd.go | 13 - .../internal/socket/cmsghdr_linux_32bit.go | 13 - .../internal/socket/cmsghdr_linux_64bit.go | 13 - .../internal/socket/cmsghdr_solaris_64bit.go | 13 - .../x/net/internal/socket/cmsghdr_stub.go | 27 - .../x/net/internal/socket/cmsghdr_unix.go | 21 - .../net/internal/socket/cmsghdr_zos_s390x.go | 11 - .../net/internal/socket/complete_dontwait.go | 25 - .../internal/socket/complete_nodontwait.go | 21 - .../golang.org/x/net/internal/socket/empty.s | 7 - .../x/net/internal/socket/error_unix.go | 31 - .../x/net/internal/socket/error_windows.go | 26 - .../x/net/internal/socket/iovec_32bit.go | 18 - .../x/net/internal/socket/iovec_64bit.go | 18 - .../internal/socket/iovec_solaris_64bit.go | 18 - .../x/net/internal/socket/iovec_stub.go | 11 - .../x/net/internal/socket/mmsghdr_stub.go | 21 - .../x/net/internal/socket/mmsghdr_unix.go | 195 - .../x/net/internal/socket/msghdr_bsd.go | 39 - .../x/net/internal/socket/msghdr_bsdvar.go | 16 - .../x/net/internal/socket/msghdr_linux.go | 36 - .../net/internal/socket/msghdr_linux_32bit.go | 23 - .../net/internal/socket/msghdr_linux_64bit.go | 23 - .../x/net/internal/socket/msghdr_openbsd.go | 14 - .../internal/socket/msghdr_solaris_64bit.go | 38 - .../x/net/internal/socket/msghdr_stub.go | 14 - .../x/net/internal/socket/msghdr_zos_s390x.go | 35 - .../x/net/internal/socket/norace.go | 12 - .../golang.org/x/net/internal/socket/race.go | 37 - .../x/net/internal/socket/rawconn.go | 91 - .../x/net/internal/socket/rawconn_mmsg.go | 53 - .../x/net/internal/socket/rawconn_msg.go | 59 - .../x/net/internal/socket/rawconn_nommsg.go | 15 - .../x/net/internal/socket/rawconn_nomsg.go | 15 - .../x/net/internal/socket/socket.go | 281 - .../x/net/internal/socket/sys_bsd.go | 15 - .../x/net/internal/socket/sys_const_unix.go | 20 - .../x/net/internal/socket/sys_linux.go | 22 - .../x/net/internal/socket/sys_linux_386.go | 28 - .../x/net/internal/socket/sys_linux_386.s | 11 - .../x/net/internal/socket/sys_linux_amd64.go | 10 - .../x/net/internal/socket/sys_linux_arm.go | 10 - .../x/net/internal/socket/sys_linux_arm64.go | 10 - .../net/internal/socket/sys_linux_loong64.go | 12 - .../x/net/internal/socket/sys_linux_mips.go | 10 - .../x/net/internal/socket/sys_linux_mips64.go | 10 - .../net/internal/socket/sys_linux_mips64le.go | 10 - .../x/net/internal/socket/sys_linux_mipsle.go | 10 - .../x/net/internal/socket/sys_linux_ppc.go | 10 - .../x/net/internal/socket/sys_linux_ppc64.go | 10 - .../net/internal/socket/sys_linux_ppc64le.go | 10 - .../net/internal/socket/sys_linux_riscv64.go | 12 - .../x/net/internal/socket/sys_linux_s390x.go | 28 - .../x/net/internal/socket/sys_linux_s390x.s | 11 - .../x/net/internal/socket/sys_netbsd.go | 25 - .../x/net/internal/socket/sys_posix.go | 184 - .../x/net/internal/socket/sys_stub.go | 52 - .../x/net/internal/socket/sys_unix.go | 121 - .../x/net/internal/socket/sys_windows.go | 55 - .../x/net/internal/socket/sys_zos_s390x.go | 66 - .../x/net/internal/socket/sys_zos_s390x.s | 11 - .../x/net/internal/socket/zsys_aix_ppc64.go | 39 - .../net/internal/socket/zsys_darwin_amd64.go | 32 - .../net/internal/socket/zsys_darwin_arm64.go | 32 - .../internal/socket/zsys_dragonfly_amd64.go | 32 - .../x/net/internal/socket/zsys_freebsd_386.go | 30 - .../net/internal/socket/zsys_freebsd_amd64.go | 32 - .../x/net/internal/socket/zsys_freebsd_arm.go | 30 - .../net/internal/socket/zsys_freebsd_arm64.go | 32 - .../internal/socket/zsys_freebsd_riscv64.go | 30 - .../x/net/internal/socket/zsys_linux_386.go | 35 - .../x/net/internal/socket/zsys_linux_amd64.go | 38 - .../x/net/internal/socket/zsys_linux_arm.go | 35 - .../x/net/internal/socket/zsys_linux_arm64.go | 38 - .../net/internal/socket/zsys_linux_loong64.go | 39 - .../x/net/internal/socket/zsys_linux_mips.go | 35 - .../net/internal/socket/zsys_linux_mips64.go | 38 - .../internal/socket/zsys_linux_mips64le.go | 38 - .../net/internal/socket/zsys_linux_mipsle.go | 35 - .../x/net/internal/socket/zsys_linux_ppc.go | 35 - .../x/net/internal/socket/zsys_linux_ppc64.go | 38 - .../net/internal/socket/zsys_linux_ppc64le.go | 38 - .../net/internal/socket/zsys_linux_riscv64.go | 39 - .../x/net/internal/socket/zsys_linux_s390x.go | 38 - .../x/net/internal/socket/zsys_netbsd_386.go | 35 - .../net/internal/socket/zsys_netbsd_amd64.go | 38 - .../x/net/internal/socket/zsys_netbsd_arm.go | 35 - .../net/internal/socket/zsys_netbsd_arm64.go | 38 - .../x/net/internal/socket/zsys_openbsd_386.go | 30 - .../net/internal/socket/zsys_openbsd_amd64.go | 32 - .../x/net/internal/socket/zsys_openbsd_arm.go | 30 - .../net/internal/socket/zsys_openbsd_arm64.go | 32 - .../internal/socket/zsys_openbsd_mips64.go | 30 - .../net/internal/socket/zsys_openbsd_ppc64.go | 30 - .../internal/socket/zsys_openbsd_riscv64.go | 30 - .../net/internal/socket/zsys_solaris_amd64.go | 32 - .../x/net/internal/socket/zsys_zos_s390x.go | 28 - .../golang.org/x/net/internal/socks/client.go | 168 - .../golang.org/x/net/internal/socks/socks.go | 317 - .../x/net/internal/timeseries/timeseries.go | 525 - vendor/golang.org/x/net/ipv4/batch.go | 194 - vendor/golang.org/x/net/ipv4/control.go | 144 - vendor/golang.org/x/net/ipv4/control_bsd.go | 43 - .../golang.org/x/net/ipv4/control_pktinfo.go | 41 - vendor/golang.org/x/net/ipv4/control_stub.go | 13 - vendor/golang.org/x/net/ipv4/control_unix.go | 75 - .../golang.org/x/net/ipv4/control_windows.go | 12 - vendor/golang.org/x/net/ipv4/control_zos.go | 88 - vendor/golang.org/x/net/ipv4/dgramopt.go | 264 - vendor/golang.org/x/net/ipv4/doc.go | 240 - vendor/golang.org/x/net/ipv4/endpoint.go | 186 - vendor/golang.org/x/net/ipv4/genericopt.go | 55 - vendor/golang.org/x/net/ipv4/header.go | 170 - vendor/golang.org/x/net/ipv4/helper.go | 77 - vendor/golang.org/x/net/ipv4/iana.go | 38 - vendor/golang.org/x/net/ipv4/icmp.go | 57 - vendor/golang.org/x/net/ipv4/icmp_linux.go | 25 - vendor/golang.org/x/net/ipv4/icmp_stub.go | 25 - vendor/golang.org/x/net/ipv4/packet.go | 117 - vendor/golang.org/x/net/ipv4/payload.go | 23 - vendor/golang.org/x/net/ipv4/payload_cmsg.go | 84 - .../golang.org/x/net/ipv4/payload_nocmsg.go | 39 - vendor/golang.org/x/net/ipv4/sockopt.go | 44 - vendor/golang.org/x/net/ipv4/sockopt_posix.go | 71 - vendor/golang.org/x/net/ipv4/sockopt_stub.go | 42 - vendor/golang.org/x/net/ipv4/sys_aix.go | 43 - vendor/golang.org/x/net/ipv4/sys_asmreq.go | 122 - .../golang.org/x/net/ipv4/sys_asmreq_stub.go | 25 - vendor/golang.org/x/net/ipv4/sys_asmreqn.go | 44 - .../golang.org/x/net/ipv4/sys_asmreqn_stub.go | 21 - vendor/golang.org/x/net/ipv4/sys_bpf.go | 24 - vendor/golang.org/x/net/ipv4/sys_bpf_stub.go | 16 - vendor/golang.org/x/net/ipv4/sys_bsd.go | 41 - vendor/golang.org/x/net/ipv4/sys_darwin.go | 69 - vendor/golang.org/x/net/ipv4/sys_dragonfly.go | 39 - vendor/golang.org/x/net/ipv4/sys_freebsd.go | 80 - vendor/golang.org/x/net/ipv4/sys_linux.go | 61 - vendor/golang.org/x/net/ipv4/sys_solaris.go | 61 - vendor/golang.org/x/net/ipv4/sys_ssmreq.go | 52 - .../golang.org/x/net/ipv4/sys_ssmreq_stub.go | 21 - vendor/golang.org/x/net/ipv4/sys_stub.go | 13 - vendor/golang.org/x/net/ipv4/sys_windows.go | 44 - vendor/golang.org/x/net/ipv4/sys_zos.go | 57 - .../golang.org/x/net/ipv4/zsys_aix_ppc64.go | 16 - vendor/golang.org/x/net/ipv4/zsys_darwin.go | 59 - .../golang.org/x/net/ipv4/zsys_dragonfly.go | 13 - .../golang.org/x/net/ipv4/zsys_freebsd_386.go | 52 - .../x/net/ipv4/zsys_freebsd_amd64.go | 54 - .../golang.org/x/net/ipv4/zsys_freebsd_arm.go | 54 - .../x/net/ipv4/zsys_freebsd_arm64.go | 52 - .../x/net/ipv4/zsys_freebsd_riscv64.go | 52 - .../golang.org/x/net/ipv4/zsys_linux_386.go | 72 - .../golang.org/x/net/ipv4/zsys_linux_amd64.go | 74 - .../golang.org/x/net/ipv4/zsys_linux_arm.go | 72 - .../golang.org/x/net/ipv4/zsys_linux_arm64.go | 74 - .../x/net/ipv4/zsys_linux_loong64.go | 76 - .../golang.org/x/net/ipv4/zsys_linux_mips.go | 72 - .../x/net/ipv4/zsys_linux_mips64.go | 74 - .../x/net/ipv4/zsys_linux_mips64le.go | 74 - .../x/net/ipv4/zsys_linux_mipsle.go | 72 - .../golang.org/x/net/ipv4/zsys_linux_ppc.go | 72 - .../golang.org/x/net/ipv4/zsys_linux_ppc64.go | 74 - .../x/net/ipv4/zsys_linux_ppc64le.go | 74 - .../x/net/ipv4/zsys_linux_riscv64.go | 76 - .../golang.org/x/net/ipv4/zsys_linux_s390x.go | 74 - vendor/golang.org/x/net/ipv4/zsys_netbsd.go | 13 - vendor/golang.org/x/net/ipv4/zsys_openbsd.go | 13 - vendor/golang.org/x/net/ipv4/zsys_solaris.go | 57 - .../golang.org/x/net/ipv4/zsys_zos_s390x.go | 56 - vendor/golang.org/x/net/ipv6/batch.go | 116 - vendor/golang.org/x/net/ipv6/control.go | 187 - .../x/net/ipv6/control_rfc2292_unix.go | 51 - .../x/net/ipv6/control_rfc3542_unix.go | 97 - vendor/golang.org/x/net/ipv6/control_stub.go | 13 - vendor/golang.org/x/net/ipv6/control_unix.go | 55 - .../golang.org/x/net/ipv6/control_windows.go | 12 - vendor/golang.org/x/net/ipv6/dgramopt.go | 301 - vendor/golang.org/x/net/ipv6/doc.go | 239 - vendor/golang.org/x/net/ipv6/endpoint.go | 127 - vendor/golang.org/x/net/ipv6/genericopt.go | 56 - vendor/golang.org/x/net/ipv6/header.go | 55 - vendor/golang.org/x/net/ipv6/helper.go | 58 - vendor/golang.org/x/net/ipv6/iana.go | 86 - vendor/golang.org/x/net/ipv6/icmp.go | 60 - vendor/golang.org/x/net/ipv6/icmp_bsd.go | 29 - vendor/golang.org/x/net/ipv6/icmp_linux.go | 27 - vendor/golang.org/x/net/ipv6/icmp_solaris.go | 27 - vendor/golang.org/x/net/ipv6/icmp_stub.go | 23 - vendor/golang.org/x/net/ipv6/icmp_windows.go | 22 - vendor/golang.org/x/net/ipv6/icmp_zos.go | 29 - vendor/golang.org/x/net/ipv6/payload.go | 23 - vendor/golang.org/x/net/ipv6/payload_cmsg.go | 70 - .../golang.org/x/net/ipv6/payload_nocmsg.go | 38 - vendor/golang.org/x/net/ipv6/sockopt.go | 43 - vendor/golang.org/x/net/ipv6/sockopt_posix.go | 89 - vendor/golang.org/x/net/ipv6/sockopt_stub.go | 46 - vendor/golang.org/x/net/ipv6/sys_aix.go | 79 - vendor/golang.org/x/net/ipv6/sys_asmreq.go | 24 - .../golang.org/x/net/ipv6/sys_asmreq_stub.go | 17 - vendor/golang.org/x/net/ipv6/sys_bpf.go | 24 - vendor/golang.org/x/net/ipv6/sys_bpf_stub.go | 16 - vendor/golang.org/x/net/ipv6/sys_bsd.go | 59 - vendor/golang.org/x/net/ipv6/sys_darwin.go | 80 - vendor/golang.org/x/net/ipv6/sys_freebsd.go | 94 - vendor/golang.org/x/net/ipv6/sys_linux.go | 76 - vendor/golang.org/x/net/ipv6/sys_solaris.go | 76 - vendor/golang.org/x/net/ipv6/sys_ssmreq.go | 54 - .../golang.org/x/net/ipv6/sys_ssmreq_stub.go | 21 - vendor/golang.org/x/net/ipv6/sys_stub.go | 13 - vendor/golang.org/x/net/ipv6/sys_windows.go | 68 - vendor/golang.org/x/net/ipv6/sys_zos.go | 72 - .../golang.org/x/net/ipv6/zsys_aix_ppc64.go | 68 - vendor/golang.org/x/net/ipv6/zsys_darwin.go | 64 - .../golang.org/x/net/ipv6/zsys_dragonfly.go | 42 - .../golang.org/x/net/ipv6/zsys_freebsd_386.go | 64 - .../x/net/ipv6/zsys_freebsd_amd64.go | 66 - .../golang.org/x/net/ipv6/zsys_freebsd_arm.go | 66 - .../x/net/ipv6/zsys_freebsd_arm64.go | 64 - .../x/net/ipv6/zsys_freebsd_riscv64.go | 64 - .../golang.org/x/net/ipv6/zsys_linux_386.go | 72 - .../golang.org/x/net/ipv6/zsys_linux_amd64.go | 74 - .../golang.org/x/net/ipv6/zsys_linux_arm.go | 72 - .../golang.org/x/net/ipv6/zsys_linux_arm64.go | 74 - .../x/net/ipv6/zsys_linux_loong64.go | 76 - .../golang.org/x/net/ipv6/zsys_linux_mips.go | 72 - .../x/net/ipv6/zsys_linux_mips64.go | 74 - .../x/net/ipv6/zsys_linux_mips64le.go | 74 - .../x/net/ipv6/zsys_linux_mipsle.go | 72 - .../golang.org/x/net/ipv6/zsys_linux_ppc.go | 72 - .../golang.org/x/net/ipv6/zsys_linux_ppc64.go | 74 - .../x/net/ipv6/zsys_linux_ppc64le.go | 74 - .../x/net/ipv6/zsys_linux_riscv64.go | 76 - .../golang.org/x/net/ipv6/zsys_linux_s390x.go | 74 - vendor/golang.org/x/net/ipv6/zsys_netbsd.go | 42 - vendor/golang.org/x/net/ipv6/zsys_openbsd.go | 42 - vendor/golang.org/x/net/ipv6/zsys_solaris.go | 63 - .../golang.org/x/net/ipv6/zsys_zos_s390x.go | 62 - vendor/golang.org/x/net/nettest/conntest.go | 467 - vendor/golang.org/x/net/nettest/nettest.go | 344 - .../golang.org/x/net/nettest/nettest_stub.go | 11 - .../golang.org/x/net/nettest/nettest_unix.go | 21 - .../x/net/nettest/nettest_windows.go | 26 - vendor/golang.org/x/net/proxy/dial.go | 54 - vendor/golang.org/x/net/proxy/direct.go | 31 - vendor/golang.org/x/net/proxy/per_host.go | 153 - vendor/golang.org/x/net/proxy/proxy.go | 149 - vendor/golang.org/x/net/proxy/socks5.go | 42 - vendor/golang.org/x/net/trace/events.go | 532 - vendor/golang.org/x/net/trace/histogram.go | 365 - vendor/golang.org/x/net/trace/trace.go | 1130 - vendor/golang.org/x/net/websocket/client.go | 139 - vendor/golang.org/x/net/websocket/dial.go | 29 - vendor/golang.org/x/net/websocket/hybi.go | 583 - vendor/golang.org/x/net/websocket/server.go | 113 - .../golang.org/x/net/websocket/websocket.go | 449 - vendor/golang.org/x/oauth2/.travis.yml | 13 - vendor/golang.org/x/oauth2/CONTRIBUTING.md | 26 - vendor/golang.org/x/oauth2/LICENSE | 27 - vendor/golang.org/x/oauth2/README.md | 35 - vendor/golang.org/x/oauth2/deviceauth.go | 227 - vendor/golang.org/x/oauth2/internal/doc.go | 6 - vendor/golang.org/x/oauth2/internal/oauth2.go | 37 - vendor/golang.org/x/oauth2/internal/token.go | 356 - .../golang.org/x/oauth2/internal/transport.go | 28 - vendor/golang.org/x/oauth2/oauth2.go | 423 - vendor/golang.org/x/oauth2/pkce.go | 69 - vendor/golang.org/x/oauth2/token.go | 213 - vendor/golang.org/x/oauth2/transport.go | 75 - vendor/golang.org/x/sync/LICENSE | 27 - vendor/golang.org/x/sync/PATENTS | 22 - vendor/golang.org/x/sync/errgroup/errgroup.go | 151 - vendor/golang.org/x/sys/LICENSE | 27 - vendor/golang.org/x/sys/PATENTS | 22 - vendor/golang.org/x/sys/cpu/asm_aix_ppc64.s | 17 - .../x/sys/cpu/asm_darwin_arm64_gc.s | 12 - .../golang.org/x/sys/cpu/asm_darwin_x86_gc.s | 17 - vendor/golang.org/x/sys/cpu/byteorder.go | 66 - vendor/golang.org/x/sys/cpu/cpu.go | 343 - vendor/golang.org/x/sys/cpu/cpu_aix.go | 33 - vendor/golang.org/x/sys/cpu/cpu_arm.go | 73 - vendor/golang.org/x/sys/cpu/cpu_arm64.go | 191 - vendor/golang.org/x/sys/cpu/cpu_arm64.s | 35 - .../golang.org/x/sys/cpu/cpu_darwin_arm64.go | 67 - .../x/sys/cpu/cpu_darwin_arm64_other.go | 31 - vendor/golang.org/x/sys/cpu/cpu_darwin_x86.go | 61 - vendor/golang.org/x/sys/cpu/cpu_gc_arm64.go | 12 - vendor/golang.org/x/sys/cpu/cpu_gc_s390x.go | 21 - vendor/golang.org/x/sys/cpu/cpu_gc_x86.go | 15 - vendor/golang.org/x/sys/cpu/cpu_gc_x86.s | 26 - .../golang.org/x/sys/cpu/cpu_gccgo_arm64.go | 12 - .../golang.org/x/sys/cpu/cpu_gccgo_s390x.go | 22 - vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.c | 37 - vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go | 25 - vendor/golang.org/x/sys/cpu/cpu_linux.go | 15 - vendor/golang.org/x/sys/cpu/cpu_linux_arm.go | 39 - .../golang.org/x/sys/cpu/cpu_linux_arm64.go | 120 - .../golang.org/x/sys/cpu/cpu_linux_loong64.go | 22 - .../golang.org/x/sys/cpu/cpu_linux_mips64x.go | 22 - .../golang.org/x/sys/cpu/cpu_linux_noinit.go | 9 - .../golang.org/x/sys/cpu/cpu_linux_ppc64x.go | 30 - .../golang.org/x/sys/cpu/cpu_linux_riscv64.go | 162 - .../golang.org/x/sys/cpu/cpu_linux_s390x.go | 40 - vendor/golang.org/x/sys/cpu/cpu_loong64.go | 62 - vendor/golang.org/x/sys/cpu/cpu_loong64.s | 13 - vendor/golang.org/x/sys/cpu/cpu_mips64x.go | 15 - vendor/golang.org/x/sys/cpu/cpu_mipsx.go | 11 - .../golang.org/x/sys/cpu/cpu_netbsd_arm64.go | 173 - .../golang.org/x/sys/cpu/cpu_openbsd_arm64.go | 65 - .../golang.org/x/sys/cpu/cpu_openbsd_arm64.s | 11 - vendor/golang.org/x/sys/cpu/cpu_other_arm.go | 9 - .../golang.org/x/sys/cpu/cpu_other_arm64.go | 11 - .../golang.org/x/sys/cpu/cpu_other_mips64x.go | 11 - .../golang.org/x/sys/cpu/cpu_other_ppc64x.go | 12 - .../golang.org/x/sys/cpu/cpu_other_riscv64.go | 11 - vendor/golang.org/x/sys/cpu/cpu_other_x86.go | 11 - vendor/golang.org/x/sys/cpu/cpu_ppc64x.go | 16 - vendor/golang.org/x/sys/cpu/cpu_riscv64.go | 33 - vendor/golang.org/x/sys/cpu/cpu_s390x.go | 172 - vendor/golang.org/x/sys/cpu/cpu_s390x.s | 57 - vendor/golang.org/x/sys/cpu/cpu_wasm.go | 17 - vendor/golang.org/x/sys/cpu/cpu_windows.go | 26 - .../golang.org/x/sys/cpu/cpu_windows_arm64.go | 38 - vendor/golang.org/x/sys/cpu/cpu_x86.go | 236 - vendor/golang.org/x/sys/cpu/cpu_zos.go | 10 - vendor/golang.org/x/sys/cpu/cpu_zos_s390x.go | 25 - vendor/golang.org/x/sys/cpu/endian_big.go | 10 - vendor/golang.org/x/sys/cpu/endian_little.go | 10 - vendor/golang.org/x/sys/cpu/hwcap_linux.go | 71 - vendor/golang.org/x/sys/cpu/parse.go | 43 - .../x/sys/cpu/proc_cpuinfo_linux.go | 53 - vendor/golang.org/x/sys/cpu/runtime_auxv.go | 16 - .../x/sys/cpu/runtime_auxv_go121.go | 18 - .../golang.org/x/sys/cpu/syscall_aix_gccgo.go | 26 - .../x/sys/cpu/syscall_aix_ppc64_gc.go | 35 - .../x/sys/cpu/syscall_darwin_arm64_gc.go | 54 - .../x/sys/cpu/syscall_darwin_x86_gc.go | 98 - vendor/golang.org/x/sys/cpu/zcpu_windows.go | 48 - vendor/golang.org/x/sys/execabs/execabs.go | 102 - .../golang.org/x/sys/execabs/execabs_go118.go | 17 - .../golang.org/x/sys/execabs/execabs_go119.go | 20 - vendor/golang.org/x/sys/plan9/asm.s | 8 - vendor/golang.org/x/sys/plan9/asm_plan9_386.s | 30 - .../golang.org/x/sys/plan9/asm_plan9_amd64.s | 30 - vendor/golang.org/x/sys/plan9/asm_plan9_arm.s | 25 - vendor/golang.org/x/sys/plan9/const_plan9.go | 70 - vendor/golang.org/x/sys/plan9/dir_plan9.go | 212 - vendor/golang.org/x/sys/plan9/env_plan9.go | 31 - vendor/golang.org/x/sys/plan9/errors_plan9.go | 50 - vendor/golang.org/x/sys/plan9/mkall.sh | 150 - vendor/golang.org/x/sys/plan9/mkerrors.sh | 246 - .../golang.org/x/sys/plan9/mksysnum_plan9.sh | 23 - vendor/golang.org/x/sys/plan9/pwd_plan9.go | 19 - vendor/golang.org/x/sys/plan9/race.go | 30 - vendor/golang.org/x/sys/plan9/race0.go | 25 - vendor/golang.org/x/sys/plan9/str.go | 22 - vendor/golang.org/x/sys/plan9/syscall.go | 109 - .../golang.org/x/sys/plan9/syscall_plan9.go | 355 - .../x/sys/plan9/zsyscall_plan9_386.go | 284 - .../x/sys/plan9/zsyscall_plan9_amd64.go | 284 - .../x/sys/plan9/zsyscall_plan9_arm.go | 284 - .../golang.org/x/sys/plan9/zsysnum_plan9.go | 49 - vendor/golang.org/x/sys/unix/.gitignore | 2 - vendor/golang.org/x/sys/unix/README.md | 184 - .../golang.org/x/sys/unix/affinity_linux.go | 189 - vendor/golang.org/x/sys/unix/aliases.go | 13 - vendor/golang.org/x/sys/unix/asm_aix_ppc64.s | 17 - vendor/golang.org/x/sys/unix/asm_bsd_386.s | 27 - vendor/golang.org/x/sys/unix/asm_bsd_amd64.s | 27 - vendor/golang.org/x/sys/unix/asm_bsd_arm.s | 27 - vendor/golang.org/x/sys/unix/asm_bsd_arm64.s | 27 - vendor/golang.org/x/sys/unix/asm_bsd_ppc64.s | 29 - .../golang.org/x/sys/unix/asm_bsd_riscv64.s | 27 - vendor/golang.org/x/sys/unix/asm_linux_386.s | 65 - .../golang.org/x/sys/unix/asm_linux_amd64.s | 57 - vendor/golang.org/x/sys/unix/asm_linux_arm.s | 56 - .../golang.org/x/sys/unix/asm_linux_arm64.s | 50 - .../golang.org/x/sys/unix/asm_linux_loong64.s | 51 - .../golang.org/x/sys/unix/asm_linux_mips64x.s | 54 - .../golang.org/x/sys/unix/asm_linux_mipsx.s | 52 - .../golang.org/x/sys/unix/asm_linux_ppc64x.s | 42 - .../golang.org/x/sys/unix/asm_linux_riscv64.s | 47 - .../golang.org/x/sys/unix/asm_linux_s390x.s | 54 - .../x/sys/unix/asm_openbsd_mips64.s | 29 - .../golang.org/x/sys/unix/asm_solaris_amd64.s | 17 - vendor/golang.org/x/sys/unix/asm_zos_s390x.s | 382 - vendor/golang.org/x/sys/unix/auxv.go | 36 - .../golang.org/x/sys/unix/auxv_unsupported.go | 13 - .../golang.org/x/sys/unix/bluetooth_linux.go | 36 - vendor/golang.org/x/sys/unix/bpxsvc_zos.go | 657 - vendor/golang.org/x/sys/unix/bpxsvc_zos.s | 192 - vendor/golang.org/x/sys/unix/cap_freebsd.go | 195 - vendor/golang.org/x/sys/unix/constants.go | 13 - vendor/golang.org/x/sys/unix/dev_aix_ppc.go | 26 - vendor/golang.org/x/sys/unix/dev_aix_ppc64.go | 28 - vendor/golang.org/x/sys/unix/dev_darwin.go | 24 - vendor/golang.org/x/sys/unix/dev_dragonfly.go | 30 - vendor/golang.org/x/sys/unix/dev_freebsd.go | 30 - vendor/golang.org/x/sys/unix/dev_linux.go | 42 - vendor/golang.org/x/sys/unix/dev_netbsd.go | 29 - vendor/golang.org/x/sys/unix/dev_openbsd.go | 29 - vendor/golang.org/x/sys/unix/dev_zos.go | 28 - vendor/golang.org/x/sys/unix/dirent.go | 102 - vendor/golang.org/x/sys/unix/endian_big.go | 9 - vendor/golang.org/x/sys/unix/endian_little.go | 9 - vendor/golang.org/x/sys/unix/env_unix.go | 31 - vendor/golang.org/x/sys/unix/fcntl.go | 36 - vendor/golang.org/x/sys/unix/fcntl_darwin.go | 24 - .../x/sys/unix/fcntl_linux_32bit.go | 13 - vendor/golang.org/x/sys/unix/fdset.go | 27 - vendor/golang.org/x/sys/unix/gccgo.go | 59 - vendor/golang.org/x/sys/unix/gccgo_c.c | 44 - .../x/sys/unix/gccgo_linux_amd64.go | 20 - vendor/golang.org/x/sys/unix/ifreq_linux.go | 139 - vendor/golang.org/x/sys/unix/ioctl_linux.go | 334 - vendor/golang.org/x/sys/unix/ioctl_signed.go | 74 - .../golang.org/x/sys/unix/ioctl_unsigned.go | 74 - vendor/golang.org/x/sys/unix/ioctl_zos.go | 71 - vendor/golang.org/x/sys/unix/mkall.sh | 250 - vendor/golang.org/x/sys/unix/mkerrors.sh | 814 - vendor/golang.org/x/sys/unix/mmap_nomremap.go | 13 - vendor/golang.org/x/sys/unix/mremap.go | 57 - vendor/golang.org/x/sys/unix/pagesize_unix.go | 15 - .../golang.org/x/sys/unix/pledge_openbsd.go | 111 - vendor/golang.org/x/sys/unix/ptrace_darwin.go | 11 - vendor/golang.org/x/sys/unix/ptrace_ios.go | 11 - vendor/golang.org/x/sys/unix/race.go | 30 - vendor/golang.org/x/sys/unix/race0.go | 25 - .../x/sys/unix/readdirent_getdents.go | 12 - .../x/sys/unix/readdirent_getdirentries.go | 19 - vendor/golang.org/x/sys/unix/readv_unix.go | 103 - .../x/sys/unix/sockcmsg_dragonfly.go | 16 - .../golang.org/x/sys/unix/sockcmsg_linux.go | 85 - vendor/golang.org/x/sys/unix/sockcmsg_unix.go | 106 - .../x/sys/unix/sockcmsg_unix_other.go | 46 - vendor/golang.org/x/sys/unix/sockcmsg_zos.go | 58 - .../golang.org/x/sys/unix/symaddr_zos_s390x.s | 75 - vendor/golang.org/x/sys/unix/syscall.go | 86 - vendor/golang.org/x/sys/unix/syscall_aix.go | 582 - .../golang.org/x/sys/unix/syscall_aix_ppc.go | 52 - .../x/sys/unix/syscall_aix_ppc64.go | 83 - vendor/golang.org/x/sys/unix/syscall_bsd.go | 609 - .../golang.org/x/sys/unix/syscall_darwin.go | 711 - .../x/sys/unix/syscall_darwin_amd64.go | 50 - .../x/sys/unix/syscall_darwin_arm64.go | 50 - .../x/sys/unix/syscall_darwin_libSystem.go | 26 - .../x/sys/unix/syscall_dragonfly.go | 359 - .../x/sys/unix/syscall_dragonfly_amd64.go | 56 - .../golang.org/x/sys/unix/syscall_freebsd.go | 455 - .../x/sys/unix/syscall_freebsd_386.go | 64 - .../x/sys/unix/syscall_freebsd_amd64.go | 64 - .../x/sys/unix/syscall_freebsd_arm.go | 60 - .../x/sys/unix/syscall_freebsd_arm64.go | 60 - .../x/sys/unix/syscall_freebsd_riscv64.go | 60 - vendor/golang.org/x/sys/unix/syscall_hurd.go | 30 - .../golang.org/x/sys/unix/syscall_hurd_386.go | 28 - .../golang.org/x/sys/unix/syscall_illumos.go | 78 - vendor/golang.org/x/sys/unix/syscall_linux.go | 2573 --- .../x/sys/unix/syscall_linux_386.go | 314 - .../x/sys/unix/syscall_linux_alarm.go | 12 - .../x/sys/unix/syscall_linux_amd64.go | 145 - .../x/sys/unix/syscall_linux_amd64_gc.go | 12 - .../x/sys/unix/syscall_linux_arm.go | 219 - .../x/sys/unix/syscall_linux_arm64.go | 189 - .../golang.org/x/sys/unix/syscall_linux_gc.go | 14 - .../x/sys/unix/syscall_linux_gc_386.go | 16 - .../x/sys/unix/syscall_linux_gc_arm.go | 13 - .../x/sys/unix/syscall_linux_gccgo_386.go | 30 - .../x/sys/unix/syscall_linux_gccgo_arm.go | 20 - .../x/sys/unix/syscall_linux_loong64.go | 221 - .../x/sys/unix/syscall_linux_mips64x.go | 188 - .../x/sys/unix/syscall_linux_mipsx.go | 174 - .../x/sys/unix/syscall_linux_ppc.go | 204 - .../x/sys/unix/syscall_linux_ppc64x.go | 115 - .../x/sys/unix/syscall_linux_riscv64.go | 194 - .../x/sys/unix/syscall_linux_s390x.go | 296 - .../x/sys/unix/syscall_linux_sparc64.go | 112 - .../golang.org/x/sys/unix/syscall_netbsd.go | 388 - .../x/sys/unix/syscall_netbsd_386.go | 37 - .../x/sys/unix/syscall_netbsd_amd64.go | 37 - .../x/sys/unix/syscall_netbsd_arm.go | 37 - .../x/sys/unix/syscall_netbsd_arm64.go | 37 - .../golang.org/x/sys/unix/syscall_openbsd.go | 346 - .../x/sys/unix/syscall_openbsd_386.go | 41 - .../x/sys/unix/syscall_openbsd_amd64.go | 41 - .../x/sys/unix/syscall_openbsd_arm.go | 41 - .../x/sys/unix/syscall_openbsd_arm64.go | 41 - .../x/sys/unix/syscall_openbsd_libc.go | 26 - .../x/sys/unix/syscall_openbsd_mips64.go | 39 - .../x/sys/unix/syscall_openbsd_ppc64.go | 41 - .../x/sys/unix/syscall_openbsd_riscv64.go | 41 - .../golang.org/x/sys/unix/syscall_solaris.go | 1183 -- .../x/sys/unix/syscall_solaris_amd64.go | 27 - vendor/golang.org/x/sys/unix/syscall_unix.go | 619 - .../golang.org/x/sys/unix/syscall_unix_gc.go | 14 - .../x/sys/unix/syscall_unix_gc_ppc64x.go | 22 - .../x/sys/unix/syscall_zos_s390x.go | 3213 --- vendor/golang.org/x/sys/unix/sysvshm_linux.go | 20 - vendor/golang.org/x/sys/unix/sysvshm_unix.go | 51 - .../x/sys/unix/sysvshm_unix_other.go | 13 - vendor/golang.org/x/sys/unix/timestruct.go | 76 - .../golang.org/x/sys/unix/unveil_openbsd.go | 51 - .../golang.org/x/sys/unix/vgetrandom_linux.go | 13 - .../x/sys/unix/vgetrandom_unsupported.go | 11 - vendor/golang.org/x/sys/unix/xattr_bsd.go | 280 - .../golang.org/x/sys/unix/zerrors_aix_ppc.go | 1384 -- .../x/sys/unix/zerrors_aix_ppc64.go | 1385 -- .../x/sys/unix/zerrors_darwin_amd64.go | 1922 -- .../x/sys/unix/zerrors_darwin_arm64.go | 1922 -- .../x/sys/unix/zerrors_dragonfly_amd64.go | 1737 -- .../x/sys/unix/zerrors_freebsd_386.go | 2042 -- .../x/sys/unix/zerrors_freebsd_amd64.go | 2039 -- .../x/sys/unix/zerrors_freebsd_arm.go | 2033 -- .../x/sys/unix/zerrors_freebsd_arm64.go | 2033 -- .../x/sys/unix/zerrors_freebsd_riscv64.go | 2147 -- vendor/golang.org/x/sys/unix/zerrors_linux.go | 4201 ---- .../x/sys/unix/zerrors_linux_386.go | 883 - .../x/sys/unix/zerrors_linux_amd64.go | 883 - .../x/sys/unix/zerrors_linux_arm.go | 888 - .../x/sys/unix/zerrors_linux_arm64.go | 885 - .../x/sys/unix/zerrors_linux_loong64.go | 875 - .../x/sys/unix/zerrors_linux_mips.go | 889 - .../x/sys/unix/zerrors_linux_mips64.go | 889 - .../x/sys/unix/zerrors_linux_mips64le.go | 889 - .../x/sys/unix/zerrors_linux_mipsle.go | 889 - .../x/sys/unix/zerrors_linux_ppc.go | 941 - .../x/sys/unix/zerrors_linux_ppc64.go | 945 - .../x/sys/unix/zerrors_linux_ppc64le.go | 945 - .../x/sys/unix/zerrors_linux_riscv64.go | 885 - .../x/sys/unix/zerrors_linux_s390x.go | 944 - .../x/sys/unix/zerrors_linux_sparc64.go | 987 - .../x/sys/unix/zerrors_netbsd_386.go | 1779 -- .../x/sys/unix/zerrors_netbsd_amd64.go | 1769 -- .../x/sys/unix/zerrors_netbsd_arm.go | 1758 -- .../x/sys/unix/zerrors_netbsd_arm64.go | 1769 -- .../x/sys/unix/zerrors_openbsd_386.go | 1905 -- .../x/sys/unix/zerrors_openbsd_amd64.go | 1905 -- .../x/sys/unix/zerrors_openbsd_arm.go | 1905 -- .../x/sys/unix/zerrors_openbsd_arm64.go | 1905 -- .../x/sys/unix/zerrors_openbsd_mips64.go | 1905 -- .../x/sys/unix/zerrors_openbsd_ppc64.go | 1904 -- .../x/sys/unix/zerrors_openbsd_riscv64.go | 1903 -- .../x/sys/unix/zerrors_solaris_amd64.go | 1556 -- .../x/sys/unix/zerrors_zos_s390x.go | 990 - .../x/sys/unix/zptrace_armnn_linux.go | 40 - .../x/sys/unix/zptrace_linux_arm64.go | 17 - .../x/sys/unix/zptrace_mipsnn_linux.go | 49 - .../x/sys/unix/zptrace_mipsnnle_linux.go | 49 - .../x/sys/unix/zptrace_x86_linux.go | 79 - .../x/sys/unix/zsymaddr_zos_s390x.s | 364 - .../golang.org/x/sys/unix/zsyscall_aix_ppc.go | 1461 -- .../x/sys/unix/zsyscall_aix_ppc64.go | 1420 -- .../x/sys/unix/zsyscall_aix_ppc64_gc.go | 1188 -- .../x/sys/unix/zsyscall_aix_ppc64_gccgo.go | 1069 - .../x/sys/unix/zsyscall_darwin_amd64.go | 2728 --- .../x/sys/unix/zsyscall_darwin_amd64.s | 799 - .../x/sys/unix/zsyscall_darwin_arm64.go | 2728 --- .../x/sys/unix/zsyscall_darwin_arm64.s | 799 - .../x/sys/unix/zsyscall_dragonfly_amd64.go | 1666 -- .../x/sys/unix/zsyscall_freebsd_386.go | 1886 -- .../x/sys/unix/zsyscall_freebsd_amd64.go | 1886 -- .../x/sys/unix/zsyscall_freebsd_arm.go | 1886 -- .../x/sys/unix/zsyscall_freebsd_arm64.go | 1886 -- .../x/sys/unix/zsyscall_freebsd_riscv64.go | 1886 -- .../x/sys/unix/zsyscall_illumos_amd64.go | 101 - .../golang.org/x/sys/unix/zsyscall_linux.go | 2250 -- .../x/sys/unix/zsyscall_linux_386.go | 486 - .../x/sys/unix/zsyscall_linux_amd64.go | 653 - .../x/sys/unix/zsyscall_linux_arm.go | 601 - .../x/sys/unix/zsyscall_linux_arm64.go | 552 - .../x/sys/unix/zsyscall_linux_loong64.go | 486 - .../x/sys/unix/zsyscall_linux_mips.go | 653 - .../x/sys/unix/zsyscall_linux_mips64.go | 647 - .../x/sys/unix/zsyscall_linux_mips64le.go | 636 - .../x/sys/unix/zsyscall_linux_mipsle.go | 653 - .../x/sys/unix/zsyscall_linux_ppc.go | 658 - .../x/sys/unix/zsyscall_linux_ppc64.go | 704 - .../x/sys/unix/zsyscall_linux_ppc64le.go | 704 - .../x/sys/unix/zsyscall_linux_riscv64.go | 548 - .../x/sys/unix/zsyscall_linux_s390x.go | 495 - .../x/sys/unix/zsyscall_linux_sparc64.go | 648 - .../x/sys/unix/zsyscall_netbsd_386.go | 1848 -- .../x/sys/unix/zsyscall_netbsd_amd64.go | 1848 -- .../x/sys/unix/zsyscall_netbsd_arm.go | 1848 -- .../x/sys/unix/zsyscall_netbsd_arm64.go | 1848 -- .../x/sys/unix/zsyscall_openbsd_386.go | 2407 --- .../x/sys/unix/zsyscall_openbsd_386.s | 719 - .../x/sys/unix/zsyscall_openbsd_amd64.go | 2407 --- .../x/sys/unix/zsyscall_openbsd_amd64.s | 719 - .../x/sys/unix/zsyscall_openbsd_arm.go | 2407 --- .../x/sys/unix/zsyscall_openbsd_arm.s | 719 - .../x/sys/unix/zsyscall_openbsd_arm64.go | 2407 --- .../x/sys/unix/zsyscall_openbsd_arm64.s | 719 - .../x/sys/unix/zsyscall_openbsd_mips64.go | 2407 --- .../x/sys/unix/zsyscall_openbsd_mips64.s | 719 - .../x/sys/unix/zsyscall_openbsd_ppc64.go | 2407 --- .../x/sys/unix/zsyscall_openbsd_ppc64.s | 862 - .../x/sys/unix/zsyscall_openbsd_riscv64.go | 2407 --- .../x/sys/unix/zsyscall_openbsd_riscv64.s | 719 - .../x/sys/unix/zsyscall_solaris_amd64.go | 2217 -- .../x/sys/unix/zsyscall_zos_s390x.go | 3458 ---- .../x/sys/unix/zsysctl_openbsd_386.go | 280 - .../x/sys/unix/zsysctl_openbsd_amd64.go | 280 - .../x/sys/unix/zsysctl_openbsd_arm.go | 280 - .../x/sys/unix/zsysctl_openbsd_arm64.go | 280 - .../x/sys/unix/zsysctl_openbsd_mips64.go | 280 - .../x/sys/unix/zsysctl_openbsd_ppc64.go | 280 - .../x/sys/unix/zsysctl_openbsd_riscv64.go | 281 - .../x/sys/unix/zsysnum_darwin_amd64.go | 439 - .../x/sys/unix/zsysnum_darwin_arm64.go | 437 - .../x/sys/unix/zsysnum_dragonfly_amd64.go | 316 - .../x/sys/unix/zsysnum_freebsd_386.go | 393 - .../x/sys/unix/zsysnum_freebsd_amd64.go | 393 - .../x/sys/unix/zsysnum_freebsd_arm.go | 393 - .../x/sys/unix/zsysnum_freebsd_arm64.go | 393 - .../x/sys/unix/zsysnum_freebsd_riscv64.go | 393 - .../x/sys/unix/zsysnum_linux_386.go | 470 - .../x/sys/unix/zsysnum_linux_amd64.go | 394 - .../x/sys/unix/zsysnum_linux_arm.go | 434 - .../x/sys/unix/zsysnum_linux_arm64.go | 337 - .../x/sys/unix/zsysnum_linux_loong64.go | 334 - .../x/sys/unix/zsysnum_linux_mips.go | 454 - .../x/sys/unix/zsysnum_linux_mips64.go | 384 - .../x/sys/unix/zsysnum_linux_mips64le.go | 384 - .../x/sys/unix/zsysnum_linux_mipsle.go | 454 - .../x/sys/unix/zsysnum_linux_ppc.go | 461 - .../x/sys/unix/zsysnum_linux_ppc64.go | 433 - .../x/sys/unix/zsysnum_linux_ppc64le.go | 433 - .../x/sys/unix/zsysnum_linux_riscv64.go | 338 - .../x/sys/unix/zsysnum_linux_s390x.go | 399 - .../x/sys/unix/zsysnum_linux_sparc64.go | 413 - .../x/sys/unix/zsysnum_netbsd_386.go | 274 - .../x/sys/unix/zsysnum_netbsd_amd64.go | 274 - .../x/sys/unix/zsysnum_netbsd_arm.go | 274 - .../x/sys/unix/zsysnum_netbsd_arm64.go | 274 - .../x/sys/unix/zsysnum_openbsd_386.go | 219 - .../x/sys/unix/zsysnum_openbsd_amd64.go | 219 - .../x/sys/unix/zsysnum_openbsd_arm.go | 219 - .../x/sys/unix/zsysnum_openbsd_arm64.go | 218 - .../x/sys/unix/zsysnum_openbsd_mips64.go | 221 - .../x/sys/unix/zsysnum_openbsd_ppc64.go | 217 - .../x/sys/unix/zsysnum_openbsd_riscv64.go | 218 - .../x/sys/unix/zsysnum_zos_s390x.go | 2852 --- .../golang.org/x/sys/unix/ztypes_aix_ppc.go | 353 - .../golang.org/x/sys/unix/ztypes_aix_ppc64.go | 357 - .../x/sys/unix/ztypes_darwin_amd64.go | 878 - .../x/sys/unix/ztypes_darwin_arm64.go | 878 - .../x/sys/unix/ztypes_dragonfly_amd64.go | 473 - .../x/sys/unix/ztypes_freebsd_386.go | 651 - .../x/sys/unix/ztypes_freebsd_amd64.go | 656 - .../x/sys/unix/ztypes_freebsd_arm.go | 642 - .../x/sys/unix/ztypes_freebsd_arm64.go | 636 - .../x/sys/unix/ztypes_freebsd_riscv64.go | 638 - vendor/golang.org/x/sys/unix/ztypes_linux.go | 6475 ------ .../golang.org/x/sys/unix/ztypes_linux_386.go | 717 - .../x/sys/unix/ztypes_linux_amd64.go | 731 - .../golang.org/x/sys/unix/ztypes_linux_arm.go | 711 - .../x/sys/unix/ztypes_linux_arm64.go | 710 - .../x/sys/unix/ztypes_linux_loong64.go | 711 - .../x/sys/unix/ztypes_linux_mips.go | 716 - .../x/sys/unix/ztypes_linux_mips64.go | 713 - .../x/sys/unix/ztypes_linux_mips64le.go | 713 - .../x/sys/unix/ztypes_linux_mipsle.go | 716 - .../golang.org/x/sys/unix/ztypes_linux_ppc.go | 724 - .../x/sys/unix/ztypes_linux_ppc64.go | 719 - .../x/sys/unix/ztypes_linux_ppc64le.go | 719 - .../x/sys/unix/ztypes_linux_riscv64.go | 798 - .../x/sys/unix/ztypes_linux_s390x.go | 733 - .../x/sys/unix/ztypes_linux_sparc64.go | 714 - .../x/sys/unix/ztypes_netbsd_386.go | 585 - .../x/sys/unix/ztypes_netbsd_amd64.go | 593 - .../x/sys/unix/ztypes_netbsd_arm.go | 590 - .../x/sys/unix/ztypes_netbsd_arm64.go | 593 - .../x/sys/unix/ztypes_openbsd_386.go | 568 - .../x/sys/unix/ztypes_openbsd_amd64.go | 568 - .../x/sys/unix/ztypes_openbsd_arm.go | 575 - .../x/sys/unix/ztypes_openbsd_arm64.go | 568 - .../x/sys/unix/ztypes_openbsd_mips64.go | 568 - .../x/sys/unix/ztypes_openbsd_ppc64.go | 570 - .../x/sys/unix/ztypes_openbsd_riscv64.go | 570 - .../x/sys/unix/ztypes_solaris_amd64.go | 516 - .../golang.org/x/sys/unix/ztypes_zos_s390x.go | 552 - vendor/golang.org/x/sys/windows/aliases.go | 13 - .../golang.org/x/sys/windows/dll_windows.go | 380 - .../golang.org/x/sys/windows/env_windows.go | 57 - vendor/golang.org/x/sys/windows/eventlog.go | 20 - .../golang.org/x/sys/windows/exec_windows.go | 248 - .../x/sys/windows/memory_windows.go | 48 - vendor/golang.org/x/sys/windows/mkerrors.bash | 70 - .../x/sys/windows/mkknownfolderids.bash | 27 - vendor/golang.org/x/sys/windows/mksyscall.go | 9 - vendor/golang.org/x/sys/windows/race.go | 30 - vendor/golang.org/x/sys/windows/race0.go | 25 - .../golang.org/x/sys/windows/registry/key.go | 227 - .../x/sys/windows/registry/mksyscall.go | 9 - .../x/sys/windows/registry/syscall.go | 32 - .../x/sys/windows/registry/value.go | 390 - .../sys/windows/registry/zsyscall_windows.go | 117 - .../x/sys/windows/security_windows.go | 1501 -- vendor/golang.org/x/sys/windows/service.go | 257 - .../x/sys/windows/setupapi_windows.go | 1425 -- vendor/golang.org/x/sys/windows/str.go | 22 - .../x/sys/windows/svc/eventlog/install.go | 80 - .../x/sys/windows/svc/eventlog/log.go | 81 - .../x/sys/windows/svc/mgr/config.go | 204 - .../golang.org/x/sys/windows/svc/mgr/mgr.go | 241 - .../x/sys/windows/svc/mgr/recovery.go | 172 - .../x/sys/windows/svc/mgr/service.go | 128 - .../golang.org/x/sys/windows/svc/security.go | 100 - .../golang.org/x/sys/windows/svc/service.go | 321 - vendor/golang.org/x/sys/windows/syscall.go | 104 - .../x/sys/windows/syscall_windows.go | 1948 -- .../golang.org/x/sys/windows/types_windows.go | 4056 ---- .../x/sys/windows/types_windows_386.go | 35 - .../x/sys/windows/types_windows_amd64.go | 34 - .../x/sys/windows/types_windows_arm.go | 35 - .../x/sys/windows/types_windows_arm64.go | 34 - .../x/sys/windows/zerrors_windows.go | 9468 --------- .../x/sys/windows/zknownfolderids_windows.go | 149 - .../x/sys/windows/zsyscall_windows.go | 4828 ----- vendor/golang.org/x/term/CONTRIBUTING.md | 26 - vendor/golang.org/x/term/LICENSE | 27 - vendor/golang.org/x/term/PATENTS | 22 - vendor/golang.org/x/term/README.md | 16 - vendor/golang.org/x/term/codereview.cfg | 1 - vendor/golang.org/x/term/term.go | 60 - vendor/golang.org/x/term/term_plan9.go | 42 - vendor/golang.org/x/term/term_unix.go | 91 - vendor/golang.org/x/term/term_unix_bsd.go | 12 - vendor/golang.org/x/term/term_unix_other.go | 12 - vendor/golang.org/x/term/term_unsupported.go | 38 - vendor/golang.org/x/term/term_windows.go | 82 - vendor/golang.org/x/term/terminal.go | 1074 - vendor/golang.org/x/text/LICENSE | 27 - vendor/golang.org/x/text/PATENTS | 22 - vendor/golang.org/x/text/cases/cases.go | 162 - vendor/golang.org/x/text/cases/context.go | 376 - vendor/golang.org/x/text/cases/fold.go | 34 - vendor/golang.org/x/text/cases/icu.go | 61 - vendor/golang.org/x/text/cases/info.go | 82 - vendor/golang.org/x/text/cases/map.go | 816 - .../golang.org/x/text/cases/tables15.0.0.go | 2527 --- .../golang.org/x/text/cases/tables17.0.0.go | 2642 --- vendor/golang.org/x/text/cases/trieval.go | 217 - vendor/golang.org/x/text/internal/internal.go | 49 - .../x/text/internal/language/common.go | 16 - .../x/text/internal/language/compact.go | 29 - .../text/internal/language/compact/compact.go | 61 - .../internal/language/compact/language.go | 260 - .../text/internal/language/compact/parents.go | 120 - .../text/internal/language/compact/tables.go | 1015 - .../x/text/internal/language/compact/tags.go | 91 - .../x/text/internal/language/compose.go | 167 - .../x/text/internal/language/coverage.go | 28 - .../x/text/internal/language/language.go | 627 - .../x/text/internal/language/lookup.go | 412 - .../x/text/internal/language/match.go | 226 - .../x/text/internal/language/parse.go | 608 - .../x/text/internal/language/tables.go | 3494 ---- .../x/text/internal/language/tags.go | 48 - vendor/golang.org/x/text/internal/match.go | 67 - vendor/golang.org/x/text/internal/tag/tag.go | 100 - vendor/golang.org/x/text/language/coverage.go | 187 - vendor/golang.org/x/text/language/doc.go | 98 - vendor/golang.org/x/text/language/language.go | 605 - vendor/golang.org/x/text/language/match.go | 735 - vendor/golang.org/x/text/language/parse.go | 256 - vendor/golang.org/x/text/language/tables.go | 298 - vendor/golang.org/x/text/language/tags.go | 145 - .../x/text/secure/bidirule/bidirule.go | 340 - .../golang.org/x/text/transform/transform.go | 709 - vendor/golang.org/x/text/unicode/bidi/bidi.go | 359 - .../golang.org/x/text/unicode/bidi/bracket.go | 335 - vendor/golang.org/x/text/unicode/bidi/core.go | 1064 - vendor/golang.org/x/text/unicode/bidi/prop.go | 206 - .../x/text/unicode/bidi/tables15.0.0.go | 2042 -- .../x/text/unicode/bidi/tables17.0.0.go | 2135 -- .../golang.org/x/text/unicode/bidi/trieval.go | 48 - .../x/text/unicode/norm/composition.go | 512 - .../x/text/unicode/norm/forminfo.go | 296 - .../golang.org/x/text/unicode/norm/input.go | 109 - vendor/golang.org/x/text/unicode/norm/iter.go | 454 - .../x/text/unicode/norm/normalize.go | 610 - .../x/text/unicode/norm/readwriter.go | 125 - .../x/text/unicode/norm/tables15.0.0.go | 7907 ------- .../x/text/unicode/norm/tables17.0.0.go | 8104 -------- .../x/text/unicode/norm/transform.go | 88 - vendor/golang.org/x/text/unicode/norm/trie.go | 54 - .../genproto/googleapis/api/LICENSE | 202 - .../googleapis/api/httpbody/httpbody.pb.go | 235 - .../genproto/googleapis/rpc/LICENSE | 202 - .../googleapis/rpc/status/status.pb.go | 202 - vendor/google.golang.org/grpc/AUTHORS | 1 - .../google.golang.org/grpc/CODE-OF-CONDUCT.md | 3 - vendor/google.golang.org/grpc/CONTRIBUTING.md | 159 - vendor/google.golang.org/grpc/GOVERNANCE.md | 1 - vendor/google.golang.org/grpc/LICENSE | 202 - vendor/google.golang.org/grpc/MAINTAINERS.md | 36 - vendor/google.golang.org/grpc/Makefile | 49 - vendor/google.golang.org/grpc/NOTICE.txt | 13 - vendor/google.golang.org/grpc/README.md | 108 - vendor/google.golang.org/grpc/SECURITY.md | 3 - .../grpc/attributes/attributes.go | 174 - vendor/google.golang.org/grpc/backoff.go | 61 - .../google.golang.org/grpc/backoff/backoff.go | 52 - .../grpc/balancer/balancer.go | 394 - .../grpc/balancer/base/balancer.go | 260 - .../grpc/balancer/base/base.go | 71 - .../grpc/balancer/conn_state_evaluator.go | 74 - .../endpointsharding/endpointsharding.go | 388 - .../grpc/balancer/grpclb/state/state.go | 51 - .../balancer/pickfirst/internal/internal.go | 37 - .../grpc/balancer/pickfirst/pickfirst.go | 961 - .../grpc/balancer/roundrobin/roundrobin.go | 72 - .../grpc/balancer/subconn.go | 120 - .../grpc/balancer_wrapper.go | 517 - .../grpc_binarylog_v1/binarylog.pb.go | 1004 - vendor/google.golang.org/grpc/call.go | 74 - .../grpc/channelz/channelz.go | 36 - vendor/google.golang.org/grpc/clientconn.go | 1974 -- .../clientconn_disconnect_reason_noplan9.go | 48 - .../clientconn_disconnect_reason_plan9.go | 39 - vendor/google.golang.org/grpc/codec.go | 105 - .../grpc/codes/code_string.go | 111 - vendor/google.golang.org/grpc/codes/codes.go | 250 - .../grpc/connectivity/connectivity.go | 94 - .../grpc/credentials/credentials.go | 337 - .../grpc/credentials/insecure/insecure.go | 104 - .../google.golang.org/grpc/credentials/tls.go | 322 - vendor/google.golang.org/grpc/dialoptions.go | 812 - vendor/google.golang.org/grpc/doc.go | 26 - .../grpc/encoding/encoding.go | 150 - .../grpc/encoding/encoding_v2.go | 81 - .../grpc/encoding/internal/internal.go | 28 - .../grpc/encoding/proto/proto.go | 112 - .../experimental/balancer/weight/weight.go | 60 - .../grpc/experimental/stats/metricregistry.go | 342 - .../grpc/experimental/stats/metrics.go | 148 - .../grpc/grpclog/component.go | 115 - .../google.golang.org/grpc/grpclog/grpclog.go | 186 - .../grpc/grpclog/internal/grpclog.go | 26 - .../grpc/grpclog/internal/logger.go | 87 - .../grpc/grpclog/internal/loggerv2.go | 267 - .../google.golang.org/grpc/grpclog/logger.go | 34 - .../grpc/grpclog/loggerv2.go | 97 - .../grpc/health/grpc_health_v1/health.pb.go | 350 - .../health/grpc_health_v1/health_grpc.pb.go | 290 - vendor/google.golang.org/grpc/interceptor.go | 108 - .../grpc/internal/backoff/backoff.go | 109 - .../balancer/gracefulswitch/config.go | 84 - .../balancer/gracefulswitch/gracefulswitch.go | 421 - .../grpc/internal/balancerload/load.go | 46 - .../grpc/internal/binarylog/binarylog.go | 192 - .../internal/binarylog/binarylog_testutil.go | 42 - .../grpc/internal/binarylog/env_config.go | 208 - .../grpc/internal/binarylog/method_logger.go | 446 - .../grpc/internal/binarylog/sink.go | 170 - .../grpc/internal/buffer/unbounded.go | 117 - .../grpc/internal/channelz/channel.go | 270 - .../grpc/internal/channelz/channelmap.go | 395 - .../grpc/internal/channelz/funcs.go | 230 - .../grpc/internal/channelz/logging.go | 75 - .../grpc/internal/channelz/server.go | 121 - .../grpc/internal/channelz/socket.go | 137 - .../grpc/internal/channelz/subchannel.go | 153 - .../grpc/internal/channelz/syscall_linux.go | 65 - .../internal/channelz/syscall_nonlinux.go | 47 - .../grpc/internal/channelz/trace.go | 213 - .../grpc/internal/credentials/credentials.go | 35 - .../grpc/internal/credentials/spiffe.go | 75 - .../grpc/internal/credentials/syscallconn.go | 58 - .../grpc/internal/credentials/util.go | 52 - .../grpc/internal/envconfig/envconfig.go | 227 - .../grpc/internal/envconfig/observability.go | 42 - .../grpc/internal/envconfig/xds.go | 101 - .../grpc/internal/experimental.go | 35 - .../grpc/internal/grpclog/prefix_logger.go | 79 - .../internal/grpcsync/callback_serializer.go | 124 - .../grpc/internal/grpcsync/event.go | 58 - .../grpc/internal/grpcsync/pubsub.go | 121 - .../grpc/internal/grpcutil/compressor.go | 42 - .../grpc/internal/grpcutil/encode_duration.go | 62 - .../grpc/internal/grpcutil/grpcutil.go | 20 - .../grpc/internal/grpcutil/metadata.go | 40 - .../grpc/internal/grpcutil/method.go | 88 - .../grpc/internal/idle/idle.go | 289 - .../grpc/internal/internal.go | 300 - .../grpc/internal/mem/buffer_pool.go | 349 - .../grpc/internal/metadata/metadata.go | 144 - .../grpc/internal/pretty/pretty.go | 73 - .../proxyattributes/proxyattributes.go | 54 - .../grpc/internal/resolver/config_selector.go | 107 - .../delegatingresolver/delegatingresolver.go | 477 - .../internal/resolver/dns/dns_resolver.go | 472 - .../resolver/dns/internal/internal.go | 77 - .../resolver/passthrough/passthrough.go | 64 - .../grpc/internal/resolver/unix/unix.go | 78 - .../grpc/internal/serviceconfig/duration.go | 130 - .../internal/serviceconfig/serviceconfig.go | 180 - .../grpc/internal/stats/labels.go | 74 - .../internal/stats/metrics_recorder_list.go | 175 - .../grpc/internal/stats/stats.go | 70 - .../grpc/internal/status/status.go | 246 - .../grpc/internal/syscall/syscall_linux.go | 112 - .../grpc/internal/syscall/syscall_nonlinux.go | 77 - .../grpc/internal/tcp_keepalive_others.go | 29 - .../grpc/internal/tcp_keepalive_unix.go | 54 - .../grpc/internal/tcp_keepalive_windows.go | 54 - .../grpc/internal/transport/bdp_estimator.go | 141 - .../grpc/internal/transport/client_stream.go | 189 - .../grpc/internal/transport/controlbuf.go | 1034 - .../grpc/internal/transport/defaults.go | 56 - .../grpc/internal/transport/flowcontrol.go | 211 - .../grpc/internal/transport/handler_server.go | 506 - .../grpc/internal/transport/http2_client.go | 1895 -- .../grpc/internal/transport/http2_server.go | 1513 -- .../grpc/internal/transport/http_util.go | 632 - .../internal/transport/internal/internal.go | 25 - .../grpc/internal/transport/logging.go | 40 - .../transport/networktype/networktype.go | 46 - .../grpc/internal/transport/proxy.go | 116 - .../transport/readyreader/raw_conn_linux.go | 39 - .../readyreader/raw_conn_nonlinux.go | 35 - .../transport/readyreader/ready_reader.go | 253 - .../grpc/internal/transport/server_stream.go | 189 - .../grpc/internal/transport/transport.go | 774 - .../grpc/keepalive/keepalive.go | 99 - .../google.golang.org/grpc/mem/buffer_pool.go | 96 - .../grpc/mem/buffer_slice.go | 345 - vendor/google.golang.org/grpc/mem/buffers.go | 317 - .../grpc/metadata/metadata.go | 295 - vendor/google.golang.org/grpc/peer/peer.go | 83 - .../google.golang.org/grpc/picker_wrapper.go | 221 - vendor/google.golang.org/grpc/preloader.go | 82 - .../grpc/resolver/dns/dns_resolver.go | 60 - vendor/google.golang.org/grpc/resolver/map.go | 281 - .../grpc/resolver/resolver.go | 359 - .../grpc/resolver_wrapper.go | 222 - vendor/google.golang.org/grpc/rpc_util.go | 1207 -- vendor/google.golang.org/grpc/server.go | 2261 -- .../google.golang.org/grpc/service_config.go | 360 - .../grpc/serviceconfig/serviceconfig.go | 44 - .../google.golang.org/grpc/stats/handlers.go | 72 - .../google.golang.org/grpc/stats/metrics.go | 81 - vendor/google.golang.org/grpc/stats/stats.go | 318 - .../google.golang.org/grpc/status/status.go | 162 - vendor/google.golang.org/grpc/stream.go | 1919 -- .../grpc/stream_interfaces.go | 238 - vendor/google.golang.org/grpc/tap/tap.go | 62 - vendor/google.golang.org/grpc/trace.go | 143 - .../google.golang.org/grpc/trace_notrace.go | 52 - .../google.golang.org/grpc/trace_withtrace.go | 39 - vendor/google.golang.org/grpc/version.go | 22 - vendor/google.golang.org/protobuf/LICENSE | 27 - vendor/google.golang.org/protobuf/PATENTS | 22 - .../encoding/protodelim/protodelim.go | 160 - .../protobuf/encoding/protojson/decode.go | 680 - .../protobuf/encoding/protojson/doc.go | 11 - .../protobuf/encoding/protojson/encode.go | 380 - .../encoding/protojson/well_known_types.go | 880 - .../protobuf/encoding/prototext/decode.go | 767 - .../protobuf/encoding/prototext/doc.go | 7 - .../protobuf/encoding/prototext/encode.go | 380 - .../protobuf/encoding/protowire/wire.go | 571 - .../protobuf/internal/descfmt/stringer.go | 414 - .../protobuf/internal/descopts/options.go | 29 - .../protobuf/internal/detrand/rand.go | 69 - .../internal/editiondefaults/defaults.go | 12 - .../editiondefaults/editions_defaults.binpb | Bin 154 -> 0 bytes .../internal/encoding/defval/default.go | 213 - .../protobuf/internal/encoding/json/decode.go | 340 - .../internal/encoding/json/decode_number.go | 254 - .../internal/encoding/json/decode_string.go | 91 - .../internal/encoding/json/decode_token.go | 192 - .../protobuf/internal/encoding/json/encode.go | 278 - .../encoding/messageset/messageset.go | 242 - .../protobuf/internal/encoding/tag/tag.go | 208 - .../protobuf/internal/encoding/text/decode.go | 729 - .../internal/encoding/text/decode_number.go | 211 - .../internal/encoding/text/decode_string.go | 161 - .../internal/encoding/text/decode_token.go | 373 - .../protobuf/internal/encoding/text/doc.go | 29 - .../protobuf/internal/encoding/text/encode.go | 272 - .../protobuf/internal/errors/errors.go | 104 - .../protobuf/internal/filedesc/build.go | 157 - .../protobuf/internal/filedesc/desc.go | 767 - .../protobuf/internal/filedesc/desc_init.go | 574 - .../protobuf/internal/filedesc/desc_lazy.go | 692 - .../protobuf/internal/filedesc/desc_list.go | 457 - .../internal/filedesc/desc_list_gen.go | 367 - .../protobuf/internal/filedesc/editions.go | 172 - .../protobuf/internal/filedesc/placeholder.go | 110 - .../protobuf/internal/filedesc/presence.go | 33 - .../protobuf/internal/filetype/build.go | 296 - .../protobuf/internal/flags/flags.go | 24 - .../internal/flags/proto_legacy_disable.go | 10 - .../internal/flags/proto_legacy_enable.go | 10 - .../protobuf/internal/genid/any_gen.go | 34 - .../protobuf/internal/genid/api_gen.go | 112 - .../protobuf/internal/genid/descriptor_gen.go | 1333 -- .../protobuf/internal/genid/doc.go | 11 - .../protobuf/internal/genid/duration_gen.go | 34 - .../protobuf/internal/genid/empty_gen.go | 19 - .../protobuf/internal/genid/field_mask_gen.go | 31 - .../internal/genid/go_features_gen.go | 70 - .../protobuf/internal/genid/goname.go | 20 - .../protobuf/internal/genid/map_entry.go | 16 - .../protobuf/internal/genid/name.go | 12 - .../internal/genid/source_context_gen.go | 31 - .../protobuf/internal/genid/struct_gen.go | 121 - .../protobuf/internal/genid/timestamp_gen.go | 34 - .../protobuf/internal/genid/type_gen.go | 228 - .../protobuf/internal/genid/wrappers.go | 13 - .../protobuf/internal/genid/wrappers_gen.go | 175 - .../protobuf/internal/impl/api_export.go | 177 - .../internal/impl/api_export_opaque.go | 128 - .../protobuf/internal/impl/bitmap.go | 34 - .../protobuf/internal/impl/bitmap_race.go | 126 - .../protobuf/internal/impl/checkinit.go | 174 - .../protobuf/internal/impl/codec_extension.go | 228 - .../protobuf/internal/impl/codec_field.go | 788 - .../internal/impl/codec_field_opaque.go | 264 - .../protobuf/internal/impl/codec_gen.go | 5724 ----- .../protobuf/internal/impl/codec_map.go | 405 - .../protobuf/internal/impl/codec_message.go | 230 - .../internal/impl/codec_message_opaque.go | 154 - .../internal/impl/codec_messageset.go | 145 - .../protobuf/internal/impl/codec_tables.go | 557 - .../protobuf/internal/impl/codec_unsafe.go | 15 - .../protobuf/internal/impl/convert.go | 495 - .../protobuf/internal/impl/convert_list.go | 141 - .../protobuf/internal/impl/convert_map.go | 121 - .../protobuf/internal/impl/decode.go | 332 - .../protobuf/internal/impl/encode.go | 315 - .../protobuf/internal/impl/enum.go | 21 - .../protobuf/internal/impl/equal.go | 224 - .../protobuf/internal/impl/extension.go | 156 - .../protobuf/internal/impl/lazy.go | 433 - .../protobuf/internal/impl/legacy_enum.go | 219 - .../protobuf/internal/impl/legacy_export.go | 92 - .../internal/impl/legacy_extension.go | 177 - .../protobuf/internal/impl/legacy_file.go | 81 - .../protobuf/internal/impl/legacy_message.go | 569 - .../protobuf/internal/impl/merge.go | 203 - .../protobuf/internal/impl/merge_gen.go | 209 - .../protobuf/internal/impl/message.go | 283 - .../protobuf/internal/impl/message_opaque.go | 598 - .../internal/impl/message_opaque_gen.go | 132 - .../protobuf/internal/impl/message_reflect.go | 462 - .../internal/impl/message_reflect_field.go | 423 - .../impl/message_reflect_field_gen.go | 273 - .../internal/impl/message_reflect_gen.go | 271 - .../protobuf/internal/impl/pointer_unsafe.go | 220 - .../internal/impl/pointer_unsafe_opaque.go | 42 - .../protobuf/internal/impl/presence.go | 139 - .../protobuf/internal/impl/validate.go | 596 - .../protobuf/internal/order/order.go | 89 - .../protobuf/internal/order/range.go | 115 - .../protobuf/internal/pragma/pragma.go | 29 - .../internal/protolazy/bufferreader.go | 364 - .../protobuf/internal/protolazy/lazy.go | 359 - .../internal/protolazy/pointer_unsafe.go | 17 - .../protobuf/internal/set/ints.go | 58 - .../protobuf/internal/strs/strings.go | 196 - .../protobuf/internal/strs/strings_unsafe.go | 71 - .../protobuf/internal/version/version.go | 79 - .../protobuf/proto/checkinit.go | 71 - .../protobuf/proto/decode.go | 311 - .../protobuf/proto/decode_gen.go | 603 - .../google.golang.org/protobuf/proto/doc.go | 86 - .../protobuf/proto/encode.go | 355 - .../protobuf/proto/encode_gen.go | 97 - .../google.golang.org/protobuf/proto/equal.go | 66 - .../protobuf/proto/extension.go | 166 - .../google.golang.org/protobuf/proto/merge.go | 145 - .../protobuf/proto/messageset.go | 98 - .../google.golang.org/protobuf/proto/proto.go | 45 - .../protobuf/proto/proto_methods.go | 20 - .../protobuf/proto/proto_reflect.go | 20 - .../google.golang.org/protobuf/proto/reset.go | 43 - .../google.golang.org/protobuf/proto/size.go | 111 - .../protobuf/proto/size_gen.go | 55 - .../protobuf/proto/wrapperopaque.go | 80 - .../protobuf/proto/wrappers.go | 29 - .../protobuf/protoadapt/convert.go | 31 - .../protobuf/reflect/protoreflect/methods.go | 88 - .../protobuf/reflect/protoreflect/proto.go | 513 - .../protobuf/reflect/protoreflect/source.go | 129 - .../reflect/protoreflect/source_gen.go | 583 - .../protobuf/reflect/protoreflect/type.go | 666 - .../protobuf/reflect/protoreflect/value.go | 285 - .../reflect/protoreflect/value_equal.go | 168 - .../reflect/protoreflect/value_union.go | 438 - .../reflect/protoreflect/value_unsafe.go | 84 - .../reflect/protoregistry/registry.go | 882 - .../protobuf/runtime/protoiface/legacy.go | 15 - .../protobuf/runtime/protoiface/methods.go | 202 - .../protobuf/runtime/protoimpl/impl.go | 48 - .../protobuf/runtime/protoimpl/version.go | 60 - .../protobuf/types/known/anypb/any.pb.go | 469 - .../types/known/durationpb/duration.pb.go | 346 - .../types/known/fieldmaskpb/field_mask.pb.go | 560 - .../types/known/structpb/struct.pb.go | 767 - .../types/known/timestamppb/timestamp.pb.go | 356 - .../types/known/wrapperspb/wrappers.pb.go | 648 - .../natefinch/lumberjack.v2/.gitignore | 23 - .../natefinch/lumberjack.v2/.travis.yml | 6 - .../gopkg.in/natefinch/lumberjack.v2/LICENSE | 21 - .../natefinch/lumberjack.v2/README.md | 179 - .../gopkg.in/natefinch/lumberjack.v2/chown.go | 11 - .../natefinch/lumberjack.v2/chown_linux.go | 19 - .../natefinch/lumberjack.v2/lumberjack.go | 541 - vendor/gopkg.in/yaml.v2/.travis.yml | 17 - vendor/gopkg.in/yaml.v2/LICENSE | 201 - vendor/gopkg.in/yaml.v2/LICENSE.libyaml | 31 - vendor/gopkg.in/yaml.v2/NOTICE | 13 - vendor/gopkg.in/yaml.v2/README.md | 133 - vendor/gopkg.in/yaml.v2/apic.go | 744 - vendor/gopkg.in/yaml.v2/decode.go | 815 - vendor/gopkg.in/yaml.v2/emitterc.go | 1685 -- vendor/gopkg.in/yaml.v2/encode.go | 390 - vendor/gopkg.in/yaml.v2/parserc.go | 1095 - vendor/gopkg.in/yaml.v2/readerc.go | 412 - vendor/gopkg.in/yaml.v2/resolve.go | 258 - vendor/gopkg.in/yaml.v2/scannerc.go | 2711 --- vendor/gopkg.in/yaml.v2/sorter.go | 113 - vendor/gopkg.in/yaml.v2/writerc.go | 26 - vendor/gopkg.in/yaml.v2/yaml.go | 478 - vendor/gopkg.in/yaml.v2/yamlh.go | 739 - vendor/gopkg.in/yaml.v2/yamlprivateh.go | 173 - vendor/gopkg.in/yaml.v3/LICENSE | 50 - vendor/gopkg.in/yaml.v3/NOTICE | 13 - vendor/gopkg.in/yaml.v3/README.md | 150 - vendor/gopkg.in/yaml.v3/apic.go | 747 - vendor/gopkg.in/yaml.v3/decode.go | 1000 - vendor/gopkg.in/yaml.v3/emitterc.go | 2020 -- vendor/gopkg.in/yaml.v3/encode.go | 577 - vendor/gopkg.in/yaml.v3/parserc.go | 1258 -- vendor/gopkg.in/yaml.v3/readerc.go | 434 - vendor/gopkg.in/yaml.v3/resolve.go | 326 - vendor/gopkg.in/yaml.v3/scannerc.go | 3038 --- vendor/gopkg.in/yaml.v3/sorter.go | 134 - vendor/gopkg.in/yaml.v3/writerc.go | 48 - vendor/gopkg.in/yaml.v3/yaml.go | 698 - vendor/gopkg.in/yaml.v3/yamlh.go | 807 - vendor/gopkg.in/yaml.v3/yamlprivateh.go | 198 - vendor/modules.txt | 524 - vendor/nhooyr.io/websocket/.gitignore | 1 - vendor/nhooyr.io/websocket/LICENSE.txt | 21 - vendor/nhooyr.io/websocket/README.md | 132 - vendor/nhooyr.io/websocket/accept.go | 370 - vendor/nhooyr.io/websocket/accept_js.go | 20 - vendor/nhooyr.io/websocket/close.go | 76 - vendor/nhooyr.io/websocket/close_notjs.go | 211 - vendor/nhooyr.io/websocket/compress.go | 39 - vendor/nhooyr.io/websocket/compress_notjs.go | 181 - vendor/nhooyr.io/websocket/conn.go | 13 - vendor/nhooyr.io/websocket/conn_notjs.go | 265 - vendor/nhooyr.io/websocket/dial.go | 292 - vendor/nhooyr.io/websocket/doc.go | 32 - vendor/nhooyr.io/websocket/frame.go | 294 - .../websocket/internal/bpool/bpool.go | 24 - .../nhooyr.io/websocket/internal/errd/wrap.go | 14 - .../websocket/internal/wsjs/wsjs_js.go | 170 - .../nhooyr.io/websocket/internal/xsync/go.go | 25 - .../websocket/internal/xsync/int64.go | 23 - vendor/nhooyr.io/websocket/netconn.go | 166 - vendor/nhooyr.io/websocket/read.go | 474 - vendor/nhooyr.io/websocket/stringer.go | 91 - vendor/nhooyr.io/websocket/write.go | 397 - vendor/nhooyr.io/websocket/ws_js.go | 379 - vendor/rsc.io/qr/LICENSE | 27 - vendor/rsc.io/qr/README.md | 3 - vendor/rsc.io/qr/coding/qr.go | 815 - vendor/rsc.io/qr/gf256/gf256.go | 241 - vendor/rsc.io/qr/libqrencode/qrencode.go | 149 - vendor/rsc.io/qr/png.go | 400 - vendor/rsc.io/qr/qr.go | 116 - vendor/zombiezen.com/go/capnproto2/.gitignore | 12 - .../zombiezen.com/go/capnproto2/.travis.yml | 9 - vendor/zombiezen.com/go/capnproto2/AUTHORS | 32 - .../zombiezen.com/go/capnproto2/BUILD.bazel | 62 - .../zombiezen.com/go/capnproto2/CHANGELOG.md | 199 - .../go/capnproto2/CONTRIBUTING.md | 22 - .../zombiezen.com/go/capnproto2/CONTRIBUTORS | 39 - vendor/zombiezen.com/go/capnproto2/LICENSE | 25 - vendor/zombiezen.com/go/capnproto2/README.md | 68 - vendor/zombiezen.com/go/capnproto2/WORKSPACE | 45 - vendor/zombiezen.com/go/capnproto2/address.go | 116 - .../zombiezen.com/go/capnproto2/canonical.go | 161 - .../zombiezen.com/go/capnproto2/capability.go | 541 - vendor/zombiezen.com/go/capnproto2/capn.go | 434 - vendor/zombiezen.com/go/capnproto2/doc.go | 384 - .../go/capnproto2/encoding/text/BUILD.bazel | 27 - .../go/capnproto2/encoding/text/marshal.go | 582 - .../zombiezen.com/go/capnproto2/go.capnp.go | 45 - .../capnproto2/internal/fulfiller/BUILD.bazel | 19 - .../internal/fulfiller/fulfiller.go | 329 - .../capnproto2/internal/nodemap/BUILD.bazel | 13 - .../go/capnproto2/internal/nodemap/nodemap.go | 58 - .../go/capnproto2/internal/packed/BUILD.bazel | 19 - .../go/capnproto2/internal/packed/discard.go | 11 - .../internal/packed/discard_go14.go | 13 - .../go/capnproto2/internal/packed/fuzz.go | 65 - .../go/capnproto2/internal/packed/packed.go | 337 - .../go/capnproto2/internal/queue/BUILD.bazel | 14 - .../go/capnproto2/internal/queue/queue.go | 70 - .../go/capnproto2/internal/schema/BUILD.bazel | 9 - .../internal/schema/schema.capnp.go | 3071 --- .../capnproto2/internal/strquote/BUILD.bazel | 8 - .../capnproto2/internal/strquote/strquote.go | 52 - vendor/zombiezen.com/go/capnproto2/list.go | 1044 - vendor/zombiezen.com/go/capnproto2/mem.go | 913 - vendor/zombiezen.com/go/capnproto2/mem_18.go | 10 - .../zombiezen.com/go/capnproto2/mem_other.go | 12 - .../go/capnproto2/pogs/BUILD.bazel | 37 - .../zombiezen.com/go/capnproto2/pogs/doc.go | 164 - .../go/capnproto2/pogs/extract.go | 418 - .../go/capnproto2/pogs/fields.go | 350 - .../go/capnproto2/pogs/insert.go | 485 - vendor/zombiezen.com/go/capnproto2/pointer.go | 304 - .../zombiezen.com/go/capnproto2/rawpointer.go | 189 - .../zombiezen.com/go/capnproto2/readlimit.go | 38 - vendor/zombiezen.com/go/capnproto2/regen.sh | 17 - .../go/capnproto2/rpc/BUILD.bazel | 49 - .../zombiezen.com/go/capnproto2/rpc/answer.go | 498 - .../zombiezen.com/go/capnproto2/rpc/errors.go | 102 - .../rpc/internal/refcount/BUILD.bazel | 16 - .../rpc/internal/refcount/refcount.go | 116 - .../go/capnproto2/rpc/introspect.go | 347 - vendor/zombiezen.com/go/capnproto2/rpc/log.go | 49 - .../go/capnproto2/rpc/question.go | 442 - vendor/zombiezen.com/go/capnproto2/rpc/rpc.go | 913 - .../zombiezen.com/go/capnproto2/rpc/tables.go | 255 - .../go/capnproto2/rpc/transport.go | 175 - .../go/capnproto2/schemas/BUILD.bazel | 19 - .../go/capnproto2/schemas/schemas.go | 185 - .../go/capnproto2/server/BUILD.bazel | 23 - .../go/capnproto2/server/server.go | 231 - .../go/capnproto2/std/capnp/rpc/BUILD.bazel | 13 - .../go/capnproto2/std/capnp/rpc/rpc.capnp.go | 2962 --- vendor/zombiezen.com/go/capnproto2/strings.go | 125 - vendor/zombiezen.com/go/capnproto2/struct.go | 368 - 3075 files changed, 104 insertions(+), 849757 deletions(-) delete mode 100644 vendor/github.com/BurntSushi/toml/.gitignore delete mode 100644 vendor/github.com/BurntSushi/toml/COPYING delete mode 100644 vendor/github.com/BurntSushi/toml/README.md delete mode 100644 vendor/github.com/BurntSushi/toml/decode.go delete mode 100644 vendor/github.com/BurntSushi/toml/decode_go116.go delete mode 100644 vendor/github.com/BurntSushi/toml/deprecated.go delete mode 100644 vendor/github.com/BurntSushi/toml/doc.go delete mode 100644 vendor/github.com/BurntSushi/toml/encode.go delete mode 100644 vendor/github.com/BurntSushi/toml/error.go delete mode 100644 vendor/github.com/BurntSushi/toml/internal/tz.go delete mode 100644 vendor/github.com/BurntSushi/toml/lex.go delete mode 100644 vendor/github.com/BurntSushi/toml/meta.go delete mode 100644 vendor/github.com/BurntSushi/toml/parse.go delete mode 100644 vendor/github.com/BurntSushi/toml/type_fields.go delete mode 100644 vendor/github.com/BurntSushi/toml/type_toml.go delete mode 100644 vendor/github.com/beorn7/perks/LICENSE delete mode 100644 vendor/github.com/beorn7/perks/quantile/exampledata.txt delete mode 100644 vendor/github.com/beorn7/perks/quantile/stream.go delete mode 100644 vendor/github.com/cespare/xxhash/v2/LICENSE.txt delete mode 100644 vendor/github.com/cespare/xxhash/v2/README.md delete mode 100644 vendor/github.com/cespare/xxhash/v2/testall.sh delete mode 100644 vendor/github.com/cespare/xxhash/v2/xxhash.go delete mode 100644 vendor/github.com/cespare/xxhash/v2/xxhash_amd64.s delete mode 100644 vendor/github.com/cespare/xxhash/v2/xxhash_arm64.s delete mode 100644 vendor/github.com/cespare/xxhash/v2/xxhash_asm.go delete mode 100644 vendor/github.com/cespare/xxhash/v2/xxhash_other.go delete mode 100644 vendor/github.com/cespare/xxhash/v2/xxhash_safe.go delete mode 100644 vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go delete mode 100644 vendor/github.com/cloudflare/backoff/.travis.yml delete mode 100644 vendor/github.com/cloudflare/backoff/LICENSE delete mode 100644 vendor/github.com/cloudflare/backoff/README.md delete mode 100644 vendor/github.com/cloudflare/backoff/backoff.go delete mode 100644 vendor/github.com/coreos/go-oidc/v3/LICENSE delete mode 100644 vendor/github.com/coreos/go-oidc/v3/NOTICE delete mode 100644 vendor/github.com/coreos/go-oidc/v3/oidc/jose.go delete mode 100644 vendor/github.com/coreos/go-oidc/v3/oidc/jwks.go delete mode 100644 vendor/github.com/coreos/go-oidc/v3/oidc/oidc.go delete mode 100644 vendor/github.com/coreos/go-oidc/v3/oidc/verify.go delete mode 100644 vendor/github.com/coreos/go-systemd/v22/LICENSE delete mode 100644 vendor/github.com/coreos/go-systemd/v22/NOTICE delete mode 100644 vendor/github.com/coreos/go-systemd/v22/daemon/sdnotify.go delete mode 100644 vendor/github.com/coreos/go-systemd/v22/daemon/watchdog.go delete mode 100644 vendor/github.com/cpuguy83/go-md2man/v2/LICENSE.md delete mode 100644 vendor/github.com/cpuguy83/go-md2man/v2/md2man/md2man.go delete mode 100644 vendor/github.com/cpuguy83/go-md2man/v2/md2man/roff.go delete mode 100644 vendor/github.com/davecgh/go-spew/LICENSE delete mode 100644 vendor/github.com/davecgh/go-spew/spew/bypass.go delete mode 100644 vendor/github.com/davecgh/go-spew/spew/bypasssafe.go delete mode 100644 vendor/github.com/davecgh/go-spew/spew/common.go delete mode 100644 vendor/github.com/davecgh/go-spew/spew/config.go delete mode 100644 vendor/github.com/davecgh/go-spew/spew/doc.go delete mode 100644 vendor/github.com/davecgh/go-spew/spew/dump.go delete mode 100644 vendor/github.com/davecgh/go-spew/spew/format.go delete mode 100644 vendor/github.com/davecgh/go-spew/spew/spew.go delete mode 100644 vendor/github.com/ebitengine/purego/.gitignore delete mode 100644 vendor/github.com/ebitengine/purego/LICENSE delete mode 100644 vendor/github.com/ebitengine/purego/README.md delete mode 100644 vendor/github.com/ebitengine/purego/abi_amd64.h delete mode 100644 vendor/github.com/ebitengine/purego/abi_arm64.h delete mode 100644 vendor/github.com/ebitengine/purego/abi_loong64.h delete mode 100644 vendor/github.com/ebitengine/purego/cgo.go delete mode 100644 vendor/github.com/ebitengine/purego/dlerror.go delete mode 100644 vendor/github.com/ebitengine/purego/dlfcn.go delete mode 100644 vendor/github.com/ebitengine/purego/dlfcn_android.go delete mode 100644 vendor/github.com/ebitengine/purego/dlfcn_darwin.go delete mode 100644 vendor/github.com/ebitengine/purego/dlfcn_freebsd.go delete mode 100644 vendor/github.com/ebitengine/purego/dlfcn_linux.go delete mode 100644 vendor/github.com/ebitengine/purego/dlfcn_netbsd.go delete mode 100644 vendor/github.com/ebitengine/purego/dlfcn_nocgo_freebsd.go delete mode 100644 vendor/github.com/ebitengine/purego/dlfcn_nocgo_linux.go delete mode 100644 vendor/github.com/ebitengine/purego/dlfcn_nocgo_netbsd.go delete mode 100644 vendor/github.com/ebitengine/purego/dlfcn_playground.go delete mode 100644 vendor/github.com/ebitengine/purego/dlfcn_stubs.s delete mode 100644 vendor/github.com/ebitengine/purego/func.go delete mode 100644 vendor/github.com/ebitengine/purego/gen.go delete mode 100644 vendor/github.com/ebitengine/purego/go_runtime.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/cgo/dlfcn_cgo_unix.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/cgo/empty.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/cgo/syscall_cgo_unix.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/abi_amd64.h delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/abi_arm64.h delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/abi_loong64.h delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/abi_ppc64x.h delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/asm_386.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/asm_amd64.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/asm_arm.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/asm_arm64.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/asm_loong64.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/asm_ppc64le.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/asm_riscv64.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/asm_s390x.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/callbacks.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/doc.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/fakecgo.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/freebsd.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/go_darwin.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/go_freebsd.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/go_libinit.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/go_linux.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/go_netbsd.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/go_setenv.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/go_util.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/iscgo.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_darwin.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_freebsd.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_linux.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_netbsd.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/netbsd.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/setenv.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_386.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_amd64.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_arm.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_arm64.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_loong64.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_ppc64le.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_riscv64.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_darwin.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_freebsd.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_linux.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_netbsd.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_darwin.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_freebsd.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_linux.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_netbsd.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_stubs.s delete mode 100644 vendor/github.com/ebitengine/purego/internal/strings/strings.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/xreflect/reflect_go124.go delete mode 100644 vendor/github.com/ebitengine/purego/internal/xreflect/reflect_go125.go delete mode 100644 vendor/github.com/ebitengine/purego/is_ios.go delete mode 100644 vendor/github.com/ebitengine/purego/nocgo.go delete mode 100644 vendor/github.com/ebitengine/purego/struct_386.go delete mode 100644 vendor/github.com/ebitengine/purego/struct_amd64.go delete mode 100644 vendor/github.com/ebitengine/purego/struct_arm.go delete mode 100644 vendor/github.com/ebitengine/purego/struct_arm64.go delete mode 100644 vendor/github.com/ebitengine/purego/struct_loong64.go delete mode 100644 vendor/github.com/ebitengine/purego/struct_ppc64le.go delete mode 100644 vendor/github.com/ebitengine/purego/struct_riscv64.go delete mode 100644 vendor/github.com/ebitengine/purego/struct_s390x.go delete mode 100644 vendor/github.com/ebitengine/purego/sys_386.s delete mode 100644 vendor/github.com/ebitengine/purego/sys_amd64.s delete mode 100644 vendor/github.com/ebitengine/purego/sys_arm.s delete mode 100644 vendor/github.com/ebitengine/purego/sys_arm64.s delete mode 100644 vendor/github.com/ebitengine/purego/sys_loong64.s delete mode 100644 vendor/github.com/ebitengine/purego/sys_ppc64le.s delete mode 100644 vendor/github.com/ebitengine/purego/sys_riscv64.s delete mode 100644 vendor/github.com/ebitengine/purego/sys_s390x.s delete mode 100644 vendor/github.com/ebitengine/purego/sys_unix_386.s delete mode 100644 vendor/github.com/ebitengine/purego/sys_unix_arm.s delete mode 100644 vendor/github.com/ebitengine/purego/sys_unix_arm64.s delete mode 100644 vendor/github.com/ebitengine/purego/sys_unix_loong64.s delete mode 100644 vendor/github.com/ebitengine/purego/sys_unix_ppc64le.s delete mode 100644 vendor/github.com/ebitengine/purego/sys_unix_riscv64.s delete mode 100644 vendor/github.com/ebitengine/purego/sys_unix_s390x.s delete mode 100644 vendor/github.com/ebitengine/purego/syscall.go delete mode 100644 vendor/github.com/ebitengine/purego/syscall_32bit.go delete mode 100644 vendor/github.com/ebitengine/purego/syscall_cgo_linux.go delete mode 100644 vendor/github.com/ebitengine/purego/syscall_sysv.go delete mode 100644 vendor/github.com/ebitengine/purego/syscall_sysv_others.go delete mode 100644 vendor/github.com/ebitengine/purego/syscall_sysv_stackargs.go delete mode 100644 vendor/github.com/ebitengine/purego/syscall_windows.go delete mode 100644 vendor/github.com/ebitengine/purego/zcallback_386.s delete mode 100644 vendor/github.com/ebitengine/purego/zcallback_amd64.s delete mode 100644 vendor/github.com/ebitengine/purego/zcallback_arm.s delete mode 100644 vendor/github.com/ebitengine/purego/zcallback_arm64.s delete mode 100644 vendor/github.com/ebitengine/purego/zcallback_loong64.s delete mode 100644 vendor/github.com/ebitengine/purego/zcallback_ppc64le.s delete mode 100644 vendor/github.com/ebitengine/purego/zcallback_riscv64.s delete mode 100644 vendor/github.com/ebitengine/purego/zcallback_s390x.s delete mode 100644 vendor/github.com/facebookgo/grace/gracenet/net.go delete mode 100644 vendor/github.com/fortytw2/leaktest/.travis.yml delete mode 100644 vendor/github.com/fortytw2/leaktest/LICENSE delete mode 100644 vendor/github.com/fortytw2/leaktest/README.md delete mode 100644 vendor/github.com/fortytw2/leaktest/leaktest.go delete mode 100644 vendor/github.com/fsnotify/fsnotify/.editorconfig delete mode 100644 vendor/github.com/fsnotify/fsnotify/.gitattributes delete mode 100644 vendor/github.com/fsnotify/fsnotify/.gitignore delete mode 100644 vendor/github.com/fsnotify/fsnotify/.travis.yml delete mode 100644 vendor/github.com/fsnotify/fsnotify/AUTHORS delete mode 100644 vendor/github.com/fsnotify/fsnotify/CHANGELOG.md delete mode 100644 vendor/github.com/fsnotify/fsnotify/CONTRIBUTING.md delete mode 100644 vendor/github.com/fsnotify/fsnotify/LICENSE delete mode 100644 vendor/github.com/fsnotify/fsnotify/README.md delete mode 100644 vendor/github.com/fsnotify/fsnotify/fen.go delete mode 100644 vendor/github.com/fsnotify/fsnotify/fsnotify.go delete mode 100644 vendor/github.com/fsnotify/fsnotify/inotify.go delete mode 100644 vendor/github.com/fsnotify/fsnotify/inotify_poller.go delete mode 100644 vendor/github.com/fsnotify/fsnotify/kqueue.go delete mode 100644 vendor/github.com/fsnotify/fsnotify/open_mode_bsd.go delete mode 100644 vendor/github.com/fsnotify/fsnotify/open_mode_darwin.go delete mode 100644 vendor/github.com/fsnotify/fsnotify/windows.go delete mode 100644 vendor/github.com/getsentry/sentry-go/.codecov.yml delete mode 100644 vendor/github.com/getsentry/sentry-go/.craft.yml delete mode 100644 vendor/github.com/getsentry/sentry-go/.gitattributes delete mode 100644 vendor/github.com/getsentry/sentry-go/.gitignore delete mode 100644 vendor/github.com/getsentry/sentry-go/.golangci.yml delete mode 100644 vendor/github.com/getsentry/sentry-go/CHANGELOG.md delete mode 100644 vendor/github.com/getsentry/sentry-go/CONTRIBUTING.md delete mode 100644 vendor/github.com/getsentry/sentry-go/LICENSE delete mode 100644 vendor/github.com/getsentry/sentry-go/MIGRATION.md delete mode 100644 vendor/github.com/getsentry/sentry-go/Makefile delete mode 100644 vendor/github.com/getsentry/sentry-go/README.md delete mode 100644 vendor/github.com/getsentry/sentry-go/attribute/builder.go delete mode 100644 vendor/github.com/getsentry/sentry-go/attribute/rawhelpers.go delete mode 100644 vendor/github.com/getsentry/sentry-go/attribute/value.go delete mode 100644 vendor/github.com/getsentry/sentry-go/batch_processor.go delete mode 100644 vendor/github.com/getsentry/sentry-go/check_in.go delete mode 100644 vendor/github.com/getsentry/sentry-go/client.go delete mode 100644 vendor/github.com/getsentry/sentry-go/doc.go delete mode 100644 vendor/github.com/getsentry/sentry-go/dsn.go delete mode 100644 vendor/github.com/getsentry/sentry-go/dynamic_sampling_context.go delete mode 100644 vendor/github.com/getsentry/sentry-go/exception.go delete mode 100644 vendor/github.com/getsentry/sentry-go/hub.go delete mode 100644 vendor/github.com/getsentry/sentry-go/integrations.go delete mode 100644 vendor/github.com/getsentry/sentry-go/interfaces.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/debug/transport.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/debuglog/log.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/http/transport.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/otel/baggage/README.md delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/otel/baggage/baggage.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/otel/baggage/internal/baggage/baggage.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/protocol/dsn.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/protocol/envelope.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/protocol/interfaces.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/protocol/log_batch.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/protocol/metric_batch.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/protocol/types.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/protocol/uuid.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/ratelimit/category.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/ratelimit/deadline.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/ratelimit/doc.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/ratelimit/map.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/ratelimit/rate_limits.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/ratelimit/retry_after.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/telemetry/bucketed_buffer.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/telemetry/buffer.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/telemetry/processor.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/telemetry/ring_buffer.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/telemetry/scheduler.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/telemetry/trace_aware.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/util/map.go delete mode 100644 vendor/github.com/getsentry/sentry-go/internal/util/util.go delete mode 100644 vendor/github.com/getsentry/sentry-go/log.go delete mode 100644 vendor/github.com/getsentry/sentry-go/log_batch_processor.go delete mode 100644 vendor/github.com/getsentry/sentry-go/log_fallback.go delete mode 100644 vendor/github.com/getsentry/sentry-go/metric_batch_processor.go delete mode 100644 vendor/github.com/getsentry/sentry-go/metrics.go delete mode 100644 vendor/github.com/getsentry/sentry-go/mocks.go delete mode 100644 vendor/github.com/getsentry/sentry-go/propagation_context.go delete mode 100644 vendor/github.com/getsentry/sentry-go/scope.go delete mode 100644 vendor/github.com/getsentry/sentry-go/sentry.go delete mode 100644 vendor/github.com/getsentry/sentry-go/sourcereader.go delete mode 100644 vendor/github.com/getsentry/sentry-go/span_recorder.go delete mode 100644 vendor/github.com/getsentry/sentry-go/stacktrace.go delete mode 100644 vendor/github.com/getsentry/sentry-go/traces_sampler.go delete mode 100644 vendor/github.com/getsentry/sentry-go/tracing.go delete mode 100644 vendor/github.com/getsentry/sentry-go/transport.go delete mode 100644 vendor/github.com/getsentry/sentry-go/util.go delete mode 100644 vendor/github.com/go-chi/chi/v5/.gitignore delete mode 100644 vendor/github.com/go-chi/chi/v5/CHANGELOG.md delete mode 100644 vendor/github.com/go-chi/chi/v5/CONTRIBUTING.md delete mode 100644 vendor/github.com/go-chi/chi/v5/LICENSE delete mode 100644 vendor/github.com/go-chi/chi/v5/Makefile delete mode 100644 vendor/github.com/go-chi/chi/v5/README.md delete mode 100644 vendor/github.com/go-chi/chi/v5/SECURITY.md delete mode 100644 vendor/github.com/go-chi/chi/v5/chain.go delete mode 100644 vendor/github.com/go-chi/chi/v5/chi.go delete mode 100644 vendor/github.com/go-chi/chi/v5/context.go delete mode 100644 vendor/github.com/go-chi/chi/v5/mux.go delete mode 100644 vendor/github.com/go-chi/chi/v5/tree.go delete mode 100644 vendor/github.com/go-chi/cors/LICENSE delete mode 100644 vendor/github.com/go-chi/cors/README.md delete mode 100644 vendor/github.com/go-chi/cors/cors.go delete mode 100644 vendor/github.com/go-chi/cors/utils.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/.gitignore delete mode 100644 vendor/github.com/go-jose/go-jose/v4/.golangci.yml delete mode 100644 vendor/github.com/go-jose/go-jose/v4/.travis.yml delete mode 100644 vendor/github.com/go-jose/go-jose/v4/CONTRIBUTING.md delete mode 100644 vendor/github.com/go-jose/go-jose/v4/LICENSE delete mode 100644 vendor/github.com/go-jose/go-jose/v4/README.md delete mode 100644 vendor/github.com/go-jose/go-jose/v4/SECURITY.md delete mode 100644 vendor/github.com/go-jose/go-jose/v4/asymmetric.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/cipher/cbc_hmac.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/cipher/concat_kdf.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/cipher/ecdh_es.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/cipher/key_wrap.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/crypter.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/doc.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/encoding.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/json/LICENSE delete mode 100644 vendor/github.com/go-jose/go-jose/v4/json/README.md delete mode 100644 vendor/github.com/go-jose/go-jose/v4/json/decode.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/json/encode.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/json/indent.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/json/scanner.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/json/stream.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/json/tags.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/jwe.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/jwk.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/jws.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/jwt/builder.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/jwt/claims.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/jwt/doc.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/jwt/errors.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/jwt/jwt.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/jwt/validation.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/opaque.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/shared.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/signing.go delete mode 100644 vendor/github.com/go-jose/go-jose/v4/symmetric.go delete mode 100644 vendor/github.com/go-logr/logr/.golangci.yaml delete mode 100644 vendor/github.com/go-logr/logr/CHANGELOG.md delete mode 100644 vendor/github.com/go-logr/logr/CONTRIBUTING.md delete mode 100644 vendor/github.com/go-logr/logr/LICENSE delete mode 100644 vendor/github.com/go-logr/logr/README.md delete mode 100644 vendor/github.com/go-logr/logr/SECURITY.md delete mode 100644 vendor/github.com/go-logr/logr/context.go delete mode 100644 vendor/github.com/go-logr/logr/context_noslog.go delete mode 100644 vendor/github.com/go-logr/logr/context_slog.go delete mode 100644 vendor/github.com/go-logr/logr/discard.go delete mode 100644 vendor/github.com/go-logr/logr/funcr/funcr.go delete mode 100644 vendor/github.com/go-logr/logr/funcr/slogsink.go delete mode 100644 vendor/github.com/go-logr/logr/logr.go delete mode 100644 vendor/github.com/go-logr/logr/sloghandler.go delete mode 100644 vendor/github.com/go-logr/logr/slogr.go delete mode 100644 vendor/github.com/go-logr/logr/slogsink.go delete mode 100644 vendor/github.com/go-logr/stdr/LICENSE delete mode 100644 vendor/github.com/go-logr/stdr/README.md delete mode 100644 vendor/github.com/go-logr/stdr/stdr.go delete mode 100644 vendor/github.com/go-ole/go-ole/.travis.yml delete mode 100644 vendor/github.com/go-ole/go-ole/ChangeLog.md delete mode 100644 vendor/github.com/go-ole/go-ole/LICENSE delete mode 100644 vendor/github.com/go-ole/go-ole/README.md delete mode 100644 vendor/github.com/go-ole/go-ole/appveyor.yml delete mode 100644 vendor/github.com/go-ole/go-ole/com.go delete mode 100644 vendor/github.com/go-ole/go-ole/com_func.go delete mode 100644 vendor/github.com/go-ole/go-ole/connect.go delete mode 100644 vendor/github.com/go-ole/go-ole/constants.go delete mode 100644 vendor/github.com/go-ole/go-ole/error.go delete mode 100644 vendor/github.com/go-ole/go-ole/error_func.go delete mode 100644 vendor/github.com/go-ole/go-ole/error_windows.go delete mode 100644 vendor/github.com/go-ole/go-ole/guid.go delete mode 100644 vendor/github.com/go-ole/go-ole/iconnectionpoint.go delete mode 100644 vendor/github.com/go-ole/go-ole/iconnectionpoint_func.go delete mode 100644 vendor/github.com/go-ole/go-ole/iconnectionpoint_windows.go delete mode 100644 vendor/github.com/go-ole/go-ole/iconnectionpointcontainer.go delete mode 100644 vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_func.go delete mode 100644 vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_windows.go delete mode 100644 vendor/github.com/go-ole/go-ole/idispatch.go delete mode 100644 vendor/github.com/go-ole/go-ole/idispatch_func.go delete mode 100644 vendor/github.com/go-ole/go-ole/idispatch_windows.go delete mode 100644 vendor/github.com/go-ole/go-ole/ienumvariant.go delete mode 100644 vendor/github.com/go-ole/go-ole/ienumvariant_func.go delete mode 100644 vendor/github.com/go-ole/go-ole/ienumvariant_windows.go delete mode 100644 vendor/github.com/go-ole/go-ole/iinspectable.go delete mode 100644 vendor/github.com/go-ole/go-ole/iinspectable_func.go delete mode 100644 vendor/github.com/go-ole/go-ole/iinspectable_windows.go delete mode 100644 vendor/github.com/go-ole/go-ole/iprovideclassinfo.go delete mode 100644 vendor/github.com/go-ole/go-ole/iprovideclassinfo_func.go delete mode 100644 vendor/github.com/go-ole/go-ole/iprovideclassinfo_windows.go delete mode 100644 vendor/github.com/go-ole/go-ole/itypeinfo.go delete mode 100644 vendor/github.com/go-ole/go-ole/itypeinfo_func.go delete mode 100644 vendor/github.com/go-ole/go-ole/itypeinfo_windows.go delete mode 100644 vendor/github.com/go-ole/go-ole/iunknown.go delete mode 100644 vendor/github.com/go-ole/go-ole/iunknown_func.go delete mode 100644 vendor/github.com/go-ole/go-ole/iunknown_windows.go delete mode 100644 vendor/github.com/go-ole/go-ole/ole.go delete mode 100644 vendor/github.com/go-ole/go-ole/oleutil/connection.go delete mode 100644 vendor/github.com/go-ole/go-ole/oleutil/connection_func.go delete mode 100644 vendor/github.com/go-ole/go-ole/oleutil/connection_windows.go delete mode 100644 vendor/github.com/go-ole/go-ole/oleutil/go-get.go delete mode 100644 vendor/github.com/go-ole/go-ole/oleutil/oleutil.go delete mode 100644 vendor/github.com/go-ole/go-ole/safearray.go delete mode 100644 vendor/github.com/go-ole/go-ole/safearray_func.go delete mode 100644 vendor/github.com/go-ole/go-ole/safearray_windows.go delete mode 100644 vendor/github.com/go-ole/go-ole/safearrayconversion.go delete mode 100644 vendor/github.com/go-ole/go-ole/safearrayslices.go delete mode 100644 vendor/github.com/go-ole/go-ole/utility.go delete mode 100644 vendor/github.com/go-ole/go-ole/variables.go delete mode 100644 vendor/github.com/go-ole/go-ole/variant.go delete mode 100644 vendor/github.com/go-ole/go-ole/variant_386.go delete mode 100644 vendor/github.com/go-ole/go-ole/variant_amd64.go delete mode 100644 vendor/github.com/go-ole/go-ole/variant_arm.go delete mode 100644 vendor/github.com/go-ole/go-ole/variant_arm64.go delete mode 100644 vendor/github.com/go-ole/go-ole/variant_date_386.go delete mode 100644 vendor/github.com/go-ole/go-ole/variant_date_amd64.go delete mode 100644 vendor/github.com/go-ole/go-ole/variant_date_arm.go delete mode 100644 vendor/github.com/go-ole/go-ole/variant_date_arm64.go delete mode 100644 vendor/github.com/go-ole/go-ole/variant_ppc64le.go delete mode 100644 vendor/github.com/go-ole/go-ole/variant_s390x.go delete mode 100644 vendor/github.com/go-ole/go-ole/vt_string.go delete mode 100644 vendor/github.com/go-ole/go-ole/winrt.go delete mode 100644 vendor/github.com/go-ole/go-ole/winrt_doc.go delete mode 100644 vendor/github.com/gobwas/httphead/LICENSE delete mode 100644 vendor/github.com/gobwas/httphead/README.md delete mode 100644 vendor/github.com/gobwas/httphead/cookie.go delete mode 100644 vendor/github.com/gobwas/httphead/head.go delete mode 100644 vendor/github.com/gobwas/httphead/httphead.go delete mode 100644 vendor/github.com/gobwas/httphead/lexer.go delete mode 100644 vendor/github.com/gobwas/httphead/octet.go delete mode 100644 vendor/github.com/gobwas/httphead/option.go delete mode 100644 vendor/github.com/gobwas/httphead/writer.go delete mode 100644 vendor/github.com/gobwas/pool/LICENSE delete mode 100644 vendor/github.com/gobwas/pool/README.md delete mode 100644 vendor/github.com/gobwas/pool/generic.go delete mode 100644 vendor/github.com/gobwas/pool/internal/pmath/pmath.go delete mode 100644 vendor/github.com/gobwas/pool/option.go delete mode 100644 vendor/github.com/gobwas/pool/pbufio/pbufio.go delete mode 100644 vendor/github.com/gobwas/pool/pbufio/pbufio_go110.go delete mode 100644 vendor/github.com/gobwas/pool/pbufio/pbufio_go19.go delete mode 100644 vendor/github.com/gobwas/pool/pbytes/pbytes.go delete mode 100644 vendor/github.com/gobwas/pool/pbytes/pool.go delete mode 100644 vendor/github.com/gobwas/pool/pbytes/pool_sanitize.go delete mode 100644 vendor/github.com/gobwas/pool/pool.go delete mode 100644 vendor/github.com/gobwas/ws/.gitignore delete mode 100644 vendor/github.com/gobwas/ws/LICENSE delete mode 100644 vendor/github.com/gobwas/ws/Makefile delete mode 100644 vendor/github.com/gobwas/ws/README.md delete mode 100644 vendor/github.com/gobwas/ws/check.go delete mode 100644 vendor/github.com/gobwas/ws/cipher.go delete mode 100644 vendor/github.com/gobwas/ws/dialer.go delete mode 100644 vendor/github.com/gobwas/ws/dialer_tls_go17.go delete mode 100644 vendor/github.com/gobwas/ws/dialer_tls_go18.go delete mode 100644 vendor/github.com/gobwas/ws/doc.go delete mode 100644 vendor/github.com/gobwas/ws/errors.go delete mode 100644 vendor/github.com/gobwas/ws/frame.go delete mode 100644 vendor/github.com/gobwas/ws/http.go delete mode 100644 vendor/github.com/gobwas/ws/nonce.go delete mode 100644 vendor/github.com/gobwas/ws/read.go delete mode 100644 vendor/github.com/gobwas/ws/server.go delete mode 100644 vendor/github.com/gobwas/ws/util.go delete mode 100644 vendor/github.com/gobwas/ws/util_purego.go delete mode 100644 vendor/github.com/gobwas/ws/util_unsafe.go delete mode 100644 vendor/github.com/gobwas/ws/write.go delete mode 100644 vendor/github.com/gobwas/ws/wsutil/cipher.go delete mode 100644 vendor/github.com/gobwas/ws/wsutil/dialer.go delete mode 100644 vendor/github.com/gobwas/ws/wsutil/extenstion.go delete mode 100644 vendor/github.com/gobwas/ws/wsutil/handler.go delete mode 100644 vendor/github.com/gobwas/ws/wsutil/helper.go delete mode 100644 vendor/github.com/gobwas/ws/wsutil/reader.go delete mode 100644 vendor/github.com/gobwas/ws/wsutil/upgrader.go delete mode 100644 vendor/github.com/gobwas/ws/wsutil/utf8.go delete mode 100644 vendor/github.com/gobwas/ws/wsutil/writer.go delete mode 100644 vendor/github.com/gobwas/ws/wsutil/wsutil.go delete mode 100644 vendor/github.com/google/gopacket/.gitignore delete mode 100644 vendor/github.com/google/gopacket/.travis.gofmt.sh delete mode 100644 vendor/github.com/google/gopacket/.travis.golint.sh delete mode 100644 vendor/github.com/google/gopacket/.travis.govet.sh delete mode 100644 vendor/github.com/google/gopacket/.travis.install.sh delete mode 100644 vendor/github.com/google/gopacket/.travis.script.sh delete mode 100644 vendor/github.com/google/gopacket/.travis.yml delete mode 100644 vendor/github.com/google/gopacket/AUTHORS delete mode 100644 vendor/github.com/google/gopacket/CONTRIBUTING.md delete mode 100644 vendor/github.com/google/gopacket/LICENSE delete mode 100644 vendor/github.com/google/gopacket/README.md delete mode 100644 vendor/github.com/google/gopacket/base.go delete mode 100644 vendor/github.com/google/gopacket/decode.go delete mode 100644 vendor/github.com/google/gopacket/doc.go delete mode 100644 vendor/github.com/google/gopacket/flows.go delete mode 100644 vendor/github.com/google/gopacket/gc delete mode 100644 vendor/github.com/google/gopacket/layerclass.go delete mode 100644 vendor/github.com/google/gopacket/layers/.lint_blacklist delete mode 100644 vendor/github.com/google/gopacket/layers/arp.go delete mode 100644 vendor/github.com/google/gopacket/layers/asf.go delete mode 100644 vendor/github.com/google/gopacket/layers/asf_presencepong.go delete mode 100644 vendor/github.com/google/gopacket/layers/base.go delete mode 100644 vendor/github.com/google/gopacket/layers/bfd.go delete mode 100644 vendor/github.com/google/gopacket/layers/cdp.go delete mode 100644 vendor/github.com/google/gopacket/layers/ctp.go delete mode 100644 vendor/github.com/google/gopacket/layers/dhcpv4.go delete mode 100644 vendor/github.com/google/gopacket/layers/dhcpv6.go delete mode 100644 vendor/github.com/google/gopacket/layers/dhcpv6_options.go delete mode 100644 vendor/github.com/google/gopacket/layers/dns.go delete mode 100644 vendor/github.com/google/gopacket/layers/doc.go delete mode 100644 vendor/github.com/google/gopacket/layers/dot11.go delete mode 100644 vendor/github.com/google/gopacket/layers/dot1q.go delete mode 100644 vendor/github.com/google/gopacket/layers/eap.go delete mode 100644 vendor/github.com/google/gopacket/layers/eapol.go delete mode 100644 vendor/github.com/google/gopacket/layers/endpoints.go delete mode 100644 vendor/github.com/google/gopacket/layers/enums.go delete mode 100644 vendor/github.com/google/gopacket/layers/enums_generated.go delete mode 100644 vendor/github.com/google/gopacket/layers/erspan2.go delete mode 100644 vendor/github.com/google/gopacket/layers/etherip.go delete mode 100644 vendor/github.com/google/gopacket/layers/ethernet.go delete mode 100644 vendor/github.com/google/gopacket/layers/fddi.go delete mode 100644 vendor/github.com/google/gopacket/layers/fuzz_layer.go delete mode 100644 vendor/github.com/google/gopacket/layers/gen_linted.sh delete mode 100644 vendor/github.com/google/gopacket/layers/geneve.go delete mode 100644 vendor/github.com/google/gopacket/layers/gre.go delete mode 100644 vendor/github.com/google/gopacket/layers/gtp.go delete mode 100644 vendor/github.com/google/gopacket/layers/iana_ports.go delete mode 100644 vendor/github.com/google/gopacket/layers/icmp4.go delete mode 100644 vendor/github.com/google/gopacket/layers/icmp6.go delete mode 100644 vendor/github.com/google/gopacket/layers/icmp6msg.go delete mode 100644 vendor/github.com/google/gopacket/layers/igmp.go delete mode 100644 vendor/github.com/google/gopacket/layers/ip4.go delete mode 100644 vendor/github.com/google/gopacket/layers/ip6.go delete mode 100644 vendor/github.com/google/gopacket/layers/ipsec.go delete mode 100644 vendor/github.com/google/gopacket/layers/layertypes.go delete mode 100644 vendor/github.com/google/gopacket/layers/lcm.go delete mode 100644 vendor/github.com/google/gopacket/layers/linux_sll.go delete mode 100644 vendor/github.com/google/gopacket/layers/llc.go delete mode 100644 vendor/github.com/google/gopacket/layers/lldp.go delete mode 100644 vendor/github.com/google/gopacket/layers/loopback.go delete mode 100644 vendor/github.com/google/gopacket/layers/mldv1.go delete mode 100644 vendor/github.com/google/gopacket/layers/mldv2.go delete mode 100644 vendor/github.com/google/gopacket/layers/modbustcp.go delete mode 100644 vendor/github.com/google/gopacket/layers/mpls.go delete mode 100644 vendor/github.com/google/gopacket/layers/ndp.go delete mode 100644 vendor/github.com/google/gopacket/layers/ntp.go delete mode 100644 vendor/github.com/google/gopacket/layers/ospf.go delete mode 100644 vendor/github.com/google/gopacket/layers/pflog.go delete mode 100644 vendor/github.com/google/gopacket/layers/ports.go delete mode 100644 vendor/github.com/google/gopacket/layers/ppp.go delete mode 100644 vendor/github.com/google/gopacket/layers/pppoe.go delete mode 100644 vendor/github.com/google/gopacket/layers/prism.go delete mode 100644 vendor/github.com/google/gopacket/layers/radiotap.go delete mode 100644 vendor/github.com/google/gopacket/layers/radius.go delete mode 100644 vendor/github.com/google/gopacket/layers/rmcp.go delete mode 100644 vendor/github.com/google/gopacket/layers/rudp.go delete mode 100644 vendor/github.com/google/gopacket/layers/sctp.go delete mode 100644 vendor/github.com/google/gopacket/layers/sflow.go delete mode 100644 vendor/github.com/google/gopacket/layers/sip.go delete mode 100644 vendor/github.com/google/gopacket/layers/stp.go delete mode 100644 vendor/github.com/google/gopacket/layers/tcp.go delete mode 100644 vendor/github.com/google/gopacket/layers/tcpip.go delete mode 100644 vendor/github.com/google/gopacket/layers/test_creator.py delete mode 100644 vendor/github.com/google/gopacket/layers/tls.go delete mode 100644 vendor/github.com/google/gopacket/layers/tls_alert.go delete mode 100644 vendor/github.com/google/gopacket/layers/tls_appdata.go delete mode 100644 vendor/github.com/google/gopacket/layers/tls_cipherspec.go delete mode 100644 vendor/github.com/google/gopacket/layers/tls_handshake.go delete mode 100644 vendor/github.com/google/gopacket/layers/udp.go delete mode 100644 vendor/github.com/google/gopacket/layers/udplite.go delete mode 100644 vendor/github.com/google/gopacket/layers/usb.go delete mode 100644 vendor/github.com/google/gopacket/layers/vrrp.go delete mode 100644 vendor/github.com/google/gopacket/layers/vxlan.go delete mode 100644 vendor/github.com/google/gopacket/layers_decoder.go delete mode 100644 vendor/github.com/google/gopacket/layertype.go delete mode 100644 vendor/github.com/google/gopacket/packet.go delete mode 100644 vendor/github.com/google/gopacket/parser.go delete mode 100644 vendor/github.com/google/gopacket/time.go delete mode 100644 vendor/github.com/google/gopacket/writer.go delete mode 100644 vendor/github.com/google/uuid/CHANGELOG.md delete mode 100644 vendor/github.com/google/uuid/CONTRIBUTING.md delete mode 100644 vendor/github.com/google/uuid/CONTRIBUTORS delete mode 100644 vendor/github.com/google/uuid/LICENSE delete mode 100644 vendor/github.com/google/uuid/README.md delete mode 100644 vendor/github.com/google/uuid/dce.go delete mode 100644 vendor/github.com/google/uuid/doc.go delete mode 100644 vendor/github.com/google/uuid/hash.go delete mode 100644 vendor/github.com/google/uuid/marshal.go delete mode 100644 vendor/github.com/google/uuid/node.go delete mode 100644 vendor/github.com/google/uuid/node_js.go delete mode 100644 vendor/github.com/google/uuid/node_net.go delete mode 100644 vendor/github.com/google/uuid/null.go delete mode 100644 vendor/github.com/google/uuid/sql.go delete mode 100644 vendor/github.com/google/uuid/time.go delete mode 100644 vendor/github.com/google/uuid/util.go delete mode 100644 vendor/github.com/google/uuid/uuid.go delete mode 100644 vendor/github.com/google/uuid/version1.go delete mode 100644 vendor/github.com/google/uuid/version4.go delete mode 100644 vendor/github.com/google/uuid/version6.go delete mode 100644 vendor/github.com/google/uuid/version7.go delete mode 100644 vendor/github.com/gorilla/websocket/.gitignore delete mode 100644 vendor/github.com/gorilla/websocket/AUTHORS delete mode 100644 vendor/github.com/gorilla/websocket/LICENSE delete mode 100644 vendor/github.com/gorilla/websocket/README.md delete mode 100644 vendor/github.com/gorilla/websocket/client.go delete mode 100644 vendor/github.com/gorilla/websocket/compression.go delete mode 100644 vendor/github.com/gorilla/websocket/conn.go delete mode 100644 vendor/github.com/gorilla/websocket/doc.go delete mode 100644 vendor/github.com/gorilla/websocket/join.go delete mode 100644 vendor/github.com/gorilla/websocket/json.go delete mode 100644 vendor/github.com/gorilla/websocket/mask.go delete mode 100644 vendor/github.com/gorilla/websocket/mask_safe.go delete mode 100644 vendor/github.com/gorilla/websocket/prepared.go delete mode 100644 vendor/github.com/gorilla/websocket/proxy.go delete mode 100644 vendor/github.com/gorilla/websocket/server.go delete mode 100644 vendor/github.com/gorilla/websocket/tls_handshake.go delete mode 100644 vendor/github.com/gorilla/websocket/tls_handshake_116.go delete mode 100644 vendor/github.com/gorilla/websocket/util.go delete mode 100644 vendor/github.com/gorilla/websocket/x_net_proxy.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/LICENSE delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/internal/httprule/BUILD.bazel delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/internal/httprule/compile.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/internal/httprule/fuzz.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/internal/httprule/parse.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/internal/httprule/types.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/runtime/BUILD.bazel delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/runtime/context.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/runtime/convert.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/runtime/doc.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/runtime/errors.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/runtime/fieldmask.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/runtime/handler.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/runtime/marshal_httpbodyproto.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/runtime/marshal_json.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/runtime/marshal_jsonpb.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/runtime/marshal_proto.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/runtime/marshaler.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/runtime/marshaler_registry.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/runtime/mux.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/runtime/pattern.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/runtime/proto2_convert.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/runtime/query.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/utilities/BUILD.bazel delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/utilities/doc.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/utilities/pattern.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/utilities/readerfactory.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/utilities/string_array_flag.go delete mode 100644 vendor/github.com/grpc-ecosystem/grpc-gateway/v2/utilities/trie.go delete mode 100644 vendor/github.com/json-iterator/go/.codecov.yml delete mode 100644 vendor/github.com/json-iterator/go/.gitignore delete mode 100644 vendor/github.com/json-iterator/go/.travis.yml delete mode 100644 vendor/github.com/json-iterator/go/Gopkg.lock delete mode 100644 vendor/github.com/json-iterator/go/Gopkg.toml delete mode 100644 vendor/github.com/json-iterator/go/LICENSE delete mode 100644 vendor/github.com/json-iterator/go/README.md delete mode 100644 vendor/github.com/json-iterator/go/adapter.go delete mode 100644 vendor/github.com/json-iterator/go/any.go delete mode 100644 vendor/github.com/json-iterator/go/any_array.go delete mode 100644 vendor/github.com/json-iterator/go/any_bool.go delete mode 100644 vendor/github.com/json-iterator/go/any_float.go delete mode 100644 vendor/github.com/json-iterator/go/any_int32.go delete mode 100644 vendor/github.com/json-iterator/go/any_int64.go delete mode 100644 vendor/github.com/json-iterator/go/any_invalid.go delete mode 100644 vendor/github.com/json-iterator/go/any_nil.go delete mode 100644 vendor/github.com/json-iterator/go/any_number.go delete mode 100644 vendor/github.com/json-iterator/go/any_object.go delete mode 100644 vendor/github.com/json-iterator/go/any_str.go delete mode 100644 vendor/github.com/json-iterator/go/any_uint32.go delete mode 100644 vendor/github.com/json-iterator/go/any_uint64.go delete mode 100644 vendor/github.com/json-iterator/go/build.sh delete mode 100644 vendor/github.com/json-iterator/go/config.go delete mode 100644 vendor/github.com/json-iterator/go/fuzzy_mode_convert_table.md delete mode 100644 vendor/github.com/json-iterator/go/iter.go delete mode 100644 vendor/github.com/json-iterator/go/iter_array.go delete mode 100644 vendor/github.com/json-iterator/go/iter_float.go delete mode 100644 vendor/github.com/json-iterator/go/iter_int.go delete mode 100644 vendor/github.com/json-iterator/go/iter_object.go delete mode 100644 vendor/github.com/json-iterator/go/iter_skip.go delete mode 100644 vendor/github.com/json-iterator/go/iter_skip_sloppy.go delete mode 100644 vendor/github.com/json-iterator/go/iter_skip_strict.go delete mode 100644 vendor/github.com/json-iterator/go/iter_str.go delete mode 100644 vendor/github.com/json-iterator/go/jsoniter.go delete mode 100644 vendor/github.com/json-iterator/go/pool.go delete mode 100644 vendor/github.com/json-iterator/go/reflect.go delete mode 100644 vendor/github.com/json-iterator/go/reflect_array.go delete mode 100644 vendor/github.com/json-iterator/go/reflect_dynamic.go delete mode 100644 vendor/github.com/json-iterator/go/reflect_extension.go delete mode 100644 vendor/github.com/json-iterator/go/reflect_json_number.go delete mode 100644 vendor/github.com/json-iterator/go/reflect_json_raw_message.go delete mode 100644 vendor/github.com/json-iterator/go/reflect_map.go delete mode 100644 vendor/github.com/json-iterator/go/reflect_marshaler.go delete mode 100644 vendor/github.com/json-iterator/go/reflect_native.go delete mode 100644 vendor/github.com/json-iterator/go/reflect_optional.go delete mode 100644 vendor/github.com/json-iterator/go/reflect_slice.go delete mode 100644 vendor/github.com/json-iterator/go/reflect_struct_decoder.go delete mode 100644 vendor/github.com/json-iterator/go/reflect_struct_encoder.go delete mode 100644 vendor/github.com/json-iterator/go/stream.go delete mode 100644 vendor/github.com/json-iterator/go/stream_float.go delete mode 100644 vendor/github.com/json-iterator/go/stream_int.go delete mode 100644 vendor/github.com/json-iterator/go/stream_str.go delete mode 100644 vendor/github.com/json-iterator/go/test.sh delete mode 100644 vendor/github.com/klauspost/compress/LICENSE delete mode 100644 vendor/github.com/klauspost/compress/flate/deflate.go delete mode 100644 vendor/github.com/klauspost/compress/flate/dict_decoder.go delete mode 100644 vendor/github.com/klauspost/compress/flate/fast_encoder.go delete mode 100644 vendor/github.com/klauspost/compress/flate/huffman_bit_writer.go delete mode 100644 vendor/github.com/klauspost/compress/flate/huffman_code.go delete mode 100644 vendor/github.com/klauspost/compress/flate/huffman_sortByFreq.go delete mode 100644 vendor/github.com/klauspost/compress/flate/huffman_sortByLiteral.go delete mode 100644 vendor/github.com/klauspost/compress/flate/inflate.go delete mode 100644 vendor/github.com/klauspost/compress/flate/inflate_gen.go delete mode 100644 vendor/github.com/klauspost/compress/flate/level1.go delete mode 100644 vendor/github.com/klauspost/compress/flate/level2.go delete mode 100644 vendor/github.com/klauspost/compress/flate/level3.go delete mode 100644 vendor/github.com/klauspost/compress/flate/level4.go delete mode 100644 vendor/github.com/klauspost/compress/flate/level5.go delete mode 100644 vendor/github.com/klauspost/compress/flate/level6.go delete mode 100644 vendor/github.com/klauspost/compress/flate/matchlen_generic.go delete mode 100644 vendor/github.com/klauspost/compress/flate/regmask_amd64.go delete mode 100644 vendor/github.com/klauspost/compress/flate/regmask_other.go delete mode 100644 vendor/github.com/klauspost/compress/flate/stateless.go delete mode 100644 vendor/github.com/klauspost/compress/flate/token.go delete mode 100644 vendor/github.com/klauspost/compress/internal/le/le.go delete mode 100644 vendor/github.com/klauspost/compress/internal/le/unsafe_disabled.go delete mode 100644 vendor/github.com/klauspost/compress/internal/le/unsafe_enabled.go delete mode 100644 vendor/github.com/lufia/plan9stats/.gitignore delete mode 100644 vendor/github.com/lufia/plan9stats/LICENSE delete mode 100644 vendor/github.com/lufia/plan9stats/README.md delete mode 100644 vendor/github.com/lufia/plan9stats/cpu.go delete mode 100644 vendor/github.com/lufia/plan9stats/doc.go delete mode 100644 vendor/github.com/lufia/plan9stats/host.go delete mode 100644 vendor/github.com/lufia/plan9stats/int.go delete mode 100644 vendor/github.com/lufia/plan9stats/opts.go delete mode 100644 vendor/github.com/lufia/plan9stats/stats.go delete mode 100644 vendor/github.com/mattn/go-colorable/LICENSE delete mode 100644 vendor/github.com/mattn/go-colorable/README.md delete mode 100644 vendor/github.com/mattn/go-colorable/colorable_appengine.go delete mode 100644 vendor/github.com/mattn/go-colorable/colorable_others.go delete mode 100644 vendor/github.com/mattn/go-colorable/colorable_windows.go delete mode 100644 vendor/github.com/mattn/go-colorable/go.test.sh delete mode 100644 vendor/github.com/mattn/go-colorable/noncolorable.go delete mode 100644 vendor/github.com/mattn/go-isatty/LICENSE delete mode 100644 vendor/github.com/mattn/go-isatty/README.md delete mode 100644 vendor/github.com/mattn/go-isatty/doc.go delete mode 100644 vendor/github.com/mattn/go-isatty/go.test.sh delete mode 100644 vendor/github.com/mattn/go-isatty/isatty_bsd.go delete mode 100644 vendor/github.com/mattn/go-isatty/isatty_others.go delete mode 100644 vendor/github.com/mattn/go-isatty/isatty_plan9.go delete mode 100644 vendor/github.com/mattn/go-isatty/isatty_solaris.go delete mode 100644 vendor/github.com/mattn/go-isatty/isatty_tcgets.go delete mode 100644 vendor/github.com/mattn/go-isatty/isatty_windows.go delete mode 100644 vendor/github.com/mitchellh/go-homedir/LICENSE delete mode 100644 vendor/github.com/mitchellh/go-homedir/README.md delete mode 100644 vendor/github.com/mitchellh/go-homedir/homedir.go delete mode 100644 vendor/github.com/modern-go/concurrent/.gitignore delete mode 100644 vendor/github.com/modern-go/concurrent/.travis.yml delete mode 100644 vendor/github.com/modern-go/concurrent/LICENSE delete mode 100644 vendor/github.com/modern-go/concurrent/README.md delete mode 100644 vendor/github.com/modern-go/concurrent/executor.go delete mode 100644 vendor/github.com/modern-go/concurrent/go_above_19.go delete mode 100644 vendor/github.com/modern-go/concurrent/go_below_19.go delete mode 100644 vendor/github.com/modern-go/concurrent/log.go delete mode 100644 vendor/github.com/modern-go/concurrent/test.sh delete mode 100644 vendor/github.com/modern-go/concurrent/unbounded_executor.go delete mode 100644 vendor/github.com/modern-go/reflect2/.gitignore delete mode 100644 vendor/github.com/modern-go/reflect2/.travis.yml delete mode 100644 vendor/github.com/modern-go/reflect2/Gopkg.lock delete mode 100644 vendor/github.com/modern-go/reflect2/Gopkg.toml delete mode 100644 vendor/github.com/modern-go/reflect2/LICENSE delete mode 100644 vendor/github.com/modern-go/reflect2/README.md delete mode 100644 vendor/github.com/modern-go/reflect2/go_above_118.go delete mode 100644 vendor/github.com/modern-go/reflect2/go_above_19.go delete mode 100644 vendor/github.com/modern-go/reflect2/go_below_118.go delete mode 100644 vendor/github.com/modern-go/reflect2/reflect2.go delete mode 100644 vendor/github.com/modern-go/reflect2/reflect2_amd64.s delete mode 100644 vendor/github.com/modern-go/reflect2/reflect2_kind.go delete mode 100644 vendor/github.com/modern-go/reflect2/relfect2_386.s delete mode 100644 vendor/github.com/modern-go/reflect2/relfect2_amd64p32.s delete mode 100644 vendor/github.com/modern-go/reflect2/relfect2_arm.s delete mode 100644 vendor/github.com/modern-go/reflect2/relfect2_arm64.s delete mode 100644 vendor/github.com/modern-go/reflect2/relfect2_mips64x.s delete mode 100644 vendor/github.com/modern-go/reflect2/relfect2_mipsx.s delete mode 100644 vendor/github.com/modern-go/reflect2/relfect2_ppc64x.s delete mode 100644 vendor/github.com/modern-go/reflect2/relfect2_s390x.s delete mode 100644 vendor/github.com/modern-go/reflect2/safe_field.go delete mode 100644 vendor/github.com/modern-go/reflect2/safe_map.go delete mode 100644 vendor/github.com/modern-go/reflect2/safe_slice.go delete mode 100644 vendor/github.com/modern-go/reflect2/safe_struct.go delete mode 100644 vendor/github.com/modern-go/reflect2/safe_type.go delete mode 100644 vendor/github.com/modern-go/reflect2/type_map.go delete mode 100644 vendor/github.com/modern-go/reflect2/unsafe_array.go delete mode 100644 vendor/github.com/modern-go/reflect2/unsafe_eface.go delete mode 100644 vendor/github.com/modern-go/reflect2/unsafe_field.go delete mode 100644 vendor/github.com/modern-go/reflect2/unsafe_iface.go delete mode 100644 vendor/github.com/modern-go/reflect2/unsafe_link.go delete mode 100644 vendor/github.com/modern-go/reflect2/unsafe_map.go delete mode 100644 vendor/github.com/modern-go/reflect2/unsafe_ptr.go delete mode 100644 vendor/github.com/modern-go/reflect2/unsafe_slice.go delete mode 100644 vendor/github.com/modern-go/reflect2/unsafe_struct.go delete mode 100644 vendor/github.com/modern-go/reflect2/unsafe_type.go delete mode 100644 vendor/github.com/munnerz/goautoneg/LICENSE delete mode 100644 vendor/github.com/munnerz/goautoneg/Makefile delete mode 100644 vendor/github.com/munnerz/goautoneg/README.txt delete mode 100644 vendor/github.com/munnerz/goautoneg/autoneg.go delete mode 100644 vendor/github.com/pkg/errors/.gitignore delete mode 100644 vendor/github.com/pkg/errors/.travis.yml delete mode 100644 vendor/github.com/pkg/errors/LICENSE delete mode 100644 vendor/github.com/pkg/errors/Makefile delete mode 100644 vendor/github.com/pkg/errors/README.md delete mode 100644 vendor/github.com/pkg/errors/appveyor.yml delete mode 100644 vendor/github.com/pkg/errors/errors.go delete mode 100644 vendor/github.com/pkg/errors/go113.go delete mode 100644 vendor/github.com/pkg/errors/stack.go delete mode 100644 vendor/github.com/pmezard/go-difflib/LICENSE delete mode 100644 vendor/github.com/pmezard/go-difflib/difflib/difflib.go delete mode 100644 vendor/github.com/power-devops/perfstat/LICENSE delete mode 100644 vendor/github.com/power-devops/perfstat/c_helpers.c delete mode 100644 vendor/github.com/power-devops/perfstat/c_helpers.h delete mode 100644 vendor/github.com/power-devops/perfstat/config.go delete mode 100644 vendor/github.com/power-devops/perfstat/cpustat.go delete mode 100644 vendor/github.com/power-devops/perfstat/diskstat.go delete mode 100644 vendor/github.com/power-devops/perfstat/doc.go delete mode 100644 vendor/github.com/power-devops/perfstat/fsstat.go delete mode 100644 vendor/github.com/power-devops/perfstat/helpers.go delete mode 100644 vendor/github.com/power-devops/perfstat/lparstat.go delete mode 100644 vendor/github.com/power-devops/perfstat/lvmstat.go delete mode 100644 vendor/github.com/power-devops/perfstat/memstat.go delete mode 100644 vendor/github.com/power-devops/perfstat/netstat.go delete mode 100644 vendor/github.com/power-devops/perfstat/procstat.go delete mode 100644 vendor/github.com/power-devops/perfstat/sysconf.go delete mode 100644 vendor/github.com/power-devops/perfstat/systemcfg.go delete mode 100644 vendor/github.com/power-devops/perfstat/types_cpu.go delete mode 100644 vendor/github.com/power-devops/perfstat/types_disk.go delete mode 100644 vendor/github.com/power-devops/perfstat/types_fs.go delete mode 100644 vendor/github.com/power-devops/perfstat/types_lpar.go delete mode 100644 vendor/github.com/power-devops/perfstat/types_lvm.go delete mode 100644 vendor/github.com/power-devops/perfstat/types_memory.go delete mode 100644 vendor/github.com/power-devops/perfstat/types_network.go delete mode 100644 vendor/github.com/power-devops/perfstat/types_process.go delete mode 100644 vendor/github.com/power-devops/perfstat/uptime.go delete mode 100644 vendor/github.com/prometheus/client_golang/LICENSE delete mode 100644 vendor/github.com/prometheus/client_golang/NOTICE delete mode 100644 vendor/github.com/prometheus/client_golang/internal/github.com/golang/gddo/LICENSE delete mode 100644 vendor/github.com/prometheus/client_golang/internal/github.com/golang/gddo/httputil/header/header.go delete mode 100644 vendor/github.com/prometheus/client_golang/internal/github.com/golang/gddo/httputil/negotiate.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/.gitignore delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/README.md delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/build_info_collector.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/collector.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/collectorfunc.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/counter.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/desc.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/doc.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/expvar_collector.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/fnv.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/gauge.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/get_pid.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/get_pid_gopherjs.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/go_collector.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/go_collector_go116.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/go_collector_latest.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/histogram.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/internal/almost_equal.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/internal/difflib.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/internal/go_collector_options.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/internal/go_runtime_metrics.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/internal/metric.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/labels.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/metric.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/num_threads.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/num_threads_gopherjs.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/observer.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/process_collector.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/process_collector_darwin.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/process_collector_mem_cgo_darwin.c delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/process_collector_mem_cgo_darwin.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/process_collector_mem_nocgo_darwin.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/process_collector_not_supported.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/process_collector_procfsenabled.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/process_collector_windows.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/promauto/auto.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/promhttp/delegator.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/promhttp/http.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_client.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_server.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/promhttp/internal/compression.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/promhttp/option.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/registry.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/summary.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/timer.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/untyped.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/value.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/vec.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/vnext.go delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/wrap.go delete mode 100644 vendor/github.com/prometheus/client_model/LICENSE delete mode 100644 vendor/github.com/prometheus/client_model/NOTICE delete mode 100644 vendor/github.com/prometheus/client_model/go/metrics.pb.go delete mode 100644 vendor/github.com/prometheus/common/LICENSE delete mode 100644 vendor/github.com/prometheus/common/NOTICE delete mode 100644 vendor/github.com/prometheus/common/expfmt/decode.go delete mode 100644 vendor/github.com/prometheus/common/expfmt/encode.go delete mode 100644 vendor/github.com/prometheus/common/expfmt/expfmt.go delete mode 100644 vendor/github.com/prometheus/common/expfmt/fuzz.go delete mode 100644 vendor/github.com/prometheus/common/expfmt/openmetrics_create.go delete mode 100644 vendor/github.com/prometheus/common/expfmt/text_create.go delete mode 100644 vendor/github.com/prometheus/common/expfmt/text_parse.go delete mode 100644 vendor/github.com/prometheus/common/model/alert.go delete mode 100644 vendor/github.com/prometheus/common/model/fingerprinting.go delete mode 100644 vendor/github.com/prometheus/common/model/fnv.go delete mode 100644 vendor/github.com/prometheus/common/model/labels.go delete mode 100644 vendor/github.com/prometheus/common/model/labelset.go delete mode 100644 vendor/github.com/prometheus/common/model/labelset_string.go delete mode 100644 vendor/github.com/prometheus/common/model/metadata.go delete mode 100644 vendor/github.com/prometheus/common/model/metric.go delete mode 100644 vendor/github.com/prometheus/common/model/model.go delete mode 100644 vendor/github.com/prometheus/common/model/signature.go delete mode 100644 vendor/github.com/prometheus/common/model/silence.go delete mode 100644 vendor/github.com/prometheus/common/model/time.go delete mode 100644 vendor/github.com/prometheus/common/model/value.go delete mode 100644 vendor/github.com/prometheus/common/model/value_float.go delete mode 100644 vendor/github.com/prometheus/common/model/value_histogram.go delete mode 100644 vendor/github.com/prometheus/common/model/value_type.go delete mode 100644 vendor/github.com/prometheus/procfs/.gitignore delete mode 100644 vendor/github.com/prometheus/procfs/.golangci.yml delete mode 100644 vendor/github.com/prometheus/procfs/CODE_OF_CONDUCT.md delete mode 100644 vendor/github.com/prometheus/procfs/CONTRIBUTING.md delete mode 100644 vendor/github.com/prometheus/procfs/LICENSE delete mode 100644 vendor/github.com/prometheus/procfs/MAINTAINERS.md delete mode 100644 vendor/github.com/prometheus/procfs/Makefile delete mode 100644 vendor/github.com/prometheus/procfs/Makefile.common delete mode 100644 vendor/github.com/prometheus/procfs/NOTICE delete mode 100644 vendor/github.com/prometheus/procfs/README.md delete mode 100644 vendor/github.com/prometheus/procfs/SECURITY.md delete mode 100644 vendor/github.com/prometheus/procfs/arp.go delete mode 100644 vendor/github.com/prometheus/procfs/buddyinfo.go delete mode 100644 vendor/github.com/prometheus/procfs/cmdline.go delete mode 100644 vendor/github.com/prometheus/procfs/cpuinfo.go delete mode 100644 vendor/github.com/prometheus/procfs/cpuinfo_armx.go delete mode 100644 vendor/github.com/prometheus/procfs/cpuinfo_loong64.go delete mode 100644 vendor/github.com/prometheus/procfs/cpuinfo_mipsx.go delete mode 100644 vendor/github.com/prometheus/procfs/cpuinfo_others.go delete mode 100644 vendor/github.com/prometheus/procfs/cpuinfo_ppcx.go delete mode 100644 vendor/github.com/prometheus/procfs/cpuinfo_riscvx.go delete mode 100644 vendor/github.com/prometheus/procfs/cpuinfo_s390x.go delete mode 100644 vendor/github.com/prometheus/procfs/cpuinfo_x86.go delete mode 100644 vendor/github.com/prometheus/procfs/crypto.go delete mode 100644 vendor/github.com/prometheus/procfs/doc.go delete mode 100644 vendor/github.com/prometheus/procfs/fs.go delete mode 100644 vendor/github.com/prometheus/procfs/fs_statfs_notype.go delete mode 100644 vendor/github.com/prometheus/procfs/fs_statfs_type.go delete mode 100644 vendor/github.com/prometheus/procfs/fscache.go delete mode 100644 vendor/github.com/prometheus/procfs/internal/fs/fs.go delete mode 100644 vendor/github.com/prometheus/procfs/internal/util/parse.go delete mode 100644 vendor/github.com/prometheus/procfs/internal/util/readfile.go delete mode 100644 vendor/github.com/prometheus/procfs/internal/util/sysreadfile.go delete mode 100644 vendor/github.com/prometheus/procfs/internal/util/sysreadfile_compat.go delete mode 100644 vendor/github.com/prometheus/procfs/internal/util/valueparser.go delete mode 100644 vendor/github.com/prometheus/procfs/ipvs.go delete mode 100644 vendor/github.com/prometheus/procfs/kernel_random.go delete mode 100644 vendor/github.com/prometheus/procfs/loadavg.go delete mode 100644 vendor/github.com/prometheus/procfs/mdstat.go delete mode 100644 vendor/github.com/prometheus/procfs/meminfo.go delete mode 100644 vendor/github.com/prometheus/procfs/mountinfo.go delete mode 100644 vendor/github.com/prometheus/procfs/mountstats.go delete mode 100644 vendor/github.com/prometheus/procfs/net_conntrackstat.go delete mode 100644 vendor/github.com/prometheus/procfs/net_dev.go delete mode 100644 vendor/github.com/prometheus/procfs/net_ip_socket.go delete mode 100644 vendor/github.com/prometheus/procfs/net_protocols.go delete mode 100644 vendor/github.com/prometheus/procfs/net_route.go delete mode 100644 vendor/github.com/prometheus/procfs/net_sockstat.go delete mode 100644 vendor/github.com/prometheus/procfs/net_softnet.go delete mode 100644 vendor/github.com/prometheus/procfs/net_tcp.go delete mode 100644 vendor/github.com/prometheus/procfs/net_tls_stat.go delete mode 100644 vendor/github.com/prometheus/procfs/net_udp.go delete mode 100644 vendor/github.com/prometheus/procfs/net_unix.go delete mode 100644 vendor/github.com/prometheus/procfs/net_wireless.go delete mode 100644 vendor/github.com/prometheus/procfs/net_xfrm.go delete mode 100644 vendor/github.com/prometheus/procfs/netstat.go delete mode 100644 vendor/github.com/prometheus/procfs/proc.go delete mode 100644 vendor/github.com/prometheus/procfs/proc_cgroup.go delete mode 100644 vendor/github.com/prometheus/procfs/proc_cgroups.go delete mode 100644 vendor/github.com/prometheus/procfs/proc_environ.go delete mode 100644 vendor/github.com/prometheus/procfs/proc_fdinfo.go delete mode 100644 vendor/github.com/prometheus/procfs/proc_interrupts.go delete mode 100644 vendor/github.com/prometheus/procfs/proc_io.go delete mode 100644 vendor/github.com/prometheus/procfs/proc_limits.go delete mode 100644 vendor/github.com/prometheus/procfs/proc_maps.go delete mode 100644 vendor/github.com/prometheus/procfs/proc_netstat.go delete mode 100644 vendor/github.com/prometheus/procfs/proc_ns.go delete mode 100644 vendor/github.com/prometheus/procfs/proc_psi.go delete mode 100644 vendor/github.com/prometheus/procfs/proc_smaps.go delete mode 100644 vendor/github.com/prometheus/procfs/proc_snmp.go delete mode 100644 vendor/github.com/prometheus/procfs/proc_snmp6.go delete mode 100644 vendor/github.com/prometheus/procfs/proc_stat.go delete mode 100644 vendor/github.com/prometheus/procfs/proc_status.go delete mode 100644 vendor/github.com/prometheus/procfs/proc_sys.go delete mode 100644 vendor/github.com/prometheus/procfs/schedstat.go delete mode 100644 vendor/github.com/prometheus/procfs/slab.go delete mode 100644 vendor/github.com/prometheus/procfs/softirqs.go delete mode 100644 vendor/github.com/prometheus/procfs/stat.go delete mode 100644 vendor/github.com/prometheus/procfs/swaps.go delete mode 100644 vendor/github.com/prometheus/procfs/thread.go delete mode 100644 vendor/github.com/prometheus/procfs/ttar delete mode 100644 vendor/github.com/prometheus/procfs/vm.go delete mode 100644 vendor/github.com/prometheus/procfs/zoneinfo.go delete mode 100644 vendor/github.com/quic-go/quic-go/.gitignore delete mode 100644 vendor/github.com/quic-go/quic-go/.golangci.yml delete mode 100644 vendor/github.com/quic-go/quic-go/LICENSE delete mode 100644 vendor/github.com/quic-go/quic-go/README.md delete mode 100644 vendor/github.com/quic-go/quic-go/SECURITY.md delete mode 100644 vendor/github.com/quic-go/quic-go/buffer_pool.go delete mode 100644 vendor/github.com/quic-go/quic-go/client.go delete mode 100644 vendor/github.com/quic-go/quic-go/closed_conn.go delete mode 100644 vendor/github.com/quic-go/quic-go/codecov.yml delete mode 100644 vendor/github.com/quic-go/quic-go/config.go delete mode 100644 vendor/github.com/quic-go/quic-go/conn_id_generator.go delete mode 100644 vendor/github.com/quic-go/quic-go/conn_id_manager.go delete mode 100644 vendor/github.com/quic-go/quic-go/connection.go delete mode 100644 vendor/github.com/quic-go/quic-go/connection_logging.go delete mode 100644 vendor/github.com/quic-go/quic-go/crypto_stream.go delete mode 100644 vendor/github.com/quic-go/quic-go/crypto_stream_manager.go delete mode 100644 vendor/github.com/quic-go/quic-go/datagram_queue.go delete mode 100644 vendor/github.com/quic-go/quic-go/errors.go delete mode 100644 vendor/github.com/quic-go/quic-go/frame_sorter.go delete mode 100644 vendor/github.com/quic-go/quic-go/framer.go delete mode 100644 vendor/github.com/quic-go/quic-go/interface.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/ackhandler/ack_eliciting.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/ackhandler/ecn.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/ackhandler/frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/ackhandler/interfaces.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/ackhandler/lost_packet_tracker.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/ackhandler/mockgen.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/ackhandler/packet.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/ackhandler/packet_number_generator.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/ackhandler/received_packet_handler.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/ackhandler/received_packet_history.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/ackhandler/received_packet_tracker.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/ackhandler/send_mode.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/ackhandler/sent_packet_handler.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/ackhandler/sent_packet_history.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/congestion/bandwidth.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/congestion/clock.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/congestion/cubic.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/congestion/cubic_sender.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/congestion/hybrid_slow_start.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/congestion/interface.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/congestion/pacer.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/flowcontrol/base_flow_controller.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/flowcontrol/connection_flow_controller.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/flowcontrol/interface.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/flowcontrol/stream_flow_controller.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/handshake/aead.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/handshake/cipher_suite.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/handshake/crypto_setup.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/handshake/fake_conn.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/handshake/header_protector.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/handshake/hkdf.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/handshake/initial_aead.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/handshake/interface.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/handshake/retry.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/handshake/session_ticket.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/handshake/tls_config.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/handshake/token_generator.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/handshake/token_protector.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/handshake/updatable_aead.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/handshake/xor_nonce_aead_boring.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/handshake/xor_nonce_aead_noboring.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/monotime/time.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/protocol/connection_id.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/protocol/encryption_level.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/protocol/key_phase.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/protocol/packet_number.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/protocol/params.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/protocol/perspective.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/protocol/protocol.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/protocol/stream.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/protocol/version.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/qerr/error_codes.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/qerr/errors.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/utils/buffered_write_closer.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/utils/connstats.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/utils/linkedlist/README.md delete mode 100644 vendor/github.com/quic-go/quic-go/internal/utils/linkedlist/linkedlist.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/utils/log.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/utils/rand.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/utils/ringbuffer/ringbuffer.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/utils/rtt_stats.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/ack_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/ack_frequency_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/ack_range.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/connection_close_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/crypto_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/data_blocked_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/datagram_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/extended_header.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/frame_parser.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/frame_type.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/handshake_done_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/header.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/immediate_ack_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/log.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/max_data_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/max_stream_data_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/max_streams_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/new_connection_id_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/new_token_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/path_challenge_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/path_response_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/ping_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/pool.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/reset_stream_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/retire_connection_id_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/short_header.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/stop_sending_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/stream_data_blocked_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/stream_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/streams_blocked_frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/transport_parameters.go delete mode 100644 vendor/github.com/quic-go/quic-go/internal/wire/version_negotiation.go delete mode 100644 vendor/github.com/quic-go/quic-go/mockgen.go delete mode 100644 vendor/github.com/quic-go/quic-go/mtu_discoverer.go delete mode 100644 vendor/github.com/quic-go/quic-go/oss-fuzz.sh delete mode 100644 vendor/github.com/quic-go/quic-go/packet_packer.go delete mode 100644 vendor/github.com/quic-go/quic-go/packet_unpacker.go delete mode 100644 vendor/github.com/quic-go/quic-go/path_manager.go delete mode 100644 vendor/github.com/quic-go/quic-go/path_manager_outgoing.go delete mode 100644 vendor/github.com/quic-go/quic-go/qlog/event.go delete mode 100644 vendor/github.com/quic-go/quic-go/qlog/frame.go delete mode 100644 vendor/github.com/quic-go/quic-go/qlog/packet_header.go delete mode 100644 vendor/github.com/quic-go/quic-go/qlog/qlog_dir.go delete mode 100644 vendor/github.com/quic-go/quic-go/qlog/types.go delete mode 100644 vendor/github.com/quic-go/quic-go/qlogwriter/jsontext/encoder.go delete mode 100644 vendor/github.com/quic-go/quic-go/qlogwriter/trace.go delete mode 100644 vendor/github.com/quic-go/quic-go/qlogwriter/writer.go delete mode 100644 vendor/github.com/quic-go/quic-go/quicvarint/io.go delete mode 100644 vendor/github.com/quic-go/quic-go/quicvarint/varint.go delete mode 100644 vendor/github.com/quic-go/quic-go/receive_stream.go delete mode 100644 vendor/github.com/quic-go/quic-go/retransmission_queue.go delete mode 100644 vendor/github.com/quic-go/quic-go/send_conn.go delete mode 100644 vendor/github.com/quic-go/quic-go/send_queue.go delete mode 100644 vendor/github.com/quic-go/quic-go/send_stream.go delete mode 100644 vendor/github.com/quic-go/quic-go/server.go delete mode 100644 vendor/github.com/quic-go/quic-go/sni.go delete mode 100644 vendor/github.com/quic-go/quic-go/stateless_reset.go delete mode 100644 vendor/github.com/quic-go/quic-go/stream.go delete mode 100644 vendor/github.com/quic-go/quic-go/streams_map.go delete mode 100644 vendor/github.com/quic-go/quic-go/streams_map_incoming.go delete mode 100644 vendor/github.com/quic-go/quic-go/streams_map_outgoing.go delete mode 100644 vendor/github.com/quic-go/quic-go/sys_conn.go delete mode 100644 vendor/github.com/quic-go/quic-go/sys_conn_buffers.go delete mode 100644 vendor/github.com/quic-go/quic-go/sys_conn_buffers_write.go delete mode 100644 vendor/github.com/quic-go/quic-go/sys_conn_df.go delete mode 100644 vendor/github.com/quic-go/quic-go/sys_conn_df_darwin.go delete mode 100644 vendor/github.com/quic-go/quic-go/sys_conn_df_linux.go delete mode 100644 vendor/github.com/quic-go/quic-go/sys_conn_df_windows.go delete mode 100644 vendor/github.com/quic-go/quic-go/sys_conn_helper_darwin.go delete mode 100644 vendor/github.com/quic-go/quic-go/sys_conn_helper_freebsd.go delete mode 100644 vendor/github.com/quic-go/quic-go/sys_conn_helper_linux.go delete mode 100644 vendor/github.com/quic-go/quic-go/sys_conn_helper_nonlinux.go delete mode 100644 vendor/github.com/quic-go/quic-go/sys_conn_no_oob.go delete mode 100644 vendor/github.com/quic-go/quic-go/sys_conn_oob.go delete mode 100644 vendor/github.com/quic-go/quic-go/sys_conn_windows.go delete mode 100644 vendor/github.com/quic-go/quic-go/token_store.go delete mode 100644 vendor/github.com/quic-go/quic-go/transport.go delete mode 100644 vendor/github.com/rs/zerolog/.gitignore delete mode 100644 vendor/github.com/rs/zerolog/.travis.yml delete mode 100644 vendor/github.com/rs/zerolog/CNAME delete mode 100644 vendor/github.com/rs/zerolog/LICENSE delete mode 100644 vendor/github.com/rs/zerolog/README.md delete mode 100644 vendor/github.com/rs/zerolog/_config.yml delete mode 100644 vendor/github.com/rs/zerolog/array.go delete mode 100644 vendor/github.com/rs/zerolog/console.go delete mode 100644 vendor/github.com/rs/zerolog/context.go delete mode 100644 vendor/github.com/rs/zerolog/ctx.go delete mode 100644 vendor/github.com/rs/zerolog/encoder.go delete mode 100644 vendor/github.com/rs/zerolog/encoder_cbor.go delete mode 100644 vendor/github.com/rs/zerolog/encoder_json.go delete mode 100644 vendor/github.com/rs/zerolog/event.go delete mode 100644 vendor/github.com/rs/zerolog/fields.go delete mode 100644 vendor/github.com/rs/zerolog/globals.go delete mode 100644 vendor/github.com/rs/zerolog/go112.go delete mode 100644 vendor/github.com/rs/zerolog/hook.go delete mode 100644 vendor/github.com/rs/zerolog/internal/cbor/README.md delete mode 100644 vendor/github.com/rs/zerolog/internal/cbor/base.go delete mode 100644 vendor/github.com/rs/zerolog/internal/cbor/cbor.go delete mode 100644 vendor/github.com/rs/zerolog/internal/cbor/decode_stream.go delete mode 100644 vendor/github.com/rs/zerolog/internal/cbor/string.go delete mode 100644 vendor/github.com/rs/zerolog/internal/cbor/time.go delete mode 100644 vendor/github.com/rs/zerolog/internal/cbor/types.go delete mode 100644 vendor/github.com/rs/zerolog/internal/json/base.go delete mode 100644 vendor/github.com/rs/zerolog/internal/json/bytes.go delete mode 100644 vendor/github.com/rs/zerolog/internal/json/string.go delete mode 100644 vendor/github.com/rs/zerolog/internal/json/time.go delete mode 100644 vendor/github.com/rs/zerolog/internal/json/types.go delete mode 100644 vendor/github.com/rs/zerolog/log.go delete mode 100644 vendor/github.com/rs/zerolog/log/log.go delete mode 100644 vendor/github.com/rs/zerolog/not_go112.go delete mode 100644 vendor/github.com/rs/zerolog/pretty.png delete mode 100644 vendor/github.com/rs/zerolog/sampler.go delete mode 100644 vendor/github.com/rs/zerolog/syslog.go delete mode 100644 vendor/github.com/rs/zerolog/writer.go delete mode 100644 vendor/github.com/russross/blackfriday/v2/.gitignore delete mode 100644 vendor/github.com/russross/blackfriday/v2/.travis.yml delete mode 100644 vendor/github.com/russross/blackfriday/v2/LICENSE.txt delete mode 100644 vendor/github.com/russross/blackfriday/v2/README.md delete mode 100644 vendor/github.com/russross/blackfriday/v2/block.go delete mode 100644 vendor/github.com/russross/blackfriday/v2/doc.go delete mode 100644 vendor/github.com/russross/blackfriday/v2/entities.go delete mode 100644 vendor/github.com/russross/blackfriday/v2/esc.go delete mode 100644 vendor/github.com/russross/blackfriday/v2/html.go delete mode 100644 vendor/github.com/russross/blackfriday/v2/inline.go delete mode 100644 vendor/github.com/russross/blackfriday/v2/markdown.go delete mode 100644 vendor/github.com/russross/blackfriday/v2/node.go delete mode 100644 vendor/github.com/russross/blackfriday/v2/smartypants.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/LICENSE delete mode 100644 vendor/github.com/shirou/gopsutil/v4/common/env.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_aix.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_aix_cgo.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_aix_nocgo.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_darwin.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_darwin_arm64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_darwin_fallback.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_dragonfly.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_dragonfly_amd64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_fallback.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_freebsd.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_freebsd_386.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_freebsd_amd64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_freebsd_arm.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_freebsd_arm64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_linux.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_netbsd.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_netbsd_amd64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_netbsd_arm.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_netbsd_arm64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_openbsd.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_openbsd_386.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_openbsd_amd64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_openbsd_arm.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_openbsd_arm64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_openbsd_riscv64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_plan9.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_solaris.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/cpu/cpu_windows.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/internal/common/common.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/internal/common/common_aix.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/internal/common/common_darwin.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/internal/common/common_freebsd.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/internal/common/common_linux.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/internal/common/common_netbsd.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/internal/common/common_openbsd.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/internal/common/common_unix.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/internal/common/common_windows.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/internal/common/endian.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/internal/common/readlink_linux.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/internal/common/sleep.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/internal/common/warnings.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/ex_linux.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/ex_windows.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem_aix.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem_aix_cgo.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem_aix_nocgo.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem_bsd.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem_darwin.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem_fallback.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem_freebsd.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem_linux.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem_netbsd.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem_openbsd.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem_openbsd_386.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem_openbsd_amd64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem_openbsd_arm.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem_openbsd_arm64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem_openbsd_riscv64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem_plan9.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem_solaris.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/mem/mem_windows.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/net/net.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/net/net_aix.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/net/net_aix_cgo.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/net/net_aix_nocgo.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/net/net_darwin.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/net/net_fallback.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/net/net_freebsd.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/net/net_linux.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/net/net_openbsd.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/net/net_solaris.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/net/net_unix.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/net/net_windows.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_bsd.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_darwin.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_darwin_amd64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_darwin_arm64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_fallback.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_freebsd.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_freebsd_386.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_freebsd_amd64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_freebsd_arm.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_freebsd_arm64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_linux.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_openbsd.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_openbsd_386.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_openbsd_amd64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_openbsd_arm.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_openbsd_arm64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_openbsd_riscv64.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_plan9.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_posix.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_solaris.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_windows.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_windows_32bit.go delete mode 100644 vendor/github.com/shirou/gopsutil/v4/process/process_windows_64bit.go delete mode 100644 vendor/github.com/stretchr/testify/LICENSE delete mode 100644 vendor/github.com/stretchr/testify/assert/assertion_compare.go delete mode 100644 vendor/github.com/stretchr/testify/assert/assertion_format.go delete mode 100644 vendor/github.com/stretchr/testify/assert/assertion_format.go.tmpl delete mode 100644 vendor/github.com/stretchr/testify/assert/assertion_forward.go delete mode 100644 vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl delete mode 100644 vendor/github.com/stretchr/testify/assert/assertion_order.go delete mode 100644 vendor/github.com/stretchr/testify/assert/assertions.go delete mode 100644 vendor/github.com/stretchr/testify/assert/doc.go delete mode 100644 vendor/github.com/stretchr/testify/assert/errors.go delete mode 100644 vendor/github.com/stretchr/testify/assert/forward_assertions.go delete mode 100644 vendor/github.com/stretchr/testify/assert/http_assertions.go delete mode 100644 vendor/github.com/stretchr/testify/assert/yaml/yaml_custom.go delete mode 100644 vendor/github.com/stretchr/testify/assert/yaml/yaml_default.go delete mode 100644 vendor/github.com/stretchr/testify/assert/yaml/yaml_fail.go delete mode 100644 vendor/github.com/stretchr/testify/require/doc.go delete mode 100644 vendor/github.com/stretchr/testify/require/forward_requirements.go delete mode 100644 vendor/github.com/stretchr/testify/require/require.go delete mode 100644 vendor/github.com/stretchr/testify/require/require.go.tmpl delete mode 100644 vendor/github.com/stretchr/testify/require/require_forward.go delete mode 100644 vendor/github.com/stretchr/testify/require/require_forward.go.tmpl delete mode 100644 vendor/github.com/stretchr/testify/require/requirements.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/.cirrus.yml delete mode 100644 vendor/github.com/tklauser/go-sysconf/.gitignore delete mode 100644 vendor/github.com/tklauser/go-sysconf/LICENSE delete mode 100644 vendor/github.com/tklauser/go-sysconf/README.md delete mode 100644 vendor/github.com/tklauser/go-sysconf/sysconf.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/sysconf_bsd.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/sysconf_darwin.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/sysconf_dragonfly.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/sysconf_freebsd.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/sysconf_generic.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/sysconf_linux.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/sysconf_netbsd.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/sysconf_openbsd.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/sysconf_posix.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/sysconf_solaris.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/sysconf_unsupported.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_defs_darwin.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_defs_dragonfly.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_defs_freebsd.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_defs_linux.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_defs_netbsd.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_defs_openbsd.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_defs_solaris.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_386.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_amd64.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_arm.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_arm64.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_freebsd_riscv64.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_386.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_amd64.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_arm.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_arm64.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_loong64.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mips.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mips64.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mips64le.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_mipsle.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_ppc64.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_ppc64le.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_riscv64.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_linux_s390x.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_386.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_amd64.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_arm.go delete mode 100644 vendor/github.com/tklauser/go-sysconf/zsysconf_values_netbsd_arm64.go delete mode 100644 vendor/github.com/tklauser/numcpus/.cirrus.yml delete mode 100644 vendor/github.com/tklauser/numcpus/LICENSE delete mode 100644 vendor/github.com/tklauser/numcpus/README.md delete mode 100644 vendor/github.com/tklauser/numcpus/numcpus.go delete mode 100644 vendor/github.com/tklauser/numcpus/numcpus_bsd.go delete mode 100644 vendor/github.com/tklauser/numcpus/numcpus_linux.go delete mode 100644 vendor/github.com/tklauser/numcpus/numcpus_list_unsupported.go delete mode 100644 vendor/github.com/tklauser/numcpus/numcpus_solaris.go delete mode 100644 vendor/github.com/tklauser/numcpus/numcpus_unsupported.go delete mode 100644 vendor/github.com/tklauser/numcpus/numcpus_windows.go delete mode 100644 vendor/github.com/urfave/cli/v2/.flake8 delete mode 100644 vendor/github.com/urfave/cli/v2/.gitignore delete mode 100644 vendor/github.com/urfave/cli/v2/CODE_OF_CONDUCT.md delete mode 100644 vendor/github.com/urfave/cli/v2/LICENSE delete mode 100644 vendor/github.com/urfave/cli/v2/README.md delete mode 100644 vendor/github.com/urfave/cli/v2/altsrc/default_input_source.go delete mode 100644 vendor/github.com/urfave/cli/v2/altsrc/fg.py delete mode 100644 vendor/github.com/urfave/cli/v2/altsrc/flag.go delete mode 100644 vendor/github.com/urfave/cli/v2/altsrc/flag_generated.go delete mode 100644 vendor/github.com/urfave/cli/v2/altsrc/input_source_context.go delete mode 100644 vendor/github.com/urfave/cli/v2/altsrc/json_source_context.go delete mode 100644 vendor/github.com/urfave/cli/v2/altsrc/map_input_source.go delete mode 100644 vendor/github.com/urfave/cli/v2/altsrc/toml_file_loader.go delete mode 100644 vendor/github.com/urfave/cli/v2/altsrc/yaml_file_loader.go delete mode 100644 vendor/github.com/urfave/cli/v2/app.go delete mode 100644 vendor/github.com/urfave/cli/v2/args.go delete mode 100644 vendor/github.com/urfave/cli/v2/category.go delete mode 100644 vendor/github.com/urfave/cli/v2/cli.go delete mode 100644 vendor/github.com/urfave/cli/v2/command.go delete mode 100644 vendor/github.com/urfave/cli/v2/context.go delete mode 100644 vendor/github.com/urfave/cli/v2/docs.go delete mode 100644 vendor/github.com/urfave/cli/v2/errors.go delete mode 100644 vendor/github.com/urfave/cli/v2/fish.go delete mode 100644 vendor/github.com/urfave/cli/v2/flag.go delete mode 100644 vendor/github.com/urfave/cli/v2/flag_bool.go delete mode 100644 vendor/github.com/urfave/cli/v2/flag_duration.go delete mode 100644 vendor/github.com/urfave/cli/v2/flag_float64.go delete mode 100644 vendor/github.com/urfave/cli/v2/flag_float64_slice.go delete mode 100644 vendor/github.com/urfave/cli/v2/flag_generic.go delete mode 100644 vendor/github.com/urfave/cli/v2/flag_int.go delete mode 100644 vendor/github.com/urfave/cli/v2/flag_int64.go delete mode 100644 vendor/github.com/urfave/cli/v2/flag_int64_slice.go delete mode 100644 vendor/github.com/urfave/cli/v2/flag_int_slice.go delete mode 100644 vendor/github.com/urfave/cli/v2/flag_path.go delete mode 100644 vendor/github.com/urfave/cli/v2/flag_string.go delete mode 100644 vendor/github.com/urfave/cli/v2/flag_string_slice.go delete mode 100644 vendor/github.com/urfave/cli/v2/flag_timestamp.go delete mode 100644 vendor/github.com/urfave/cli/v2/flag_uint.go delete mode 100644 vendor/github.com/urfave/cli/v2/flag_uint64.go delete mode 100644 vendor/github.com/urfave/cli/v2/funcs.go delete mode 100644 vendor/github.com/urfave/cli/v2/help.go delete mode 100644 vendor/github.com/urfave/cli/v2/parse.go delete mode 100644 vendor/github.com/urfave/cli/v2/sort.go delete mode 100644 vendor/github.com/urfave/cli/v2/template.go delete mode 100644 vendor/github.com/yusufpapurcu/wmi/LICENSE delete mode 100644 vendor/github.com/yusufpapurcu/wmi/README.md delete mode 100644 vendor/github.com/yusufpapurcu/wmi/swbemservices.go delete mode 100644 vendor/github.com/yusufpapurcu/wmi/wmi.go delete mode 100644 vendor/go.opentelemetry.io/auto/sdk/CONTRIBUTING.md delete mode 100644 vendor/go.opentelemetry.io/auto/sdk/LICENSE delete mode 100644 vendor/go.opentelemetry.io/auto/sdk/VERSIONING.md delete mode 100644 vendor/go.opentelemetry.io/auto/sdk/doc.go delete mode 100644 vendor/go.opentelemetry.io/auto/sdk/internal/telemetry/attr.go delete mode 100644 vendor/go.opentelemetry.io/auto/sdk/internal/telemetry/doc.go delete mode 100644 vendor/go.opentelemetry.io/auto/sdk/internal/telemetry/id.go delete mode 100644 vendor/go.opentelemetry.io/auto/sdk/internal/telemetry/number.go delete mode 100644 vendor/go.opentelemetry.io/auto/sdk/internal/telemetry/resource.go delete mode 100644 vendor/go.opentelemetry.io/auto/sdk/internal/telemetry/scope.go delete mode 100644 vendor/go.opentelemetry.io/auto/sdk/internal/telemetry/span.go delete mode 100644 vendor/go.opentelemetry.io/auto/sdk/internal/telemetry/status.go delete mode 100644 vendor/go.opentelemetry.io/auto/sdk/internal/telemetry/traces.go delete mode 100644 vendor/go.opentelemetry.io/auto/sdk/internal/telemetry/value.go delete mode 100644 vendor/go.opentelemetry.io/auto/sdk/limit.go delete mode 100644 vendor/go.opentelemetry.io/auto/sdk/span.go delete mode 100644 vendor/go.opentelemetry.io/auto/sdk/tracer.go delete mode 100644 vendor/go.opentelemetry.io/auto/sdk/tracer_provider.go delete mode 100644 vendor/go.opentelemetry.io/contrib/propagators/LICENSE delete mode 100644 vendor/go.opentelemetry.io/contrib/propagators/jaeger/context.go delete mode 100644 vendor/go.opentelemetry.io/contrib/propagators/jaeger/doc.go delete mode 100644 vendor/go.opentelemetry.io/contrib/propagators/jaeger/jaeger_propagator.go delete mode 100644 vendor/go.opentelemetry.io/otel/.clomonitor.yml delete mode 100644 vendor/go.opentelemetry.io/otel/.codespellignore delete mode 100644 vendor/go.opentelemetry.io/otel/.codespellrc delete mode 100644 vendor/go.opentelemetry.io/otel/.gitattributes delete mode 100644 vendor/go.opentelemetry.io/otel/.gitignore delete mode 100644 vendor/go.opentelemetry.io/otel/.golangci.yml delete mode 100644 vendor/go.opentelemetry.io/otel/.lycheeignore delete mode 100644 vendor/go.opentelemetry.io/otel/.markdownlint.yaml delete mode 100644 vendor/go.opentelemetry.io/otel/AGENTS.md delete mode 100644 vendor/go.opentelemetry.io/otel/CHANGELOG.md delete mode 100644 vendor/go.opentelemetry.io/otel/CLAUDE.md delete mode 100644 vendor/go.opentelemetry.io/otel/CODEOWNERS delete mode 100644 vendor/go.opentelemetry.io/otel/CONTRIBUTING.md delete mode 100644 vendor/go.opentelemetry.io/otel/LICENSE delete mode 100644 vendor/go.opentelemetry.io/otel/Makefile delete mode 100644 vendor/go.opentelemetry.io/otel/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/RELEASING.md delete mode 100644 vendor/go.opentelemetry.io/otel/SECURITY-INSIGHTS.yml delete mode 100644 vendor/go.opentelemetry.io/otel/VERSIONING.md delete mode 100644 vendor/go.opentelemetry.io/otel/attribute/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/attribute/doc.go delete mode 100644 vendor/go.opentelemetry.io/otel/attribute/encoder.go delete mode 100644 vendor/go.opentelemetry.io/otel/attribute/filter.go delete mode 100644 vendor/go.opentelemetry.io/otel/attribute/hash.go delete mode 100644 vendor/go.opentelemetry.io/otel/attribute/internal/attribute.go delete mode 100644 vendor/go.opentelemetry.io/otel/attribute/internal/xxhash/xxhash.go delete mode 100644 vendor/go.opentelemetry.io/otel/attribute/iterator.go delete mode 100644 vendor/go.opentelemetry.io/otel/attribute/key.go delete mode 100644 vendor/go.opentelemetry.io/otel/attribute/kv.go delete mode 100644 vendor/go.opentelemetry.io/otel/attribute/rawhelpers.go delete mode 100644 vendor/go.opentelemetry.io/otel/attribute/set.go delete mode 100644 vendor/go.opentelemetry.io/otel/attribute/type_string.go delete mode 100644 vendor/go.opentelemetry.io/otel/attribute/value.go delete mode 100644 vendor/go.opentelemetry.io/otel/baggage/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/baggage/baggage.go delete mode 100644 vendor/go.opentelemetry.io/otel/baggage/context.go delete mode 100644 vendor/go.opentelemetry.io/otel/baggage/doc.go delete mode 100644 vendor/go.opentelemetry.io/otel/codes/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/codes/codes.go delete mode 100644 vendor/go.opentelemetry.io/otel/codes/doc.go delete mode 100644 vendor/go.opentelemetry.io/otel/dependencies.Dockerfile delete mode 100644 vendor/go.opentelemetry.io/otel/doc.go delete mode 100644 vendor/go.opentelemetry.io/otel/error_handler.go delete mode 100644 vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/LICENSE delete mode 100644 vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/clients.go delete mode 100644 vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/doc.go delete mode 100644 vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/exporter.go delete mode 100644 vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/attribute.go delete mode 100644 vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/instrumentation.go delete mode 100644 vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/resource.go delete mode 100644 vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/span.go delete mode 100644 vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/version.go delete mode 100644 vendor/go.opentelemetry.io/otel/handler.go delete mode 100644 vendor/go.opentelemetry.io/otel/internal/baggage/baggage.go delete mode 100644 vendor/go.opentelemetry.io/otel/internal/baggage/context.go delete mode 100644 vendor/go.opentelemetry.io/otel/internal/errorhandler/errorhandler.go delete mode 100644 vendor/go.opentelemetry.io/otel/internal/global/handler.go delete mode 100644 vendor/go.opentelemetry.io/otel/internal/global/instruments.go delete mode 100644 vendor/go.opentelemetry.io/otel/internal/global/internal_logging.go delete mode 100644 vendor/go.opentelemetry.io/otel/internal/global/meter.go delete mode 100644 vendor/go.opentelemetry.io/otel/internal/global/propagator.go delete mode 100644 vendor/go.opentelemetry.io/otel/internal/global/state.go delete mode 100644 vendor/go.opentelemetry.io/otel/internal/global/trace.go delete mode 100644 vendor/go.opentelemetry.io/otel/internal_logging.go delete mode 100644 vendor/go.opentelemetry.io/otel/metric.go delete mode 100644 vendor/go.opentelemetry.io/otel/metric/LICENSE delete mode 100644 vendor/go.opentelemetry.io/otel/metric/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/metric/asyncfloat64.go delete mode 100644 vendor/go.opentelemetry.io/otel/metric/asyncint64.go delete mode 100644 vendor/go.opentelemetry.io/otel/metric/config.go delete mode 100644 vendor/go.opentelemetry.io/otel/metric/doc.go delete mode 100644 vendor/go.opentelemetry.io/otel/metric/embedded/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/metric/embedded/embedded.go delete mode 100644 vendor/go.opentelemetry.io/otel/metric/instrument.go delete mode 100644 vendor/go.opentelemetry.io/otel/metric/meter.go delete mode 100644 vendor/go.opentelemetry.io/otel/metric/noop/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/metric/noop/noop.go delete mode 100644 vendor/go.opentelemetry.io/otel/metric/syncfloat64.go delete mode 100644 vendor/go.opentelemetry.io/otel/metric/syncint64.go delete mode 100644 vendor/go.opentelemetry.io/otel/propagation.go delete mode 100644 vendor/go.opentelemetry.io/otel/propagation/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/propagation/baggage.go delete mode 100644 vendor/go.opentelemetry.io/otel/propagation/doc.go delete mode 100644 vendor/go.opentelemetry.io/otel/propagation/propagation.go delete mode 100644 vendor/go.opentelemetry.io/otel/propagation/trace_context.go delete mode 100644 vendor/go.opentelemetry.io/otel/renovate.json delete mode 100644 vendor/go.opentelemetry.io/otel/requirements.txt delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/LICENSE delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/instrumentation/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/instrumentation/doc.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/instrumentation/library.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/instrumentation/scope.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/internal/x/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/internal/x/features.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/internal/x/x.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/auto.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/builtin.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/config.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/container.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/doc.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/env.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/host_id.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/host_id_bsd.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/host_id_darwin.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/host_id_exec.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/host_id_linux.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/host_id_readfile.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/host_id_unsupported.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/host_id_windows.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/os.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/os_release_darwin.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/os_release_unix.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/os_unix.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/os_unsupported.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/os_windows.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/process.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/resource/resource.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/batch_span_processor.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/doc.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/event.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/evictedqueue.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/id_generator.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/internal/env/env.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/batch_span_processor.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/doc.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/simple_span_processor.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/tracer.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/link.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/provider.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/sampler_env.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/sampling.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/simple_span_processor.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/snapshot.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/span.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/span_exporter.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/span_limits.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/span_processor.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/trace/tracer.go delete mode 100644 vendor/go.opentelemetry.io/otel/sdk/version.go delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/internal/http.go delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.37.0/MIGRATION.md delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.37.0/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.37.0/attribute_group.go delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.37.0/doc.go delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.37.0/error_type.go delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.37.0/exception.go delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.37.0/schema.go delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.41.0/MIGRATION.md delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.41.0/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.41.0/attribute_group.go delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.41.0/doc.go delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.41.0/error_type.go delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.41.0/exception.go delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.41.0/otelconv/metric.go delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.41.0/schema.go delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.7.0/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.7.0/doc.go delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.7.0/exception.go delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.7.0/http.go delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.7.0/resource.go delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.7.0/schema.go delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.7.0/trace.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/LICENSE delete mode 100644 vendor/go.opentelemetry.io/otel/trace/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/trace/auto.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/config.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/context.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/doc.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/embedded/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/trace/embedded/embedded.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/hex.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/internal/telemetry/attr.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/internal/telemetry/doc.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/internal/telemetry/id.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/internal/telemetry/number.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/internal/telemetry/resource.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/internal/telemetry/scope.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/internal/telemetry/span.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/internal/telemetry/status.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/internal/telemetry/traces.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/internal/telemetry/value.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/nonrecording.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/noop.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/noop/README.md delete mode 100644 vendor/go.opentelemetry.io/otel/trace/noop/noop.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/provider.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/span.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/trace.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/tracer.go delete mode 100644 vendor/go.opentelemetry.io/otel/trace/tracestate.go delete mode 100644 vendor/go.opentelemetry.io/otel/verify_released_changelog.sh delete mode 100644 vendor/go.opentelemetry.io/otel/version.go delete mode 100644 vendor/go.opentelemetry.io/otel/versions.yaml delete mode 100644 vendor/go.opentelemetry.io/proto/otlp/LICENSE delete mode 100644 vendor/go.opentelemetry.io/proto/otlp/collector/trace/v1/trace_service.pb.go delete mode 100644 vendor/go.opentelemetry.io/proto/otlp/collector/trace/v1/trace_service.pb.gw.go delete mode 100644 vendor/go.opentelemetry.io/proto/otlp/collector/trace/v1/trace_service_grpc.pb.go delete mode 100644 vendor/go.opentelemetry.io/proto/otlp/common/v1/common.pb.go delete mode 100644 vendor/go.opentelemetry.io/proto/otlp/resource/v1/resource.pb.go delete mode 100644 vendor/go.opentelemetry.io/proto/otlp/trace/v1/trace.pb.go delete mode 100644 vendor/go.uber.org/automaxprocs/LICENSE delete mode 100644 vendor/go.uber.org/automaxprocs/internal/cgroups/cgroup.go delete mode 100644 vendor/go.uber.org/automaxprocs/internal/cgroups/cgroups.go delete mode 100644 vendor/go.uber.org/automaxprocs/internal/cgroups/cgroups2.go delete mode 100644 vendor/go.uber.org/automaxprocs/internal/cgroups/doc.go delete mode 100644 vendor/go.uber.org/automaxprocs/internal/cgroups/errors.go delete mode 100644 vendor/go.uber.org/automaxprocs/internal/cgroups/mountpoint.go delete mode 100644 vendor/go.uber.org/automaxprocs/internal/cgroups/subsys.go delete mode 100644 vendor/go.uber.org/automaxprocs/internal/runtime/cpu_quota_linux.go delete mode 100644 vendor/go.uber.org/automaxprocs/internal/runtime/cpu_quota_unsupported.go delete mode 100644 vendor/go.uber.org/automaxprocs/internal/runtime/runtime.go delete mode 100644 vendor/go.uber.org/automaxprocs/maxprocs/maxprocs.go delete mode 100644 vendor/go.uber.org/automaxprocs/maxprocs/version.go delete mode 100644 vendor/go.uber.org/mock/AUTHORS delete mode 100644 vendor/go.uber.org/mock/LICENSE delete mode 100644 vendor/go.uber.org/mock/gomock/call.go delete mode 100644 vendor/go.uber.org/mock/gomock/callset.go delete mode 100644 vendor/go.uber.org/mock/gomock/controller.go delete mode 100644 vendor/go.uber.org/mock/gomock/doc.go delete mode 100644 vendor/go.uber.org/mock/gomock/matchers.go delete mode 100644 vendor/go.uber.org/mock/gomock/string.go delete mode 100644 vendor/golang.org/x/crypto/LICENSE delete mode 100644 vendor/golang.org/x/crypto/PATENTS delete mode 100644 vendor/golang.org/x/crypto/blake2b/blake2b.go delete mode 100644 vendor/golang.org/x/crypto/blake2b/blake2bAVX2_amd64.go delete mode 100644 vendor/golang.org/x/crypto/blake2b/blake2bAVX2_amd64.s delete mode 100644 vendor/golang.org/x/crypto/blake2b/blake2b_amd64.s delete mode 100644 vendor/golang.org/x/crypto/blake2b/blake2b_generic.go delete mode 100644 vendor/golang.org/x/crypto/blake2b/blake2b_ref.go delete mode 100644 vendor/golang.org/x/crypto/blake2b/blake2x.go delete mode 100644 vendor/golang.org/x/crypto/blake2b/register.go delete mode 100644 vendor/golang.org/x/crypto/blowfish/block.go delete mode 100644 vendor/golang.org/x/crypto/blowfish/cipher.go delete mode 100644 vendor/golang.org/x/crypto/blowfish/const.go delete mode 100644 vendor/golang.org/x/crypto/chacha20/chacha_arm64.go delete mode 100644 vendor/golang.org/x/crypto/chacha20/chacha_arm64.s delete mode 100644 vendor/golang.org/x/crypto/chacha20/chacha_generic.go delete mode 100644 vendor/golang.org/x/crypto/chacha20/chacha_noasm.go delete mode 100644 vendor/golang.org/x/crypto/chacha20/chacha_ppc64x.go delete mode 100644 vendor/golang.org/x/crypto/chacha20/chacha_ppc64x.s delete mode 100644 vendor/golang.org/x/crypto/chacha20/chacha_s390x.go delete mode 100644 vendor/golang.org/x/crypto/chacha20/chacha_s390x.s delete mode 100644 vendor/golang.org/x/crypto/chacha20/xor.go delete mode 100644 vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305.go delete mode 100644 vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_amd64.go delete mode 100644 vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_amd64.s delete mode 100644 vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_generic.go delete mode 100644 vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_noasm.go delete mode 100644 vendor/golang.org/x/crypto/chacha20poly1305/fips140only_compat.go delete mode 100644 vendor/golang.org/x/crypto/chacha20poly1305/fips140only_go1.26.go delete mode 100644 vendor/golang.org/x/crypto/chacha20poly1305/xchacha20poly1305.go delete mode 100644 vendor/golang.org/x/crypto/cryptobyte/asn1.go delete mode 100644 vendor/golang.org/x/crypto/cryptobyte/asn1/asn1.go delete mode 100644 vendor/golang.org/x/crypto/cryptobyte/builder.go delete mode 100644 vendor/golang.org/x/crypto/cryptobyte/string.go delete mode 100644 vendor/golang.org/x/crypto/curve25519/curve25519.go delete mode 100644 vendor/golang.org/x/crypto/hkdf/hkdf.go delete mode 100644 vendor/golang.org/x/crypto/internal/alias/alias.go delete mode 100644 vendor/golang.org/x/crypto/internal/alias/alias_purego.go delete mode 100644 vendor/golang.org/x/crypto/internal/poly1305/mac_noasm.go delete mode 100644 vendor/golang.org/x/crypto/internal/poly1305/poly1305.go delete mode 100644 vendor/golang.org/x/crypto/internal/poly1305/sum_amd64.s delete mode 100644 vendor/golang.org/x/crypto/internal/poly1305/sum_asm.go delete mode 100644 vendor/golang.org/x/crypto/internal/poly1305/sum_generic.go delete mode 100644 vendor/golang.org/x/crypto/internal/poly1305/sum_loong64.s delete mode 100644 vendor/golang.org/x/crypto/internal/poly1305/sum_ppc64x.s delete mode 100644 vendor/golang.org/x/crypto/internal/poly1305/sum_s390x.go delete mode 100644 vendor/golang.org/x/crypto/internal/poly1305/sum_s390x.s delete mode 100644 vendor/golang.org/x/crypto/nacl/box/box.go delete mode 100644 vendor/golang.org/x/crypto/nacl/secretbox/secretbox.go delete mode 100644 vendor/golang.org/x/crypto/salsa20/salsa/hsalsa20.go delete mode 100644 vendor/golang.org/x/crypto/salsa20/salsa/salsa208.go delete mode 100644 vendor/golang.org/x/crypto/salsa20/salsa/salsa20_amd64.go delete mode 100644 vendor/golang.org/x/crypto/salsa20/salsa/salsa20_amd64.s delete mode 100644 vendor/golang.org/x/crypto/salsa20/salsa/salsa20_noasm.go delete mode 100644 vendor/golang.org/x/crypto/salsa20/salsa/salsa20_ref.go delete mode 100644 vendor/golang.org/x/crypto/ssh/buffer.go delete mode 100644 vendor/golang.org/x/crypto/ssh/certs.go delete mode 100644 vendor/golang.org/x/crypto/ssh/channel.go delete mode 100644 vendor/golang.org/x/crypto/ssh/cipher.go delete mode 100644 vendor/golang.org/x/crypto/ssh/client.go delete mode 100644 vendor/golang.org/x/crypto/ssh/client_auth.go delete mode 100644 vendor/golang.org/x/crypto/ssh/common.go delete mode 100644 vendor/golang.org/x/crypto/ssh/connection.go delete mode 100644 vendor/golang.org/x/crypto/ssh/control.go delete mode 100644 vendor/golang.org/x/crypto/ssh/doc.go delete mode 100644 vendor/golang.org/x/crypto/ssh/handshake.go delete mode 100644 vendor/golang.org/x/crypto/ssh/internal/bcrypt_pbkdf/bcrypt_pbkdf.go delete mode 100644 vendor/golang.org/x/crypto/ssh/kex.go delete mode 100644 vendor/golang.org/x/crypto/ssh/keys.go delete mode 100644 vendor/golang.org/x/crypto/ssh/mac.go delete mode 100644 vendor/golang.org/x/crypto/ssh/messages.go delete mode 100644 vendor/golang.org/x/crypto/ssh/mlkem.go delete mode 100644 vendor/golang.org/x/crypto/ssh/mux.go delete mode 100644 vendor/golang.org/x/crypto/ssh/server.go delete mode 100644 vendor/golang.org/x/crypto/ssh/session.go delete mode 100644 vendor/golang.org/x/crypto/ssh/ssh_gss.go delete mode 100644 vendor/golang.org/x/crypto/ssh/streamlocal.go delete mode 100644 vendor/golang.org/x/crypto/ssh/tcpip.go delete mode 100644 vendor/golang.org/x/crypto/ssh/transport.go delete mode 100644 vendor/golang.org/x/net/LICENSE delete mode 100644 vendor/golang.org/x/net/PATENTS delete mode 100644 vendor/golang.org/x/net/bpf/asm.go delete mode 100644 vendor/golang.org/x/net/bpf/constants.go delete mode 100644 vendor/golang.org/x/net/bpf/doc.go delete mode 100644 vendor/golang.org/x/net/bpf/instructions.go delete mode 100644 vendor/golang.org/x/net/bpf/setter.go delete mode 100644 vendor/golang.org/x/net/bpf/vm.go delete mode 100644 vendor/golang.org/x/net/bpf/vm_instructions.go delete mode 100644 vendor/golang.org/x/net/context/context.go delete mode 100644 vendor/golang.org/x/net/http/httpguts/guts.go delete mode 100644 vendor/golang.org/x/net/http/httpguts/httplex.go delete mode 100644 vendor/golang.org/x/net/http2/.gitignore delete mode 100644 vendor/golang.org/x/net/http2/README.md delete mode 100644 vendor/golang.org/x/net/http2/ascii.go delete mode 100644 vendor/golang.org/x/net/http2/ciphers.go delete mode 100644 vendor/golang.org/x/net/http2/client_conn_pool.go delete mode 100644 vendor/golang.org/x/net/http2/client_priority_go126.go delete mode 100644 vendor/golang.org/x/net/http2/client_priority_go127.go delete mode 100644 vendor/golang.org/x/net/http2/clientconn.go delete mode 100644 vendor/golang.org/x/net/http2/config.go delete mode 100644 vendor/golang.org/x/net/http2/config_go125.go delete mode 100644 vendor/golang.org/x/net/http2/config_go126.go delete mode 100644 vendor/golang.org/x/net/http2/databuffer.go delete mode 100644 vendor/golang.org/x/net/http2/errors.go delete mode 100644 vendor/golang.org/x/net/http2/flow.go delete mode 100644 vendor/golang.org/x/net/http2/frame.go delete mode 100644 vendor/golang.org/x/net/http2/gotrack.go delete mode 100644 vendor/golang.org/x/net/http2/hpack/encode.go delete mode 100644 vendor/golang.org/x/net/http2/hpack/hpack.go delete mode 100644 vendor/golang.org/x/net/http2/hpack/huffman.go delete mode 100644 vendor/golang.org/x/net/http2/hpack/static_table.go delete mode 100644 vendor/golang.org/x/net/http2/hpack/tables.go delete mode 100644 vendor/golang.org/x/net/http2/http2.go delete mode 100644 vendor/golang.org/x/net/http2/pipe.go delete mode 100644 vendor/golang.org/x/net/http2/server.go delete mode 100644 vendor/golang.org/x/net/http2/server_common.go delete mode 100644 vendor/golang.org/x/net/http2/server_wrap.go delete mode 100644 vendor/golang.org/x/net/http2/transport.go delete mode 100644 vendor/golang.org/x/net/http2/transport_common.go delete mode 100644 vendor/golang.org/x/net/http2/transport_wrap.go delete mode 100644 vendor/golang.org/x/net/http2/unencrypted.go delete mode 100644 vendor/golang.org/x/net/http2/write.go delete mode 100644 vendor/golang.org/x/net/http2/writesched.go delete mode 100644 vendor/golang.org/x/net/http2/writesched_common.go delete mode 100644 vendor/golang.org/x/net/http2/writesched_priority_rfc7540.go delete mode 100644 vendor/golang.org/x/net/http2/writesched_priority_rfc9218.go delete mode 100644 vendor/golang.org/x/net/http2/writesched_random.go delete mode 100644 vendor/golang.org/x/net/http2/writesched_roundrobin.go delete mode 100644 vendor/golang.org/x/net/icmp/dstunreach.go delete mode 100644 vendor/golang.org/x/net/icmp/echo.go delete mode 100644 vendor/golang.org/x/net/icmp/endpoint.go delete mode 100644 vendor/golang.org/x/net/icmp/extension.go delete mode 100644 vendor/golang.org/x/net/icmp/helper_posix.go delete mode 100644 vendor/golang.org/x/net/icmp/interface.go delete mode 100644 vendor/golang.org/x/net/icmp/ipv4.go delete mode 100644 vendor/golang.org/x/net/icmp/ipv6.go delete mode 100644 vendor/golang.org/x/net/icmp/listen_posix.go delete mode 100644 vendor/golang.org/x/net/icmp/listen_stub.go delete mode 100644 vendor/golang.org/x/net/icmp/message.go delete mode 100644 vendor/golang.org/x/net/icmp/messagebody.go delete mode 100644 vendor/golang.org/x/net/icmp/mpls.go delete mode 100644 vendor/golang.org/x/net/icmp/multipart.go delete mode 100644 vendor/golang.org/x/net/icmp/packettoobig.go delete mode 100644 vendor/golang.org/x/net/icmp/paramprob.go delete mode 100644 vendor/golang.org/x/net/icmp/sys_freebsd.go delete mode 100644 vendor/golang.org/x/net/icmp/timeexceeded.go delete mode 100644 vendor/golang.org/x/net/idna/idna.go delete mode 100644 vendor/golang.org/x/net/idna/punycode.go delete mode 100644 vendor/golang.org/x/net/idna/tables15.0.0.go delete mode 100644 vendor/golang.org/x/net/idna/tables17.0.0.go delete mode 100644 vendor/golang.org/x/net/idna/trie.go delete mode 100644 vendor/golang.org/x/net/idna/trieval.go delete mode 100644 vendor/golang.org/x/net/internal/httpcommon/ascii.go delete mode 100644 vendor/golang.org/x/net/internal/httpcommon/headermap.go delete mode 100644 vendor/golang.org/x/net/internal/httpcommon/request.go delete mode 100644 vendor/golang.org/x/net/internal/httpsfv/httpsfv.go delete mode 100644 vendor/golang.org/x/net/internal/iana/const.go delete mode 100644 vendor/golang.org/x/net/internal/socket/cmsghdr.go delete mode 100644 vendor/golang.org/x/net/internal/socket/cmsghdr_bsd.go delete mode 100644 vendor/golang.org/x/net/internal/socket/cmsghdr_linux_32bit.go delete mode 100644 vendor/golang.org/x/net/internal/socket/cmsghdr_linux_64bit.go delete mode 100644 vendor/golang.org/x/net/internal/socket/cmsghdr_solaris_64bit.go delete mode 100644 vendor/golang.org/x/net/internal/socket/cmsghdr_stub.go delete mode 100644 vendor/golang.org/x/net/internal/socket/cmsghdr_unix.go delete mode 100644 vendor/golang.org/x/net/internal/socket/cmsghdr_zos_s390x.go delete mode 100644 vendor/golang.org/x/net/internal/socket/complete_dontwait.go delete mode 100644 vendor/golang.org/x/net/internal/socket/complete_nodontwait.go delete mode 100644 vendor/golang.org/x/net/internal/socket/empty.s delete mode 100644 vendor/golang.org/x/net/internal/socket/error_unix.go delete mode 100644 vendor/golang.org/x/net/internal/socket/error_windows.go delete mode 100644 vendor/golang.org/x/net/internal/socket/iovec_32bit.go delete mode 100644 vendor/golang.org/x/net/internal/socket/iovec_64bit.go delete mode 100644 vendor/golang.org/x/net/internal/socket/iovec_solaris_64bit.go delete mode 100644 vendor/golang.org/x/net/internal/socket/iovec_stub.go delete mode 100644 vendor/golang.org/x/net/internal/socket/mmsghdr_stub.go delete mode 100644 vendor/golang.org/x/net/internal/socket/mmsghdr_unix.go delete mode 100644 vendor/golang.org/x/net/internal/socket/msghdr_bsd.go delete mode 100644 vendor/golang.org/x/net/internal/socket/msghdr_bsdvar.go delete mode 100644 vendor/golang.org/x/net/internal/socket/msghdr_linux.go delete mode 100644 vendor/golang.org/x/net/internal/socket/msghdr_linux_32bit.go delete mode 100644 vendor/golang.org/x/net/internal/socket/msghdr_linux_64bit.go delete mode 100644 vendor/golang.org/x/net/internal/socket/msghdr_openbsd.go delete mode 100644 vendor/golang.org/x/net/internal/socket/msghdr_solaris_64bit.go delete mode 100644 vendor/golang.org/x/net/internal/socket/msghdr_stub.go delete mode 100644 vendor/golang.org/x/net/internal/socket/msghdr_zos_s390x.go delete mode 100644 vendor/golang.org/x/net/internal/socket/norace.go delete mode 100644 vendor/golang.org/x/net/internal/socket/race.go delete mode 100644 vendor/golang.org/x/net/internal/socket/rawconn.go delete mode 100644 vendor/golang.org/x/net/internal/socket/rawconn_mmsg.go delete mode 100644 vendor/golang.org/x/net/internal/socket/rawconn_msg.go delete mode 100644 vendor/golang.org/x/net/internal/socket/rawconn_nommsg.go delete mode 100644 vendor/golang.org/x/net/internal/socket/rawconn_nomsg.go delete mode 100644 vendor/golang.org/x/net/internal/socket/socket.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_bsd.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_const_unix.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_linux.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_linux_386.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_linux_386.s delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_linux_amd64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_linux_arm.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_linux_arm64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_linux_loong64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_linux_mips.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_linux_mips64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_linux_mips64le.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_linux_mipsle.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_linux_ppc.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_linux_ppc64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_linux_ppc64le.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_linux_riscv64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_linux_s390x.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_linux_s390x.s delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_netbsd.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_posix.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_stub.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_unix.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_windows.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_zos_s390x.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_zos_s390x.s delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_aix_ppc64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_darwin_amd64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_darwin_arm64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_dragonfly_amd64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_freebsd_386.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_freebsd_amd64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_freebsd_arm.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_freebsd_arm64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_freebsd_riscv64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_linux_386.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_linux_amd64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_linux_arm.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_linux_arm64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_linux_loong64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_linux_mips.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_linux_mips64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_linux_mips64le.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_linux_mipsle.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_linux_ppc.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_linux_ppc64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_linux_ppc64le.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_linux_riscv64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_linux_s390x.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_netbsd_386.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_netbsd_amd64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_netbsd_arm.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_netbsd_arm64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_openbsd_386.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_openbsd_amd64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_openbsd_arm.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_openbsd_arm64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_openbsd_mips64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_openbsd_ppc64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_openbsd_riscv64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_solaris_amd64.go delete mode 100644 vendor/golang.org/x/net/internal/socket/zsys_zos_s390x.go delete mode 100644 vendor/golang.org/x/net/internal/socks/client.go delete mode 100644 vendor/golang.org/x/net/internal/socks/socks.go delete mode 100644 vendor/golang.org/x/net/internal/timeseries/timeseries.go delete mode 100644 vendor/golang.org/x/net/ipv4/batch.go delete mode 100644 vendor/golang.org/x/net/ipv4/control.go delete mode 100644 vendor/golang.org/x/net/ipv4/control_bsd.go delete mode 100644 vendor/golang.org/x/net/ipv4/control_pktinfo.go delete mode 100644 vendor/golang.org/x/net/ipv4/control_stub.go delete mode 100644 vendor/golang.org/x/net/ipv4/control_unix.go delete mode 100644 vendor/golang.org/x/net/ipv4/control_windows.go delete mode 100644 vendor/golang.org/x/net/ipv4/control_zos.go delete mode 100644 vendor/golang.org/x/net/ipv4/dgramopt.go delete mode 100644 vendor/golang.org/x/net/ipv4/doc.go delete mode 100644 vendor/golang.org/x/net/ipv4/endpoint.go delete mode 100644 vendor/golang.org/x/net/ipv4/genericopt.go delete mode 100644 vendor/golang.org/x/net/ipv4/header.go delete mode 100644 vendor/golang.org/x/net/ipv4/helper.go delete mode 100644 vendor/golang.org/x/net/ipv4/iana.go delete mode 100644 vendor/golang.org/x/net/ipv4/icmp.go delete mode 100644 vendor/golang.org/x/net/ipv4/icmp_linux.go delete mode 100644 vendor/golang.org/x/net/ipv4/icmp_stub.go delete mode 100644 vendor/golang.org/x/net/ipv4/packet.go delete mode 100644 vendor/golang.org/x/net/ipv4/payload.go delete mode 100644 vendor/golang.org/x/net/ipv4/payload_cmsg.go delete mode 100644 vendor/golang.org/x/net/ipv4/payload_nocmsg.go delete mode 100644 vendor/golang.org/x/net/ipv4/sockopt.go delete mode 100644 vendor/golang.org/x/net/ipv4/sockopt_posix.go delete mode 100644 vendor/golang.org/x/net/ipv4/sockopt_stub.go delete mode 100644 vendor/golang.org/x/net/ipv4/sys_aix.go delete mode 100644 vendor/golang.org/x/net/ipv4/sys_asmreq.go delete mode 100644 vendor/golang.org/x/net/ipv4/sys_asmreq_stub.go delete mode 100644 vendor/golang.org/x/net/ipv4/sys_asmreqn.go delete mode 100644 vendor/golang.org/x/net/ipv4/sys_asmreqn_stub.go delete mode 100644 vendor/golang.org/x/net/ipv4/sys_bpf.go delete mode 100644 vendor/golang.org/x/net/ipv4/sys_bpf_stub.go delete mode 100644 vendor/golang.org/x/net/ipv4/sys_bsd.go delete mode 100644 vendor/golang.org/x/net/ipv4/sys_darwin.go delete mode 100644 vendor/golang.org/x/net/ipv4/sys_dragonfly.go delete mode 100644 vendor/golang.org/x/net/ipv4/sys_freebsd.go delete mode 100644 vendor/golang.org/x/net/ipv4/sys_linux.go delete mode 100644 vendor/golang.org/x/net/ipv4/sys_solaris.go delete mode 100644 vendor/golang.org/x/net/ipv4/sys_ssmreq.go delete mode 100644 vendor/golang.org/x/net/ipv4/sys_ssmreq_stub.go delete mode 100644 vendor/golang.org/x/net/ipv4/sys_stub.go delete mode 100644 vendor/golang.org/x/net/ipv4/sys_windows.go delete mode 100644 vendor/golang.org/x/net/ipv4/sys_zos.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_aix_ppc64.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_darwin.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_dragonfly.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_freebsd_386.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_freebsd_amd64.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_freebsd_arm.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_freebsd_arm64.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_freebsd_riscv64.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_linux_386.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_linux_amd64.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_linux_arm.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_linux_arm64.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_linux_loong64.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_linux_mips.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_linux_mips64.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_linux_mips64le.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_linux_mipsle.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_linux_ppc.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_linux_ppc64.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_linux_ppc64le.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_linux_riscv64.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_linux_s390x.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_netbsd.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_openbsd.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_solaris.go delete mode 100644 vendor/golang.org/x/net/ipv4/zsys_zos_s390x.go delete mode 100644 vendor/golang.org/x/net/ipv6/batch.go delete mode 100644 vendor/golang.org/x/net/ipv6/control.go delete mode 100644 vendor/golang.org/x/net/ipv6/control_rfc2292_unix.go delete mode 100644 vendor/golang.org/x/net/ipv6/control_rfc3542_unix.go delete mode 100644 vendor/golang.org/x/net/ipv6/control_stub.go delete mode 100644 vendor/golang.org/x/net/ipv6/control_unix.go delete mode 100644 vendor/golang.org/x/net/ipv6/control_windows.go delete mode 100644 vendor/golang.org/x/net/ipv6/dgramopt.go delete mode 100644 vendor/golang.org/x/net/ipv6/doc.go delete mode 100644 vendor/golang.org/x/net/ipv6/endpoint.go delete mode 100644 vendor/golang.org/x/net/ipv6/genericopt.go delete mode 100644 vendor/golang.org/x/net/ipv6/header.go delete mode 100644 vendor/golang.org/x/net/ipv6/helper.go delete mode 100644 vendor/golang.org/x/net/ipv6/iana.go delete mode 100644 vendor/golang.org/x/net/ipv6/icmp.go delete mode 100644 vendor/golang.org/x/net/ipv6/icmp_bsd.go delete mode 100644 vendor/golang.org/x/net/ipv6/icmp_linux.go delete mode 100644 vendor/golang.org/x/net/ipv6/icmp_solaris.go delete mode 100644 vendor/golang.org/x/net/ipv6/icmp_stub.go delete mode 100644 vendor/golang.org/x/net/ipv6/icmp_windows.go delete mode 100644 vendor/golang.org/x/net/ipv6/icmp_zos.go delete mode 100644 vendor/golang.org/x/net/ipv6/payload.go delete mode 100644 vendor/golang.org/x/net/ipv6/payload_cmsg.go delete mode 100644 vendor/golang.org/x/net/ipv6/payload_nocmsg.go delete mode 100644 vendor/golang.org/x/net/ipv6/sockopt.go delete mode 100644 vendor/golang.org/x/net/ipv6/sockopt_posix.go delete mode 100644 vendor/golang.org/x/net/ipv6/sockopt_stub.go delete mode 100644 vendor/golang.org/x/net/ipv6/sys_aix.go delete mode 100644 vendor/golang.org/x/net/ipv6/sys_asmreq.go delete mode 100644 vendor/golang.org/x/net/ipv6/sys_asmreq_stub.go delete mode 100644 vendor/golang.org/x/net/ipv6/sys_bpf.go delete mode 100644 vendor/golang.org/x/net/ipv6/sys_bpf_stub.go delete mode 100644 vendor/golang.org/x/net/ipv6/sys_bsd.go delete mode 100644 vendor/golang.org/x/net/ipv6/sys_darwin.go delete mode 100644 vendor/golang.org/x/net/ipv6/sys_freebsd.go delete mode 100644 vendor/golang.org/x/net/ipv6/sys_linux.go delete mode 100644 vendor/golang.org/x/net/ipv6/sys_solaris.go delete mode 100644 vendor/golang.org/x/net/ipv6/sys_ssmreq.go delete mode 100644 vendor/golang.org/x/net/ipv6/sys_ssmreq_stub.go delete mode 100644 vendor/golang.org/x/net/ipv6/sys_stub.go delete mode 100644 vendor/golang.org/x/net/ipv6/sys_windows.go delete mode 100644 vendor/golang.org/x/net/ipv6/sys_zos.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_aix_ppc64.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_darwin.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_dragonfly.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_freebsd_386.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_freebsd_amd64.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_freebsd_arm.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_freebsd_arm64.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_freebsd_riscv64.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_linux_386.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_linux_amd64.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_linux_arm.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_linux_arm64.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_linux_loong64.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_linux_mips.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_linux_mips64.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_linux_mips64le.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_linux_mipsle.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_linux_ppc.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_linux_ppc64.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_linux_ppc64le.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_linux_riscv64.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_linux_s390x.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_netbsd.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_openbsd.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_solaris.go delete mode 100644 vendor/golang.org/x/net/ipv6/zsys_zos_s390x.go delete mode 100644 vendor/golang.org/x/net/nettest/conntest.go delete mode 100644 vendor/golang.org/x/net/nettest/nettest.go delete mode 100644 vendor/golang.org/x/net/nettest/nettest_stub.go delete mode 100644 vendor/golang.org/x/net/nettest/nettest_unix.go delete mode 100644 vendor/golang.org/x/net/nettest/nettest_windows.go delete mode 100644 vendor/golang.org/x/net/proxy/dial.go delete mode 100644 vendor/golang.org/x/net/proxy/direct.go delete mode 100644 vendor/golang.org/x/net/proxy/per_host.go delete mode 100644 vendor/golang.org/x/net/proxy/proxy.go delete mode 100644 vendor/golang.org/x/net/proxy/socks5.go delete mode 100644 vendor/golang.org/x/net/trace/events.go delete mode 100644 vendor/golang.org/x/net/trace/histogram.go delete mode 100644 vendor/golang.org/x/net/trace/trace.go delete mode 100644 vendor/golang.org/x/net/websocket/client.go delete mode 100644 vendor/golang.org/x/net/websocket/dial.go delete mode 100644 vendor/golang.org/x/net/websocket/hybi.go delete mode 100644 vendor/golang.org/x/net/websocket/server.go delete mode 100644 vendor/golang.org/x/net/websocket/websocket.go delete mode 100644 vendor/golang.org/x/oauth2/.travis.yml delete mode 100644 vendor/golang.org/x/oauth2/CONTRIBUTING.md delete mode 100644 vendor/golang.org/x/oauth2/LICENSE delete mode 100644 vendor/golang.org/x/oauth2/README.md delete mode 100644 vendor/golang.org/x/oauth2/deviceauth.go delete mode 100644 vendor/golang.org/x/oauth2/internal/doc.go delete mode 100644 vendor/golang.org/x/oauth2/internal/oauth2.go delete mode 100644 vendor/golang.org/x/oauth2/internal/token.go delete mode 100644 vendor/golang.org/x/oauth2/internal/transport.go delete mode 100644 vendor/golang.org/x/oauth2/oauth2.go delete mode 100644 vendor/golang.org/x/oauth2/pkce.go delete mode 100644 vendor/golang.org/x/oauth2/token.go delete mode 100644 vendor/golang.org/x/oauth2/transport.go delete mode 100644 vendor/golang.org/x/sync/LICENSE delete mode 100644 vendor/golang.org/x/sync/PATENTS delete mode 100644 vendor/golang.org/x/sync/errgroup/errgroup.go delete mode 100644 vendor/golang.org/x/sys/LICENSE delete mode 100644 vendor/golang.org/x/sys/PATENTS delete mode 100644 vendor/golang.org/x/sys/cpu/asm_aix_ppc64.s delete mode 100644 vendor/golang.org/x/sys/cpu/asm_darwin_arm64_gc.s delete mode 100644 vendor/golang.org/x/sys/cpu/asm_darwin_x86_gc.s delete mode 100644 vendor/golang.org/x/sys/cpu/byteorder.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_aix.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_arm.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_arm64.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_arm64.s delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_darwin_arm64.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_darwin_arm64_other.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_darwin_x86.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_gc_arm64.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_gc_s390x.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_gc_x86.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_gc_x86.s delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_gccgo_arm64.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_gccgo_s390x.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.c delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_linux.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_linux_arm.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_linux_loong64.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_linux_mips64x.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_linux_ppc64x.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_linux_s390x.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_loong64.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_loong64.s delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_mips64x.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_mipsx.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_netbsd_arm64.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_openbsd_arm64.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_openbsd_arm64.s delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_other_arm.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_other_arm64.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_other_mips64x.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_other_ppc64x.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_other_riscv64.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_other_x86.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_ppc64x.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_riscv64.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_s390x.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_s390x.s delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_wasm.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_windows.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_windows_arm64.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_x86.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_zos.go delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_zos_s390x.go delete mode 100644 vendor/golang.org/x/sys/cpu/endian_big.go delete mode 100644 vendor/golang.org/x/sys/cpu/endian_little.go delete mode 100644 vendor/golang.org/x/sys/cpu/hwcap_linux.go delete mode 100644 vendor/golang.org/x/sys/cpu/parse.go delete mode 100644 vendor/golang.org/x/sys/cpu/proc_cpuinfo_linux.go delete mode 100644 vendor/golang.org/x/sys/cpu/runtime_auxv.go delete mode 100644 vendor/golang.org/x/sys/cpu/runtime_auxv_go121.go delete mode 100644 vendor/golang.org/x/sys/cpu/syscall_aix_gccgo.go delete mode 100644 vendor/golang.org/x/sys/cpu/syscall_aix_ppc64_gc.go delete mode 100644 vendor/golang.org/x/sys/cpu/syscall_darwin_arm64_gc.go delete mode 100644 vendor/golang.org/x/sys/cpu/syscall_darwin_x86_gc.go delete mode 100644 vendor/golang.org/x/sys/cpu/zcpu_windows.go delete mode 100644 vendor/golang.org/x/sys/execabs/execabs.go delete mode 100644 vendor/golang.org/x/sys/execabs/execabs_go118.go delete mode 100644 vendor/golang.org/x/sys/execabs/execabs_go119.go delete mode 100644 vendor/golang.org/x/sys/plan9/asm.s delete mode 100644 vendor/golang.org/x/sys/plan9/asm_plan9_386.s delete mode 100644 vendor/golang.org/x/sys/plan9/asm_plan9_amd64.s delete mode 100644 vendor/golang.org/x/sys/plan9/asm_plan9_arm.s delete mode 100644 vendor/golang.org/x/sys/plan9/const_plan9.go delete mode 100644 vendor/golang.org/x/sys/plan9/dir_plan9.go delete mode 100644 vendor/golang.org/x/sys/plan9/env_plan9.go delete mode 100644 vendor/golang.org/x/sys/plan9/errors_plan9.go delete mode 100644 vendor/golang.org/x/sys/plan9/mkall.sh delete mode 100644 vendor/golang.org/x/sys/plan9/mkerrors.sh delete mode 100644 vendor/golang.org/x/sys/plan9/mksysnum_plan9.sh delete mode 100644 vendor/golang.org/x/sys/plan9/pwd_plan9.go delete mode 100644 vendor/golang.org/x/sys/plan9/race.go delete mode 100644 vendor/golang.org/x/sys/plan9/race0.go delete mode 100644 vendor/golang.org/x/sys/plan9/str.go delete mode 100644 vendor/golang.org/x/sys/plan9/syscall.go delete mode 100644 vendor/golang.org/x/sys/plan9/syscall_plan9.go delete mode 100644 vendor/golang.org/x/sys/plan9/zsyscall_plan9_386.go delete mode 100644 vendor/golang.org/x/sys/plan9/zsyscall_plan9_amd64.go delete mode 100644 vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm.go delete mode 100644 vendor/golang.org/x/sys/plan9/zsysnum_plan9.go delete mode 100644 vendor/golang.org/x/sys/unix/.gitignore delete mode 100644 vendor/golang.org/x/sys/unix/README.md delete mode 100644 vendor/golang.org/x/sys/unix/affinity_linux.go delete mode 100644 vendor/golang.org/x/sys/unix/aliases.go delete mode 100644 vendor/golang.org/x/sys/unix/asm_aix_ppc64.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_bsd_386.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_bsd_amd64.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_bsd_arm.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_bsd_arm64.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_bsd_ppc64.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_bsd_riscv64.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_linux_386.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_linux_amd64.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_linux_arm.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_linux_arm64.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_linux_loong64.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_linux_mips64x.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_linux_mipsx.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_linux_riscv64.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_linux_s390x.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_openbsd_mips64.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_solaris_amd64.s delete mode 100644 vendor/golang.org/x/sys/unix/asm_zos_s390x.s delete mode 100644 vendor/golang.org/x/sys/unix/auxv.go delete mode 100644 vendor/golang.org/x/sys/unix/auxv_unsupported.go delete mode 100644 vendor/golang.org/x/sys/unix/bluetooth_linux.go delete mode 100644 vendor/golang.org/x/sys/unix/bpxsvc_zos.go delete mode 100644 vendor/golang.org/x/sys/unix/bpxsvc_zos.s delete mode 100644 vendor/golang.org/x/sys/unix/cap_freebsd.go delete mode 100644 vendor/golang.org/x/sys/unix/constants.go delete mode 100644 vendor/golang.org/x/sys/unix/dev_aix_ppc.go delete mode 100644 vendor/golang.org/x/sys/unix/dev_aix_ppc64.go delete mode 100644 vendor/golang.org/x/sys/unix/dev_darwin.go delete mode 100644 vendor/golang.org/x/sys/unix/dev_dragonfly.go delete mode 100644 vendor/golang.org/x/sys/unix/dev_freebsd.go delete mode 100644 vendor/golang.org/x/sys/unix/dev_linux.go delete mode 100644 vendor/golang.org/x/sys/unix/dev_netbsd.go delete mode 100644 vendor/golang.org/x/sys/unix/dev_openbsd.go delete mode 100644 vendor/golang.org/x/sys/unix/dev_zos.go delete mode 100644 vendor/golang.org/x/sys/unix/dirent.go delete mode 100644 vendor/golang.org/x/sys/unix/endian_big.go delete mode 100644 vendor/golang.org/x/sys/unix/endian_little.go delete mode 100644 vendor/golang.org/x/sys/unix/env_unix.go delete mode 100644 vendor/golang.org/x/sys/unix/fcntl.go delete mode 100644 vendor/golang.org/x/sys/unix/fcntl_darwin.go delete mode 100644 vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go delete mode 100644 vendor/golang.org/x/sys/unix/fdset.go delete mode 100644 vendor/golang.org/x/sys/unix/gccgo.go delete mode 100644 vendor/golang.org/x/sys/unix/gccgo_c.c delete mode 100644 vendor/golang.org/x/sys/unix/gccgo_linux_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/ifreq_linux.go delete mode 100644 vendor/golang.org/x/sys/unix/ioctl_linux.go delete mode 100644 vendor/golang.org/x/sys/unix/ioctl_signed.go delete mode 100644 vendor/golang.org/x/sys/unix/ioctl_unsigned.go delete mode 100644 vendor/golang.org/x/sys/unix/ioctl_zos.go delete mode 100644 vendor/golang.org/x/sys/unix/mkall.sh delete mode 100644 vendor/golang.org/x/sys/unix/mkerrors.sh delete mode 100644 vendor/golang.org/x/sys/unix/mmap_nomremap.go delete mode 100644 vendor/golang.org/x/sys/unix/mremap.go delete mode 100644 vendor/golang.org/x/sys/unix/pagesize_unix.go delete mode 100644 vendor/golang.org/x/sys/unix/pledge_openbsd.go delete mode 100644 vendor/golang.org/x/sys/unix/ptrace_darwin.go delete mode 100644 vendor/golang.org/x/sys/unix/ptrace_ios.go delete mode 100644 vendor/golang.org/x/sys/unix/race.go delete mode 100644 vendor/golang.org/x/sys/unix/race0.go delete mode 100644 vendor/golang.org/x/sys/unix/readdirent_getdents.go delete mode 100644 vendor/golang.org/x/sys/unix/readdirent_getdirentries.go delete mode 100644 vendor/golang.org/x/sys/unix/readv_unix.go delete mode 100644 vendor/golang.org/x/sys/unix/sockcmsg_dragonfly.go delete mode 100644 vendor/golang.org/x/sys/unix/sockcmsg_linux.go delete mode 100644 vendor/golang.org/x/sys/unix/sockcmsg_unix.go delete mode 100644 vendor/golang.org/x/sys/unix/sockcmsg_unix_other.go delete mode 100644 vendor/golang.org/x/sys/unix/sockcmsg_zos.go delete mode 100644 vendor/golang.org/x/sys/unix/symaddr_zos_s390x.s delete mode 100644 vendor/golang.org/x/sys/unix/syscall.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_aix.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_aix_ppc.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_aix_ppc64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_bsd.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_darwin.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_darwin_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_darwin_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_dragonfly.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_dragonfly_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_freebsd.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_freebsd_386.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_freebsd_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_freebsd_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_freebsd_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_freebsd_riscv64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_hurd.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_hurd_386.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_illumos.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_386.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_alarm.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_amd64_gc.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_gc.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_gc_386.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_gc_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_gccgo_386.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_gccgo_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_loong64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_mips64x.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_mipsx.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_ppc.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_s390x.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_netbsd.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_netbsd_386.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_netbsd_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_netbsd_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_netbsd_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_openbsd.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_openbsd_386.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_openbsd_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_openbsd_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_openbsd_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_openbsd_libc.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_openbsd_mips64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_openbsd_ppc64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_openbsd_riscv64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_solaris.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_solaris_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_unix.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_unix_gc.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_unix_gc_ppc64x.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_zos_s390x.go delete mode 100644 vendor/golang.org/x/sys/unix/sysvshm_linux.go delete mode 100644 vendor/golang.org/x/sys/unix/sysvshm_unix.go delete mode 100644 vendor/golang.org/x/sys/unix/sysvshm_unix_other.go delete mode 100644 vendor/golang.org/x/sys/unix/timestruct.go delete mode 100644 vendor/golang.org/x/sys/unix/unveil_openbsd.go delete mode 100644 vendor/golang.org/x/sys/unix/vgetrandom_linux.go delete mode 100644 vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go delete mode 100644 vendor/golang.org/x/sys/unix/xattr_bsd.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_aix_ppc.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_aix_ppc64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_dragonfly_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_freebsd_386.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_freebsd_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_freebsd_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_freebsd_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_freebsd_riscv64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_linux.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_linux_386.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_linux_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_linux_mips.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_netbsd_386.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_netbsd_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_netbsd_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_netbsd_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_openbsd_386.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_openbsd_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_openbsd_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_openbsd_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_openbsd_mips64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_openbsd_ppc64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_openbsd_riscv64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_solaris_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go delete mode 100644 vendor/golang.org/x/sys/unix/zptrace_armnn_linux.go delete mode 100644 vendor/golang.org/x/sys/unix/zptrace_linux_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/zptrace_mipsnn_linux.go delete mode 100644 vendor/golang.org/x/sys/unix/zptrace_mipsnnle_linux.go delete mode 100644 vendor/golang.org/x/sys/unix/zptrace_x86_linux.go delete mode 100644 vendor/golang.org/x/sys/unix/zsymaddr_zos_s390x.s delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_aix_ppc.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64_gc.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64_gccgo.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_dragonfly_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_freebsd_386.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_freebsd_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_freebsd_riscv64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_illumos_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_linux.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_linux_386.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_linux_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_linux_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_linux_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_linux_loong64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_linux_mips.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_linux_mips64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_linux_mips64le.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_linux_mipsle.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_linux_ppc.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64le.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_linux_riscv64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_linux_s390x.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_linux_sparc64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.s delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.s delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.s delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.s delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.s delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.s delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.s delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_zos_s390x.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysctl_openbsd_386.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysctl_openbsd_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysctl_openbsd_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysctl_openbsd_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysctl_openbsd_mips64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysctl_openbsd_ppc64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysctl_openbsd_riscv64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_darwin_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_darwin_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_dragonfly_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_freebsd_386.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_freebsd_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_freebsd_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_freebsd_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_freebsd_riscv64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_linux_386.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_netbsd_386.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_netbsd_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_netbsd_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_netbsd_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_openbsd_386.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_openbsd_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_openbsd_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_openbsd_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_openbsd_mips64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_openbsd_ppc64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_openbsd_riscv64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_aix_ppc.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_aix_ppc64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_dragonfly_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_linux.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_linux_386.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_linux_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_linux_mips.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_netbsd_386.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_netbsd_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_netbsd_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_openbsd_386.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_openbsd_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_openbsd_arm.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_openbsd_arm64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_openbsd_mips64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_openbsd_ppc64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_openbsd_riscv64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_solaris_amd64.go delete mode 100644 vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go delete mode 100644 vendor/golang.org/x/sys/windows/aliases.go delete mode 100644 vendor/golang.org/x/sys/windows/dll_windows.go delete mode 100644 vendor/golang.org/x/sys/windows/env_windows.go delete mode 100644 vendor/golang.org/x/sys/windows/eventlog.go delete mode 100644 vendor/golang.org/x/sys/windows/exec_windows.go delete mode 100644 vendor/golang.org/x/sys/windows/memory_windows.go delete mode 100644 vendor/golang.org/x/sys/windows/mkerrors.bash delete mode 100644 vendor/golang.org/x/sys/windows/mkknownfolderids.bash delete mode 100644 vendor/golang.org/x/sys/windows/mksyscall.go delete mode 100644 vendor/golang.org/x/sys/windows/race.go delete mode 100644 vendor/golang.org/x/sys/windows/race0.go delete mode 100644 vendor/golang.org/x/sys/windows/registry/key.go delete mode 100644 vendor/golang.org/x/sys/windows/registry/mksyscall.go delete mode 100644 vendor/golang.org/x/sys/windows/registry/syscall.go delete mode 100644 vendor/golang.org/x/sys/windows/registry/value.go delete mode 100644 vendor/golang.org/x/sys/windows/registry/zsyscall_windows.go delete mode 100644 vendor/golang.org/x/sys/windows/security_windows.go delete mode 100644 vendor/golang.org/x/sys/windows/service.go delete mode 100644 vendor/golang.org/x/sys/windows/setupapi_windows.go delete mode 100644 vendor/golang.org/x/sys/windows/str.go delete mode 100644 vendor/golang.org/x/sys/windows/svc/eventlog/install.go delete mode 100644 vendor/golang.org/x/sys/windows/svc/eventlog/log.go delete mode 100644 vendor/golang.org/x/sys/windows/svc/mgr/config.go delete mode 100644 vendor/golang.org/x/sys/windows/svc/mgr/mgr.go delete mode 100644 vendor/golang.org/x/sys/windows/svc/mgr/recovery.go delete mode 100644 vendor/golang.org/x/sys/windows/svc/mgr/service.go delete mode 100644 vendor/golang.org/x/sys/windows/svc/security.go delete mode 100644 vendor/golang.org/x/sys/windows/svc/service.go delete mode 100644 vendor/golang.org/x/sys/windows/syscall.go delete mode 100644 vendor/golang.org/x/sys/windows/syscall_windows.go delete mode 100644 vendor/golang.org/x/sys/windows/types_windows.go delete mode 100644 vendor/golang.org/x/sys/windows/types_windows_386.go delete mode 100644 vendor/golang.org/x/sys/windows/types_windows_amd64.go delete mode 100644 vendor/golang.org/x/sys/windows/types_windows_arm.go delete mode 100644 vendor/golang.org/x/sys/windows/types_windows_arm64.go delete mode 100644 vendor/golang.org/x/sys/windows/zerrors_windows.go delete mode 100644 vendor/golang.org/x/sys/windows/zknownfolderids_windows.go delete mode 100644 vendor/golang.org/x/sys/windows/zsyscall_windows.go delete mode 100644 vendor/golang.org/x/term/CONTRIBUTING.md delete mode 100644 vendor/golang.org/x/term/LICENSE delete mode 100644 vendor/golang.org/x/term/PATENTS delete mode 100644 vendor/golang.org/x/term/README.md delete mode 100644 vendor/golang.org/x/term/codereview.cfg delete mode 100644 vendor/golang.org/x/term/term.go delete mode 100644 vendor/golang.org/x/term/term_plan9.go delete mode 100644 vendor/golang.org/x/term/term_unix.go delete mode 100644 vendor/golang.org/x/term/term_unix_bsd.go delete mode 100644 vendor/golang.org/x/term/term_unix_other.go delete mode 100644 vendor/golang.org/x/term/term_unsupported.go delete mode 100644 vendor/golang.org/x/term/term_windows.go delete mode 100644 vendor/golang.org/x/term/terminal.go delete mode 100644 vendor/golang.org/x/text/LICENSE delete mode 100644 vendor/golang.org/x/text/PATENTS delete mode 100644 vendor/golang.org/x/text/cases/cases.go delete mode 100644 vendor/golang.org/x/text/cases/context.go delete mode 100644 vendor/golang.org/x/text/cases/fold.go delete mode 100644 vendor/golang.org/x/text/cases/icu.go delete mode 100644 vendor/golang.org/x/text/cases/info.go delete mode 100644 vendor/golang.org/x/text/cases/map.go delete mode 100644 vendor/golang.org/x/text/cases/tables15.0.0.go delete mode 100644 vendor/golang.org/x/text/cases/tables17.0.0.go delete mode 100644 vendor/golang.org/x/text/cases/trieval.go delete mode 100644 vendor/golang.org/x/text/internal/internal.go delete mode 100644 vendor/golang.org/x/text/internal/language/common.go delete mode 100644 vendor/golang.org/x/text/internal/language/compact.go delete mode 100644 vendor/golang.org/x/text/internal/language/compact/compact.go delete mode 100644 vendor/golang.org/x/text/internal/language/compact/language.go delete mode 100644 vendor/golang.org/x/text/internal/language/compact/parents.go delete mode 100644 vendor/golang.org/x/text/internal/language/compact/tables.go delete mode 100644 vendor/golang.org/x/text/internal/language/compact/tags.go delete mode 100644 vendor/golang.org/x/text/internal/language/compose.go delete mode 100644 vendor/golang.org/x/text/internal/language/coverage.go delete mode 100644 vendor/golang.org/x/text/internal/language/language.go delete mode 100644 vendor/golang.org/x/text/internal/language/lookup.go delete mode 100644 vendor/golang.org/x/text/internal/language/match.go delete mode 100644 vendor/golang.org/x/text/internal/language/parse.go delete mode 100644 vendor/golang.org/x/text/internal/language/tables.go delete mode 100644 vendor/golang.org/x/text/internal/language/tags.go delete mode 100644 vendor/golang.org/x/text/internal/match.go delete mode 100644 vendor/golang.org/x/text/internal/tag/tag.go delete mode 100644 vendor/golang.org/x/text/language/coverage.go delete mode 100644 vendor/golang.org/x/text/language/doc.go delete mode 100644 vendor/golang.org/x/text/language/language.go delete mode 100644 vendor/golang.org/x/text/language/match.go delete mode 100644 vendor/golang.org/x/text/language/parse.go delete mode 100644 vendor/golang.org/x/text/language/tables.go delete mode 100644 vendor/golang.org/x/text/language/tags.go delete mode 100644 vendor/golang.org/x/text/secure/bidirule/bidirule.go delete mode 100644 vendor/golang.org/x/text/transform/transform.go delete mode 100644 vendor/golang.org/x/text/unicode/bidi/bidi.go delete mode 100644 vendor/golang.org/x/text/unicode/bidi/bracket.go delete mode 100644 vendor/golang.org/x/text/unicode/bidi/core.go delete mode 100644 vendor/golang.org/x/text/unicode/bidi/prop.go delete mode 100644 vendor/golang.org/x/text/unicode/bidi/tables15.0.0.go delete mode 100644 vendor/golang.org/x/text/unicode/bidi/tables17.0.0.go delete mode 100644 vendor/golang.org/x/text/unicode/bidi/trieval.go delete mode 100644 vendor/golang.org/x/text/unicode/norm/composition.go delete mode 100644 vendor/golang.org/x/text/unicode/norm/forminfo.go delete mode 100644 vendor/golang.org/x/text/unicode/norm/input.go delete mode 100644 vendor/golang.org/x/text/unicode/norm/iter.go delete mode 100644 vendor/golang.org/x/text/unicode/norm/normalize.go delete mode 100644 vendor/golang.org/x/text/unicode/norm/readwriter.go delete mode 100644 vendor/golang.org/x/text/unicode/norm/tables15.0.0.go delete mode 100644 vendor/golang.org/x/text/unicode/norm/tables17.0.0.go delete mode 100644 vendor/golang.org/x/text/unicode/norm/transform.go delete mode 100644 vendor/golang.org/x/text/unicode/norm/trie.go delete mode 100644 vendor/google.golang.org/genproto/googleapis/api/LICENSE delete mode 100644 vendor/google.golang.org/genproto/googleapis/api/httpbody/httpbody.pb.go delete mode 100644 vendor/google.golang.org/genproto/googleapis/rpc/LICENSE delete mode 100644 vendor/google.golang.org/genproto/googleapis/rpc/status/status.pb.go delete mode 100644 vendor/google.golang.org/grpc/AUTHORS delete mode 100644 vendor/google.golang.org/grpc/CODE-OF-CONDUCT.md delete mode 100644 vendor/google.golang.org/grpc/CONTRIBUTING.md delete mode 100644 vendor/google.golang.org/grpc/GOVERNANCE.md delete mode 100644 vendor/google.golang.org/grpc/LICENSE delete mode 100644 vendor/google.golang.org/grpc/MAINTAINERS.md delete mode 100644 vendor/google.golang.org/grpc/Makefile delete mode 100644 vendor/google.golang.org/grpc/NOTICE.txt delete mode 100644 vendor/google.golang.org/grpc/README.md delete mode 100644 vendor/google.golang.org/grpc/SECURITY.md delete mode 100644 vendor/google.golang.org/grpc/attributes/attributes.go delete mode 100644 vendor/google.golang.org/grpc/backoff.go delete mode 100644 vendor/google.golang.org/grpc/backoff/backoff.go delete mode 100644 vendor/google.golang.org/grpc/balancer/balancer.go delete mode 100644 vendor/google.golang.org/grpc/balancer/base/balancer.go delete mode 100644 vendor/google.golang.org/grpc/balancer/base/base.go delete mode 100644 vendor/google.golang.org/grpc/balancer/conn_state_evaluator.go delete mode 100644 vendor/google.golang.org/grpc/balancer/endpointsharding/endpointsharding.go delete mode 100644 vendor/google.golang.org/grpc/balancer/grpclb/state/state.go delete mode 100644 vendor/google.golang.org/grpc/balancer/pickfirst/internal/internal.go delete mode 100644 vendor/google.golang.org/grpc/balancer/pickfirst/pickfirst.go delete mode 100644 vendor/google.golang.org/grpc/balancer/roundrobin/roundrobin.go delete mode 100644 vendor/google.golang.org/grpc/balancer/subconn.go delete mode 100644 vendor/google.golang.org/grpc/balancer_wrapper.go delete mode 100644 vendor/google.golang.org/grpc/binarylog/grpc_binarylog_v1/binarylog.pb.go delete mode 100644 vendor/google.golang.org/grpc/call.go delete mode 100644 vendor/google.golang.org/grpc/channelz/channelz.go delete mode 100644 vendor/google.golang.org/grpc/clientconn.go delete mode 100644 vendor/google.golang.org/grpc/clientconn_disconnect_reason_noplan9.go delete mode 100644 vendor/google.golang.org/grpc/clientconn_disconnect_reason_plan9.go delete mode 100644 vendor/google.golang.org/grpc/codec.go delete mode 100644 vendor/google.golang.org/grpc/codes/code_string.go delete mode 100644 vendor/google.golang.org/grpc/codes/codes.go delete mode 100644 vendor/google.golang.org/grpc/connectivity/connectivity.go delete mode 100644 vendor/google.golang.org/grpc/credentials/credentials.go delete mode 100644 vendor/google.golang.org/grpc/credentials/insecure/insecure.go delete mode 100644 vendor/google.golang.org/grpc/credentials/tls.go delete mode 100644 vendor/google.golang.org/grpc/dialoptions.go delete mode 100644 vendor/google.golang.org/grpc/doc.go delete mode 100644 vendor/google.golang.org/grpc/encoding/encoding.go delete mode 100644 vendor/google.golang.org/grpc/encoding/encoding_v2.go delete mode 100644 vendor/google.golang.org/grpc/encoding/internal/internal.go delete mode 100644 vendor/google.golang.org/grpc/encoding/proto/proto.go delete mode 100644 vendor/google.golang.org/grpc/experimental/balancer/weight/weight.go delete mode 100644 vendor/google.golang.org/grpc/experimental/stats/metricregistry.go delete mode 100644 vendor/google.golang.org/grpc/experimental/stats/metrics.go delete mode 100644 vendor/google.golang.org/grpc/grpclog/component.go delete mode 100644 vendor/google.golang.org/grpc/grpclog/grpclog.go delete mode 100644 vendor/google.golang.org/grpc/grpclog/internal/grpclog.go delete mode 100644 vendor/google.golang.org/grpc/grpclog/internal/logger.go delete mode 100644 vendor/google.golang.org/grpc/grpclog/internal/loggerv2.go delete mode 100644 vendor/google.golang.org/grpc/grpclog/logger.go delete mode 100644 vendor/google.golang.org/grpc/grpclog/loggerv2.go delete mode 100644 vendor/google.golang.org/grpc/health/grpc_health_v1/health.pb.go delete mode 100644 vendor/google.golang.org/grpc/health/grpc_health_v1/health_grpc.pb.go delete mode 100644 vendor/google.golang.org/grpc/interceptor.go delete mode 100644 vendor/google.golang.org/grpc/internal/backoff/backoff.go delete mode 100644 vendor/google.golang.org/grpc/internal/balancer/gracefulswitch/config.go delete mode 100644 vendor/google.golang.org/grpc/internal/balancer/gracefulswitch/gracefulswitch.go delete mode 100644 vendor/google.golang.org/grpc/internal/balancerload/load.go delete mode 100644 vendor/google.golang.org/grpc/internal/binarylog/binarylog.go delete mode 100644 vendor/google.golang.org/grpc/internal/binarylog/binarylog_testutil.go delete mode 100644 vendor/google.golang.org/grpc/internal/binarylog/env_config.go delete mode 100644 vendor/google.golang.org/grpc/internal/binarylog/method_logger.go delete mode 100644 vendor/google.golang.org/grpc/internal/binarylog/sink.go delete mode 100644 vendor/google.golang.org/grpc/internal/buffer/unbounded.go delete mode 100644 vendor/google.golang.org/grpc/internal/channelz/channel.go delete mode 100644 vendor/google.golang.org/grpc/internal/channelz/channelmap.go delete mode 100644 vendor/google.golang.org/grpc/internal/channelz/funcs.go delete mode 100644 vendor/google.golang.org/grpc/internal/channelz/logging.go delete mode 100644 vendor/google.golang.org/grpc/internal/channelz/server.go delete mode 100644 vendor/google.golang.org/grpc/internal/channelz/socket.go delete mode 100644 vendor/google.golang.org/grpc/internal/channelz/subchannel.go delete mode 100644 vendor/google.golang.org/grpc/internal/channelz/syscall_linux.go delete mode 100644 vendor/google.golang.org/grpc/internal/channelz/syscall_nonlinux.go delete mode 100644 vendor/google.golang.org/grpc/internal/channelz/trace.go delete mode 100644 vendor/google.golang.org/grpc/internal/credentials/credentials.go delete mode 100644 vendor/google.golang.org/grpc/internal/credentials/spiffe.go delete mode 100644 vendor/google.golang.org/grpc/internal/credentials/syscallconn.go delete mode 100644 vendor/google.golang.org/grpc/internal/credentials/util.go delete mode 100644 vendor/google.golang.org/grpc/internal/envconfig/envconfig.go delete mode 100644 vendor/google.golang.org/grpc/internal/envconfig/observability.go delete mode 100644 vendor/google.golang.org/grpc/internal/envconfig/xds.go delete mode 100644 vendor/google.golang.org/grpc/internal/experimental.go delete mode 100644 vendor/google.golang.org/grpc/internal/grpclog/prefix_logger.go delete mode 100644 vendor/google.golang.org/grpc/internal/grpcsync/callback_serializer.go delete mode 100644 vendor/google.golang.org/grpc/internal/grpcsync/event.go delete mode 100644 vendor/google.golang.org/grpc/internal/grpcsync/pubsub.go delete mode 100644 vendor/google.golang.org/grpc/internal/grpcutil/compressor.go delete mode 100644 vendor/google.golang.org/grpc/internal/grpcutil/encode_duration.go delete mode 100644 vendor/google.golang.org/grpc/internal/grpcutil/grpcutil.go delete mode 100644 vendor/google.golang.org/grpc/internal/grpcutil/metadata.go delete mode 100644 vendor/google.golang.org/grpc/internal/grpcutil/method.go delete mode 100644 vendor/google.golang.org/grpc/internal/idle/idle.go delete mode 100644 vendor/google.golang.org/grpc/internal/internal.go delete mode 100644 vendor/google.golang.org/grpc/internal/mem/buffer_pool.go delete mode 100644 vendor/google.golang.org/grpc/internal/metadata/metadata.go delete mode 100644 vendor/google.golang.org/grpc/internal/pretty/pretty.go delete mode 100644 vendor/google.golang.org/grpc/internal/proxyattributes/proxyattributes.go delete mode 100644 vendor/google.golang.org/grpc/internal/resolver/config_selector.go delete mode 100644 vendor/google.golang.org/grpc/internal/resolver/delegatingresolver/delegatingresolver.go delete mode 100644 vendor/google.golang.org/grpc/internal/resolver/dns/dns_resolver.go delete mode 100644 vendor/google.golang.org/grpc/internal/resolver/dns/internal/internal.go delete mode 100644 vendor/google.golang.org/grpc/internal/resolver/passthrough/passthrough.go delete mode 100644 vendor/google.golang.org/grpc/internal/resolver/unix/unix.go delete mode 100644 vendor/google.golang.org/grpc/internal/serviceconfig/duration.go delete mode 100644 vendor/google.golang.org/grpc/internal/serviceconfig/serviceconfig.go delete mode 100644 vendor/google.golang.org/grpc/internal/stats/labels.go delete mode 100644 vendor/google.golang.org/grpc/internal/stats/metrics_recorder_list.go delete mode 100644 vendor/google.golang.org/grpc/internal/stats/stats.go delete mode 100644 vendor/google.golang.org/grpc/internal/status/status.go delete mode 100644 vendor/google.golang.org/grpc/internal/syscall/syscall_linux.go delete mode 100644 vendor/google.golang.org/grpc/internal/syscall/syscall_nonlinux.go delete mode 100644 vendor/google.golang.org/grpc/internal/tcp_keepalive_others.go delete mode 100644 vendor/google.golang.org/grpc/internal/tcp_keepalive_unix.go delete mode 100644 vendor/google.golang.org/grpc/internal/tcp_keepalive_windows.go delete mode 100644 vendor/google.golang.org/grpc/internal/transport/bdp_estimator.go delete mode 100644 vendor/google.golang.org/grpc/internal/transport/client_stream.go delete mode 100644 vendor/google.golang.org/grpc/internal/transport/controlbuf.go delete mode 100644 vendor/google.golang.org/grpc/internal/transport/defaults.go delete mode 100644 vendor/google.golang.org/grpc/internal/transport/flowcontrol.go delete mode 100644 vendor/google.golang.org/grpc/internal/transport/handler_server.go delete mode 100644 vendor/google.golang.org/grpc/internal/transport/http2_client.go delete mode 100644 vendor/google.golang.org/grpc/internal/transport/http2_server.go delete mode 100644 vendor/google.golang.org/grpc/internal/transport/http_util.go delete mode 100644 vendor/google.golang.org/grpc/internal/transport/internal/internal.go delete mode 100644 vendor/google.golang.org/grpc/internal/transport/logging.go delete mode 100644 vendor/google.golang.org/grpc/internal/transport/networktype/networktype.go delete mode 100644 vendor/google.golang.org/grpc/internal/transport/proxy.go delete mode 100644 vendor/google.golang.org/grpc/internal/transport/readyreader/raw_conn_linux.go delete mode 100644 vendor/google.golang.org/grpc/internal/transport/readyreader/raw_conn_nonlinux.go delete mode 100644 vendor/google.golang.org/grpc/internal/transport/readyreader/ready_reader.go delete mode 100644 vendor/google.golang.org/grpc/internal/transport/server_stream.go delete mode 100644 vendor/google.golang.org/grpc/internal/transport/transport.go delete mode 100644 vendor/google.golang.org/grpc/keepalive/keepalive.go delete mode 100644 vendor/google.golang.org/grpc/mem/buffer_pool.go delete mode 100644 vendor/google.golang.org/grpc/mem/buffer_slice.go delete mode 100644 vendor/google.golang.org/grpc/mem/buffers.go delete mode 100644 vendor/google.golang.org/grpc/metadata/metadata.go delete mode 100644 vendor/google.golang.org/grpc/peer/peer.go delete mode 100644 vendor/google.golang.org/grpc/picker_wrapper.go delete mode 100644 vendor/google.golang.org/grpc/preloader.go delete mode 100644 vendor/google.golang.org/grpc/resolver/dns/dns_resolver.go delete mode 100644 vendor/google.golang.org/grpc/resolver/map.go delete mode 100644 vendor/google.golang.org/grpc/resolver/resolver.go delete mode 100644 vendor/google.golang.org/grpc/resolver_wrapper.go delete mode 100644 vendor/google.golang.org/grpc/rpc_util.go delete mode 100644 vendor/google.golang.org/grpc/server.go delete mode 100644 vendor/google.golang.org/grpc/service_config.go delete mode 100644 vendor/google.golang.org/grpc/serviceconfig/serviceconfig.go delete mode 100644 vendor/google.golang.org/grpc/stats/handlers.go delete mode 100644 vendor/google.golang.org/grpc/stats/metrics.go delete mode 100644 vendor/google.golang.org/grpc/stats/stats.go delete mode 100644 vendor/google.golang.org/grpc/status/status.go delete mode 100644 vendor/google.golang.org/grpc/stream.go delete mode 100644 vendor/google.golang.org/grpc/stream_interfaces.go delete mode 100644 vendor/google.golang.org/grpc/tap/tap.go delete mode 100644 vendor/google.golang.org/grpc/trace.go delete mode 100644 vendor/google.golang.org/grpc/trace_notrace.go delete mode 100644 vendor/google.golang.org/grpc/trace_withtrace.go delete mode 100644 vendor/google.golang.org/grpc/version.go delete mode 100644 vendor/google.golang.org/protobuf/LICENSE delete mode 100644 vendor/google.golang.org/protobuf/PATENTS delete mode 100644 vendor/google.golang.org/protobuf/encoding/protodelim/protodelim.go delete mode 100644 vendor/google.golang.org/protobuf/encoding/protojson/decode.go delete mode 100644 vendor/google.golang.org/protobuf/encoding/protojson/doc.go delete mode 100644 vendor/google.golang.org/protobuf/encoding/protojson/encode.go delete mode 100644 vendor/google.golang.org/protobuf/encoding/protojson/well_known_types.go delete mode 100644 vendor/google.golang.org/protobuf/encoding/prototext/decode.go delete mode 100644 vendor/google.golang.org/protobuf/encoding/prototext/doc.go delete mode 100644 vendor/google.golang.org/protobuf/encoding/prototext/encode.go delete mode 100644 vendor/google.golang.org/protobuf/encoding/protowire/wire.go delete mode 100644 vendor/google.golang.org/protobuf/internal/descfmt/stringer.go delete mode 100644 vendor/google.golang.org/protobuf/internal/descopts/options.go delete mode 100644 vendor/google.golang.org/protobuf/internal/detrand/rand.go delete mode 100644 vendor/google.golang.org/protobuf/internal/editiondefaults/defaults.go delete mode 100644 vendor/google.golang.org/protobuf/internal/editiondefaults/editions_defaults.binpb delete mode 100644 vendor/google.golang.org/protobuf/internal/encoding/defval/default.go delete mode 100644 vendor/google.golang.org/protobuf/internal/encoding/json/decode.go delete mode 100644 vendor/google.golang.org/protobuf/internal/encoding/json/decode_number.go delete mode 100644 vendor/google.golang.org/protobuf/internal/encoding/json/decode_string.go delete mode 100644 vendor/google.golang.org/protobuf/internal/encoding/json/decode_token.go delete mode 100644 vendor/google.golang.org/protobuf/internal/encoding/json/encode.go delete mode 100644 vendor/google.golang.org/protobuf/internal/encoding/messageset/messageset.go delete mode 100644 vendor/google.golang.org/protobuf/internal/encoding/tag/tag.go delete mode 100644 vendor/google.golang.org/protobuf/internal/encoding/text/decode.go delete mode 100644 vendor/google.golang.org/protobuf/internal/encoding/text/decode_number.go delete mode 100644 vendor/google.golang.org/protobuf/internal/encoding/text/decode_string.go delete mode 100644 vendor/google.golang.org/protobuf/internal/encoding/text/decode_token.go delete mode 100644 vendor/google.golang.org/protobuf/internal/encoding/text/doc.go delete mode 100644 vendor/google.golang.org/protobuf/internal/encoding/text/encode.go delete mode 100644 vendor/google.golang.org/protobuf/internal/errors/errors.go delete mode 100644 vendor/google.golang.org/protobuf/internal/filedesc/build.go delete mode 100644 vendor/google.golang.org/protobuf/internal/filedesc/desc.go delete mode 100644 vendor/google.golang.org/protobuf/internal/filedesc/desc_init.go delete mode 100644 vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go delete mode 100644 vendor/google.golang.org/protobuf/internal/filedesc/desc_list.go delete mode 100644 vendor/google.golang.org/protobuf/internal/filedesc/desc_list_gen.go delete mode 100644 vendor/google.golang.org/protobuf/internal/filedesc/editions.go delete mode 100644 vendor/google.golang.org/protobuf/internal/filedesc/placeholder.go delete mode 100644 vendor/google.golang.org/protobuf/internal/filedesc/presence.go delete mode 100644 vendor/google.golang.org/protobuf/internal/filetype/build.go delete mode 100644 vendor/google.golang.org/protobuf/internal/flags/flags.go delete mode 100644 vendor/google.golang.org/protobuf/internal/flags/proto_legacy_disable.go delete mode 100644 vendor/google.golang.org/protobuf/internal/flags/proto_legacy_enable.go delete mode 100644 vendor/google.golang.org/protobuf/internal/genid/any_gen.go delete mode 100644 vendor/google.golang.org/protobuf/internal/genid/api_gen.go delete mode 100644 vendor/google.golang.org/protobuf/internal/genid/descriptor_gen.go delete mode 100644 vendor/google.golang.org/protobuf/internal/genid/doc.go delete mode 100644 vendor/google.golang.org/protobuf/internal/genid/duration_gen.go delete mode 100644 vendor/google.golang.org/protobuf/internal/genid/empty_gen.go delete mode 100644 vendor/google.golang.org/protobuf/internal/genid/field_mask_gen.go delete mode 100644 vendor/google.golang.org/protobuf/internal/genid/go_features_gen.go delete mode 100644 vendor/google.golang.org/protobuf/internal/genid/goname.go delete mode 100644 vendor/google.golang.org/protobuf/internal/genid/map_entry.go delete mode 100644 vendor/google.golang.org/protobuf/internal/genid/name.go delete mode 100644 vendor/google.golang.org/protobuf/internal/genid/source_context_gen.go delete mode 100644 vendor/google.golang.org/protobuf/internal/genid/struct_gen.go delete mode 100644 vendor/google.golang.org/protobuf/internal/genid/timestamp_gen.go delete mode 100644 vendor/google.golang.org/protobuf/internal/genid/type_gen.go delete mode 100644 vendor/google.golang.org/protobuf/internal/genid/wrappers.go delete mode 100644 vendor/google.golang.org/protobuf/internal/genid/wrappers_gen.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/api_export.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/api_export_opaque.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/bitmap.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/bitmap_race.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/checkinit.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/codec_extension.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/codec_field.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/codec_field_opaque.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/codec_gen.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/codec_map.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/codec_message.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/codec_message_opaque.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/codec_messageset.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/codec_tables.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/codec_unsafe.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/convert.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/convert_list.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/convert_map.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/decode.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/encode.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/enum.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/equal.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/extension.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/lazy.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/legacy_enum.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/legacy_export.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/legacy_extension.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/legacy_file.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/legacy_message.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/merge.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/merge_gen.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/message.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/message_opaque.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/message_opaque_gen.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/message_reflect.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/message_reflect_field.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/message_reflect_field_gen.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/message_reflect_gen.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe_opaque.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/presence.go delete mode 100644 vendor/google.golang.org/protobuf/internal/impl/validate.go delete mode 100644 vendor/google.golang.org/protobuf/internal/order/order.go delete mode 100644 vendor/google.golang.org/protobuf/internal/order/range.go delete mode 100644 vendor/google.golang.org/protobuf/internal/pragma/pragma.go delete mode 100644 vendor/google.golang.org/protobuf/internal/protolazy/bufferreader.go delete mode 100644 vendor/google.golang.org/protobuf/internal/protolazy/lazy.go delete mode 100644 vendor/google.golang.org/protobuf/internal/protolazy/pointer_unsafe.go delete mode 100644 vendor/google.golang.org/protobuf/internal/set/ints.go delete mode 100644 vendor/google.golang.org/protobuf/internal/strs/strings.go delete mode 100644 vendor/google.golang.org/protobuf/internal/strs/strings_unsafe.go delete mode 100644 vendor/google.golang.org/protobuf/internal/version/version.go delete mode 100644 vendor/google.golang.org/protobuf/proto/checkinit.go delete mode 100644 vendor/google.golang.org/protobuf/proto/decode.go delete mode 100644 vendor/google.golang.org/protobuf/proto/decode_gen.go delete mode 100644 vendor/google.golang.org/protobuf/proto/doc.go delete mode 100644 vendor/google.golang.org/protobuf/proto/encode.go delete mode 100644 vendor/google.golang.org/protobuf/proto/encode_gen.go delete mode 100644 vendor/google.golang.org/protobuf/proto/equal.go delete mode 100644 vendor/google.golang.org/protobuf/proto/extension.go delete mode 100644 vendor/google.golang.org/protobuf/proto/merge.go delete mode 100644 vendor/google.golang.org/protobuf/proto/messageset.go delete mode 100644 vendor/google.golang.org/protobuf/proto/proto.go delete mode 100644 vendor/google.golang.org/protobuf/proto/proto_methods.go delete mode 100644 vendor/google.golang.org/protobuf/proto/proto_reflect.go delete mode 100644 vendor/google.golang.org/protobuf/proto/reset.go delete mode 100644 vendor/google.golang.org/protobuf/proto/size.go delete mode 100644 vendor/google.golang.org/protobuf/proto/size_gen.go delete mode 100644 vendor/google.golang.org/protobuf/proto/wrapperopaque.go delete mode 100644 vendor/google.golang.org/protobuf/proto/wrappers.go delete mode 100644 vendor/google.golang.org/protobuf/protoadapt/convert.go delete mode 100644 vendor/google.golang.org/protobuf/reflect/protoreflect/methods.go delete mode 100644 vendor/google.golang.org/protobuf/reflect/protoreflect/proto.go delete mode 100644 vendor/google.golang.org/protobuf/reflect/protoreflect/source.go delete mode 100644 vendor/google.golang.org/protobuf/reflect/protoreflect/source_gen.go delete mode 100644 vendor/google.golang.org/protobuf/reflect/protoreflect/type.go delete mode 100644 vendor/google.golang.org/protobuf/reflect/protoreflect/value.go delete mode 100644 vendor/google.golang.org/protobuf/reflect/protoreflect/value_equal.go delete mode 100644 vendor/google.golang.org/protobuf/reflect/protoreflect/value_union.go delete mode 100644 vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe.go delete mode 100644 vendor/google.golang.org/protobuf/reflect/protoregistry/registry.go delete mode 100644 vendor/google.golang.org/protobuf/runtime/protoiface/legacy.go delete mode 100644 vendor/google.golang.org/protobuf/runtime/protoiface/methods.go delete mode 100644 vendor/google.golang.org/protobuf/runtime/protoimpl/impl.go delete mode 100644 vendor/google.golang.org/protobuf/runtime/protoimpl/version.go delete mode 100644 vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go delete mode 100644 vendor/google.golang.org/protobuf/types/known/durationpb/duration.pb.go delete mode 100644 vendor/google.golang.org/protobuf/types/known/fieldmaskpb/field_mask.pb.go delete mode 100644 vendor/google.golang.org/protobuf/types/known/structpb/struct.pb.go delete mode 100644 vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go delete mode 100644 vendor/google.golang.org/protobuf/types/known/wrapperspb/wrappers.pb.go delete mode 100644 vendor/gopkg.in/natefinch/lumberjack.v2/.gitignore delete mode 100644 vendor/gopkg.in/natefinch/lumberjack.v2/.travis.yml delete mode 100644 vendor/gopkg.in/natefinch/lumberjack.v2/LICENSE delete mode 100644 vendor/gopkg.in/natefinch/lumberjack.v2/README.md delete mode 100644 vendor/gopkg.in/natefinch/lumberjack.v2/chown.go delete mode 100644 vendor/gopkg.in/natefinch/lumberjack.v2/chown_linux.go delete mode 100644 vendor/gopkg.in/natefinch/lumberjack.v2/lumberjack.go delete mode 100644 vendor/gopkg.in/yaml.v2/.travis.yml delete mode 100644 vendor/gopkg.in/yaml.v2/LICENSE delete mode 100644 vendor/gopkg.in/yaml.v2/LICENSE.libyaml delete mode 100644 vendor/gopkg.in/yaml.v2/NOTICE delete mode 100644 vendor/gopkg.in/yaml.v2/README.md delete mode 100644 vendor/gopkg.in/yaml.v2/apic.go delete mode 100644 vendor/gopkg.in/yaml.v2/decode.go delete mode 100644 vendor/gopkg.in/yaml.v2/emitterc.go delete mode 100644 vendor/gopkg.in/yaml.v2/encode.go delete mode 100644 vendor/gopkg.in/yaml.v2/parserc.go delete mode 100644 vendor/gopkg.in/yaml.v2/readerc.go delete mode 100644 vendor/gopkg.in/yaml.v2/resolve.go delete mode 100644 vendor/gopkg.in/yaml.v2/scannerc.go delete mode 100644 vendor/gopkg.in/yaml.v2/sorter.go delete mode 100644 vendor/gopkg.in/yaml.v2/writerc.go delete mode 100644 vendor/gopkg.in/yaml.v2/yaml.go delete mode 100644 vendor/gopkg.in/yaml.v2/yamlh.go delete mode 100644 vendor/gopkg.in/yaml.v2/yamlprivateh.go delete mode 100644 vendor/gopkg.in/yaml.v3/LICENSE delete mode 100644 vendor/gopkg.in/yaml.v3/NOTICE delete mode 100644 vendor/gopkg.in/yaml.v3/README.md delete mode 100644 vendor/gopkg.in/yaml.v3/apic.go delete mode 100644 vendor/gopkg.in/yaml.v3/decode.go delete mode 100644 vendor/gopkg.in/yaml.v3/emitterc.go delete mode 100644 vendor/gopkg.in/yaml.v3/encode.go delete mode 100644 vendor/gopkg.in/yaml.v3/parserc.go delete mode 100644 vendor/gopkg.in/yaml.v3/readerc.go delete mode 100644 vendor/gopkg.in/yaml.v3/resolve.go delete mode 100644 vendor/gopkg.in/yaml.v3/scannerc.go delete mode 100644 vendor/gopkg.in/yaml.v3/sorter.go delete mode 100644 vendor/gopkg.in/yaml.v3/writerc.go delete mode 100644 vendor/gopkg.in/yaml.v3/yaml.go delete mode 100644 vendor/gopkg.in/yaml.v3/yamlh.go delete mode 100644 vendor/gopkg.in/yaml.v3/yamlprivateh.go delete mode 100644 vendor/modules.txt delete mode 100644 vendor/nhooyr.io/websocket/.gitignore delete mode 100644 vendor/nhooyr.io/websocket/LICENSE.txt delete mode 100644 vendor/nhooyr.io/websocket/README.md delete mode 100644 vendor/nhooyr.io/websocket/accept.go delete mode 100644 vendor/nhooyr.io/websocket/accept_js.go delete mode 100644 vendor/nhooyr.io/websocket/close.go delete mode 100644 vendor/nhooyr.io/websocket/close_notjs.go delete mode 100644 vendor/nhooyr.io/websocket/compress.go delete mode 100644 vendor/nhooyr.io/websocket/compress_notjs.go delete mode 100644 vendor/nhooyr.io/websocket/conn.go delete mode 100644 vendor/nhooyr.io/websocket/conn_notjs.go delete mode 100644 vendor/nhooyr.io/websocket/dial.go delete mode 100644 vendor/nhooyr.io/websocket/doc.go delete mode 100644 vendor/nhooyr.io/websocket/frame.go delete mode 100644 vendor/nhooyr.io/websocket/internal/bpool/bpool.go delete mode 100644 vendor/nhooyr.io/websocket/internal/errd/wrap.go delete mode 100644 vendor/nhooyr.io/websocket/internal/wsjs/wsjs_js.go delete mode 100644 vendor/nhooyr.io/websocket/internal/xsync/go.go delete mode 100644 vendor/nhooyr.io/websocket/internal/xsync/int64.go delete mode 100644 vendor/nhooyr.io/websocket/netconn.go delete mode 100644 vendor/nhooyr.io/websocket/read.go delete mode 100644 vendor/nhooyr.io/websocket/stringer.go delete mode 100644 vendor/nhooyr.io/websocket/write.go delete mode 100644 vendor/nhooyr.io/websocket/ws_js.go delete mode 100644 vendor/rsc.io/qr/LICENSE delete mode 100644 vendor/rsc.io/qr/README.md delete mode 100644 vendor/rsc.io/qr/coding/qr.go delete mode 100644 vendor/rsc.io/qr/gf256/gf256.go delete mode 100644 vendor/rsc.io/qr/libqrencode/qrencode.go delete mode 100644 vendor/rsc.io/qr/png.go delete mode 100644 vendor/rsc.io/qr/qr.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/.gitignore delete mode 100644 vendor/zombiezen.com/go/capnproto2/.travis.yml delete mode 100644 vendor/zombiezen.com/go/capnproto2/AUTHORS delete mode 100644 vendor/zombiezen.com/go/capnproto2/BUILD.bazel delete mode 100644 vendor/zombiezen.com/go/capnproto2/CHANGELOG.md delete mode 100644 vendor/zombiezen.com/go/capnproto2/CONTRIBUTING.md delete mode 100644 vendor/zombiezen.com/go/capnproto2/CONTRIBUTORS delete mode 100644 vendor/zombiezen.com/go/capnproto2/LICENSE delete mode 100644 vendor/zombiezen.com/go/capnproto2/README.md delete mode 100644 vendor/zombiezen.com/go/capnproto2/WORKSPACE delete mode 100644 vendor/zombiezen.com/go/capnproto2/address.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/canonical.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/capability.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/capn.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/doc.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/encoding/text/BUILD.bazel delete mode 100644 vendor/zombiezen.com/go/capnproto2/encoding/text/marshal.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/go.capnp.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/internal/fulfiller/BUILD.bazel delete mode 100644 vendor/zombiezen.com/go/capnproto2/internal/fulfiller/fulfiller.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/internal/nodemap/BUILD.bazel delete mode 100644 vendor/zombiezen.com/go/capnproto2/internal/nodemap/nodemap.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/internal/packed/BUILD.bazel delete mode 100644 vendor/zombiezen.com/go/capnproto2/internal/packed/discard.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/internal/packed/discard_go14.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/internal/packed/fuzz.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/internal/packed/packed.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/internal/queue/BUILD.bazel delete mode 100644 vendor/zombiezen.com/go/capnproto2/internal/queue/queue.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/internal/schema/BUILD.bazel delete mode 100644 vendor/zombiezen.com/go/capnproto2/internal/schema/schema.capnp.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/internal/strquote/BUILD.bazel delete mode 100644 vendor/zombiezen.com/go/capnproto2/internal/strquote/strquote.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/list.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/mem.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/mem_18.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/mem_other.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/pogs/BUILD.bazel delete mode 100644 vendor/zombiezen.com/go/capnproto2/pogs/doc.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/pogs/extract.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/pogs/fields.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/pogs/insert.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/pointer.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/rawpointer.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/readlimit.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/regen.sh delete mode 100644 vendor/zombiezen.com/go/capnproto2/rpc/BUILD.bazel delete mode 100644 vendor/zombiezen.com/go/capnproto2/rpc/answer.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/rpc/errors.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/rpc/internal/refcount/BUILD.bazel delete mode 100644 vendor/zombiezen.com/go/capnproto2/rpc/internal/refcount/refcount.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/rpc/introspect.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/rpc/log.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/rpc/question.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/rpc/rpc.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/rpc/tables.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/rpc/transport.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/schemas/BUILD.bazel delete mode 100644 vendor/zombiezen.com/go/capnproto2/schemas/schemas.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/server/BUILD.bazel delete mode 100644 vendor/zombiezen.com/go/capnproto2/server/server.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/std/capnp/rpc/BUILD.bazel delete mode 100644 vendor/zombiezen.com/go/capnproto2/std/capnp/rpc/rpc.capnp.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/strings.go delete mode 100644 vendor/zombiezen.com/go/capnproto2/struct.go diff --git a/.ci/linux.gitlab-ci.yml b/.ci/linux.gitlab-ci.yml index cb28108b15a..1b70f558841 100644 --- a/.ci/linux.gitlab-ci.yml +++ b/.ci/linux.gitlab-ci.yml @@ -15,7 +15,13 @@ rules: - !reference [.default-rules, run-on-master] image: $BUILD_IMAGE - cache: {} + cache: + key: + prefix: "$CI_COMMIT_REF_PROTECTED-$GO_VERSION-$CI_RUNNER_EXECUTABLE_ARCH" + files: + - go.sum + paths: + - .cache/go/ artifacts: paths: - artifacts/* diff --git a/.ci/mac.gitlab-ci.yml b/.ci/mac.gitlab-ci.yml index e2401e5eb71..d0295904696 100644 --- a/.ci/mac.gitlab-ci.yml +++ b/.ci/mac.gitlab-ci.yml @@ -5,6 +5,16 @@ include: ### Defaults for Mac Builds ### ############################### .mac-build-defaults: &mac-build-defaults + variables: + # Athens is not reachable from macOS runners. + GOPROXY: "https://proxy.golang.org,direct" + cache: + key: + prefix: "$CI_COMMIT_REF_PROTECTED-$GO_VERSION-$CI_RUNNER_EXECUTABLE_ARCH" + files: + - go.sum + paths: + - .cache/go/ rules: - !reference [.default-rules, run-on-mr] tags: @@ -12,7 +22,6 @@ include: parallel: matrix: - RUNNER_ARCH: [arm, intel] - cache: {} ###################################### ### Build Cloudflared Mac Binaries ### diff --git a/.ci/scripts/fmt-check.sh b/.ci/scripts/fmt-check.sh index 3776ec4f355..4af723e072a 100755 --- a/.ci/scripts/fmt-check.sh +++ b/.ci/scripts/fmt-check.sh @@ -1,7 +1,7 @@ #!/bin/bash set -e -u -o pipefail -OUTPUT=$(go run -mod=readonly golang.org/x/tools/cmd/goimports@v0.30.0 -l -d -local github.com/cloudflare/cloudflared $(go list -mod=vendor -f '{{.Dir}}' -a ./... | fgrep -v tunnelrpc)) +OUTPUT=$(go run -mod=readonly golang.org/x/tools/cmd/goimports@v0.30.0 -l -d -local github.com/cloudflare/cloudflared $(go list -mod=readonly -f '{{.Dir}}' -a ./... | fgrep -v tunnelrpc)) if [ -n "$OUTPUT" ] ; then PAGER=$(which colordiff || echo cat) diff --git a/.ci/scripts/mac/build.sh b/.ci/scripts/mac/build.sh index 765c1de518a..b24d17352e2 100755 --- a/.ci/scripts/mac/build.sh +++ b/.ci/scripts/mac/build.sh @@ -36,6 +36,10 @@ mkdir -p ../src/github.com/cloudflare/ cp -r . ../src/github.com/cloudflare/cloudflared cd ../src/github.com/cloudflare/cloudflared +go mod download +# Module downloads must not change the committed dependency lockfiles. +git diff --exit-code -- go.mod go.sum + # Imports certificates to the Apple KeyChain import_certificate() { local CERTIFICATE_NAME=$1 @@ -165,7 +169,7 @@ fi # cleanup the build directory because the previous execution might have failed without cleaning up. rm -rf "${TARGET_DIRECTORY}" export TARGET_OS="darwin" -GOCACHE="$PWD/../../../../" GOPATH="$PWD/../../../../" CGO_ENABLED=1 make cloudflared +CGO_ENABLED=1 make cloudflared # This allows apple tools to use the certificates in the keychain without requiring password input. diff --git a/.ci/scripts/windows/builds.ps1 b/.ci/scripts/windows/builds.ps1 index 3abae290e38..5e285f460b1 100644 --- a/.ci/scripts/windows/builds.ps1 +++ b/.ci/scripts/windows/builds.ps1 @@ -8,6 +8,13 @@ $TIMESTAMP_RFC3161 = "http://timestamp.digicert.com" New-Item -Path ".\artifacts" -ItemType Directory +Write-Output "Downloading Go modules" +go mod download +if ($LASTEXITCODE -ne 0) { throw "Failed to download Go modules" } +# Module downloads must not change the committed dependency lockfiles. +git diff --exit-code -- go.mod go.sum +if ($LASTEXITCODE -ne 0) { throw "Go module download changed module metadata" } + Write-Output "Building for amd64" $env:TARGET_ARCH = "amd64" $env:LOCAL_ARCH = "amd64" diff --git a/.ci/scripts/windows/component-test.ps1 b/.ci/scripts/windows/component-test.ps1 index dea9e115986..6e2e7630040 100644 --- a/.ci/scripts/windows/component-test.ps1 +++ b/.ci/scripts/windows/component-test.ps1 @@ -13,6 +13,11 @@ python -m pip --version Write-Host "Building cloudflared" +go mod download +if ($LASTEXITCODE -ne 0) { throw "Failed to download Go modules" } +# Module downloads must not change the committed dependency lockfiles. +git diff --exit-code -- go.mod go.sum +if ($LASTEXITCODE -ne 0) { throw "Go module download changed module metadata" } & make cloudflared if ($LASTEXITCODE -ne 0) { throw "Failed to build cloudflared" } @@ -20,7 +25,7 @@ if ($LASTEXITCODE -ne 0) { throw "Failed to build cloudflared" } Write-Host "Running unit tests" # Not testing with race detector because of https://github.com/golang/go/issues/61058 # We already test it on other platforms -go test -failfast -v -mod=vendor ./... +go test -failfast -v -mod=readonly ./... if ($LASTEXITCODE -ne 0) { throw "Failed unit tests" } diff --git a/.ci/windows.gitlab-ci.yml b/.ci/windows.gitlab-ci.yml index c2b68b0730c..619836c1c1c 100644 --- a/.ci/windows.gitlab-ci.yml +++ b/.ci/windows.gitlab-ci.yml @@ -10,11 +10,19 @@ include: # causing GitLab's default fetch-and-clean strategy to fail with # "Permission denied" during get_sources. Use a fresh clone instead. GIT_STRATEGY: clone + # Athens is not reachable from Windows runners. + GOPROXY: "https://proxy.golang.org,direct" + cache: + key: + prefix: "$CI_COMMIT_REF_PROTECTED-$GO_VERSION-$CI_RUNNER_EXECUTABLE_ARCH" + files: + - go.sum + paths: + - .cache/go/ rules: - !reference [.default-rules, run-always] tags: - canary-windows-x86 - cache: {} ########################################## ### Build Cloudflared Windows Binaries ### @@ -109,6 +117,7 @@ windows-package-sign: rules: - !reference [.default-rules, run-on-master] stage: package + cache: {} needs: - windows-package - windows-load-env-variables diff --git a/.dockerignore b/.dockerignore index e69de29bb2d..59e22c6424a 100644 --- a/.dockerignore +++ b/.dockerignore @@ -0,0 +1,16 @@ +/tmp +/bin +/.build +/cloudflared +/cloudflared.pkg +/cloudflared.exe +/cloudflared.msi +/cloudflared-x86-64* +/cloudflared.1 +/packaging +/.cover +/built_artifacts +/component-tests/.venv +/component-tests/env +/artifacts +/vendor diff --git a/.gitignore b/.gitignore index 46e818f1544..a9c4772fd95 100644 --- a/.gitignore +++ b/.gitignore @@ -19,3 +19,4 @@ ssh_server_tests/.env built_artifacts/ component-tests/.venv /artifacts +/vendor diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index e290fdec715..570bd5fb43a 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -3,6 +3,10 @@ variables: MAC_GO_VERSION: "go@$GO_VERSION" WIN_GO_VERSION: "go$GO_VERSION" GIT_DEPTH: "0" + # Athens caches public modules for faster CI downloads; direct preserves public fallback. + GOPROXY: "https://athens.cfdata.org|https://proxy.golang.org|direct" + GOMODCACHE: "$CI_PROJECT_DIR/.cache/go/pkg/mod" + GOCACHE: "$CI_PROJECT_DIR/.cache/go/build" default: id_tokens: diff --git a/.golangci.yaml b/.golangci.yaml index b11059fabc8..59bb800d185 100644 --- a/.golangci.yaml +++ b/.golangci.yaml @@ -44,7 +44,7 @@ formatters: run: timeout: 5m - modules-download-mode: vendor + modules-download-mode: readonly # output configuration options output: @@ -77,15 +77,6 @@ issues: # Show issues in any part of update files (requires new-from-rev or new-from-patch). # Default: false whole-files: true - # Which dirs to exclude: issues from them won't be reported. - # Can use regexp here: `generated.*`, regexp is applied on full path, - # including the path prefix if one is set. - # Default dirs are skipped independently of this option's value (see exclude-dirs-use-default). - # "/" will be replaced by current OS file path separator to properly work on Windows. - # Default: [] - exclude-dirs: - - vendor - linters-settings: # Check exhaustiveness of enum switch statements. exhaustive: diff --git a/AGENTS.md b/AGENTS.md index 67f6163c5cd..78346f2084a 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -265,7 +265,6 @@ type TunnelProperties struct { - Use generic package names (`util`, `helper`, `common`) - Commit code that fails `make test lint` - Use `fmt.Print*` instead of structured logging -- Modify vendor dependencies directly - Commit secrets, credentials, or sensitive data - Use deprecated or unsafe Go patterns - Skip testing for new functionality @@ -274,7 +273,10 @@ type TunnelProperties struct { ## Dependencies Management - Use Go modules (`go.mod`) exclusively -- Vendor dependencies for reproducible builds +- Resolve dependencies from the locked module graph with `go mod download`; do not vendor dependencies. +- Builds, tests, vet, and lint use `-mod=readonly`; `go.mod` and `go.sum` must not drift in CI. +- Linux CI uses Athens before public and direct module sources; macOS and Windows use the public proxy directly. +- CI caches modules in `$GOMODCACHE` and compiled packages in `$GOCACHE` under `.cache/go/` for Go-running jobs. - Keep dependencies up-to-date and secure - Prefer standard library when possible - Cloudflared uses a fork of quic-go always check release notes before bumping diff --git a/Dockerfile b/Dockerfile index 4206ae345c7..5bfffee0f63 100644 --- a/Dockerfile +++ b/Dockerfile @@ -4,6 +4,7 @@ ARG TARGET_GOARCH FROM golang:1.26.4 AS builder ENV GO111MODULE=on \ CGO_ENABLED=0 \ + GOPROXY=https://athens.cfdata.org|https://proxy.golang.org|direct \ TARGET_GOOS=${TARGET_GOOS} \ TARGET_GOARCH=${TARGET_GOARCH} \ # the CONTAINER_BUILD envvar is used set github.com/cloudflare/cloudflared/metrics.Runtime=virtual @@ -13,7 +14,10 @@ ENV GO111MODULE=on \ WORKDIR /go/src/github.com/cloudflare/cloudflared/ -# copy our sources into the builder image +# Download dependencies in their own layer so source-only changes reuse it. +COPY go.mod go.sum ./ +RUN go mod download + COPY . . # compile cloudflared diff --git a/Dockerfile.amd64 b/Dockerfile.amd64 index 05d634b8ab0..2e4e37a2086 100644 --- a/Dockerfile.amd64 +++ b/Dockerfile.amd64 @@ -2,13 +2,17 @@ FROM golang:1.26.4 AS builder ENV GO111MODULE=on \ CGO_ENABLED=0 \ + GOPROXY=https://athens.cfdata.org|https://proxy.golang.org|direct \ # the CONTAINER_BUILD envvar is used set github.com/cloudflare/cloudflared/metrics.Runtime=virtual # which changes how cloudflared binds the metrics server CONTAINER_BUILD=1 WORKDIR /go/src/github.com/cloudflare/cloudflared/ -# copy our sources into the builder image +# Download dependencies in their own layer so source-only changes reuse it. +COPY go.mod go.sum ./ +RUN go mod download + COPY . . # compile cloudflared diff --git a/Dockerfile.arm64 b/Dockerfile.arm64 index f17cf9d2363..e1df83439f2 100644 --- a/Dockerfile.arm64 +++ b/Dockerfile.arm64 @@ -2,13 +2,17 @@ FROM golang:1.26.4 AS builder ENV GO111MODULE=on \ CGO_ENABLED=0 \ + GOPROXY=https://athens.cfdata.org|https://proxy.golang.org|direct \ # the CONTAINER_BUILD envvar is used set github.com/cloudflare/cloudflared/metrics.Runtime=virtual # which changes how cloudflared binds the metrics server CONTAINER_BUILD=1 WORKDIR /go/src/github.com/cloudflare/cloudflared/ -# copy our sources into the builder image +# Download dependencies in their own layer so source-only changes reuse it. +COPY go.mod go.sum ./ +RUN go mod download + COPY . . # compile cloudflared diff --git a/Dockerfile.fips.amd64 b/Dockerfile.fips.amd64 index 0081502e1dd..016ea0fb1ee 100644 --- a/Dockerfile.fips.amd64 +++ b/Dockerfile.fips.amd64 @@ -3,13 +3,17 @@ ARG CLOUDFLARE_DOCKER_REGISTRY_HOST FROM ${CLOUDFLARE_DOCKER_REGISTRY_HOST:-registry.cfdata.org}/stash/plat/dockerfiles/debian-trixie-golang-boring/master:1.26.4-1@sha256:6306b83f8fcec303db94ebb69ad2f1f0aea5c09115f845839757afca4699925c AS builder ENV GO111MODULE=on \ CGO_ENABLED=1 \ + GOPROXY=https://athens.cfdata.org|https://proxy.golang.org|direct \ # the CONTAINER_BUILD envvar is used set github.com/cloudflare/cloudflared/metrics.Runtime=virtual # which changes how cloudflared binds the metrics server CONTAINER_BUILD=1 WORKDIR /go/src/github.com/cloudflare/cloudflared/ -# copy our sources into the builder image +# Download dependencies in their own layer so source-only changes reuse it. +COPY go.mod go.sum ./ +RUN go mod download + COPY . . # compile cloudflared diff --git a/Dockerfile.fips.arm64 b/Dockerfile.fips.arm64 index 8a7ff8ec740..c8a0fd47a45 100644 --- a/Dockerfile.fips.arm64 +++ b/Dockerfile.fips.arm64 @@ -3,13 +3,17 @@ ARG CLOUDFLARE_DOCKER_REGISTRY_HOST FROM ${CLOUDFLARE_DOCKER_REGISTRY_HOST:-registry.cfdata.org}/stash/plat/dockerfiles/debian-trixie-golang-boring/master:1.26.4-1@sha256:6306b83f8fcec303db94ebb69ad2f1f0aea5c09115f845839757afca4699925c AS builder ENV GO111MODULE=on \ CGO_ENABLED=1 \ + GOPROXY=https://athens.cfdata.org|https://proxy.golang.org|direct \ # the CONTAINER_BUILD envvar is used set github.com/cloudflare/cloudflared/metrics.Runtime=virtual # which changes how cloudflared binds the metrics server CONTAINER_BUILD=1 WORKDIR /go/src/github.com/cloudflare/cloudflared/ -# copy our sources into the builder image +# Download dependencies in their own layer so source-only changes reuse it. +COPY go.mod go.sum ./ +RUN go mod download + COPY . . # compile cloudflared diff --git a/Makefile b/Makefile index cb6d52c01a0..a18a42c312b 100644 --- a/Makefile +++ b/Makefile @@ -146,7 +146,7 @@ cloudflared: ifeq ($(FIPS), true) $(info Building cloudflared with go-fips) endif - GOOS=$(TARGET_OS) GOARCH=$(TARGET_ARCH) $(ARM_COMMAND) go build -mod=vendor $(GO_BUILD_TAGS) $(LDFLAGS) $(IMPORT_PATH)/cmd/cloudflared + GOOS=$(TARGET_OS) GOARCH=$(TARGET_ARCH) $(ARM_COMMAND) go build -mod=readonly $(GO_BUILD_TAGS) $(LDFLAGS) $(IMPORT_PATH)/cmd/cloudflared ifeq ($(FIPS), true) ./check-fips.sh cloudflared endif @@ -170,7 +170,7 @@ generate-internal-image-version: .PHONY: test test: vet - $Q go test -json -v -mod=vendor -race $(LDFLAGS) ./... 2>&1 | tee $(GO_TEST_LOG_OUTPUT) + $Q go test -json -v -mod=readonly -race $(LDFLAGS) ./... 2>&1 | tee $(GO_TEST_LOG_OUTPUT) ifneq ($(FIPS), true) @go run -mod=readonly github.com/gotesttools/gotestfmt/v2/cmd/gotestfmt@latest -input $(GO_TEST_LOG_OUTPUT) endif @@ -259,12 +259,12 @@ capnp: .PHONY: vet vet: - $Q go vet -mod=vendor github.com/cloudflare/cloudflared/... + $Q go vet -mod=readonly github.com/cloudflare/cloudflared/... .PHONY: fmt fmt: - @goimports -l -w -local github.com/cloudflare/cloudflared $$(go list -mod=vendor -f '{{.Dir}}' -a ./... | fgrep -v tunnelrpc/proto) - @go fmt $$(go list -mod=vendor -f '{{.Dir}}' -a ./... | fgrep -v tunnelrpc/proto) + @goimports -l -w -local github.com/cloudflare/cloudflared $$(go list -mod=readonly -f '{{.Dir}}' -a ./... | fgrep -v tunnelrpc/proto) + @go fmt $$(go list -mod=readonly -f '{{.Dir}}' -a ./... | fgrep -v tunnelrpc/proto) .PHONY: fmt-check fmt-check: diff --git a/check-fips.sh b/check-fips.sh index 98c05af1aff..3b4a9d709bc 100755 --- a/check-fips.sh +++ b/check-fips.sh @@ -1,3 +1,5 @@ +#!/bin/sh + # Pass the path to the executable to check for FIPS compliance exe=$1 diff --git a/go.sum b/go.sum index b8871713ff3..87360e5abfb 100644 --- a/go.sum +++ b/go.sum @@ -105,8 +105,6 @@ github.com/google/gopacket v1.1.19/go.mod h1:iJ8V8n6KS+z2U1A8pUwu8bW5SyEMkXJB8Yo github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= -github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc= -github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/grpc-ecosystem/grpc-gateway/v2 v2.28.0 h1:HWRh5R2+9EifMyIHV7ZV+MIZqgz+PMpZ14Jynv3O2Zs= diff --git a/vendor/github.com/BurntSushi/toml/.gitignore b/vendor/github.com/BurntSushi/toml/.gitignore deleted file mode 100644 index fe79e3adda2..00000000000 --- a/vendor/github.com/BurntSushi/toml/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -/toml.test -/toml-test diff --git a/vendor/github.com/BurntSushi/toml/COPYING b/vendor/github.com/BurntSushi/toml/COPYING deleted file mode 100644 index 01b5743200b..00000000000 --- a/vendor/github.com/BurntSushi/toml/COPYING +++ /dev/null @@ -1,21 +0,0 @@ -The MIT License (MIT) - -Copyright (c) 2013 TOML authors - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. diff --git a/vendor/github.com/BurntSushi/toml/README.md b/vendor/github.com/BurntSushi/toml/README.md deleted file mode 100644 index 3651cfa9609..00000000000 --- a/vendor/github.com/BurntSushi/toml/README.md +++ /dev/null @@ -1,120 +0,0 @@ -TOML stands for Tom's Obvious, Minimal Language. This Go package provides a -reflection interface similar to Go's standard library `json` and `xml` packages. - -Compatible with TOML version [v1.0.0](https://toml.io/en/v1.0.0). - -Documentation: https://godocs.io/github.com/BurntSushi/toml - -See the [releases page](https://github.com/BurntSushi/toml/releases) for a -changelog; this information is also in the git tag annotations (e.g. `git show -v0.4.0`). - -This library requires Go 1.13 or newer; add it to your go.mod with: - - % go get github.com/BurntSushi/toml@latest - -It also comes with a TOML validator CLI tool: - - % go install github.com/BurntSushi/toml/cmd/tomlv@latest - % tomlv some-toml-file.toml - -### Examples -For the simplest example, consider some TOML file as just a list of keys and -values: - -```toml -Age = 25 -Cats = [ "Cauchy", "Plato" ] -Pi = 3.14 -Perfection = [ 6, 28, 496, 8128 ] -DOB = 1987-07-05T05:45:00Z -``` - -Which can be decoded with: - -```go -type Config struct { - Age int - Cats []string - Pi float64 - Perfection []int - DOB time.Time -} - -var conf Config -_, err := toml.Decode(tomlData, &conf) -``` - -You can also use struct tags if your struct field name doesn't map to a TOML key -value directly: - -```toml -some_key_NAME = "wat" -``` - -```go -type TOML struct { - ObscureKey string `toml:"some_key_NAME"` -} -``` - -Beware that like other decoders **only exported fields** are considered when -encoding and decoding; private fields are silently ignored. - -### Using the `Marshaler` and `encoding.TextUnmarshaler` interfaces -Here's an example that automatically parses values in a `mail.Address`: - -```toml -contacts = [ - "Donald Duck ", - "Scrooge McDuck ", -] -``` - -Can be decoded with: - -```go -// Create address type which satisfies the encoding.TextUnmarshaler interface. -type address struct { - *mail.Address -} - -func (a *address) UnmarshalText(text []byte) error { - var err error - a.Address, err = mail.ParseAddress(string(text)) - return err -} - -// Decode it. -func decode() { - blob := ` - contacts = [ - "Donald Duck ", - "Scrooge McDuck ", - ] - ` - - var contacts struct { - Contacts []address - } - - _, err := toml.Decode(blob, &contacts) - if err != nil { - log.Fatal(err) - } - - for _, c := range contacts.Contacts { - fmt.Printf("%#v\n", c.Address) - } - - // Output: - // &mail.Address{Name:"Donald Duck", Address:"donald@duckburg.com"} - // &mail.Address{Name:"Scrooge McDuck", Address:"scrooge@duckburg.com"} -} -``` - -To target TOML specifically you can implement `UnmarshalTOML` TOML interface in -a similar way. - -### More complex usage -See the [`_example/`](/_example) directory for a more complex example. diff --git a/vendor/github.com/BurntSushi/toml/decode.go b/vendor/github.com/BurntSushi/toml/decode.go deleted file mode 100644 index 09523315b83..00000000000 --- a/vendor/github.com/BurntSushi/toml/decode.go +++ /dev/null @@ -1,602 +0,0 @@ -package toml - -import ( - "bytes" - "encoding" - "encoding/json" - "fmt" - "io" - "io/ioutil" - "math" - "os" - "reflect" - "strconv" - "strings" - "time" -) - -// Unmarshaler is the interface implemented by objects that can unmarshal a -// TOML description of themselves. -type Unmarshaler interface { - UnmarshalTOML(interface{}) error -} - -// Unmarshal decodes the contents of `data` in TOML format into a pointer `v`. -func Unmarshal(data []byte, v interface{}) error { - _, err := NewDecoder(bytes.NewReader(data)).Decode(v) - return err -} - -// Decode the TOML data in to the pointer v. -// -// See the documentation on Decoder for a description of the decoding process. -func Decode(data string, v interface{}) (MetaData, error) { - return NewDecoder(strings.NewReader(data)).Decode(v) -} - -// DecodeFile is just like Decode, except it will automatically read the -// contents of the file at path and decode it for you. -func DecodeFile(path string, v interface{}) (MetaData, error) { - fp, err := os.Open(path) - if err != nil { - return MetaData{}, err - } - defer fp.Close() - return NewDecoder(fp).Decode(v) -} - -// Primitive is a TOML value that hasn't been decoded into a Go value. -// -// This type can be used for any value, which will cause decoding to be delayed. -// You can use the PrimitiveDecode() function to "manually" decode these values. -// -// NOTE: The underlying representation of a `Primitive` value is subject to -// change. Do not rely on it. -// -// NOTE: Primitive values are still parsed, so using them will only avoid the -// overhead of reflection. They can be useful when you don't know the exact type -// of TOML data until runtime. -type Primitive struct { - undecoded interface{} - context Key -} - -// The significand precision for float32 and float64 is 24 and 53 bits; this is -// the range a natural number can be stored in a float without loss of data. -const ( - maxSafeFloat32Int = 16777215 // 2^24-1 - maxSafeFloat64Int = int64(9007199254740991) // 2^53-1 -) - -// Decoder decodes TOML data. -// -// TOML tables correspond to Go structs or maps (dealer's choice – they can be -// used interchangeably). -// -// TOML table arrays correspond to either a slice of structs or a slice of maps. -// -// TOML datetimes correspond to Go time.Time values. Local datetimes are parsed -// in the local timezone. -// -// time.Duration types are treated as nanoseconds if the TOML value is an -// integer, or they're parsed with time.ParseDuration() if they're strings. -// -// All other TOML types (float, string, int, bool and array) correspond to the -// obvious Go types. -// -// An exception to the above rules is if a type implements the TextUnmarshaler -// interface, in which case any primitive TOML value (floats, strings, integers, -// booleans, datetimes) will be converted to a []byte and given to the value's -// UnmarshalText method. See the Unmarshaler example for a demonstration with -// email addresses. -// -// Key mapping -// -// TOML keys can map to either keys in a Go map or field names in a Go struct. -// The special `toml` struct tag can be used to map TOML keys to struct fields -// that don't match the key name exactly (see the example). A case insensitive -// match to struct names will be tried if an exact match can't be found. -// -// The mapping between TOML values and Go values is loose. That is, there may -// exist TOML values that cannot be placed into your representation, and there -// may be parts of your representation that do not correspond to TOML values. -// This loose mapping can be made stricter by using the IsDefined and/or -// Undecoded methods on the MetaData returned. -// -// This decoder does not handle cyclic types. Decode will not terminate if a -// cyclic type is passed. -type Decoder struct { - r io.Reader -} - -// NewDecoder creates a new Decoder. -func NewDecoder(r io.Reader) *Decoder { - return &Decoder{r: r} -} - -var ( - unmarshalToml = reflect.TypeOf((*Unmarshaler)(nil)).Elem() - unmarshalText = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem() - primitiveType = reflect.TypeOf((*Primitive)(nil)).Elem() -) - -// Decode TOML data in to the pointer `v`. -func (dec *Decoder) Decode(v interface{}) (MetaData, error) { - rv := reflect.ValueOf(v) - if rv.Kind() != reflect.Ptr { - s := "%q" - if reflect.TypeOf(v) == nil { - s = "%v" - } - - return MetaData{}, fmt.Errorf("toml: cannot decode to non-pointer "+s, reflect.TypeOf(v)) - } - if rv.IsNil() { - return MetaData{}, fmt.Errorf("toml: cannot decode to nil value of %q", reflect.TypeOf(v)) - } - - // Check if this is a supported type: struct, map, interface{}, or something - // that implements UnmarshalTOML or UnmarshalText. - rv = indirect(rv) - rt := rv.Type() - if rv.Kind() != reflect.Struct && rv.Kind() != reflect.Map && - !(rv.Kind() == reflect.Interface && rv.NumMethod() == 0) && - !rt.Implements(unmarshalToml) && !rt.Implements(unmarshalText) { - return MetaData{}, fmt.Errorf("toml: cannot decode to type %s", rt) - } - - // TODO: parser should read from io.Reader? Or at the very least, make it - // read from []byte rather than string - data, err := ioutil.ReadAll(dec.r) - if err != nil { - return MetaData{}, err - } - - p, err := parse(string(data)) - if err != nil { - return MetaData{}, err - } - - md := MetaData{ - mapping: p.mapping, - keyInfo: p.keyInfo, - keys: p.ordered, - decoded: make(map[string]struct{}, len(p.ordered)), - context: nil, - data: data, - } - return md, md.unify(p.mapping, rv) -} - -// PrimitiveDecode is just like the other `Decode*` functions, except it -// decodes a TOML value that has already been parsed. Valid primitive values -// can *only* be obtained from values filled by the decoder functions, -// including this method. (i.e., `v` may contain more `Primitive` -// values.) -// -// Meta data for primitive values is included in the meta data returned by -// the `Decode*` functions with one exception: keys returned by the Undecoded -// method will only reflect keys that were decoded. Namely, any keys hidden -// behind a Primitive will be considered undecoded. Executing this method will -// update the undecoded keys in the meta data. (See the example.) -func (md *MetaData) PrimitiveDecode(primValue Primitive, v interface{}) error { - md.context = primValue.context - defer func() { md.context = nil }() - return md.unify(primValue.undecoded, rvalue(v)) -} - -// unify performs a sort of type unification based on the structure of `rv`, -// which is the client representation. -// -// Any type mismatch produces an error. Finding a type that we don't know -// how to handle produces an unsupported type error. -func (md *MetaData) unify(data interface{}, rv reflect.Value) error { - // Special case. Look for a `Primitive` value. - // TODO: #76 would make this superfluous after implemented. - if rv.Type() == primitiveType { - // Save the undecoded data and the key context into the primitive - // value. - context := make(Key, len(md.context)) - copy(context, md.context) - rv.Set(reflect.ValueOf(Primitive{ - undecoded: data, - context: context, - })) - return nil - } - - rvi := rv.Interface() - if v, ok := rvi.(Unmarshaler); ok { - return v.UnmarshalTOML(data) - } - if v, ok := rvi.(encoding.TextUnmarshaler); ok { - return md.unifyText(data, v) - } - - // TODO: - // The behavior here is incorrect whenever a Go type satisfies the - // encoding.TextUnmarshaler interface but also corresponds to a TOML hash or - // array. In particular, the unmarshaler should only be applied to primitive - // TOML values. But at this point, it will be applied to all kinds of values - // and produce an incorrect error whenever those values are hashes or arrays - // (including arrays of tables). - - k := rv.Kind() - - if k >= reflect.Int && k <= reflect.Uint64 { - return md.unifyInt(data, rv) - } - switch k { - case reflect.Ptr: - elem := reflect.New(rv.Type().Elem()) - err := md.unify(data, reflect.Indirect(elem)) - if err != nil { - return err - } - rv.Set(elem) - return nil - case reflect.Struct: - return md.unifyStruct(data, rv) - case reflect.Map: - return md.unifyMap(data, rv) - case reflect.Array: - return md.unifyArray(data, rv) - case reflect.Slice: - return md.unifySlice(data, rv) - case reflect.String: - return md.unifyString(data, rv) - case reflect.Bool: - return md.unifyBool(data, rv) - case reflect.Interface: - if rv.NumMethod() > 0 { // Only support empty interfaces are supported. - return md.e("unsupported type %s", rv.Type()) - } - return md.unifyAnything(data, rv) - case reflect.Float32, reflect.Float64: - return md.unifyFloat64(data, rv) - } - return md.e("unsupported type %s", rv.Kind()) -} - -func (md *MetaData) unifyStruct(mapping interface{}, rv reflect.Value) error { - tmap, ok := mapping.(map[string]interface{}) - if !ok { - if mapping == nil { - return nil - } - return md.e("type mismatch for %s: expected table but found %T", - rv.Type().String(), mapping) - } - - for key, datum := range tmap { - var f *field - fields := cachedTypeFields(rv.Type()) - for i := range fields { - ff := &fields[i] - if ff.name == key { - f = ff - break - } - if f == nil && strings.EqualFold(ff.name, key) { - f = ff - } - } - if f != nil { - subv := rv - for _, i := range f.index { - subv = indirect(subv.Field(i)) - } - - if isUnifiable(subv) { - md.decoded[md.context.add(key).String()] = struct{}{} - md.context = append(md.context, key) - - err := md.unify(datum, subv) - if err != nil { - return err - } - md.context = md.context[0 : len(md.context)-1] - } else if f.name != "" { - return md.e("cannot write unexported field %s.%s", rv.Type().String(), f.name) - } - } - } - return nil -} - -func (md *MetaData) unifyMap(mapping interface{}, rv reflect.Value) error { - keyType := rv.Type().Key().Kind() - if keyType != reflect.String && keyType != reflect.Interface { - return fmt.Errorf("toml: cannot decode to a map with non-string key type (%s in %q)", - keyType, rv.Type()) - } - - tmap, ok := mapping.(map[string]interface{}) - if !ok { - if tmap == nil { - return nil - } - return md.badtype("map", mapping) - } - if rv.IsNil() { - rv.Set(reflect.MakeMap(rv.Type())) - } - for k, v := range tmap { - md.decoded[md.context.add(k).String()] = struct{}{} - md.context = append(md.context, k) - - rvval := reflect.Indirect(reflect.New(rv.Type().Elem())) - - err := md.unify(v, indirect(rvval)) - if err != nil { - return err - } - md.context = md.context[0 : len(md.context)-1] - - rvkey := indirect(reflect.New(rv.Type().Key())) - - switch keyType { - case reflect.Interface: - rvkey.Set(reflect.ValueOf(k)) - case reflect.String: - rvkey.SetString(k) - } - - rv.SetMapIndex(rvkey, rvval) - } - return nil -} - -func (md *MetaData) unifyArray(data interface{}, rv reflect.Value) error { - datav := reflect.ValueOf(data) - if datav.Kind() != reflect.Slice { - if !datav.IsValid() { - return nil - } - return md.badtype("slice", data) - } - if l := datav.Len(); l != rv.Len() { - return md.e("expected array length %d; got TOML array of length %d", rv.Len(), l) - } - return md.unifySliceArray(datav, rv) -} - -func (md *MetaData) unifySlice(data interface{}, rv reflect.Value) error { - datav := reflect.ValueOf(data) - if datav.Kind() != reflect.Slice { - if !datav.IsValid() { - return nil - } - return md.badtype("slice", data) - } - n := datav.Len() - if rv.IsNil() || rv.Cap() < n { - rv.Set(reflect.MakeSlice(rv.Type(), n, n)) - } - rv.SetLen(n) - return md.unifySliceArray(datav, rv) -} - -func (md *MetaData) unifySliceArray(data, rv reflect.Value) error { - l := data.Len() - for i := 0; i < l; i++ { - err := md.unify(data.Index(i).Interface(), indirect(rv.Index(i))) - if err != nil { - return err - } - } - return nil -} - -func (md *MetaData) unifyString(data interface{}, rv reflect.Value) error { - _, ok := rv.Interface().(json.Number) - if ok { - if i, ok := data.(int64); ok { - rv.SetString(strconv.FormatInt(i, 10)) - } else if f, ok := data.(float64); ok { - rv.SetString(strconv.FormatFloat(f, 'f', -1, 64)) - } else { - return md.badtype("string", data) - } - return nil - } - - if s, ok := data.(string); ok { - rv.SetString(s) - return nil - } - return md.badtype("string", data) -} - -func (md *MetaData) unifyFloat64(data interface{}, rv reflect.Value) error { - rvk := rv.Kind() - - if num, ok := data.(float64); ok { - switch rvk { - case reflect.Float32: - if num < -math.MaxFloat32 || num > math.MaxFloat32 { - return md.parseErr(errParseRange{i: num, size: rvk.String()}) - } - fallthrough - case reflect.Float64: - rv.SetFloat(num) - default: - panic("bug") - } - return nil - } - - if num, ok := data.(int64); ok { - if (rvk == reflect.Float32 && (num < -maxSafeFloat32Int || num > maxSafeFloat32Int)) || - (rvk == reflect.Float64 && (num < -maxSafeFloat64Int || num > maxSafeFloat64Int)) { - return md.parseErr(errParseRange{i: num, size: rvk.String()}) - } - rv.SetFloat(float64(num)) - return nil - } - - return md.badtype("float", data) -} - -func (md *MetaData) unifyInt(data interface{}, rv reflect.Value) error { - _, ok := rv.Interface().(time.Duration) - if ok { - // Parse as string duration, and fall back to regular integer parsing - // (as nanosecond) if this is not a string. - if s, ok := data.(string); ok { - dur, err := time.ParseDuration(s) - if err != nil { - return md.parseErr(errParseDuration{s}) - } - rv.SetInt(int64(dur)) - return nil - } - } - - num, ok := data.(int64) - if !ok { - return md.badtype("integer", data) - } - - rvk := rv.Kind() - switch { - case rvk >= reflect.Int && rvk <= reflect.Int64: - if (rvk == reflect.Int8 && (num < math.MinInt8 || num > math.MaxInt8)) || - (rvk == reflect.Int16 && (num < math.MinInt16 || num > math.MaxInt16)) || - (rvk == reflect.Int32 && (num < math.MinInt32 || num > math.MaxInt32)) { - return md.parseErr(errParseRange{i: num, size: rvk.String()}) - } - rv.SetInt(num) - case rvk >= reflect.Uint && rvk <= reflect.Uint64: - unum := uint64(num) - if rvk == reflect.Uint8 && (num < 0 || unum > math.MaxUint8) || - rvk == reflect.Uint16 && (num < 0 || unum > math.MaxUint16) || - rvk == reflect.Uint32 && (num < 0 || unum > math.MaxUint32) { - return md.parseErr(errParseRange{i: num, size: rvk.String()}) - } - rv.SetUint(unum) - default: - panic("unreachable") - } - return nil -} - -func (md *MetaData) unifyBool(data interface{}, rv reflect.Value) error { - if b, ok := data.(bool); ok { - rv.SetBool(b) - return nil - } - return md.badtype("boolean", data) -} - -func (md *MetaData) unifyAnything(data interface{}, rv reflect.Value) error { - rv.Set(reflect.ValueOf(data)) - return nil -} - -func (md *MetaData) unifyText(data interface{}, v encoding.TextUnmarshaler) error { - var s string - switch sdata := data.(type) { - case Marshaler: - text, err := sdata.MarshalTOML() - if err != nil { - return err - } - s = string(text) - case encoding.TextMarshaler: - text, err := sdata.MarshalText() - if err != nil { - return err - } - s = string(text) - case fmt.Stringer: - s = sdata.String() - case string: - s = sdata - case bool: - s = fmt.Sprintf("%v", sdata) - case int64: - s = fmt.Sprintf("%d", sdata) - case float64: - s = fmt.Sprintf("%f", sdata) - default: - return md.badtype("primitive (string-like)", data) - } - if err := v.UnmarshalText([]byte(s)); err != nil { - return err - } - return nil -} - -func (md *MetaData) badtype(dst string, data interface{}) error { - return md.e("incompatible types: TOML value has type %T; destination has type %s", data, dst) -} - -func (md *MetaData) parseErr(err error) error { - k := md.context.String() - return ParseError{ - LastKey: k, - Position: md.keyInfo[k].pos, - Line: md.keyInfo[k].pos.Line, - err: err, - input: string(md.data), - } -} - -func (md *MetaData) e(format string, args ...interface{}) error { - f := "toml: " - if len(md.context) > 0 { - f = fmt.Sprintf("toml: (last key %q): ", md.context) - p := md.keyInfo[md.context.String()].pos - if p.Line > 0 { - f = fmt.Sprintf("toml: line %d (last key %q): ", p.Line, md.context) - } - } - return fmt.Errorf(f+format, args...) -} - -// rvalue returns a reflect.Value of `v`. All pointers are resolved. -func rvalue(v interface{}) reflect.Value { - return indirect(reflect.ValueOf(v)) -} - -// indirect returns the value pointed to by a pointer. -// -// Pointers are followed until the value is not a pointer. New values are -// allocated for each nil pointer. -// -// An exception to this rule is if the value satisfies an interface of interest -// to us (like encoding.TextUnmarshaler). -func indirect(v reflect.Value) reflect.Value { - if v.Kind() != reflect.Ptr { - if v.CanSet() { - pv := v.Addr() - pvi := pv.Interface() - if _, ok := pvi.(encoding.TextUnmarshaler); ok { - return pv - } - if _, ok := pvi.(Unmarshaler); ok { - return pv - } - } - return v - } - if v.IsNil() { - v.Set(reflect.New(v.Type().Elem())) - } - return indirect(reflect.Indirect(v)) -} - -func isUnifiable(rv reflect.Value) bool { - if rv.CanSet() { - return true - } - rvi := rv.Interface() - if _, ok := rvi.(encoding.TextUnmarshaler); ok { - return true - } - if _, ok := rvi.(Unmarshaler); ok { - return true - } - return false -} diff --git a/vendor/github.com/BurntSushi/toml/decode_go116.go b/vendor/github.com/BurntSushi/toml/decode_go116.go deleted file mode 100644 index eddfb641b86..00000000000 --- a/vendor/github.com/BurntSushi/toml/decode_go116.go +++ /dev/null @@ -1,19 +0,0 @@ -//go:build go1.16 -// +build go1.16 - -package toml - -import ( - "io/fs" -) - -// DecodeFS is just like Decode, except it will automatically read the contents -// of the file at `path` from a fs.FS instance. -func DecodeFS(fsys fs.FS, path string, v interface{}) (MetaData, error) { - fp, err := fsys.Open(path) - if err != nil { - return MetaData{}, err - } - defer fp.Close() - return NewDecoder(fp).Decode(v) -} diff --git a/vendor/github.com/BurntSushi/toml/deprecated.go b/vendor/github.com/BurntSushi/toml/deprecated.go deleted file mode 100644 index c6af3f239dd..00000000000 --- a/vendor/github.com/BurntSushi/toml/deprecated.go +++ /dev/null @@ -1,21 +0,0 @@ -package toml - -import ( - "encoding" - "io" -) - -// Deprecated: use encoding.TextMarshaler -type TextMarshaler encoding.TextMarshaler - -// Deprecated: use encoding.TextUnmarshaler -type TextUnmarshaler encoding.TextUnmarshaler - -// Deprecated: use MetaData.PrimitiveDecode. -func PrimitiveDecode(primValue Primitive, v interface{}) error { - md := MetaData{decoded: make(map[string]struct{})} - return md.unify(primValue.undecoded, rvalue(v)) -} - -// Deprecated: use NewDecoder(reader).Decode(&value). -func DecodeReader(r io.Reader, v interface{}) (MetaData, error) { return NewDecoder(r).Decode(v) } diff --git a/vendor/github.com/BurntSushi/toml/doc.go b/vendor/github.com/BurntSushi/toml/doc.go deleted file mode 100644 index 099c4a77d2d..00000000000 --- a/vendor/github.com/BurntSushi/toml/doc.go +++ /dev/null @@ -1,13 +0,0 @@ -/* -Package toml implements decoding and encoding of TOML files. - -This package supports TOML v1.0.0, as listed on https://toml.io - -There is also support for delaying decoding with the Primitive type, and -querying the set of keys in a TOML document with the MetaData type. - -The github.com/BurntSushi/toml/cmd/tomlv package implements a TOML validator, -and can be used to verify if TOML document is valid. It can also be used to -print the type of each key. -*/ -package toml diff --git a/vendor/github.com/BurntSushi/toml/encode.go b/vendor/github.com/BurntSushi/toml/encode.go deleted file mode 100644 index dc8568d1b9b..00000000000 --- a/vendor/github.com/BurntSushi/toml/encode.go +++ /dev/null @@ -1,736 +0,0 @@ -package toml - -import ( - "bufio" - "encoding" - "encoding/json" - "errors" - "fmt" - "io" - "math" - "reflect" - "sort" - "strconv" - "strings" - "time" - - "github.com/BurntSushi/toml/internal" -) - -type tomlEncodeError struct{ error } - -var ( - errArrayNilElement = errors.New("toml: cannot encode array with nil element") - errNonString = errors.New("toml: cannot encode a map with non-string key type") - errNoKey = errors.New("toml: top-level values must be Go maps or structs") - errAnything = errors.New("") // used in testing -) - -var dblQuotedReplacer = strings.NewReplacer( - "\"", "\\\"", - "\\", "\\\\", - "\x00", `\u0000`, - "\x01", `\u0001`, - "\x02", `\u0002`, - "\x03", `\u0003`, - "\x04", `\u0004`, - "\x05", `\u0005`, - "\x06", `\u0006`, - "\x07", `\u0007`, - "\b", `\b`, - "\t", `\t`, - "\n", `\n`, - "\x0b", `\u000b`, - "\f", `\f`, - "\r", `\r`, - "\x0e", `\u000e`, - "\x0f", `\u000f`, - "\x10", `\u0010`, - "\x11", `\u0011`, - "\x12", `\u0012`, - "\x13", `\u0013`, - "\x14", `\u0014`, - "\x15", `\u0015`, - "\x16", `\u0016`, - "\x17", `\u0017`, - "\x18", `\u0018`, - "\x19", `\u0019`, - "\x1a", `\u001a`, - "\x1b", `\u001b`, - "\x1c", `\u001c`, - "\x1d", `\u001d`, - "\x1e", `\u001e`, - "\x1f", `\u001f`, - "\x7f", `\u007f`, -) - -var ( - marshalToml = reflect.TypeOf((*Marshaler)(nil)).Elem() - marshalText = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem() - timeType = reflect.TypeOf((*time.Time)(nil)).Elem() -) - -// Marshaler is the interface implemented by types that can marshal themselves -// into valid TOML. -type Marshaler interface { - MarshalTOML() ([]byte, error) -} - -// Encoder encodes a Go to a TOML document. -// -// The mapping between Go values and TOML values should be precisely the same as -// for the Decode* functions. -// -// time.Time is encoded as a RFC 3339 string, and time.Duration as its string -// representation. -// -// The toml.Marshaler and encoder.TextMarshaler interfaces are supported to -// encoding the value as custom TOML. -// -// If you want to write arbitrary binary data then you will need to use -// something like base64 since TOML does not have any binary types. -// -// When encoding TOML hashes (Go maps or structs), keys without any sub-hashes -// are encoded first. -// -// Go maps will be sorted alphabetically by key for deterministic output. -// -// The toml struct tag can be used to provide the key name; if omitted the -// struct field name will be used. If the "omitempty" option is present the -// following value will be skipped: -// -// - arrays, slices, maps, and string with len of 0 -// - struct with all zero values -// - bool false -// -// If omitzero is given all int and float types with a value of 0 will be -// skipped. -// -// Encoding Go values without a corresponding TOML representation will return an -// error. Examples of this includes maps with non-string keys, slices with nil -// elements, embedded non-struct types, and nested slices containing maps or -// structs. (e.g. [][]map[string]string is not allowed but []map[string]string -// is okay, as is []map[string][]string). -// -// NOTE: only exported keys are encoded due to the use of reflection. Unexported -// keys are silently discarded. -type Encoder struct { - // String to use for a single indentation level; default is two spaces. - Indent string - - w *bufio.Writer - hasWritten bool // written any output to w yet? -} - -// NewEncoder create a new Encoder. -func NewEncoder(w io.Writer) *Encoder { - return &Encoder{ - w: bufio.NewWriter(w), - Indent: " ", - } -} - -// Encode writes a TOML representation of the Go value to the Encoder's writer. -// -// An error is returned if the value given cannot be encoded to a valid TOML -// document. -func (enc *Encoder) Encode(v interface{}) error { - rv := eindirect(reflect.ValueOf(v)) - if err := enc.safeEncode(Key([]string{}), rv); err != nil { - return err - } - return enc.w.Flush() -} - -func (enc *Encoder) safeEncode(key Key, rv reflect.Value) (err error) { - defer func() { - if r := recover(); r != nil { - if terr, ok := r.(tomlEncodeError); ok { - err = terr.error - return - } - panic(r) - } - }() - enc.encode(key, rv) - return nil -} - -func (enc *Encoder) encode(key Key, rv reflect.Value) { - // If we can marshal the type to text, then we use that. This prevents the - // encoder for handling these types as generic structs (or whatever the - // underlying type of a TextMarshaler is). - switch { - case isMarshaler(rv): - enc.writeKeyValue(key, rv, false) - return - case rv.Type() == primitiveType: // TODO: #76 would make this superfluous after implemented. - enc.encode(key, reflect.ValueOf(rv.Interface().(Primitive).undecoded)) - return - } - - k := rv.Kind() - switch k { - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, - reflect.Int64, - reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, - reflect.Uint64, - reflect.Float32, reflect.Float64, reflect.String, reflect.Bool: - enc.writeKeyValue(key, rv, false) - case reflect.Array, reflect.Slice: - if typeEqual(tomlArrayHash, tomlTypeOfGo(rv)) { - enc.eArrayOfTables(key, rv) - } else { - enc.writeKeyValue(key, rv, false) - } - case reflect.Interface: - if rv.IsNil() { - return - } - enc.encode(key, rv.Elem()) - case reflect.Map: - if rv.IsNil() { - return - } - enc.eTable(key, rv) - case reflect.Ptr: - if rv.IsNil() { - return - } - enc.encode(key, rv.Elem()) - case reflect.Struct: - enc.eTable(key, rv) - default: - encPanic(fmt.Errorf("unsupported type for key '%s': %s", key, k)) - } -} - -// eElement encodes any value that can be an array element. -func (enc *Encoder) eElement(rv reflect.Value) { - switch v := rv.Interface().(type) { - case time.Time: // Using TextMarshaler adds extra quotes, which we don't want. - format := time.RFC3339Nano - switch v.Location() { - case internal.LocalDatetime: - format = "2006-01-02T15:04:05.999999999" - case internal.LocalDate: - format = "2006-01-02" - case internal.LocalTime: - format = "15:04:05.999999999" - } - switch v.Location() { - default: - enc.wf(v.Format(format)) - case internal.LocalDatetime, internal.LocalDate, internal.LocalTime: - enc.wf(v.In(time.UTC).Format(format)) - } - return - case Marshaler: - s, err := v.MarshalTOML() - if err != nil { - encPanic(err) - } - if s == nil { - encPanic(errors.New("MarshalTOML returned nil and no error")) - } - enc.w.Write(s) - return - case encoding.TextMarshaler: - s, err := v.MarshalText() - if err != nil { - encPanic(err) - } - if s == nil { - encPanic(errors.New("MarshalText returned nil and no error")) - } - enc.writeQuoted(string(s)) - return - case time.Duration: - enc.writeQuoted(v.String()) - return - case json.Number: - n, _ := rv.Interface().(json.Number) - - if n == "" { /// Useful zero value. - enc.w.WriteByte('0') - return - } else if v, err := n.Int64(); err == nil { - enc.eElement(reflect.ValueOf(v)) - return - } else if v, err := n.Float64(); err == nil { - enc.eElement(reflect.ValueOf(v)) - return - } - encPanic(errors.New(fmt.Sprintf("Unable to convert \"%s\" to neither int64 nor float64", n))) - } - - switch rv.Kind() { - case reflect.Ptr: - enc.eElement(rv.Elem()) - return - case reflect.String: - enc.writeQuoted(rv.String()) - case reflect.Bool: - enc.wf(strconv.FormatBool(rv.Bool())) - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - enc.wf(strconv.FormatInt(rv.Int(), 10)) - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - enc.wf(strconv.FormatUint(rv.Uint(), 10)) - case reflect.Float32: - f := rv.Float() - if math.IsNaN(f) { - enc.wf("nan") - } else if math.IsInf(f, 0) { - enc.wf("%cinf", map[bool]byte{true: '-', false: '+'}[math.Signbit(f)]) - } else { - enc.wf(floatAddDecimal(strconv.FormatFloat(f, 'f', -1, 32))) - } - case reflect.Float64: - f := rv.Float() - if math.IsNaN(f) { - enc.wf("nan") - } else if math.IsInf(f, 0) { - enc.wf("%cinf", map[bool]byte{true: '-', false: '+'}[math.Signbit(f)]) - } else { - enc.wf(floatAddDecimal(strconv.FormatFloat(f, 'f', -1, 64))) - } - case reflect.Array, reflect.Slice: - enc.eArrayOrSliceElement(rv) - case reflect.Struct: - enc.eStruct(nil, rv, true) - case reflect.Map: - enc.eMap(nil, rv, true) - case reflect.Interface: - enc.eElement(rv.Elem()) - default: - encPanic(fmt.Errorf("unexpected type: %T", rv.Interface())) - } -} - -// By the TOML spec, all floats must have a decimal with at least one number on -// either side. -func floatAddDecimal(fstr string) string { - if !strings.Contains(fstr, ".") { - return fstr + ".0" - } - return fstr -} - -func (enc *Encoder) writeQuoted(s string) { - enc.wf("\"%s\"", dblQuotedReplacer.Replace(s)) -} - -func (enc *Encoder) eArrayOrSliceElement(rv reflect.Value) { - length := rv.Len() - enc.wf("[") - for i := 0; i < length; i++ { - elem := eindirect(rv.Index(i)) - enc.eElement(elem) - if i != length-1 { - enc.wf(", ") - } - } - enc.wf("]") -} - -func (enc *Encoder) eArrayOfTables(key Key, rv reflect.Value) { - if len(key) == 0 { - encPanic(errNoKey) - } - for i := 0; i < rv.Len(); i++ { - trv := eindirect(rv.Index(i)) - if isNil(trv) { - continue - } - enc.newline() - enc.wf("%s[[%s]]", enc.indentStr(key), key) - enc.newline() - enc.eMapOrStruct(key, trv, false) - } -} - -func (enc *Encoder) eTable(key Key, rv reflect.Value) { - if len(key) == 1 { - // Output an extra newline between top-level tables. - // (The newline isn't written if nothing else has been written though.) - enc.newline() - } - if len(key) > 0 { - enc.wf("%s[%s]", enc.indentStr(key), key) - enc.newline() - } - enc.eMapOrStruct(key, rv, false) -} - -func (enc *Encoder) eMapOrStruct(key Key, rv reflect.Value, inline bool) { - switch rv.Kind() { - case reflect.Map: - enc.eMap(key, rv, inline) - case reflect.Struct: - enc.eStruct(key, rv, inline) - default: - // Should never happen? - panic("eTable: unhandled reflect.Value Kind: " + rv.Kind().String()) - } -} - -func (enc *Encoder) eMap(key Key, rv reflect.Value, inline bool) { - rt := rv.Type() - if rt.Key().Kind() != reflect.String { - encPanic(errNonString) - } - - // Sort keys so that we have deterministic output. And write keys directly - // underneath this key first, before writing sub-structs or sub-maps. - var mapKeysDirect, mapKeysSub []string - for _, mapKey := range rv.MapKeys() { - k := mapKey.String() - if typeIsTable(tomlTypeOfGo(eindirect(rv.MapIndex(mapKey)))) { - mapKeysSub = append(mapKeysSub, k) - } else { - mapKeysDirect = append(mapKeysDirect, k) - } - } - - var writeMapKeys = func(mapKeys []string, trailC bool) { - sort.Strings(mapKeys) - for i, mapKey := range mapKeys { - val := eindirect(rv.MapIndex(reflect.ValueOf(mapKey))) - if isNil(val) { - continue - } - - if inline { - enc.writeKeyValue(Key{mapKey}, val, true) - if trailC || i != len(mapKeys)-1 { - enc.wf(", ") - } - } else { - enc.encode(key.add(mapKey), val) - } - } - } - - if inline { - enc.wf("{") - } - writeMapKeys(mapKeysDirect, len(mapKeysSub) > 0) - writeMapKeys(mapKeysSub, false) - if inline { - enc.wf("}") - } -} - -const is32Bit = (32 << (^uint(0) >> 63)) == 32 - -func pointerTo(t reflect.Type) reflect.Type { - if t.Kind() == reflect.Ptr { - return pointerTo(t.Elem()) - } - return t -} - -func (enc *Encoder) eStruct(key Key, rv reflect.Value, inline bool) { - // Write keys for fields directly under this key first, because if we write - // a field that creates a new table then all keys under it will be in that - // table (not the one we're writing here). - // - // Fields is a [][]int: for fieldsDirect this always has one entry (the - // struct index). For fieldsSub it contains two entries: the parent field - // index from tv, and the field indexes for the fields of the sub. - var ( - rt = rv.Type() - fieldsDirect, fieldsSub [][]int - addFields func(rt reflect.Type, rv reflect.Value, start []int) - ) - addFields = func(rt reflect.Type, rv reflect.Value, start []int) { - for i := 0; i < rt.NumField(); i++ { - f := rt.Field(i) - isEmbed := f.Anonymous && pointerTo(f.Type).Kind() == reflect.Struct - if f.PkgPath != "" && !isEmbed { /// Skip unexported fields. - continue - } - opts := getOptions(f.Tag) - if opts.skip { - continue - } - - frv := eindirect(rv.Field(i)) - - // Treat anonymous struct fields with tag names as though they are - // not anonymous, like encoding/json does. - // - // Non-struct anonymous fields use the normal encoding logic. - if isEmbed { - if getOptions(f.Tag).name == "" && frv.Kind() == reflect.Struct { - addFields(frv.Type(), frv, append(start, f.Index...)) - continue - } - } - - if typeIsTable(tomlTypeOfGo(frv)) { - fieldsSub = append(fieldsSub, append(start, f.Index...)) - } else { - // Copy so it works correct on 32bit archs; not clear why this - // is needed. See #314, and https://www.reddit.com/r/golang/comments/pnx8v4 - // This also works fine on 64bit, but 32bit archs are somewhat - // rare and this is a wee bit faster. - if is32Bit { - copyStart := make([]int, len(start)) - copy(copyStart, start) - fieldsDirect = append(fieldsDirect, append(copyStart, f.Index...)) - } else { - fieldsDirect = append(fieldsDirect, append(start, f.Index...)) - } - } - } - } - addFields(rt, rv, nil) - - writeFields := func(fields [][]int) { - for _, fieldIndex := range fields { - fieldType := rt.FieldByIndex(fieldIndex) - fieldVal := eindirect(rv.FieldByIndex(fieldIndex)) - - if isNil(fieldVal) { /// Don't write anything for nil fields. - continue - } - - opts := getOptions(fieldType.Tag) - if opts.skip { - continue - } - keyName := fieldType.Name - if opts.name != "" { - keyName = opts.name - } - if opts.omitempty && isEmpty(fieldVal) { - continue - } - if opts.omitzero && isZero(fieldVal) { - continue - } - - if inline { - enc.writeKeyValue(Key{keyName}, fieldVal, true) - if fieldIndex[0] != len(fields)-1 { - enc.wf(", ") - } - } else { - enc.encode(key.add(keyName), fieldVal) - } - } - } - - if inline { - enc.wf("{") - } - writeFields(fieldsDirect) - writeFields(fieldsSub) - if inline { - enc.wf("}") - } -} - -// tomlTypeOfGo returns the TOML type name of the Go value's type. -// -// It is used to determine whether the types of array elements are mixed (which -// is forbidden). If the Go value is nil, then it is illegal for it to be an -// array element, and valueIsNil is returned as true. -// -// The type may be `nil`, which means no concrete TOML type could be found. -func tomlTypeOfGo(rv reflect.Value) tomlType { - if isNil(rv) || !rv.IsValid() { - return nil - } - - if rv.Kind() == reflect.Struct { - if rv.Type() == timeType { - return tomlDatetime - } - if isMarshaler(rv) { - return tomlString - } - return tomlHash - } - - if isMarshaler(rv) { - return tomlString - } - - switch rv.Kind() { - case reflect.Bool: - return tomlBool - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, - reflect.Int64, - reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, - reflect.Uint64: - return tomlInteger - case reflect.Float32, reflect.Float64: - return tomlFloat - case reflect.Array, reflect.Slice: - if isTableArray(rv) { - return tomlArrayHash - } - return tomlArray - case reflect.Ptr, reflect.Interface: - return tomlTypeOfGo(rv.Elem()) - case reflect.String: - return tomlString - case reflect.Map: - return tomlHash - default: - encPanic(errors.New("unsupported type: " + rv.Kind().String())) - panic("unreachable") - } -} - -func isMarshaler(rv reflect.Value) bool { - return rv.Type().Implements(marshalText) || rv.Type().Implements(marshalToml) -} - -// isTableArray reports if all entries in the array or slice are a table. -func isTableArray(arr reflect.Value) bool { - if isNil(arr) || !arr.IsValid() || arr.Len() == 0 { - return false - } - - ret := true - for i := 0; i < arr.Len(); i++ { - tt := tomlTypeOfGo(eindirect(arr.Index(i))) - // Don't allow nil. - if tt == nil { - encPanic(errArrayNilElement) - } - - if ret && !typeEqual(tomlHash, tt) { - ret = false - } - } - return ret -} - -type tagOptions struct { - skip bool // "-" - name string - omitempty bool - omitzero bool -} - -func getOptions(tag reflect.StructTag) tagOptions { - t := tag.Get("toml") - if t == "-" { - return tagOptions{skip: true} - } - var opts tagOptions - parts := strings.Split(t, ",") - opts.name = parts[0] - for _, s := range parts[1:] { - switch s { - case "omitempty": - opts.omitempty = true - case "omitzero": - opts.omitzero = true - } - } - return opts -} - -func isZero(rv reflect.Value) bool { - switch rv.Kind() { - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - return rv.Int() == 0 - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - return rv.Uint() == 0 - case reflect.Float32, reflect.Float64: - return rv.Float() == 0.0 - } - return false -} - -func isEmpty(rv reflect.Value) bool { - switch rv.Kind() { - case reflect.Array, reflect.Slice, reflect.Map, reflect.String: - return rv.Len() == 0 - case reflect.Struct: - return reflect.Zero(rv.Type()).Interface() == rv.Interface() - case reflect.Bool: - return !rv.Bool() - } - return false -} - -func (enc *Encoder) newline() { - if enc.hasWritten { - enc.wf("\n") - } -} - -// Write a key/value pair: -// -// key = -// -// This is also used for "k = v" in inline tables; so something like this will -// be written in three calls: -// -// ┌────────────────────┐ -// │ ┌───┐ ┌─────┐│ -// v v v v vv -// key = {k = v, k2 = v2} -// -func (enc *Encoder) writeKeyValue(key Key, val reflect.Value, inline bool) { - if len(key) == 0 { - encPanic(errNoKey) - } - enc.wf("%s%s = ", enc.indentStr(key), key.maybeQuoted(len(key)-1)) - enc.eElement(val) - if !inline { - enc.newline() - } -} - -func (enc *Encoder) wf(format string, v ...interface{}) { - _, err := fmt.Fprintf(enc.w, format, v...) - if err != nil { - encPanic(err) - } - enc.hasWritten = true -} - -func (enc *Encoder) indentStr(key Key) string { - return strings.Repeat(enc.Indent, len(key)-1) -} - -func encPanic(err error) { - panic(tomlEncodeError{err}) -} - -// Resolve any level of pointers to the actual value (e.g. **string → string). -func eindirect(v reflect.Value) reflect.Value { - if v.Kind() != reflect.Ptr && v.Kind() != reflect.Interface { - if isMarshaler(v) { - return v - } - if v.CanAddr() { /// Special case for marshalers; see #358. - if pv := v.Addr(); isMarshaler(pv) { - return pv - } - } - return v - } - - if v.IsNil() { - return v - } - - return eindirect(v.Elem()) -} - -func isNil(rv reflect.Value) bool { - switch rv.Kind() { - case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: - return rv.IsNil() - default: - return false - } -} diff --git a/vendor/github.com/BurntSushi/toml/error.go b/vendor/github.com/BurntSushi/toml/error.go deleted file mode 100644 index 2ac24e77eb8..00000000000 --- a/vendor/github.com/BurntSushi/toml/error.go +++ /dev/null @@ -1,276 +0,0 @@ -package toml - -import ( - "fmt" - "strings" -) - -// ParseError is returned when there is an error parsing the TOML syntax. -// -// For example invalid syntax, duplicate keys, etc. -// -// In addition to the error message itself, you can also print detailed location -// information with context by using ErrorWithPosition(): -// -// toml: error: Key 'fruit' was already created and cannot be used as an array. -// -// At line 4, column 2-7: -// -// 2 | fruit = [] -// 3 | -// 4 | [[fruit]] # Not allowed -// ^^^^^ -// -// Furthermore, the ErrorWithUsage() can be used to print the above with some -// more detailed usage guidance: -// -// toml: error: newlines not allowed within inline tables -// -// At line 1, column 18: -// -// 1 | x = [{ key = 42 # -// ^ -// -// Error help: -// -// Inline tables must always be on a single line: -// -// table = {key = 42, second = 43} -// -// It is invalid to split them over multiple lines like so: -// -// # INVALID -// table = { -// key = 42, -// second = 43 -// } -// -// Use regular for this: -// -// [table] -// key = 42 -// second = 43 -type ParseError struct { - Message string // Short technical message. - Usage string // Longer message with usage guidance; may be blank. - Position Position // Position of the error - LastKey string // Last parsed key, may be blank. - Line int // Line the error occurred. Deprecated: use Position. - - err error - input string -} - -// Position of an error. -type Position struct { - Line int // Line number, starting at 1. - Start int // Start of error, as byte offset starting at 0. - Len int // Lenght in bytes. -} - -func (pe ParseError) Error() string { - msg := pe.Message - if msg == "" { // Error from errorf() - msg = pe.err.Error() - } - - if pe.LastKey == "" { - return fmt.Sprintf("toml: line %d: %s", pe.Position.Line, msg) - } - return fmt.Sprintf("toml: line %d (last key %q): %s", - pe.Position.Line, pe.LastKey, msg) -} - -// ErrorWithUsage() returns the error with detailed location context. -// -// See the documentation on ParseError. -func (pe ParseError) ErrorWithPosition() string { - if pe.input == "" { // Should never happen, but just in case. - return pe.Error() - } - - var ( - lines = strings.Split(pe.input, "\n") - col = pe.column(lines) - b = new(strings.Builder) - ) - - msg := pe.Message - if msg == "" { - msg = pe.err.Error() - } - - // TODO: don't show control characters as literals? This may not show up - // well everywhere. - - if pe.Position.Len == 1 { - fmt.Fprintf(b, "toml: error: %s\n\nAt line %d, column %d:\n\n", - msg, pe.Position.Line, col+1) - } else { - fmt.Fprintf(b, "toml: error: %s\n\nAt line %d, column %d-%d:\n\n", - msg, pe.Position.Line, col, col+pe.Position.Len) - } - if pe.Position.Line > 2 { - fmt.Fprintf(b, "% 7d | %s\n", pe.Position.Line-2, lines[pe.Position.Line-3]) - } - if pe.Position.Line > 1 { - fmt.Fprintf(b, "% 7d | %s\n", pe.Position.Line-1, lines[pe.Position.Line-2]) - } - fmt.Fprintf(b, "% 7d | %s\n", pe.Position.Line, lines[pe.Position.Line-1]) - fmt.Fprintf(b, "% 10s%s%s\n", "", strings.Repeat(" ", col), strings.Repeat("^", pe.Position.Len)) - return b.String() -} - -// ErrorWithUsage() returns the error with detailed location context and usage -// guidance. -// -// See the documentation on ParseError. -func (pe ParseError) ErrorWithUsage() string { - m := pe.ErrorWithPosition() - if u, ok := pe.err.(interface{ Usage() string }); ok && u.Usage() != "" { - lines := strings.Split(strings.TrimSpace(u.Usage()), "\n") - for i := range lines { - if lines[i] != "" { - lines[i] = " " + lines[i] - } - } - return m + "Error help:\n\n" + strings.Join(lines, "\n") + "\n" - } - return m -} - -func (pe ParseError) column(lines []string) int { - var pos, col int - for i := range lines { - ll := len(lines[i]) + 1 // +1 for the removed newline - if pos+ll >= pe.Position.Start { - col = pe.Position.Start - pos - if col < 0 { // Should never happen, but just in case. - col = 0 - } - break - } - pos += ll - } - - return col -} - -type ( - errLexControl struct{ r rune } - errLexEscape struct{ r rune } - errLexUTF8 struct{ b byte } - errLexInvalidNum struct{ v string } - errLexInvalidDate struct{ v string } - errLexInlineTableNL struct{} - errLexStringNL struct{} - errParseRange struct { - i interface{} // int or float - size string // "int64", "uint16", etc. - } - errParseDuration struct{ d string } -) - -func (e errLexControl) Error() string { - return fmt.Sprintf("TOML files cannot contain control characters: '0x%02x'", e.r) -} -func (e errLexControl) Usage() string { return "" } - -func (e errLexEscape) Error() string { return fmt.Sprintf(`invalid escape in string '\%c'`, e.r) } -func (e errLexEscape) Usage() string { return usageEscape } -func (e errLexUTF8) Error() string { return fmt.Sprintf("invalid UTF-8 byte: 0x%02x", e.b) } -func (e errLexUTF8) Usage() string { return "" } -func (e errLexInvalidNum) Error() string { return fmt.Sprintf("invalid number: %q", e.v) } -func (e errLexInvalidNum) Usage() string { return "" } -func (e errLexInvalidDate) Error() string { return fmt.Sprintf("invalid date: %q", e.v) } -func (e errLexInvalidDate) Usage() string { return "" } -func (e errLexInlineTableNL) Error() string { return "newlines not allowed within inline tables" } -func (e errLexInlineTableNL) Usage() string { return usageInlineNewline } -func (e errLexStringNL) Error() string { return "strings cannot contain newlines" } -func (e errLexStringNL) Usage() string { return usageStringNewline } -func (e errParseRange) Error() string { return fmt.Sprintf("%v is out of range for %s", e.i, e.size) } -func (e errParseRange) Usage() string { return usageIntOverflow } -func (e errParseDuration) Error() string { return fmt.Sprintf("invalid duration: %q", e.d) } -func (e errParseDuration) Usage() string { return usageDuration } - -const usageEscape = ` -A '\' inside a "-delimited string is interpreted as an escape character. - -The following escape sequences are supported: -\b, \t, \n, \f, \r, \", \\, \uXXXX, and \UXXXXXXXX - -To prevent a '\' from being recognized as an escape character, use either: - -- a ' or '''-delimited string; escape characters aren't processed in them; or -- write two backslashes to get a single backslash: '\\'. - -If you're trying to add a Windows path (e.g. "C:\Users\martin") then using '/' -instead of '\' will usually also work: "C:/Users/martin". -` - -const usageInlineNewline = ` -Inline tables must always be on a single line: - - table = {key = 42, second = 43} - -It is invalid to split them over multiple lines like so: - - # INVALID - table = { - key = 42, - second = 43 - } - -Use regular for this: - - [table] - key = 42 - second = 43 -` - -const usageStringNewline = ` -Strings must always be on a single line, and cannot span more than one line: - - # INVALID - string = "Hello, - world!" - -Instead use """ or ''' to split strings over multiple lines: - - string = """Hello, - world!""" -` - -const usageIntOverflow = ` -This number is too large; this may be an error in the TOML, but it can also be a -bug in the program that uses too small of an integer. - -The maximum and minimum values are: - - size │ lowest │ highest - ───────┼────────────────┼────────── - int8 │ -128 │ 127 - int16 │ -32,768 │ 32,767 - int32 │ -2,147,483,648 │ 2,147,483,647 - int64 │ -9.2 × 10¹⁷ │ 9.2 × 10¹⁷ - uint8 │ 0 │ 255 - uint16 │ 0 │ 65535 - uint32 │ 0 │ 4294967295 - uint64 │ 0 │ 1.8 × 10¹⁸ - -int refers to int32 on 32-bit systems and int64 on 64-bit systems. -` - -const usageDuration = ` -A duration must be as "number", without any spaces. Valid units are: - - ns nanoseconds (billionth of a second) - us, µs microseconds (millionth of a second) - ms milliseconds (thousands of a second) - s seconds - m minutes - h hours - -You can combine multiple units; for example "5m10s" for 5 minutes and 10 -seconds. -` diff --git a/vendor/github.com/BurntSushi/toml/internal/tz.go b/vendor/github.com/BurntSushi/toml/internal/tz.go deleted file mode 100644 index 022f15bc2b8..00000000000 --- a/vendor/github.com/BurntSushi/toml/internal/tz.go +++ /dev/null @@ -1,36 +0,0 @@ -package internal - -import "time" - -// Timezones used for local datetime, date, and time TOML types. -// -// The exact way times and dates without a timezone should be interpreted is not -// well-defined in the TOML specification and left to the implementation. These -// defaults to current local timezone offset of the computer, but this can be -// changed by changing these variables before decoding. -// -// TODO: -// Ideally we'd like to offer people the ability to configure the used timezone -// by setting Decoder.Timezone and Encoder.Timezone; however, this is a bit -// tricky: the reason we use three different variables for this is to support -// round-tripping – without these specific TZ names we wouldn't know which -// format to use. -// -// There isn't a good way to encode this right now though, and passing this sort -// of information also ties in to various related issues such as string format -// encoding, encoding of comments, etc. -// -// So, for the time being, just put this in internal until we can write a good -// comprehensive API for doing all of this. -// -// The reason they're exported is because they're referred from in e.g. -// internal/tag. -// -// Note that this behaviour is valid according to the TOML spec as the exact -// behaviour is left up to implementations. -var ( - localOffset = func() int { _, o := time.Now().Zone(); return o }() - LocalDatetime = time.FixedZone("datetime-local", localOffset) - LocalDate = time.FixedZone("date-local", localOffset) - LocalTime = time.FixedZone("time-local", localOffset) -) diff --git a/vendor/github.com/BurntSushi/toml/lex.go b/vendor/github.com/BurntSushi/toml/lex.go deleted file mode 100644 index 28ed4dd353c..00000000000 --- a/vendor/github.com/BurntSushi/toml/lex.go +++ /dev/null @@ -1,1233 +0,0 @@ -package toml - -import ( - "fmt" - "reflect" - "runtime" - "strings" - "unicode" - "unicode/utf8" -) - -type itemType int - -const ( - itemError itemType = iota - itemNIL // used in the parser to indicate no type - itemEOF - itemText - itemString - itemRawString - itemMultilineString - itemRawMultilineString - itemBool - itemInteger - itemFloat - itemDatetime - itemArray // the start of an array - itemArrayEnd - itemTableStart - itemTableEnd - itemArrayTableStart - itemArrayTableEnd - itemKeyStart - itemKeyEnd - itemCommentStart - itemInlineTableStart - itemInlineTableEnd -) - -const eof = 0 - -type stateFn func(lx *lexer) stateFn - -func (p Position) String() string { - return fmt.Sprintf("at line %d; start %d; length %d", p.Line, p.Start, p.Len) -} - -type lexer struct { - input string - start int - pos int - line int - state stateFn - items chan item - - // Allow for backing up up to 4 runes. This is necessary because TOML - // contains 3-rune tokens (""" and '''). - prevWidths [4]int - nprev int // how many of prevWidths are in use - atEOF bool // If we emit an eof, we can still back up, but it is not OK to call next again. - - // A stack of state functions used to maintain context. - // - // The idea is to reuse parts of the state machine in various places. For - // example, values can appear at the top level or within arbitrarily nested - // arrays. The last state on the stack is used after a value has been lexed. - // Similarly for comments. - stack []stateFn -} - -type item struct { - typ itemType - val string - err error - pos Position -} - -func (lx *lexer) nextItem() item { - for { - select { - case item := <-lx.items: - return item - default: - lx.state = lx.state(lx) - //fmt.Printf(" STATE %-24s current: %-10s stack: %s\n", lx.state, lx.current(), lx.stack) - } - } -} - -func lex(input string) *lexer { - lx := &lexer{ - input: input, - state: lexTop, - items: make(chan item, 10), - stack: make([]stateFn, 0, 10), - line: 1, - } - return lx -} - -func (lx *lexer) push(state stateFn) { - lx.stack = append(lx.stack, state) -} - -func (lx *lexer) pop() stateFn { - if len(lx.stack) == 0 { - return lx.errorf("BUG in lexer: no states to pop") - } - last := lx.stack[len(lx.stack)-1] - lx.stack = lx.stack[0 : len(lx.stack)-1] - return last -} - -func (lx *lexer) current() string { - return lx.input[lx.start:lx.pos] -} - -func (lx lexer) getPos() Position { - p := Position{ - Line: lx.line, - Start: lx.start, - Len: lx.pos - lx.start, - } - if p.Len <= 0 { - p.Len = 1 - } - return p -} - -func (lx *lexer) emit(typ itemType) { - // Needed for multiline strings ending with an incomplete UTF-8 sequence. - if lx.start > lx.pos { - lx.error(errLexUTF8{lx.input[lx.pos]}) - return - } - lx.items <- item{typ: typ, pos: lx.getPos(), val: lx.current()} - lx.start = lx.pos -} - -func (lx *lexer) emitTrim(typ itemType) { - lx.items <- item{typ: typ, pos: lx.getPos(), val: strings.TrimSpace(lx.current())} - lx.start = lx.pos -} - -func (lx *lexer) next() (r rune) { - if lx.atEOF { - panic("BUG in lexer: next called after EOF") - } - if lx.pos >= len(lx.input) { - lx.atEOF = true - return eof - } - - if lx.input[lx.pos] == '\n' { - lx.line++ - } - lx.prevWidths[3] = lx.prevWidths[2] - lx.prevWidths[2] = lx.prevWidths[1] - lx.prevWidths[1] = lx.prevWidths[0] - if lx.nprev < 4 { - lx.nprev++ - } - - r, w := utf8.DecodeRuneInString(lx.input[lx.pos:]) - if r == utf8.RuneError { - lx.error(errLexUTF8{lx.input[lx.pos]}) - return utf8.RuneError - } - - // Note: don't use peek() here, as this calls next(). - if isControl(r) || (r == '\r' && (len(lx.input)-1 == lx.pos || lx.input[lx.pos+1] != '\n')) { - lx.errorControlChar(r) - return utf8.RuneError - } - - lx.prevWidths[0] = w - lx.pos += w - return r -} - -// ignore skips over the pending input before this point. -func (lx *lexer) ignore() { - lx.start = lx.pos -} - -// backup steps back one rune. Can be called 4 times between calls to next. -func (lx *lexer) backup() { - if lx.atEOF { - lx.atEOF = false - return - } - if lx.nprev < 1 { - panic("BUG in lexer: backed up too far") - } - w := lx.prevWidths[0] - lx.prevWidths[0] = lx.prevWidths[1] - lx.prevWidths[1] = lx.prevWidths[2] - lx.prevWidths[2] = lx.prevWidths[3] - lx.nprev-- - - lx.pos -= w - if lx.pos < len(lx.input) && lx.input[lx.pos] == '\n' { - lx.line-- - } -} - -// accept consumes the next rune if it's equal to `valid`. -func (lx *lexer) accept(valid rune) bool { - if lx.next() == valid { - return true - } - lx.backup() - return false -} - -// peek returns but does not consume the next rune in the input. -func (lx *lexer) peek() rune { - r := lx.next() - lx.backup() - return r -} - -// skip ignores all input that matches the given predicate. -func (lx *lexer) skip(pred func(rune) bool) { - for { - r := lx.next() - if pred(r) { - continue - } - lx.backup() - lx.ignore() - return - } -} - -// error stops all lexing by emitting an error and returning `nil`. -// -// Note that any value that is a character is escaped if it's a special -// character (newlines, tabs, etc.). -func (lx *lexer) error(err error) stateFn { - if lx.atEOF { - return lx.errorPrevLine(err) - } - lx.items <- item{typ: itemError, pos: lx.getPos(), err: err} - return nil -} - -// errorfPrevline is like error(), but sets the position to the last column of -// the previous line. -// -// This is so that unexpected EOF or NL errors don't show on a new blank line. -func (lx *lexer) errorPrevLine(err error) stateFn { - pos := lx.getPos() - pos.Line-- - pos.Len = 1 - pos.Start = lx.pos - 1 - lx.items <- item{typ: itemError, pos: pos, err: err} - return nil -} - -// errorPos is like error(), but allows explicitly setting the position. -func (lx *lexer) errorPos(start, length int, err error) stateFn { - pos := lx.getPos() - pos.Start = start - pos.Len = length - lx.items <- item{typ: itemError, pos: pos, err: err} - return nil -} - -// errorf is like error, and creates a new error. -func (lx *lexer) errorf(format string, values ...interface{}) stateFn { - if lx.atEOF { - pos := lx.getPos() - pos.Line-- - pos.Len = 1 - pos.Start = lx.pos - 1 - lx.items <- item{typ: itemError, pos: pos, err: fmt.Errorf(format, values...)} - return nil - } - lx.items <- item{typ: itemError, pos: lx.getPos(), err: fmt.Errorf(format, values...)} - return nil -} - -func (lx *lexer) errorControlChar(cc rune) stateFn { - return lx.errorPos(lx.pos-1, 1, errLexControl{cc}) -} - -// lexTop consumes elements at the top level of TOML data. -func lexTop(lx *lexer) stateFn { - r := lx.next() - if isWhitespace(r) || isNL(r) { - return lexSkip(lx, lexTop) - } - switch r { - case '#': - lx.push(lexTop) - return lexCommentStart - case '[': - return lexTableStart - case eof: - if lx.pos > lx.start { - return lx.errorf("unexpected EOF") - } - lx.emit(itemEOF) - return nil - } - - // At this point, the only valid item can be a key, so we back up - // and let the key lexer do the rest. - lx.backup() - lx.push(lexTopEnd) - return lexKeyStart -} - -// lexTopEnd is entered whenever a top-level item has been consumed. (A value -// or a table.) It must see only whitespace, and will turn back to lexTop -// upon a newline. If it sees EOF, it will quit the lexer successfully. -func lexTopEnd(lx *lexer) stateFn { - r := lx.next() - switch { - case r == '#': - // a comment will read to a newline for us. - lx.push(lexTop) - return lexCommentStart - case isWhitespace(r): - return lexTopEnd - case isNL(r): - lx.ignore() - return lexTop - case r == eof: - lx.emit(itemEOF) - return nil - } - return lx.errorf( - "expected a top-level item to end with a newline, comment, or EOF, but got %q instead", - r) -} - -// lexTable lexes the beginning of a table. Namely, it makes sure that -// it starts with a character other than '.' and ']'. -// It assumes that '[' has already been consumed. -// It also handles the case that this is an item in an array of tables. -// e.g., '[[name]]'. -func lexTableStart(lx *lexer) stateFn { - if lx.peek() == '[' { - lx.next() - lx.emit(itemArrayTableStart) - lx.push(lexArrayTableEnd) - } else { - lx.emit(itemTableStart) - lx.push(lexTableEnd) - } - return lexTableNameStart -} - -func lexTableEnd(lx *lexer) stateFn { - lx.emit(itemTableEnd) - return lexTopEnd -} - -func lexArrayTableEnd(lx *lexer) stateFn { - if r := lx.next(); r != ']' { - return lx.errorf("expected end of table array name delimiter ']', but got %q instead", r) - } - lx.emit(itemArrayTableEnd) - return lexTopEnd -} - -func lexTableNameStart(lx *lexer) stateFn { - lx.skip(isWhitespace) - switch r := lx.peek(); { - case r == ']' || r == eof: - return lx.errorf("unexpected end of table name (table names cannot be empty)") - case r == '.': - return lx.errorf("unexpected table separator (table names cannot be empty)") - case r == '"' || r == '\'': - lx.ignore() - lx.push(lexTableNameEnd) - return lexQuotedName - default: - lx.push(lexTableNameEnd) - return lexBareName - } -} - -// lexTableNameEnd reads the end of a piece of a table name, optionally -// consuming whitespace. -func lexTableNameEnd(lx *lexer) stateFn { - lx.skip(isWhitespace) - switch r := lx.next(); { - case isWhitespace(r): - return lexTableNameEnd - case r == '.': - lx.ignore() - return lexTableNameStart - case r == ']': - return lx.pop() - default: - return lx.errorf("expected '.' or ']' to end table name, but got %q instead", r) - } -} - -// lexBareName lexes one part of a key or table. -// -// It assumes that at least one valid character for the table has already been -// read. -// -// Lexes only one part, e.g. only 'a' inside 'a.b'. -func lexBareName(lx *lexer) stateFn { - r := lx.next() - if isBareKeyChar(r) { - return lexBareName - } - lx.backup() - lx.emit(itemText) - return lx.pop() -} - -// lexBareName lexes one part of a key or table. -// -// It assumes that at least one valid character for the table has already been -// read. -// -// Lexes only one part, e.g. only '"a"' inside '"a".b'. -func lexQuotedName(lx *lexer) stateFn { - r := lx.next() - switch { - case isWhitespace(r): - return lexSkip(lx, lexValue) - case r == '"': - lx.ignore() // ignore the '"' - return lexString - case r == '\'': - lx.ignore() // ignore the "'" - return lexRawString - case r == eof: - return lx.errorf("unexpected EOF; expected value") - default: - return lx.errorf("expected value but found %q instead", r) - } -} - -// lexKeyStart consumes all key parts until a '='. -func lexKeyStart(lx *lexer) stateFn { - lx.skip(isWhitespace) - switch r := lx.peek(); { - case r == '=' || r == eof: - return lx.errorf("unexpected '=': key name appears blank") - case r == '.': - return lx.errorf("unexpected '.': keys cannot start with a '.'") - case r == '"' || r == '\'': - lx.ignore() - fallthrough - default: // Bare key - lx.emit(itemKeyStart) - return lexKeyNameStart - } -} - -func lexKeyNameStart(lx *lexer) stateFn { - lx.skip(isWhitespace) - switch r := lx.peek(); { - case r == '=' || r == eof: - return lx.errorf("unexpected '='") - case r == '.': - return lx.errorf("unexpected '.'") - case r == '"' || r == '\'': - lx.ignore() - lx.push(lexKeyEnd) - return lexQuotedName - default: - lx.push(lexKeyEnd) - return lexBareName - } -} - -// lexKeyEnd consumes the end of a key and trims whitespace (up to the key -// separator). -func lexKeyEnd(lx *lexer) stateFn { - lx.skip(isWhitespace) - switch r := lx.next(); { - case isWhitespace(r): - return lexSkip(lx, lexKeyEnd) - case r == eof: - return lx.errorf("unexpected EOF; expected key separator '='") - case r == '.': - lx.ignore() - return lexKeyNameStart - case r == '=': - lx.emit(itemKeyEnd) - return lexSkip(lx, lexValue) - default: - return lx.errorf("expected '.' or '=', but got %q instead", r) - } -} - -// lexValue starts the consumption of a value anywhere a value is expected. -// lexValue will ignore whitespace. -// After a value is lexed, the last state on the next is popped and returned. -func lexValue(lx *lexer) stateFn { - // We allow whitespace to precede a value, but NOT newlines. - // In array syntax, the array states are responsible for ignoring newlines. - r := lx.next() - switch { - case isWhitespace(r): - return lexSkip(lx, lexValue) - case isDigit(r): - lx.backup() // avoid an extra state and use the same as above - return lexNumberOrDateStart - } - switch r { - case '[': - lx.ignore() - lx.emit(itemArray) - return lexArrayValue - case '{': - lx.ignore() - lx.emit(itemInlineTableStart) - return lexInlineTableValue - case '"': - if lx.accept('"') { - if lx.accept('"') { - lx.ignore() // Ignore """ - return lexMultilineString - } - lx.backup() - } - lx.ignore() // ignore the '"' - return lexString - case '\'': - if lx.accept('\'') { - if lx.accept('\'') { - lx.ignore() // Ignore """ - return lexMultilineRawString - } - lx.backup() - } - lx.ignore() // ignore the "'" - return lexRawString - case '.': // special error case, be kind to users - return lx.errorf("floats must start with a digit, not '.'") - case 'i', 'n': - if (lx.accept('n') && lx.accept('f')) || (lx.accept('a') && lx.accept('n')) { - lx.emit(itemFloat) - return lx.pop() - } - case '-', '+': - return lexDecimalNumberStart - } - if unicode.IsLetter(r) { - // Be permissive here; lexBool will give a nice error if the - // user wrote something like - // x = foo - // (i.e. not 'true' or 'false' but is something else word-like.) - lx.backup() - return lexBool - } - if r == eof { - return lx.errorf("unexpected EOF; expected value") - } - return lx.errorf("expected value but found %q instead", r) -} - -// lexArrayValue consumes one value in an array. It assumes that '[' or ',' -// have already been consumed. All whitespace and newlines are ignored. -func lexArrayValue(lx *lexer) stateFn { - r := lx.next() - switch { - case isWhitespace(r) || isNL(r): - return lexSkip(lx, lexArrayValue) - case r == '#': - lx.push(lexArrayValue) - return lexCommentStart - case r == ',': - return lx.errorf("unexpected comma") - case r == ']': - return lexArrayEnd - } - - lx.backup() - lx.push(lexArrayValueEnd) - return lexValue -} - -// lexArrayValueEnd consumes everything between the end of an array value and -// the next value (or the end of the array): it ignores whitespace and newlines -// and expects either a ',' or a ']'. -func lexArrayValueEnd(lx *lexer) stateFn { - switch r := lx.next(); { - case isWhitespace(r) || isNL(r): - return lexSkip(lx, lexArrayValueEnd) - case r == '#': - lx.push(lexArrayValueEnd) - return lexCommentStart - case r == ',': - lx.ignore() - return lexArrayValue // move on to the next value - case r == ']': - return lexArrayEnd - default: - return lx.errorf("expected a comma (',') or array terminator (']'), but got %s", runeOrEOF(r)) - } -} - -// lexArrayEnd finishes the lexing of an array. -// It assumes that a ']' has just been consumed. -func lexArrayEnd(lx *lexer) stateFn { - lx.ignore() - lx.emit(itemArrayEnd) - return lx.pop() -} - -// lexInlineTableValue consumes one key/value pair in an inline table. -// It assumes that '{' or ',' have already been consumed. Whitespace is ignored. -func lexInlineTableValue(lx *lexer) stateFn { - r := lx.next() - switch { - case isWhitespace(r): - return lexSkip(lx, lexInlineTableValue) - case isNL(r): - return lx.errorPrevLine(errLexInlineTableNL{}) - case r == '#': - lx.push(lexInlineTableValue) - return lexCommentStart - case r == ',': - return lx.errorf("unexpected comma") - case r == '}': - return lexInlineTableEnd - } - lx.backup() - lx.push(lexInlineTableValueEnd) - return lexKeyStart -} - -// lexInlineTableValueEnd consumes everything between the end of an inline table -// key/value pair and the next pair (or the end of the table): -// it ignores whitespace and expects either a ',' or a '}'. -func lexInlineTableValueEnd(lx *lexer) stateFn { - switch r := lx.next(); { - case isWhitespace(r): - return lexSkip(lx, lexInlineTableValueEnd) - case isNL(r): - return lx.errorPrevLine(errLexInlineTableNL{}) - case r == '#': - lx.push(lexInlineTableValueEnd) - return lexCommentStart - case r == ',': - lx.ignore() - lx.skip(isWhitespace) - if lx.peek() == '}' { - return lx.errorf("trailing comma not allowed in inline tables") - } - return lexInlineTableValue - case r == '}': - return lexInlineTableEnd - default: - return lx.errorf("expected a comma or an inline table terminator '}', but got %s instead", runeOrEOF(r)) - } -} - -func runeOrEOF(r rune) string { - if r == eof { - return "end of file" - } - return "'" + string(r) + "'" -} - -// lexInlineTableEnd finishes the lexing of an inline table. -// It assumes that a '}' has just been consumed. -func lexInlineTableEnd(lx *lexer) stateFn { - lx.ignore() - lx.emit(itemInlineTableEnd) - return lx.pop() -} - -// lexString consumes the inner contents of a string. It assumes that the -// beginning '"' has already been consumed and ignored. -func lexString(lx *lexer) stateFn { - r := lx.next() - switch { - case r == eof: - return lx.errorf(`unexpected EOF; expected '"'`) - case isNL(r): - return lx.errorPrevLine(errLexStringNL{}) - case r == '\\': - lx.push(lexString) - return lexStringEscape - case r == '"': - lx.backup() - lx.emit(itemString) - lx.next() - lx.ignore() - return lx.pop() - } - return lexString -} - -// lexMultilineString consumes the inner contents of a string. It assumes that -// the beginning '"""' has already been consumed and ignored. -func lexMultilineString(lx *lexer) stateFn { - r := lx.next() - switch r { - default: - return lexMultilineString - case eof: - return lx.errorf(`unexpected EOF; expected '"""'`) - case '\\': - return lexMultilineStringEscape - case '"': - /// Found " → try to read two more "". - if lx.accept('"') { - if lx.accept('"') { - /// Peek ahead: the string can contain " and "", including at the - /// end: """str""""" - /// 6 or more at the end, however, is an error. - if lx.peek() == '"' { - /// Check if we already lexed 5 's; if so we have 6 now, and - /// that's just too many man! - /// - /// Second check is for the edge case: - /// - /// two quotes allowed. - /// vv - /// """lol \"""""" - /// ^^ ^^^---- closing three - /// escaped - /// - /// But ugly, but it works - if strings.HasSuffix(lx.current(), `"""""`) && !strings.HasSuffix(lx.current(), `\"""""`) { - return lx.errorf(`unexpected '""""""'`) - } - lx.backup() - lx.backup() - return lexMultilineString - } - - lx.backup() /// backup: don't include the """ in the item. - lx.backup() - lx.backup() - lx.emit(itemMultilineString) - lx.next() /// Read over ''' again and discard it. - lx.next() - lx.next() - lx.ignore() - return lx.pop() - } - lx.backup() - } - return lexMultilineString - } -} - -// lexRawString consumes a raw string. Nothing can be escaped in such a string. -// It assumes that the beginning "'" has already been consumed and ignored. -func lexRawString(lx *lexer) stateFn { - r := lx.next() - switch { - default: - return lexRawString - case r == eof: - return lx.errorf(`unexpected EOF; expected "'"`) - case isNL(r): - return lx.errorPrevLine(errLexStringNL{}) - case r == '\'': - lx.backup() - lx.emit(itemRawString) - lx.next() - lx.ignore() - return lx.pop() - } -} - -// lexMultilineRawString consumes a raw string. Nothing can be escaped in such -// a string. It assumes that the beginning "'''" has already been consumed and -// ignored. -func lexMultilineRawString(lx *lexer) stateFn { - r := lx.next() - switch r { - default: - return lexMultilineRawString - case eof: - return lx.errorf(`unexpected EOF; expected "'''"`) - case '\'': - /// Found ' → try to read two more ''. - if lx.accept('\'') { - if lx.accept('\'') { - /// Peek ahead: the string can contain ' and '', including at the - /// end: '''str''''' - /// 6 or more at the end, however, is an error. - if lx.peek() == '\'' { - /// Check if we already lexed 5 's; if so we have 6 now, and - /// that's just too many man! - if strings.HasSuffix(lx.current(), "'''''") { - return lx.errorf(`unexpected "''''''"`) - } - lx.backup() - lx.backup() - return lexMultilineRawString - } - - lx.backup() /// backup: don't include the ''' in the item. - lx.backup() - lx.backup() - lx.emit(itemRawMultilineString) - lx.next() /// Read over ''' again and discard it. - lx.next() - lx.next() - lx.ignore() - return lx.pop() - } - lx.backup() - } - return lexMultilineRawString - } -} - -// lexMultilineStringEscape consumes an escaped character. It assumes that the -// preceding '\\' has already been consumed. -func lexMultilineStringEscape(lx *lexer) stateFn { - if isNL(lx.next()) { /// \ escaping newline. - return lexMultilineString - } - lx.backup() - lx.push(lexMultilineString) - return lexStringEscape(lx) -} - -func lexStringEscape(lx *lexer) stateFn { - r := lx.next() - switch r { - case 'b': - fallthrough - case 't': - fallthrough - case 'n': - fallthrough - case 'f': - fallthrough - case 'r': - fallthrough - case '"': - fallthrough - case ' ', '\t': - // Inside """ .. """ strings you can use \ to escape newlines, and any - // amount of whitespace can be between the \ and \n. - fallthrough - case '\\': - return lx.pop() - case 'u': - return lexShortUnicodeEscape - case 'U': - return lexLongUnicodeEscape - } - return lx.error(errLexEscape{r}) -} - -func lexShortUnicodeEscape(lx *lexer) stateFn { - var r rune - for i := 0; i < 4; i++ { - r = lx.next() - if !isHexadecimal(r) { - return lx.errorf( - `expected four hexadecimal digits after '\u', but got %q instead`, - lx.current()) - } - } - return lx.pop() -} - -func lexLongUnicodeEscape(lx *lexer) stateFn { - var r rune - for i := 0; i < 8; i++ { - r = lx.next() - if !isHexadecimal(r) { - return lx.errorf( - `expected eight hexadecimal digits after '\U', but got %q instead`, - lx.current()) - } - } - return lx.pop() -} - -// lexNumberOrDateStart processes the first character of a value which begins -// with a digit. It exists to catch values starting with '0', so that -// lexBaseNumberOrDate can differentiate base prefixed integers from other -// types. -func lexNumberOrDateStart(lx *lexer) stateFn { - r := lx.next() - switch r { - case '0': - return lexBaseNumberOrDate - } - - if !isDigit(r) { - // The only way to reach this state is if the value starts - // with a digit, so specifically treat anything else as an - // error. - return lx.errorf("expected a digit but got %q", r) - } - - return lexNumberOrDate -} - -// lexNumberOrDate consumes either an integer, float or datetime. -func lexNumberOrDate(lx *lexer) stateFn { - r := lx.next() - if isDigit(r) { - return lexNumberOrDate - } - switch r { - case '-', ':': - return lexDatetime - case '_': - return lexDecimalNumber - case '.', 'e', 'E': - return lexFloat - } - - lx.backup() - lx.emit(itemInteger) - return lx.pop() -} - -// lexDatetime consumes a Datetime, to a first approximation. -// The parser validates that it matches one of the accepted formats. -func lexDatetime(lx *lexer) stateFn { - r := lx.next() - if isDigit(r) { - return lexDatetime - } - switch r { - case '-', ':', 'T', 't', ' ', '.', 'Z', 'z', '+': - return lexDatetime - } - - lx.backup() - lx.emitTrim(itemDatetime) - return lx.pop() -} - -// lexHexInteger consumes a hexadecimal integer after seeing the '0x' prefix. -func lexHexInteger(lx *lexer) stateFn { - r := lx.next() - if isHexadecimal(r) { - return lexHexInteger - } - switch r { - case '_': - return lexHexInteger - } - - lx.backup() - lx.emit(itemInteger) - return lx.pop() -} - -// lexOctalInteger consumes an octal integer after seeing the '0o' prefix. -func lexOctalInteger(lx *lexer) stateFn { - r := lx.next() - if isOctal(r) { - return lexOctalInteger - } - switch r { - case '_': - return lexOctalInteger - } - - lx.backup() - lx.emit(itemInteger) - return lx.pop() -} - -// lexBinaryInteger consumes a binary integer after seeing the '0b' prefix. -func lexBinaryInteger(lx *lexer) stateFn { - r := lx.next() - if isBinary(r) { - return lexBinaryInteger - } - switch r { - case '_': - return lexBinaryInteger - } - - lx.backup() - lx.emit(itemInteger) - return lx.pop() -} - -// lexDecimalNumber consumes a decimal float or integer. -func lexDecimalNumber(lx *lexer) stateFn { - r := lx.next() - if isDigit(r) { - return lexDecimalNumber - } - switch r { - case '.', 'e', 'E': - return lexFloat - case '_': - return lexDecimalNumber - } - - lx.backup() - lx.emit(itemInteger) - return lx.pop() -} - -// lexDecimalNumber consumes the first digit of a number beginning with a sign. -// It assumes the sign has already been consumed. Values which start with a sign -// are only allowed to be decimal integers or floats. -// -// The special "nan" and "inf" values are also recognized. -func lexDecimalNumberStart(lx *lexer) stateFn { - r := lx.next() - - // Special error cases to give users better error messages - switch r { - case 'i': - if !lx.accept('n') || !lx.accept('f') { - return lx.errorf("invalid float: '%s'", lx.current()) - } - lx.emit(itemFloat) - return lx.pop() - case 'n': - if !lx.accept('a') || !lx.accept('n') { - return lx.errorf("invalid float: '%s'", lx.current()) - } - lx.emit(itemFloat) - return lx.pop() - case '0': - p := lx.peek() - switch p { - case 'b', 'o', 'x': - return lx.errorf("cannot use sign with non-decimal numbers: '%s%c'", lx.current(), p) - } - case '.': - return lx.errorf("floats must start with a digit, not '.'") - } - - if isDigit(r) { - return lexDecimalNumber - } - - return lx.errorf("expected a digit but got %q", r) -} - -// lexBaseNumberOrDate differentiates between the possible values which -// start with '0'. It assumes that before reaching this state, the initial '0' -// has been consumed. -func lexBaseNumberOrDate(lx *lexer) stateFn { - r := lx.next() - // Note: All datetimes start with at least two digits, so we don't - // handle date characters (':', '-', etc.) here. - if isDigit(r) { - return lexNumberOrDate - } - switch r { - case '_': - // Can only be decimal, because there can't be an underscore - // between the '0' and the base designator, and dates can't - // contain underscores. - return lexDecimalNumber - case '.', 'e', 'E': - return lexFloat - case 'b': - r = lx.peek() - if !isBinary(r) { - lx.errorf("not a binary number: '%s%c'", lx.current(), r) - } - return lexBinaryInteger - case 'o': - r = lx.peek() - if !isOctal(r) { - lx.errorf("not an octal number: '%s%c'", lx.current(), r) - } - return lexOctalInteger - case 'x': - r = lx.peek() - if !isHexadecimal(r) { - lx.errorf("not a hexidecimal number: '%s%c'", lx.current(), r) - } - return lexHexInteger - } - - lx.backup() - lx.emit(itemInteger) - return lx.pop() -} - -// lexFloat consumes the elements of a float. It allows any sequence of -// float-like characters, so floats emitted by the lexer are only a first -// approximation and must be validated by the parser. -func lexFloat(lx *lexer) stateFn { - r := lx.next() - if isDigit(r) { - return lexFloat - } - switch r { - case '_', '.', '-', '+', 'e', 'E': - return lexFloat - } - - lx.backup() - lx.emit(itemFloat) - return lx.pop() -} - -// lexBool consumes a bool string: 'true' or 'false. -func lexBool(lx *lexer) stateFn { - var rs []rune - for { - r := lx.next() - if !unicode.IsLetter(r) { - lx.backup() - break - } - rs = append(rs, r) - } - s := string(rs) - switch s { - case "true", "false": - lx.emit(itemBool) - return lx.pop() - } - return lx.errorf("expected value but found %q instead", s) -} - -// lexCommentStart begins the lexing of a comment. It will emit -// itemCommentStart and consume no characters, passing control to lexComment. -func lexCommentStart(lx *lexer) stateFn { - lx.ignore() - lx.emit(itemCommentStart) - return lexComment -} - -// lexComment lexes an entire comment. It assumes that '#' has been consumed. -// It will consume *up to* the first newline character, and pass control -// back to the last state on the stack. -func lexComment(lx *lexer) stateFn { - switch r := lx.next(); { - case isNL(r) || r == eof: - lx.backup() - lx.emit(itemText) - return lx.pop() - default: - return lexComment - } -} - -// lexSkip ignores all slurped input and moves on to the next state. -func lexSkip(lx *lexer, nextState stateFn) stateFn { - lx.ignore() - return nextState -} - -func (s stateFn) String() string { - name := runtime.FuncForPC(reflect.ValueOf(s).Pointer()).Name() - if i := strings.LastIndexByte(name, '.'); i > -1 { - name = name[i+1:] - } - if s == nil { - name = "" - } - return name + "()" -} - -func (itype itemType) String() string { - switch itype { - case itemError: - return "Error" - case itemNIL: - return "NIL" - case itemEOF: - return "EOF" - case itemText: - return "Text" - case itemString, itemRawString, itemMultilineString, itemRawMultilineString: - return "String" - case itemBool: - return "Bool" - case itemInteger: - return "Integer" - case itemFloat: - return "Float" - case itemDatetime: - return "DateTime" - case itemTableStart: - return "TableStart" - case itemTableEnd: - return "TableEnd" - case itemKeyStart: - return "KeyStart" - case itemKeyEnd: - return "KeyEnd" - case itemArray: - return "Array" - case itemArrayEnd: - return "ArrayEnd" - case itemCommentStart: - return "CommentStart" - case itemInlineTableStart: - return "InlineTableStart" - case itemInlineTableEnd: - return "InlineTableEnd" - } - panic(fmt.Sprintf("BUG: Unknown type '%d'.", int(itype))) -} - -func (item item) String() string { - return fmt.Sprintf("(%s, %s)", item.typ.String(), item.val) -} - -func isWhitespace(r rune) bool { return r == '\t' || r == ' ' } -func isNL(r rune) bool { return r == '\n' || r == '\r' } -func isControl(r rune) bool { // Control characters except \t, \r, \n - switch r { - case '\t', '\r', '\n': - return false - default: - return (r >= 0x00 && r <= 0x1f) || r == 0x7f - } -} -func isDigit(r rune) bool { return r >= '0' && r <= '9' } -func isBinary(r rune) bool { return r == '0' || r == '1' } -func isOctal(r rune) bool { return r >= '0' && r <= '7' } -func isHexadecimal(r rune) bool { - return (r >= '0' && r <= '9') || (r >= 'a' && r <= 'f') || (r >= 'A' && r <= 'F') -} -func isBareKeyChar(r rune) bool { - return (r >= 'A' && r <= 'Z') || - (r >= 'a' && r <= 'z') || - (r >= '0' && r <= '9') || - r == '_' || r == '-' -} diff --git a/vendor/github.com/BurntSushi/toml/meta.go b/vendor/github.com/BurntSushi/toml/meta.go deleted file mode 100644 index d284f2a0c8a..00000000000 --- a/vendor/github.com/BurntSushi/toml/meta.go +++ /dev/null @@ -1,121 +0,0 @@ -package toml - -import ( - "strings" -) - -// MetaData allows access to meta information about TOML data that's not -// accessible otherwise. -// -// It allows checking if a key is defined in the TOML data, whether any keys -// were undecoded, and the TOML type of a key. -type MetaData struct { - context Key // Used only during decoding. - - keyInfo map[string]keyInfo - mapping map[string]interface{} - keys []Key - decoded map[string]struct{} - data []byte // Input file; for errors. -} - -// IsDefined reports if the key exists in the TOML data. -// -// The key should be specified hierarchically, for example to access the TOML -// key "a.b.c" you would use IsDefined("a", "b", "c"). Keys are case sensitive. -// -// Returns false for an empty key. -func (md *MetaData) IsDefined(key ...string) bool { - if len(key) == 0 { - return false - } - - var ( - hash map[string]interface{} - ok bool - hashOrVal interface{} = md.mapping - ) - for _, k := range key { - if hash, ok = hashOrVal.(map[string]interface{}); !ok { - return false - } - if hashOrVal, ok = hash[k]; !ok { - return false - } - } - return true -} - -// Type returns a string representation of the type of the key specified. -// -// Type will return the empty string if given an empty key or a key that does -// not exist. Keys are case sensitive. -func (md *MetaData) Type(key ...string) string { - if ki, ok := md.keyInfo[Key(key).String()]; ok { - return ki.tomlType.typeString() - } - return "" -} - -// Keys returns a slice of every key in the TOML data, including key groups. -// -// Each key is itself a slice, where the first element is the top of the -// hierarchy and the last is the most specific. The list will have the same -// order as the keys appeared in the TOML data. -// -// All keys returned are non-empty. -func (md *MetaData) Keys() []Key { - return md.keys -} - -// Undecoded returns all keys that have not been decoded in the order in which -// they appear in the original TOML document. -// -// This includes keys that haven't been decoded because of a Primitive value. -// Once the Primitive value is decoded, the keys will be considered decoded. -// -// Also note that decoding into an empty interface will result in no decoding, -// and so no keys will be considered decoded. -// -// In this sense, the Undecoded keys correspond to keys in the TOML document -// that do not have a concrete type in your representation. -func (md *MetaData) Undecoded() []Key { - undecoded := make([]Key, 0, len(md.keys)) - for _, key := range md.keys { - if _, ok := md.decoded[key.String()]; !ok { - undecoded = append(undecoded, key) - } - } - return undecoded -} - -// Key represents any TOML key, including key groups. Use (MetaData).Keys to get -// values of this type. -type Key []string - -func (k Key) String() string { - ss := make([]string, len(k)) - for i := range k { - ss[i] = k.maybeQuoted(i) - } - return strings.Join(ss, ".") -} - -func (k Key) maybeQuoted(i int) string { - if k[i] == "" { - return `""` - } - for _, c := range k[i] { - if !isBareKeyChar(c) { - return `"` + dblQuotedReplacer.Replace(k[i]) + `"` - } - } - return k[i] -} - -func (k Key) add(piece string) Key { - newKey := make(Key, len(k)+1) - copy(newKey, k) - newKey[len(k)] = piece - return newKey -} diff --git a/vendor/github.com/BurntSushi/toml/parse.go b/vendor/github.com/BurntSushi/toml/parse.go deleted file mode 100644 index d2542d6f926..00000000000 --- a/vendor/github.com/BurntSushi/toml/parse.go +++ /dev/null @@ -1,781 +0,0 @@ -package toml - -import ( - "fmt" - "strconv" - "strings" - "time" - "unicode/utf8" - - "github.com/BurntSushi/toml/internal" -) - -type parser struct { - lx *lexer - context Key // Full key for the current hash in scope. - currentKey string // Base key name for everything except hashes. - pos Position // Current position in the TOML file. - - ordered []Key // List of keys in the order that they appear in the TOML data. - - keyInfo map[string]keyInfo // Map keyname → info about the TOML key. - mapping map[string]interface{} // Map keyname → key value. - implicits map[string]struct{} // Record implicit keys (e.g. "key.group.names"). -} - -type keyInfo struct { - pos Position - tomlType tomlType -} - -func parse(data string) (p *parser, err error) { - defer func() { - if r := recover(); r != nil { - if pErr, ok := r.(ParseError); ok { - pErr.input = data - err = pErr - return - } - panic(r) - } - }() - - // Read over BOM; do this here as the lexer calls utf8.DecodeRuneInString() - // which mangles stuff. - if strings.HasPrefix(data, "\xff\xfe") || strings.HasPrefix(data, "\xfe\xff") { - data = data[2:] - } - - // Examine first few bytes for NULL bytes; this probably means it's a UTF-16 - // file (second byte in surrogate pair being NULL). Again, do this here to - // avoid having to deal with UTF-8/16 stuff in the lexer. - ex := 6 - if len(data) < 6 { - ex = len(data) - } - if i := strings.IndexRune(data[:ex], 0); i > -1 { - return nil, ParseError{ - Message: "files cannot contain NULL bytes; probably using UTF-16; TOML files must be UTF-8", - Position: Position{Line: 1, Start: i, Len: 1}, - Line: 1, - input: data, - } - } - - p = &parser{ - keyInfo: make(map[string]keyInfo), - mapping: make(map[string]interface{}), - lx: lex(data), - ordered: make([]Key, 0), - implicits: make(map[string]struct{}), - } - for { - item := p.next() - if item.typ == itemEOF { - break - } - p.topLevel(item) - } - - return p, nil -} - -func (p *parser) panicErr(it item, err error) { - panic(ParseError{ - err: err, - Position: it.pos, - Line: it.pos.Len, - LastKey: p.current(), - }) -} - -func (p *parser) panicItemf(it item, format string, v ...interface{}) { - panic(ParseError{ - Message: fmt.Sprintf(format, v...), - Position: it.pos, - Line: it.pos.Len, - LastKey: p.current(), - }) -} - -func (p *parser) panicf(format string, v ...interface{}) { - panic(ParseError{ - Message: fmt.Sprintf(format, v...), - Position: p.pos, - Line: p.pos.Line, - LastKey: p.current(), - }) -} - -func (p *parser) next() item { - it := p.lx.nextItem() - //fmt.Printf("ITEM %-18s line %-3d │ %q\n", it.typ, it.pos.Line, it.val) - if it.typ == itemError { - if it.err != nil { - panic(ParseError{ - Position: it.pos, - Line: it.pos.Line, - LastKey: p.current(), - err: it.err, - }) - } - - p.panicItemf(it, "%s", it.val) - } - return it -} - -func (p *parser) nextPos() item { - it := p.next() - p.pos = it.pos - return it -} - -func (p *parser) bug(format string, v ...interface{}) { - panic(fmt.Sprintf("BUG: "+format+"\n\n", v...)) -} - -func (p *parser) expect(typ itemType) item { - it := p.next() - p.assertEqual(typ, it.typ) - return it -} - -func (p *parser) assertEqual(expected, got itemType) { - if expected != got { - p.bug("Expected '%s' but got '%s'.", expected, got) - } -} - -func (p *parser) topLevel(item item) { - switch item.typ { - case itemCommentStart: // # .. - p.expect(itemText) - case itemTableStart: // [ .. ] - name := p.nextPos() - - var key Key - for ; name.typ != itemTableEnd && name.typ != itemEOF; name = p.next() { - key = append(key, p.keyString(name)) - } - p.assertEqual(itemTableEnd, name.typ) - - p.addContext(key, false) - p.setType("", tomlHash, item.pos) - p.ordered = append(p.ordered, key) - case itemArrayTableStart: // [[ .. ]] - name := p.nextPos() - - var key Key - for ; name.typ != itemArrayTableEnd && name.typ != itemEOF; name = p.next() { - key = append(key, p.keyString(name)) - } - p.assertEqual(itemArrayTableEnd, name.typ) - - p.addContext(key, true) - p.setType("", tomlArrayHash, item.pos) - p.ordered = append(p.ordered, key) - case itemKeyStart: // key = .. - outerContext := p.context - /// Read all the key parts (e.g. 'a' and 'b' in 'a.b') - k := p.nextPos() - var key Key - for ; k.typ != itemKeyEnd && k.typ != itemEOF; k = p.next() { - key = append(key, p.keyString(k)) - } - p.assertEqual(itemKeyEnd, k.typ) - - /// The current key is the last part. - p.currentKey = key[len(key)-1] - - /// All the other parts (if any) are the context; need to set each part - /// as implicit. - context := key[:len(key)-1] - for i := range context { - p.addImplicitContext(append(p.context, context[i:i+1]...)) - } - - /// Set value. - vItem := p.next() - val, typ := p.value(vItem, false) - p.set(p.currentKey, val, typ, vItem.pos) - p.ordered = append(p.ordered, p.context.add(p.currentKey)) - - /// Remove the context we added (preserving any context from [tbl] lines). - p.context = outerContext - p.currentKey = "" - default: - p.bug("Unexpected type at top level: %s", item.typ) - } -} - -// Gets a string for a key (or part of a key in a table name). -func (p *parser) keyString(it item) string { - switch it.typ { - case itemText: - return it.val - case itemString, itemMultilineString, - itemRawString, itemRawMultilineString: - s, _ := p.value(it, false) - return s.(string) - default: - p.bug("Unexpected key type: %s", it.typ) - } - panic("unreachable") -} - -var datetimeRepl = strings.NewReplacer( - "z", "Z", - "t", "T", - " ", "T") - -// value translates an expected value from the lexer into a Go value wrapped -// as an empty interface. -func (p *parser) value(it item, parentIsArray bool) (interface{}, tomlType) { - switch it.typ { - case itemString: - return p.replaceEscapes(it, it.val), p.typeOfPrimitive(it) - case itemMultilineString: - return p.replaceEscapes(it, stripFirstNewline(p.stripEscapedNewlines(it.val))), p.typeOfPrimitive(it) - case itemRawString: - return it.val, p.typeOfPrimitive(it) - case itemRawMultilineString: - return stripFirstNewline(it.val), p.typeOfPrimitive(it) - case itemInteger: - return p.valueInteger(it) - case itemFloat: - return p.valueFloat(it) - case itemBool: - switch it.val { - case "true": - return true, p.typeOfPrimitive(it) - case "false": - return false, p.typeOfPrimitive(it) - default: - p.bug("Expected boolean value, but got '%s'.", it.val) - } - case itemDatetime: - return p.valueDatetime(it) - case itemArray: - return p.valueArray(it) - case itemInlineTableStart: - return p.valueInlineTable(it, parentIsArray) - default: - p.bug("Unexpected value type: %s", it.typ) - } - panic("unreachable") -} - -func (p *parser) valueInteger(it item) (interface{}, tomlType) { - if !numUnderscoresOK(it.val) { - p.panicItemf(it, "Invalid integer %q: underscores must be surrounded by digits", it.val) - } - if numHasLeadingZero(it.val) { - p.panicItemf(it, "Invalid integer %q: cannot have leading zeroes", it.val) - } - - num, err := strconv.ParseInt(it.val, 0, 64) - if err != nil { - // Distinguish integer values. Normally, it'd be a bug if the lexer - // provides an invalid integer, but it's possible that the number is - // out of range of valid values (which the lexer cannot determine). - // So mark the former as a bug but the latter as a legitimate user - // error. - if e, ok := err.(*strconv.NumError); ok && e.Err == strconv.ErrRange { - p.panicErr(it, errParseRange{i: it.val, size: "int64"}) - } else { - p.bug("Expected integer value, but got '%s'.", it.val) - } - } - return num, p.typeOfPrimitive(it) -} - -func (p *parser) valueFloat(it item) (interface{}, tomlType) { - parts := strings.FieldsFunc(it.val, func(r rune) bool { - switch r { - case '.', 'e', 'E': - return true - } - return false - }) - for _, part := range parts { - if !numUnderscoresOK(part) { - p.panicItemf(it, "Invalid float %q: underscores must be surrounded by digits", it.val) - } - } - if len(parts) > 0 && numHasLeadingZero(parts[0]) { - p.panicItemf(it, "Invalid float %q: cannot have leading zeroes", it.val) - } - if !numPeriodsOK(it.val) { - // As a special case, numbers like '123.' or '1.e2', - // which are valid as far as Go/strconv are concerned, - // must be rejected because TOML says that a fractional - // part consists of '.' followed by 1+ digits. - p.panicItemf(it, "Invalid float %q: '.' must be followed by one or more digits", it.val) - } - val := strings.Replace(it.val, "_", "", -1) - if val == "+nan" || val == "-nan" { // Go doesn't support this, but TOML spec does. - val = "nan" - } - num, err := strconv.ParseFloat(val, 64) - if err != nil { - if e, ok := err.(*strconv.NumError); ok && e.Err == strconv.ErrRange { - p.panicErr(it, errParseRange{i: it.val, size: "float64"}) - } else { - p.panicItemf(it, "Invalid float value: %q", it.val) - } - } - return num, p.typeOfPrimitive(it) -} - -var dtTypes = []struct { - fmt string - zone *time.Location -}{ - {time.RFC3339Nano, time.Local}, - {"2006-01-02T15:04:05.999999999", internal.LocalDatetime}, - {"2006-01-02", internal.LocalDate}, - {"15:04:05.999999999", internal.LocalTime}, -} - -func (p *parser) valueDatetime(it item) (interface{}, tomlType) { - it.val = datetimeRepl.Replace(it.val) - var ( - t time.Time - ok bool - err error - ) - for _, dt := range dtTypes { - t, err = time.ParseInLocation(dt.fmt, it.val, dt.zone) - if err == nil { - ok = true - break - } - } - if !ok { - p.panicItemf(it, "Invalid TOML Datetime: %q.", it.val) - } - return t, p.typeOfPrimitive(it) -} - -func (p *parser) valueArray(it item) (interface{}, tomlType) { - p.setType(p.currentKey, tomlArray, it.pos) - - var ( - types []tomlType - - // Initialize to a non-nil empty slice. This makes it consistent with - // how S = [] decodes into a non-nil slice inside something like struct - // { S []string }. See #338 - array = []interface{}{} - ) - for it = p.next(); it.typ != itemArrayEnd; it = p.next() { - if it.typ == itemCommentStart { - p.expect(itemText) - continue - } - - val, typ := p.value(it, true) - array = append(array, val) - types = append(types, typ) - - // XXX: types isn't used here, we need it to record the accurate type - // information. - // - // Not entirely sure how to best store this; could use "key[0]", - // "key[1]" notation, or maybe store it on the Array type? - } - return array, tomlArray -} - -func (p *parser) valueInlineTable(it item, parentIsArray bool) (interface{}, tomlType) { - var ( - hash = make(map[string]interface{}) - outerContext = p.context - outerKey = p.currentKey - ) - - p.context = append(p.context, p.currentKey) - prevContext := p.context - p.currentKey = "" - - p.addImplicit(p.context) - p.addContext(p.context, parentIsArray) - - /// Loop over all table key/value pairs. - for it := p.next(); it.typ != itemInlineTableEnd; it = p.next() { - if it.typ == itemCommentStart { - p.expect(itemText) - continue - } - - /// Read all key parts. - k := p.nextPos() - var key Key - for ; k.typ != itemKeyEnd && k.typ != itemEOF; k = p.next() { - key = append(key, p.keyString(k)) - } - p.assertEqual(itemKeyEnd, k.typ) - - /// The current key is the last part. - p.currentKey = key[len(key)-1] - - /// All the other parts (if any) are the context; need to set each part - /// as implicit. - context := key[:len(key)-1] - for i := range context { - p.addImplicitContext(append(p.context, context[i:i+1]...)) - } - - /// Set the value. - val, typ := p.value(p.next(), false) - p.set(p.currentKey, val, typ, it.pos) - p.ordered = append(p.ordered, p.context.add(p.currentKey)) - hash[p.currentKey] = val - - /// Restore context. - p.context = prevContext - } - p.context = outerContext - p.currentKey = outerKey - return hash, tomlHash -} - -// numHasLeadingZero checks if this number has leading zeroes, allowing for '0', -// +/- signs, and base prefixes. -func numHasLeadingZero(s string) bool { - if len(s) > 1 && s[0] == '0' && !(s[1] == 'b' || s[1] == 'o' || s[1] == 'x') { // Allow 0b, 0o, 0x - return true - } - if len(s) > 2 && (s[0] == '-' || s[0] == '+') && s[1] == '0' { - return true - } - return false -} - -// numUnderscoresOK checks whether each underscore in s is surrounded by -// characters that are not underscores. -func numUnderscoresOK(s string) bool { - switch s { - case "nan", "+nan", "-nan", "inf", "-inf", "+inf": - return true - } - accept := false - for _, r := range s { - if r == '_' { - if !accept { - return false - } - } - - // isHexadecimal is a superset of all the permissable characters - // surrounding an underscore. - accept = isHexadecimal(r) - } - return accept -} - -// numPeriodsOK checks whether every period in s is followed by a digit. -func numPeriodsOK(s string) bool { - period := false - for _, r := range s { - if period && !isDigit(r) { - return false - } - period = r == '.' - } - return !period -} - -// Set the current context of the parser, where the context is either a hash or -// an array of hashes, depending on the value of the `array` parameter. -// -// Establishing the context also makes sure that the key isn't a duplicate, and -// will create implicit hashes automatically. -func (p *parser) addContext(key Key, array bool) { - var ok bool - - // Always start at the top level and drill down for our context. - hashContext := p.mapping - keyContext := make(Key, 0) - - // We only need implicit hashes for key[0:-1] - for _, k := range key[0 : len(key)-1] { - _, ok = hashContext[k] - keyContext = append(keyContext, k) - - // No key? Make an implicit hash and move on. - if !ok { - p.addImplicit(keyContext) - hashContext[k] = make(map[string]interface{}) - } - - // If the hash context is actually an array of tables, then set - // the hash context to the last element in that array. - // - // Otherwise, it better be a table, since this MUST be a key group (by - // virtue of it not being the last element in a key). - switch t := hashContext[k].(type) { - case []map[string]interface{}: - hashContext = t[len(t)-1] - case map[string]interface{}: - hashContext = t - default: - p.panicf("Key '%s' was already created as a hash.", keyContext) - } - } - - p.context = keyContext - if array { - // If this is the first element for this array, then allocate a new - // list of tables for it. - k := key[len(key)-1] - if _, ok := hashContext[k]; !ok { - hashContext[k] = make([]map[string]interface{}, 0, 4) - } - - // Add a new table. But make sure the key hasn't already been used - // for something else. - if hash, ok := hashContext[k].([]map[string]interface{}); ok { - hashContext[k] = append(hash, make(map[string]interface{})) - } else { - p.panicf("Key '%s' was already created and cannot be used as an array.", key) - } - } else { - p.setValue(key[len(key)-1], make(map[string]interface{})) - } - p.context = append(p.context, key[len(key)-1]) -} - -// set calls setValue and setType. -func (p *parser) set(key string, val interface{}, typ tomlType, pos Position) { - p.setValue(key, val) - p.setType(key, typ, pos) - -} - -// setValue sets the given key to the given value in the current context. -// It will make sure that the key hasn't already been defined, account for -// implicit key groups. -func (p *parser) setValue(key string, value interface{}) { - var ( - tmpHash interface{} - ok bool - hash = p.mapping - keyContext Key - ) - for _, k := range p.context { - keyContext = append(keyContext, k) - if tmpHash, ok = hash[k]; !ok { - p.bug("Context for key '%s' has not been established.", keyContext) - } - switch t := tmpHash.(type) { - case []map[string]interface{}: - // The context is a table of hashes. Pick the most recent table - // defined as the current hash. - hash = t[len(t)-1] - case map[string]interface{}: - hash = t - default: - p.panicf("Key '%s' has already been defined.", keyContext) - } - } - keyContext = append(keyContext, key) - - if _, ok := hash[key]; ok { - // Normally redefining keys isn't allowed, but the key could have been - // defined implicitly and it's allowed to be redefined concretely. (See - // the `valid/implicit-and-explicit-after.toml` in toml-test) - // - // But we have to make sure to stop marking it as an implicit. (So that - // another redefinition provokes an error.) - // - // Note that since it has already been defined (as a hash), we don't - // want to overwrite it. So our business is done. - if p.isArray(keyContext) { - p.removeImplicit(keyContext) - hash[key] = value - return - } - if p.isImplicit(keyContext) { - p.removeImplicit(keyContext) - return - } - - // Otherwise, we have a concrete key trying to override a previous - // key, which is *always* wrong. - p.panicf("Key '%s' has already been defined.", keyContext) - } - - hash[key] = value -} - -// setType sets the type of a particular value at a given key. It should be -// called immediately AFTER setValue. -// -// Note that if `key` is empty, then the type given will be applied to the -// current context (which is either a table or an array of tables). -func (p *parser) setType(key string, typ tomlType, pos Position) { - keyContext := make(Key, 0, len(p.context)+1) - keyContext = append(keyContext, p.context...) - if len(key) > 0 { // allow type setting for hashes - keyContext = append(keyContext, key) - } - // Special case to make empty keys ("" = 1) work. - // Without it it will set "" rather than `""`. - // TODO: why is this needed? And why is this only needed here? - if len(keyContext) == 0 { - keyContext = Key{""} - } - p.keyInfo[keyContext.String()] = keyInfo{tomlType: typ, pos: pos} -} - -// Implicit keys need to be created when tables are implied in "a.b.c.d = 1" and -// "[a.b.c]" (the "a", "b", and "c" hashes are never created explicitly). -func (p *parser) addImplicit(key Key) { p.implicits[key.String()] = struct{}{} } -func (p *parser) removeImplicit(key Key) { delete(p.implicits, key.String()) } -func (p *parser) isImplicit(key Key) bool { _, ok := p.implicits[key.String()]; return ok } -func (p *parser) isArray(key Key) bool { return p.keyInfo[key.String()].tomlType == tomlArray } -func (p *parser) addImplicitContext(key Key) { - p.addImplicit(key) - p.addContext(key, false) -} - -// current returns the full key name of the current context. -func (p *parser) current() string { - if len(p.currentKey) == 0 { - return p.context.String() - } - if len(p.context) == 0 { - return p.currentKey - } - return fmt.Sprintf("%s.%s", p.context, p.currentKey) -} - -func stripFirstNewline(s string) string { - if len(s) > 0 && s[0] == '\n' { - return s[1:] - } - if len(s) > 1 && s[0] == '\r' && s[1] == '\n' { - return s[2:] - } - return s -} - -// Remove newlines inside triple-quoted strings if a line ends with "\". -func (p *parser) stripEscapedNewlines(s string) string { - split := strings.Split(s, "\n") - if len(split) < 1 { - return s - } - - escNL := false // Keep track of the last non-blank line was escaped. - for i, line := range split { - line = strings.TrimRight(line, " \t\r") - - if len(line) == 0 || line[len(line)-1] != '\\' { - split[i] = strings.TrimRight(split[i], "\r") - if !escNL && i != len(split)-1 { - split[i] += "\n" - } - continue - } - - escBS := true - for j := len(line) - 1; j >= 0 && line[j] == '\\'; j-- { - escBS = !escBS - } - if escNL { - line = strings.TrimLeft(line, " \t\r") - } - escNL = !escBS - - if escBS { - split[i] += "\n" - continue - } - - if i == len(split)-1 { - p.panicf("invalid escape: '\\ '") - } - - split[i] = line[:len(line)-1] // Remove \ - if len(split)-1 > i { - split[i+1] = strings.TrimLeft(split[i+1], " \t\r") - } - } - return strings.Join(split, "") -} - -func (p *parser) replaceEscapes(it item, str string) string { - replaced := make([]rune, 0, len(str)) - s := []byte(str) - r := 0 - for r < len(s) { - if s[r] != '\\' { - c, size := utf8.DecodeRune(s[r:]) - r += size - replaced = append(replaced, c) - continue - } - r += 1 - if r >= len(s) { - p.bug("Escape sequence at end of string.") - return "" - } - switch s[r] { - default: - p.bug("Expected valid escape code after \\, but got %q.", s[r]) - case ' ', '\t': - p.panicItemf(it, "invalid escape: '\\%c'", s[r]) - case 'b': - replaced = append(replaced, rune(0x0008)) - r += 1 - case 't': - replaced = append(replaced, rune(0x0009)) - r += 1 - case 'n': - replaced = append(replaced, rune(0x000A)) - r += 1 - case 'f': - replaced = append(replaced, rune(0x000C)) - r += 1 - case 'r': - replaced = append(replaced, rune(0x000D)) - r += 1 - case '"': - replaced = append(replaced, rune(0x0022)) - r += 1 - case '\\': - replaced = append(replaced, rune(0x005C)) - r += 1 - case 'u': - // At this point, we know we have a Unicode escape of the form - // `uXXXX` at [r, r+5). (Because the lexer guarantees this - // for us.) - escaped := p.asciiEscapeToUnicode(it, s[r+1:r+5]) - replaced = append(replaced, escaped) - r += 5 - case 'U': - // At this point, we know we have a Unicode escape of the form - // `uXXXX` at [r, r+9). (Because the lexer guarantees this - // for us.) - escaped := p.asciiEscapeToUnicode(it, s[r+1:r+9]) - replaced = append(replaced, escaped) - r += 9 - } - } - return string(replaced) -} - -func (p *parser) asciiEscapeToUnicode(it item, bs []byte) rune { - s := string(bs) - hex, err := strconv.ParseUint(strings.ToLower(s), 16, 32) - if err != nil { - p.bug("Could not parse '%s' as a hexadecimal number, but the lexer claims it's OK: %s", s, err) - } - if !utf8.ValidRune(rune(hex)) { - p.panicItemf(it, "Escaped character '\\u%s' is not valid UTF-8.", s) - } - return rune(hex) -} diff --git a/vendor/github.com/BurntSushi/toml/type_fields.go b/vendor/github.com/BurntSushi/toml/type_fields.go deleted file mode 100644 index 254ca82e549..00000000000 --- a/vendor/github.com/BurntSushi/toml/type_fields.go +++ /dev/null @@ -1,242 +0,0 @@ -package toml - -// Struct field handling is adapted from code in encoding/json: -// -// Copyright 2010 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the Go distribution. - -import ( - "reflect" - "sort" - "sync" -) - -// A field represents a single field found in a struct. -type field struct { - name string // the name of the field (`toml` tag included) - tag bool // whether field has a `toml` tag - index []int // represents the depth of an anonymous field - typ reflect.Type // the type of the field -} - -// byName sorts field by name, breaking ties with depth, -// then breaking ties with "name came from toml tag", then -// breaking ties with index sequence. -type byName []field - -func (x byName) Len() int { return len(x) } - -func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] } - -func (x byName) Less(i, j int) bool { - if x[i].name != x[j].name { - return x[i].name < x[j].name - } - if len(x[i].index) != len(x[j].index) { - return len(x[i].index) < len(x[j].index) - } - if x[i].tag != x[j].tag { - return x[i].tag - } - return byIndex(x).Less(i, j) -} - -// byIndex sorts field by index sequence. -type byIndex []field - -func (x byIndex) Len() int { return len(x) } - -func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] } - -func (x byIndex) Less(i, j int) bool { - for k, xik := range x[i].index { - if k >= len(x[j].index) { - return false - } - if xik != x[j].index[k] { - return xik < x[j].index[k] - } - } - return len(x[i].index) < len(x[j].index) -} - -// typeFields returns a list of fields that TOML should recognize for the given -// type. The algorithm is breadth-first search over the set of structs to -// include - the top struct and then any reachable anonymous structs. -func typeFields(t reflect.Type) []field { - // Anonymous fields to explore at the current level and the next. - current := []field{} - next := []field{{typ: t}} - - // Count of queued names for current level and the next. - var count map[reflect.Type]int - var nextCount map[reflect.Type]int - - // Types already visited at an earlier level. - visited := map[reflect.Type]bool{} - - // Fields found. - var fields []field - - for len(next) > 0 { - current, next = next, current[:0] - count, nextCount = nextCount, map[reflect.Type]int{} - - for _, f := range current { - if visited[f.typ] { - continue - } - visited[f.typ] = true - - // Scan f.typ for fields to include. - for i := 0; i < f.typ.NumField(); i++ { - sf := f.typ.Field(i) - if sf.PkgPath != "" && !sf.Anonymous { // unexported - continue - } - opts := getOptions(sf.Tag) - if opts.skip { - continue - } - index := make([]int, len(f.index)+1) - copy(index, f.index) - index[len(f.index)] = i - - ft := sf.Type - if ft.Name() == "" && ft.Kind() == reflect.Ptr { - // Follow pointer. - ft = ft.Elem() - } - - // Record found field and index sequence. - if opts.name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct { - tagged := opts.name != "" - name := opts.name - if name == "" { - name = sf.Name - } - fields = append(fields, field{name, tagged, index, ft}) - if count[f.typ] > 1 { - // If there were multiple instances, add a second, - // so that the annihilation code will see a duplicate. - // It only cares about the distinction between 1 or 2, - // so don't bother generating any more copies. - fields = append(fields, fields[len(fields)-1]) - } - continue - } - - // Record new anonymous struct to explore in next round. - nextCount[ft]++ - if nextCount[ft] == 1 { - f := field{name: ft.Name(), index: index, typ: ft} - next = append(next, f) - } - } - } - } - - sort.Sort(byName(fields)) - - // Delete all fields that are hidden by the Go rules for embedded fields, - // except that fields with TOML tags are promoted. - - // The fields are sorted in primary order of name, secondary order - // of field index length. Loop over names; for each name, delete - // hidden fields by choosing the one dominant field that survives. - out := fields[:0] - for advance, i := 0, 0; i < len(fields); i += advance { - // One iteration per name. - // Find the sequence of fields with the name of this first field. - fi := fields[i] - name := fi.name - for advance = 1; i+advance < len(fields); advance++ { - fj := fields[i+advance] - if fj.name != name { - break - } - } - if advance == 1 { // Only one field with this name - out = append(out, fi) - continue - } - dominant, ok := dominantField(fields[i : i+advance]) - if ok { - out = append(out, dominant) - } - } - - fields = out - sort.Sort(byIndex(fields)) - - return fields -} - -// dominantField looks through the fields, all of which are known to -// have the same name, to find the single field that dominates the -// others using Go's embedding rules, modified by the presence of -// TOML tags. If there are multiple top-level fields, the boolean -// will be false: This condition is an error in Go and we skip all -// the fields. -func dominantField(fields []field) (field, bool) { - // The fields are sorted in increasing index-length order. The winner - // must therefore be one with the shortest index length. Drop all - // longer entries, which is easy: just truncate the slice. - length := len(fields[0].index) - tagged := -1 // Index of first tagged field. - for i, f := range fields { - if len(f.index) > length { - fields = fields[:i] - break - } - if f.tag { - if tagged >= 0 { - // Multiple tagged fields at the same level: conflict. - // Return no field. - return field{}, false - } - tagged = i - } - } - if tagged >= 0 { - return fields[tagged], true - } - // All remaining fields have the same length. If there's more than one, - // we have a conflict (two fields named "X" at the same level) and we - // return no field. - if len(fields) > 1 { - return field{}, false - } - return fields[0], true -} - -var fieldCache struct { - sync.RWMutex - m map[reflect.Type][]field -} - -// cachedTypeFields is like typeFields but uses a cache to avoid repeated work. -func cachedTypeFields(t reflect.Type) []field { - fieldCache.RLock() - f := fieldCache.m[t] - fieldCache.RUnlock() - if f != nil { - return f - } - - // Compute fields without lock. - // Might duplicate effort but won't hold other computations back. - f = typeFields(t) - if f == nil { - f = []field{} - } - - fieldCache.Lock() - if fieldCache.m == nil { - fieldCache.m = map[reflect.Type][]field{} - } - fieldCache.m[t] = f - fieldCache.Unlock() - return f -} diff --git a/vendor/github.com/BurntSushi/toml/type_toml.go b/vendor/github.com/BurntSushi/toml/type_toml.go deleted file mode 100644 index 4e90d77373b..00000000000 --- a/vendor/github.com/BurntSushi/toml/type_toml.go +++ /dev/null @@ -1,70 +0,0 @@ -package toml - -// tomlType represents any Go type that corresponds to a TOML type. -// While the first draft of the TOML spec has a simplistic type system that -// probably doesn't need this level of sophistication, we seem to be militating -// toward adding real composite types. -type tomlType interface { - typeString() string -} - -// typeEqual accepts any two types and returns true if they are equal. -func typeEqual(t1, t2 tomlType) bool { - if t1 == nil || t2 == nil { - return false - } - return t1.typeString() == t2.typeString() -} - -func typeIsTable(t tomlType) bool { - return typeEqual(t, tomlHash) || typeEqual(t, tomlArrayHash) -} - -type tomlBaseType string - -func (btype tomlBaseType) typeString() string { - return string(btype) -} - -func (btype tomlBaseType) String() string { - return btype.typeString() -} - -var ( - tomlInteger tomlBaseType = "Integer" - tomlFloat tomlBaseType = "Float" - tomlDatetime tomlBaseType = "Datetime" - tomlString tomlBaseType = "String" - tomlBool tomlBaseType = "Bool" - tomlArray tomlBaseType = "Array" - tomlHash tomlBaseType = "Hash" - tomlArrayHash tomlBaseType = "ArrayHash" -) - -// typeOfPrimitive returns a tomlType of any primitive value in TOML. -// Primitive values are: Integer, Float, Datetime, String and Bool. -// -// Passing a lexer item other than the following will cause a BUG message -// to occur: itemString, itemBool, itemInteger, itemFloat, itemDatetime. -func (p *parser) typeOfPrimitive(lexItem item) tomlType { - switch lexItem.typ { - case itemInteger: - return tomlInteger - case itemFloat: - return tomlFloat - case itemDatetime: - return tomlDatetime - case itemString: - return tomlString - case itemMultilineString: - return tomlString - case itemRawString: - return tomlString - case itemRawMultilineString: - return tomlString - case itemBool: - return tomlBool - } - p.bug("Cannot infer primitive type of lex item '%s'.", lexItem) - panic("unreachable") -} diff --git a/vendor/github.com/beorn7/perks/LICENSE b/vendor/github.com/beorn7/perks/LICENSE deleted file mode 100644 index 339177be663..00000000000 --- a/vendor/github.com/beorn7/perks/LICENSE +++ /dev/null @@ -1,20 +0,0 @@ -Copyright (C) 2013 Blake Mizerany - -Permission is hereby granted, free of charge, to any person obtaining -a copy of this software and associated documentation files (the -"Software"), to deal in the Software without restriction, including -without limitation the rights to use, copy, modify, merge, publish, -distribute, sublicense, and/or sell copies of the Software, and to -permit persons to whom the Software is furnished to do so, subject to -the following conditions: - -The above copyright notice and this permission notice shall be -included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE -LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION -WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/vendor/github.com/beorn7/perks/quantile/exampledata.txt b/vendor/github.com/beorn7/perks/quantile/exampledata.txt deleted file mode 100644 index 1602287d7ce..00000000000 --- a/vendor/github.com/beorn7/perks/quantile/exampledata.txt +++ /dev/null @@ -1,2388 +0,0 @@ -8 -5 -26 -12 -5 -235 -13 -6 -28 -30 -3 -3 -3 -3 -5 -2 -33 -7 -2 -4 -7 -12 -14 -5 -8 -3 -10 -4 -5 -3 -6 -6 -209 -20 -3 -10 -14 -3 -4 -6 -8 -5 -11 -7 -3 -2 -3 -3 -212 -5 -222 -4 -10 -10 -5 -6 -3 -8 -3 -10 -254 -220 -2 -3 -5 -24 -5 -4 -222 -7 -3 -3 -223 -8 -15 -12 -14 -14 -3 -2 -2 -3 -13 -3 -11 -4 -4 -6 -5 -7 -13 -5 -3 -5 -2 -5 -3 -5 -2 -7 -15 -17 -14 -3 -6 -6 -3 -17 -5 -4 -7 -6 -4 -4 -8 -6 -8 -3 -9 -3 -6 -3 -4 -5 -3 -3 -660 -4 -6 -10 -3 -6 -3 -2 -5 -13 -2 -4 -4 -10 -4 -8 -4 -3 -7 -9 -9 -3 -10 -37 -3 -13 -4 -12 -3 -6 -10 -8 -5 -21 -2 -3 -8 -3 -2 -3 -3 -4 -12 -2 -4 -8 -8 -4 -3 -2 -20 -1 -6 -32 -2 -11 -6 -18 -3 -8 -11 -3 -212 -3 -4 -2 -6 -7 -12 -11 -3 -2 -16 -10 -6 -4 -6 -3 -2 -7 -3 -2 -2 -2 -2 -5 -6 -4 -3 -10 -3 -4 -6 -5 -3 -4 -4 -5 -6 -4 -3 -4 -4 -5 -7 -5 -5 -3 -2 -7 -2 -4 -12 -4 -5 -6 -2 -4 -4 -8 -4 -15 -13 -7 -16 -5 -3 -23 -5 -5 -7 -3 -2 -9 -8 -7 -5 -8 -11 -4 -10 -76 -4 -47 -4 -3 -2 -7 -4 -2 -3 -37 -10 -4 -2 -20 -5 -4 -4 -10 -10 -4 -3 -7 -23 -240 -7 -13 -5 -5 -3 -3 -2 -5 -4 -2 -8 -7 -19 -2 -23 -8 -7 -2 -5 -3 -8 -3 -8 -13 -5 -5 -5 -2 -3 -23 -4 -9 -8 -4 -3 -3 -5 -220 -2 -3 -4 -6 -14 -3 -53 -6 -2 -5 -18 -6 -3 -219 -6 -5 -2 -5 -3 -6 -5 -15 -4 -3 -17 -3 -2 -4 -7 -2 -3 -3 -4 -4 -3 -2 -664 -6 -3 -23 -5 -5 -16 -5 -8 -2 -4 -2 -24 -12 -3 -2 -3 -5 -8 -3 -5 -4 -3 -14 -3 -5 -8 -2 -3 -7 -9 -4 -2 -3 -6 -8 -4 -3 -4 -6 -5 -3 -3 -6 -3 -19 -4 -4 -6 -3 -6 -3 -5 -22 -5 -4 -4 -3 -8 -11 -4 -9 -7 -6 -13 -4 -4 -4 -6 -17 -9 -3 -3 -3 -4 -3 -221 -5 -11 -3 -4 -2 -12 -6 -3 -5 -7 -5 -7 -4 -9 -7 -14 -37 -19 -217 -16 -3 -5 -2 -2 -7 -19 -7 -6 -7 -4 -24 -5 -11 -4 -7 -7 -9 -13 -3 -4 -3 -6 -28 -4 -4 -5 -5 -2 -5 -6 -4 -4 -6 -10 -5 -4 -3 -2 -3 -3 -6 -5 -5 -4 -3 -2 -3 -7 -4 -6 -18 -16 -8 -16 -4 -5 -8 -6 -9 -13 -1545 -6 -215 -6 -5 -6 -3 -45 -31 -5 -2 -2 -4 -3 -3 -2 -5 -4 -3 -5 -7 -7 -4 -5 -8 -5 -4 -749 -2 -31 -9 -11 -2 -11 -5 -4 -4 -7 -9 -11 -4 -5 -4 -7 -3 -4 -6 -2 -15 -3 -4 -3 -4 -3 -5 -2 -13 -5 -5 -3 -3 -23 -4 -4 -5 -7 -4 -13 -2 -4 -3 -4 -2 -6 -2 -7 -3 -5 -5 -3 -29 -5 -4 -4 -3 -10 -2 -3 -79 -16 -6 -6 -7 -7 -3 -5 -5 -7 -4 -3 -7 -9 -5 -6 -5 -9 -6 -3 -6 -4 -17 -2 -10 -9 -3 -6 -2 -3 -21 -22 -5 -11 -4 -2 -17 -2 -224 -2 -14 -3 -4 -4 -2 -4 -4 -4 -4 -5 -3 -4 -4 -10 -2 -6 -3 -3 -5 -7 -2 -7 -5 -6 -3 -218 -2 -2 -5 -2 -6 -3 -5 -222 -14 -6 -33 -3 -2 -5 -3 -3 -3 -9 -5 -3 -3 -2 -7 -4 -3 -4 -3 -5 -6 -5 -26 -4 -13 -9 -7 -3 -221 -3 -3 -4 -4 -4 -4 -2 -18 -5 -3 -7 -9 -6 -8 -3 -10 -3 -11 -9 -5 -4 -17 -5 -5 -6 -6 -3 -2 -4 -12 -17 -6 -7 -218 -4 -2 -4 -10 -3 -5 -15 -3 -9 -4 -3 -3 -6 -29 -3 -3 -4 -5 -5 -3 -8 -5 -6 -6 -7 -5 -3 -5 -3 -29 -2 -31 -5 -15 -24 -16 -5 -207 -4 -3 -3 -2 -15 -4 -4 -13 -5 -5 -4 -6 -10 -2 -7 -8 -4 -6 -20 -5 -3 -4 -3 -12 -12 -5 -17 -7 -3 -3 -3 -6 -10 -3 -5 -25 -80 -4 -9 -3 -2 -11 -3 -3 -2 -3 -8 -7 -5 -5 -19 -5 -3 -3 -12 -11 -2 -6 -5 -5 -5 -3 -3 -3 -4 -209 -14 -3 -2 -5 -19 -4 -4 -3 -4 -14 -5 -6 -4 -13 -9 -7 -4 -7 -10 -2 -9 -5 -7 -2 -8 -4 -6 -5 -5 -222 -8 -7 -12 -5 -216 -3 -4 -4 -6 -3 -14 -8 -7 -13 -4 -3 -3 -3 -3 -17 -5 -4 -3 -33 -6 -6 -33 -7 -5 -3 -8 -7 -5 -2 -9 -4 -2 -233 -24 -7 -4 -8 -10 -3 -4 -15 -2 -16 -3 -3 -13 -12 -7 -5 -4 -207 -4 -2 -4 -27 -15 -2 -5 -2 -25 -6 -5 -5 -6 -13 -6 -18 -6 -4 -12 -225 -10 -7 -5 -2 -2 -11 -4 -14 -21 -8 -10 -3 -5 -4 -232 -2 -5 -5 -3 -7 -17 -11 -6 -6 -23 -4 -6 -3 -5 -4 -2 -17 -3 -6 -5 -8 -3 -2 -2 -14 -9 -4 -4 -2 -5 -5 -3 -7 -6 -12 -6 -10 -3 -6 -2 -2 -19 -5 -4 -4 -9 -2 -4 -13 -3 -5 -6 -3 -6 -5 -4 -9 -6 -3 -5 -7 -3 -6 -6 -4 -3 -10 -6 -3 -221 -3 -5 -3 -6 -4 -8 -5 -3 -6 -4 -4 -2 -54 -5 -6 -11 -3 -3 -4 -4 -4 -3 -7 -3 -11 -11 -7 -10 -6 -13 -223 -213 -15 -231 -7 -3 -7 -228 -2 -3 -4 -4 -5 -6 -7 -4 -13 -3 -4 -5 -3 -6 -4 -6 -7 -2 -4 -3 -4 -3 -3 -6 -3 -7 -3 -5 -18 -5 -6 -8 -10 -3 -3 -3 -2 -4 -2 -4 -4 -5 -6 -6 -4 -10 -13 -3 -12 -5 -12 -16 -8 -4 -19 -11 -2 -4 -5 -6 -8 -5 -6 -4 -18 -10 -4 -2 -216 -6 -6 -6 -2 -4 -12 -8 -3 -11 -5 -6 -14 -5 -3 -13 -4 -5 -4 -5 -3 -28 -6 -3 -7 -219 -3 -9 -7 -3 -10 -6 -3 -4 -19 -5 -7 -11 -6 -15 -19 -4 -13 -11 -3 -7 -5 -10 -2 -8 -11 -2 -6 -4 -6 -24 -6 -3 -3 -3 -3 -6 -18 -4 -11 -4 -2 -5 -10 -8 -3 -9 -5 -3 -4 -5 -6 -2 -5 -7 -4 -4 -14 -6 -4 -4 -5 -5 -7 -2 -4 -3 -7 -3 -3 -6 -4 -5 -4 -4 -4 -3 -3 -3 -3 -8 -14 -2 -3 -5 -3 -2 -4 -5 -3 -7 -3 -3 -18 -3 -4 -4 -5 -7 -3 -3 -3 -13 -5 -4 -8 -211 -5 -5 -3 -5 -2 -5 -4 -2 -655 -6 -3 -5 -11 -2 -5 -3 -12 -9 -15 -11 -5 -12 -217 -2 -6 -17 -3 -3 -207 -5 -5 -4 -5 -9 -3 -2 -8 -5 -4 -3 -2 -5 -12 -4 -14 -5 -4 -2 -13 -5 -8 -4 -225 -4 -3 -4 -5 -4 -3 -3 -6 -23 -9 -2 -6 -7 -233 -4 -4 -6 -18 -3 -4 -6 -3 -4 -4 -2 -3 -7 -4 -13 -227 -4 -3 -5 -4 -2 -12 -9 -17 -3 -7 -14 -6 -4 -5 -21 -4 -8 -9 -2 -9 -25 -16 -3 -6 -4 -7 -8 -5 -2 -3 -5 -4 -3 -3 -5 -3 -3 -3 -2 -3 -19 -2 -4 -3 -4 -2 -3 -4 -4 -2 -4 -3 -3 -3 -2 -6 -3 -17 -5 -6 -4 -3 -13 -5 -3 -3 -3 -4 -9 -4 -2 -14 -12 -4 -5 -24 -4 -3 -37 -12 -11 -21 -3 -4 -3 -13 -4 -2 -3 -15 -4 -11 -4 -4 -3 -8 -3 -4 -4 -12 -8 -5 -3 -3 -4 -2 -220 -3 -5 -223 -3 -3 -3 -10 -3 -15 -4 -241 -9 -7 -3 -6 -6 -23 -4 -13 -7 -3 -4 -7 -4 -9 -3 -3 -4 -10 -5 -5 -1 -5 -24 -2 -4 -5 -5 -6 -14 -3 -8 -2 -3 -5 -13 -13 -3 -5 -2 -3 -15 -3 -4 -2 -10 -4 -4 -4 -5 -5 -3 -5 -3 -4 -7 -4 -27 -3 -6 -4 -15 -3 -5 -6 -6 -5 -4 -8 -3 -9 -2 -6 -3 -4 -3 -7 -4 -18 -3 -11 -3 -3 -8 -9 -7 -24 -3 -219 -7 -10 -4 -5 -9 -12 -2 -5 -4 -4 -4 -3 -3 -19 -5 -8 -16 -8 -6 -22 -3 -23 -3 -242 -9 -4 -3 -3 -5 -7 -3 -3 -5 -8 -3 -7 -5 -14 -8 -10 -3 -4 -3 -7 -4 -6 -7 -4 -10 -4 -3 -11 -3 -7 -10 -3 -13 -6 -8 -12 -10 -5 -7 -9 -3 -4 -7 -7 -10 -8 -30 -9 -19 -4 -3 -19 -15 -4 -13 -3 -215 -223 -4 -7 -4 -8 -17 -16 -3 -7 -6 -5 -5 -4 -12 -3 -7 -4 -4 -13 -4 -5 -2 -5 -6 -5 -6 -6 -7 -10 -18 -23 -9 -3 -3 -6 -5 -2 -4 -2 -7 -3 -3 -2 -5 -5 -14 -10 -224 -6 -3 -4 -3 -7 -5 -9 -3 -6 -4 -2 -5 -11 -4 -3 -3 -2 -8 -4 -7 -4 -10 -7 -3 -3 -18 -18 -17 -3 -3 -3 -4 -5 -3 -3 -4 -12 -7 -3 -11 -13 -5 -4 -7 -13 -5 -4 -11 -3 -12 -3 -6 -4 -4 -21 -4 -6 -9 -5 -3 -10 -8 -4 -6 -4 -4 -6 -5 -4 -8 -6 -4 -6 -4 -4 -5 -9 -6 -3 -4 -2 -9 -3 -18 -2 -4 -3 -13 -3 -6 -6 -8 -7 -9 -3 -2 -16 -3 -4 -6 -3 -2 -33 -22 -14 -4 -9 -12 -4 -5 -6 -3 -23 -9 -4 -3 -5 -5 -3 -4 -5 -3 -5 -3 -10 -4 -5 -5 -8 -4 -4 -6 -8 -5 -4 -3 -4 -6 -3 -3 -3 -5 -9 -12 -6 -5 -9 -3 -5 -3 -2 -2 -2 -18 -3 -2 -21 -2 -5 -4 -6 -4 -5 -10 -3 -9 -3 -2 -10 -7 -3 -6 -6 -4 -4 -8 -12 -7 -3 -7 -3 -3 -9 -3 -4 -5 -4 -4 -5 -5 -10 -15 -4 -4 -14 -6 -227 -3 -14 -5 -216 -22 -5 -4 -2 -2 -6 -3 -4 -2 -9 -9 -4 -3 -28 -13 -11 -4 -5 -3 -3 -2 -3 -3 -5 -3 -4 -3 -5 -23 -26 -3 -4 -5 -6 -4 -6 -3 -5 -5 -3 -4 -3 -2 -2 -2 -7 -14 -3 -6 -7 -17 -2 -2 -15 -14 -16 -4 -6 -7 -13 -6 -4 -5 -6 -16 -3 -3 -28 -3 -6 -15 -3 -9 -2 -4 -6 -3 -3 -22 -4 -12 -6 -7 -2 -5 -4 -10 -3 -16 -6 -9 -2 -5 -12 -7 -5 -5 -5 -5 -2 -11 -9 -17 -4 -3 -11 -7 -3 -5 -15 -4 -3 -4 -211 -8 -7 -5 -4 -7 -6 -7 -6 -3 -6 -5 -6 -5 -3 -4 -4 -26 -4 -6 -10 -4 -4 -3 -2 -3 -3 -4 -5 -9 -3 -9 -4 -4 -5 -5 -8 -2 -4 -2 -3 -8 -4 -11 -19 -5 -8 -6 -3 -5 -6 -12 -3 -2 -4 -16 -12 -3 -4 -4 -8 -6 -5 -6 -6 -219 -8 -222 -6 -16 -3 -13 -19 -5 -4 -3 -11 -6 -10 -4 -7 -7 -12 -5 -3 -3 -5 -6 -10 -3 -8 -2 -5 -4 -7 -2 -4 -4 -2 -12 -9 -6 -4 -2 -40 -2 -4 -10 -4 -223 -4 -2 -20 -6 -7 -24 -5 -4 -5 -2 -20 -16 -6 -5 -13 -2 -3 -3 -19 -3 -2 -4 -5 -6 -7 -11 -12 -5 -6 -7 -7 -3 -5 -3 -5 -3 -14 -3 -4 -4 -2 -11 -1 -7 -3 -9 -6 -11 -12 -5 -8 -6 -221 -4 -2 -12 -4 -3 -15 -4 -5 -226 -7 -218 -7 -5 -4 -5 -18 -4 -5 -9 -4 -4 -2 -9 -18 -18 -9 -5 -6 -6 -3 -3 -7 -3 -5 -4 -4 -4 -12 -3 -6 -31 -5 -4 -7 -3 -6 -5 -6 -5 -11 -2 -2 -11 -11 -6 -7 -5 -8 -7 -10 -5 -23 -7 -4 -3 -5 -34 -2 -5 -23 -7 -3 -6 -8 -4 -4 -4 -2 -5 -3 -8 -5 -4 -8 -25 -2 -3 -17 -8 -3 -4 -8 -7 -3 -15 -6 -5 -7 -21 -9 -5 -6 -6 -5 -3 -2 -3 -10 -3 -6 -3 -14 -7 -4 -4 -8 -7 -8 -2 -6 -12 -4 -213 -6 -5 -21 -8 -2 -5 -23 -3 -11 -2 -3 -6 -25 -2 -3 -6 -7 -6 -6 -4 -4 -6 -3 -17 -9 -7 -6 -4 -3 -10 -7 -2 -3 -3 -3 -11 -8 -3 -7 -6 -4 -14 -36 -3 -4 -3 -3 -22 -13 -21 -4 -2 -7 -4 -4 -17 -15 -3 -7 -11 -2 -4 -7 -6 -209 -6 -3 -2 -2 -24 -4 -9 -4 -3 -3 -3 -29 -2 -2 -4 -3 -3 -5 -4 -6 -3 -3 -2 -4 diff --git a/vendor/github.com/beorn7/perks/quantile/stream.go b/vendor/github.com/beorn7/perks/quantile/stream.go deleted file mode 100644 index d7d14f8eb63..00000000000 --- a/vendor/github.com/beorn7/perks/quantile/stream.go +++ /dev/null @@ -1,316 +0,0 @@ -// Package quantile computes approximate quantiles over an unbounded data -// stream within low memory and CPU bounds. -// -// A small amount of accuracy is traded to achieve the above properties. -// -// Multiple streams can be merged before calling Query to generate a single set -// of results. This is meaningful when the streams represent the same type of -// data. See Merge and Samples. -// -// For more detailed information about the algorithm used, see: -// -// Effective Computation of Biased Quantiles over Data Streams -// -// http://www.cs.rutgers.edu/~muthu/bquant.pdf -package quantile - -import ( - "math" - "sort" -) - -// Sample holds an observed value and meta information for compression. JSON -// tags have been added for convenience. -type Sample struct { - Value float64 `json:",string"` - Width float64 `json:",string"` - Delta float64 `json:",string"` -} - -// Samples represents a slice of samples. It implements sort.Interface. -type Samples []Sample - -func (a Samples) Len() int { return len(a) } -func (a Samples) Less(i, j int) bool { return a[i].Value < a[j].Value } -func (a Samples) Swap(i, j int) { a[i], a[j] = a[j], a[i] } - -type invariant func(s *stream, r float64) float64 - -// NewLowBiased returns an initialized Stream for low-biased quantiles -// (e.g. 0.01, 0.1, 0.5) where the needed quantiles are not known a priori, but -// error guarantees can still be given even for the lower ranks of the data -// distribution. -// -// The provided epsilon is a relative error, i.e. the true quantile of a value -// returned by a query is guaranteed to be within (1±Epsilon)*Quantile. -// -// See http://www.cs.rutgers.edu/~muthu/bquant.pdf for time, space, and error -// properties. -func NewLowBiased(epsilon float64) *Stream { - ƒ := func(s *stream, r float64) float64 { - return 2 * epsilon * r - } - return newStream(ƒ) -} - -// NewHighBiased returns an initialized Stream for high-biased quantiles -// (e.g. 0.01, 0.1, 0.5) where the needed quantiles are not known a priori, but -// error guarantees can still be given even for the higher ranks of the data -// distribution. -// -// The provided epsilon is a relative error, i.e. the true quantile of a value -// returned by a query is guaranteed to be within 1-(1±Epsilon)*(1-Quantile). -// -// See http://www.cs.rutgers.edu/~muthu/bquant.pdf for time, space, and error -// properties. -func NewHighBiased(epsilon float64) *Stream { - ƒ := func(s *stream, r float64) float64 { - return 2 * epsilon * (s.n - r) - } - return newStream(ƒ) -} - -// NewTargeted returns an initialized Stream concerned with a particular set of -// quantile values that are supplied a priori. Knowing these a priori reduces -// space and computation time. The targets map maps the desired quantiles to -// their absolute errors, i.e. the true quantile of a value returned by a query -// is guaranteed to be within (Quantile±Epsilon). -// -// See http://www.cs.rutgers.edu/~muthu/bquant.pdf for time, space, and error properties. -func NewTargeted(targetMap map[float64]float64) *Stream { - // Convert map to slice to avoid slow iterations on a map. - // ƒ is called on the hot path, so converting the map to a slice - // beforehand results in significant CPU savings. - targets := targetMapToSlice(targetMap) - - ƒ := func(s *stream, r float64) float64 { - var m = math.MaxFloat64 - var f float64 - for _, t := range targets { - if t.quantile*s.n <= r { - f = (2 * t.epsilon * r) / t.quantile - } else { - f = (2 * t.epsilon * (s.n - r)) / (1 - t.quantile) - } - if f < m { - m = f - } - } - return m - } - return newStream(ƒ) -} - -type target struct { - quantile float64 - epsilon float64 -} - -func targetMapToSlice(targetMap map[float64]float64) []target { - targets := make([]target, 0, len(targetMap)) - - for quantile, epsilon := range targetMap { - t := target{ - quantile: quantile, - epsilon: epsilon, - } - targets = append(targets, t) - } - - return targets -} - -// Stream computes quantiles for a stream of float64s. It is not thread-safe by -// design. Take care when using across multiple goroutines. -type Stream struct { - *stream - b Samples - sorted bool -} - -func newStream(ƒ invariant) *Stream { - x := &stream{ƒ: ƒ} - return &Stream{x, make(Samples, 0, 500), true} -} - -// Insert inserts v into the stream. -func (s *Stream) Insert(v float64) { - s.insert(Sample{Value: v, Width: 1}) -} - -func (s *Stream) insert(sample Sample) { - s.b = append(s.b, sample) - s.sorted = false - if len(s.b) == cap(s.b) { - s.flush() - } -} - -// Query returns the computed qth percentiles value. If s was created with -// NewTargeted, and q is not in the set of quantiles provided a priori, Query -// will return an unspecified result. -func (s *Stream) Query(q float64) float64 { - if !s.flushed() { - // Fast path when there hasn't been enough data for a flush; - // this also yields better accuracy for small sets of data. - l := len(s.b) - if l == 0 { - return 0 - } - i := int(math.Ceil(float64(l) * q)) - if i > 0 { - i -= 1 - } - s.maybeSort() - return s.b[i].Value - } - s.flush() - return s.stream.query(q) -} - -// Merge merges samples into the underlying streams samples. This is handy when -// merging multiple streams from separate threads, database shards, etc. -// -// ATTENTION: This method is broken and does not yield correct results. The -// underlying algorithm is not capable of merging streams correctly. -func (s *Stream) Merge(samples Samples) { - sort.Sort(samples) - s.stream.merge(samples) -} - -// Reset reinitializes and clears the list reusing the samples buffer memory. -func (s *Stream) Reset() { - s.stream.reset() - s.b = s.b[:0] -} - -// Samples returns stream samples held by s. -func (s *Stream) Samples() Samples { - if !s.flushed() { - return s.b - } - s.flush() - return s.stream.samples() -} - -// Count returns the total number of samples observed in the stream -// since initialization. -func (s *Stream) Count() int { - return len(s.b) + s.stream.count() -} - -func (s *Stream) flush() { - s.maybeSort() - s.stream.merge(s.b) - s.b = s.b[:0] -} - -func (s *Stream) maybeSort() { - if !s.sorted { - s.sorted = true - sort.Sort(s.b) - } -} - -func (s *Stream) flushed() bool { - return len(s.stream.l) > 0 -} - -type stream struct { - n float64 - l []Sample - ƒ invariant -} - -func (s *stream) reset() { - s.l = s.l[:0] - s.n = 0 -} - -func (s *stream) insert(v float64) { - s.merge(Samples{{v, 1, 0}}) -} - -func (s *stream) merge(samples Samples) { - // TODO(beorn7): This tries to merge not only individual samples, but - // whole summaries. The paper doesn't mention merging summaries at - // all. Unittests show that the merging is inaccurate. Find out how to - // do merges properly. - var r float64 - i := 0 - for _, sample := range samples { - for ; i < len(s.l); i++ { - c := s.l[i] - if c.Value > sample.Value { - // Insert at position i. - s.l = append(s.l, Sample{}) - copy(s.l[i+1:], s.l[i:]) - s.l[i] = Sample{ - sample.Value, - sample.Width, - math.Max(sample.Delta, math.Floor(s.ƒ(s, r))-1), - // TODO(beorn7): How to calculate delta correctly? - } - i++ - goto inserted - } - r += c.Width - } - s.l = append(s.l, Sample{sample.Value, sample.Width, 0}) - i++ - inserted: - s.n += sample.Width - r += sample.Width - } - s.compress() -} - -func (s *stream) count() int { - return int(s.n) -} - -func (s *stream) query(q float64) float64 { - t := math.Ceil(q * s.n) - t += math.Ceil(s.ƒ(s, t) / 2) - p := s.l[0] - var r float64 - for _, c := range s.l[1:] { - r += p.Width - if r+c.Width+c.Delta > t { - return p.Value - } - p = c - } - return p.Value -} - -func (s *stream) compress() { - if len(s.l) < 2 { - return - } - x := s.l[len(s.l)-1] - xi := len(s.l) - 1 - r := s.n - 1 - x.Width - - for i := len(s.l) - 2; i >= 0; i-- { - c := s.l[i] - if c.Width+x.Width+x.Delta <= s.ƒ(s, r) { - x.Width += c.Width - s.l[xi] = x - // Remove element at i. - copy(s.l[i:], s.l[i+1:]) - s.l = s.l[:len(s.l)-1] - xi -= 1 - } else { - x = c - xi = i - } - r -= c.Width - } -} - -func (s *stream) samples() Samples { - samples := make(Samples, len(s.l)) - copy(samples, s.l) - return samples -} diff --git a/vendor/github.com/cespare/xxhash/v2/LICENSE.txt b/vendor/github.com/cespare/xxhash/v2/LICENSE.txt deleted file mode 100644 index 24b53065f40..00000000000 --- a/vendor/github.com/cespare/xxhash/v2/LICENSE.txt +++ /dev/null @@ -1,22 +0,0 @@ -Copyright (c) 2016 Caleb Spare - -MIT License - -Permission is hereby granted, free of charge, to any person obtaining -a copy of this software and associated documentation files (the -"Software"), to deal in the Software without restriction, including -without limitation the rights to use, copy, modify, merge, publish, -distribute, sublicense, and/or sell copies of the Software, and to -permit persons to whom the Software is furnished to do so, subject to -the following conditions: - -The above copyright notice and this permission notice shall be -included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE -LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION -WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/vendor/github.com/cespare/xxhash/v2/README.md b/vendor/github.com/cespare/xxhash/v2/README.md deleted file mode 100644 index 33c88305c46..00000000000 --- a/vendor/github.com/cespare/xxhash/v2/README.md +++ /dev/null @@ -1,74 +0,0 @@ -# xxhash - -[![Go Reference](https://pkg.go.dev/badge/github.com/cespare/xxhash/v2.svg)](https://pkg.go.dev/github.com/cespare/xxhash/v2) -[![Test](https://github.com/cespare/xxhash/actions/workflows/test.yml/badge.svg)](https://github.com/cespare/xxhash/actions/workflows/test.yml) - -xxhash is a Go implementation of the 64-bit [xxHash] algorithm, XXH64. This is a -high-quality hashing algorithm that is much faster than anything in the Go -standard library. - -This package provides a straightforward API: - -``` -func Sum64(b []byte) uint64 -func Sum64String(s string) uint64 -type Digest struct{ ... } - func New() *Digest -``` - -The `Digest` type implements hash.Hash64. Its key methods are: - -``` -func (*Digest) Write([]byte) (int, error) -func (*Digest) WriteString(string) (int, error) -func (*Digest) Sum64() uint64 -``` - -The package is written with optimized pure Go and also contains even faster -assembly implementations for amd64 and arm64. If desired, the `purego` build tag -opts into using the Go code even on those architectures. - -[xxHash]: http://cyan4973.github.io/xxHash/ - -## Compatibility - -This package is in a module and the latest code is in version 2 of the module. -You need a version of Go with at least "minimal module compatibility" to use -github.com/cespare/xxhash/v2: - -* 1.9.7+ for Go 1.9 -* 1.10.3+ for Go 1.10 -* Go 1.11 or later - -I recommend using the latest release of Go. - -## Benchmarks - -Here are some quick benchmarks comparing the pure-Go and assembly -implementations of Sum64. - -| input size | purego | asm | -| ---------- | --------- | --------- | -| 4 B | 1.3 GB/s | 1.2 GB/s | -| 16 B | 2.9 GB/s | 3.5 GB/s | -| 100 B | 6.9 GB/s | 8.1 GB/s | -| 4 KB | 11.7 GB/s | 16.7 GB/s | -| 10 MB | 12.0 GB/s | 17.3 GB/s | - -These numbers were generated on Ubuntu 20.04 with an Intel Xeon Platinum 8252C -CPU using the following commands under Go 1.19.2: - -``` -benchstat <(go test -tags purego -benchtime 500ms -count 15 -bench 'Sum64$') -benchstat <(go test -benchtime 500ms -count 15 -bench 'Sum64$') -``` - -## Projects using this package - -- [InfluxDB](https://github.com/influxdata/influxdb) -- [Prometheus](https://github.com/prometheus/prometheus) -- [VictoriaMetrics](https://github.com/VictoriaMetrics/VictoriaMetrics) -- [FreeCache](https://github.com/coocood/freecache) -- [FastCache](https://github.com/VictoriaMetrics/fastcache) -- [Ristretto](https://github.com/dgraph-io/ristretto) -- [Badger](https://github.com/dgraph-io/badger) diff --git a/vendor/github.com/cespare/xxhash/v2/testall.sh b/vendor/github.com/cespare/xxhash/v2/testall.sh deleted file mode 100644 index 94b9c443987..00000000000 --- a/vendor/github.com/cespare/xxhash/v2/testall.sh +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/bash -set -eu -o pipefail - -# Small convenience script for running the tests with various combinations of -# arch/tags. This assumes we're running on amd64 and have qemu available. - -go test ./... -go test -tags purego ./... -GOARCH=arm64 go test -GOARCH=arm64 go test -tags purego diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash.go b/vendor/github.com/cespare/xxhash/v2/xxhash.go deleted file mode 100644 index 78bddf1ceed..00000000000 --- a/vendor/github.com/cespare/xxhash/v2/xxhash.go +++ /dev/null @@ -1,243 +0,0 @@ -// Package xxhash implements the 64-bit variant of xxHash (XXH64) as described -// at http://cyan4973.github.io/xxHash/. -package xxhash - -import ( - "encoding/binary" - "errors" - "math/bits" -) - -const ( - prime1 uint64 = 11400714785074694791 - prime2 uint64 = 14029467366897019727 - prime3 uint64 = 1609587929392839161 - prime4 uint64 = 9650029242287828579 - prime5 uint64 = 2870177450012600261 -) - -// Store the primes in an array as well. -// -// The consts are used when possible in Go code to avoid MOVs but we need a -// contiguous array for the assembly code. -var primes = [...]uint64{prime1, prime2, prime3, prime4, prime5} - -// Digest implements hash.Hash64. -// -// Note that a zero-valued Digest is not ready to receive writes. -// Call Reset or create a Digest using New before calling other methods. -type Digest struct { - v1 uint64 - v2 uint64 - v3 uint64 - v4 uint64 - total uint64 - mem [32]byte - n int // how much of mem is used -} - -// New creates a new Digest with a zero seed. -func New() *Digest { - return NewWithSeed(0) -} - -// NewWithSeed creates a new Digest with the given seed. -func NewWithSeed(seed uint64) *Digest { - var d Digest - d.ResetWithSeed(seed) - return &d -} - -// Reset clears the Digest's state so that it can be reused. -// It uses a seed value of zero. -func (d *Digest) Reset() { - d.ResetWithSeed(0) -} - -// ResetWithSeed clears the Digest's state so that it can be reused. -// It uses the given seed to initialize the state. -func (d *Digest) ResetWithSeed(seed uint64) { - d.v1 = seed + prime1 + prime2 - d.v2 = seed + prime2 - d.v3 = seed - d.v4 = seed - prime1 - d.total = 0 - d.n = 0 -} - -// Size always returns 8 bytes. -func (d *Digest) Size() int { return 8 } - -// BlockSize always returns 32 bytes. -func (d *Digest) BlockSize() int { return 32 } - -// Write adds more data to d. It always returns len(b), nil. -func (d *Digest) Write(b []byte) (n int, err error) { - n = len(b) - d.total += uint64(n) - - memleft := d.mem[d.n&(len(d.mem)-1):] - - if d.n+n < 32 { - // This new data doesn't even fill the current block. - copy(memleft, b) - d.n += n - return - } - - if d.n > 0 { - // Finish off the partial block. - c := copy(memleft, b) - d.v1 = round(d.v1, u64(d.mem[0:8])) - d.v2 = round(d.v2, u64(d.mem[8:16])) - d.v3 = round(d.v3, u64(d.mem[16:24])) - d.v4 = round(d.v4, u64(d.mem[24:32])) - b = b[c:] - d.n = 0 - } - - if len(b) >= 32 { - // One or more full blocks left. - nw := writeBlocks(d, b) - b = b[nw:] - } - - // Store any remaining partial block. - copy(d.mem[:], b) - d.n = len(b) - - return -} - -// Sum appends the current hash to b and returns the resulting slice. -func (d *Digest) Sum(b []byte) []byte { - s := d.Sum64() - return append( - b, - byte(s>>56), - byte(s>>48), - byte(s>>40), - byte(s>>32), - byte(s>>24), - byte(s>>16), - byte(s>>8), - byte(s), - ) -} - -// Sum64 returns the current hash. -func (d *Digest) Sum64() uint64 { - var h uint64 - - if d.total >= 32 { - v1, v2, v3, v4 := d.v1, d.v2, d.v3, d.v4 - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) - } else { - h = d.v3 + prime5 - } - - h += d.total - - b := d.mem[:d.n&(len(d.mem)-1)] - for ; len(b) >= 8; b = b[8:] { - k1 := round(0, u64(b[:8])) - h ^= k1 - h = rol27(h)*prime1 + prime4 - } - if len(b) >= 4 { - h ^= uint64(u32(b[:4])) * prime1 - h = rol23(h)*prime2 + prime3 - b = b[4:] - } - for ; len(b) > 0; b = b[1:] { - h ^= uint64(b[0]) * prime5 - h = rol11(h) * prime1 - } - - h ^= h >> 33 - h *= prime2 - h ^= h >> 29 - h *= prime3 - h ^= h >> 32 - - return h -} - -const ( - magic = "xxh\x06" - marshaledSize = len(magic) + 8*5 + 32 -) - -// MarshalBinary implements the encoding.BinaryMarshaler interface. -func (d *Digest) MarshalBinary() ([]byte, error) { - b := make([]byte, 0, marshaledSize) - b = append(b, magic...) - b = appendUint64(b, d.v1) - b = appendUint64(b, d.v2) - b = appendUint64(b, d.v3) - b = appendUint64(b, d.v4) - b = appendUint64(b, d.total) - b = append(b, d.mem[:d.n]...) - b = b[:len(b)+len(d.mem)-d.n] - return b, nil -} - -// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface. -func (d *Digest) UnmarshalBinary(b []byte) error { - if len(b) < len(magic) || string(b[:len(magic)]) != magic { - return errors.New("xxhash: invalid hash state identifier") - } - if len(b) != marshaledSize { - return errors.New("xxhash: invalid hash state size") - } - b = b[len(magic):] - b, d.v1 = consumeUint64(b) - b, d.v2 = consumeUint64(b) - b, d.v3 = consumeUint64(b) - b, d.v4 = consumeUint64(b) - b, d.total = consumeUint64(b) - copy(d.mem[:], b) - d.n = int(d.total % uint64(len(d.mem))) - return nil -} - -func appendUint64(b []byte, x uint64) []byte { - var a [8]byte - binary.LittleEndian.PutUint64(a[:], x) - return append(b, a[:]...) -} - -func consumeUint64(b []byte) ([]byte, uint64) { - x := u64(b) - return b[8:], x -} - -func u64(b []byte) uint64 { return binary.LittleEndian.Uint64(b) } -func u32(b []byte) uint32 { return binary.LittleEndian.Uint32(b) } - -func round(acc, input uint64) uint64 { - acc += input * prime2 - acc = rol31(acc) - acc *= prime1 - return acc -} - -func mergeRound(acc, val uint64) uint64 { - val = round(0, val) - acc ^= val - acc = acc*prime1 + prime4 - return acc -} - -func rol1(x uint64) uint64 { return bits.RotateLeft64(x, 1) } -func rol7(x uint64) uint64 { return bits.RotateLeft64(x, 7) } -func rol11(x uint64) uint64 { return bits.RotateLeft64(x, 11) } -func rol12(x uint64) uint64 { return bits.RotateLeft64(x, 12) } -func rol18(x uint64) uint64 { return bits.RotateLeft64(x, 18) } -func rol23(x uint64) uint64 { return bits.RotateLeft64(x, 23) } -func rol27(x uint64) uint64 { return bits.RotateLeft64(x, 27) } -func rol31(x uint64) uint64 { return bits.RotateLeft64(x, 31) } diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash_amd64.s b/vendor/github.com/cespare/xxhash/v2/xxhash_amd64.s deleted file mode 100644 index 3e8b132579e..00000000000 --- a/vendor/github.com/cespare/xxhash/v2/xxhash_amd64.s +++ /dev/null @@ -1,209 +0,0 @@ -//go:build !appengine && gc && !purego -// +build !appengine -// +build gc -// +build !purego - -#include "textflag.h" - -// Registers: -#define h AX -#define d AX -#define p SI // pointer to advance through b -#define n DX -#define end BX // loop end -#define v1 R8 -#define v2 R9 -#define v3 R10 -#define v4 R11 -#define x R12 -#define prime1 R13 -#define prime2 R14 -#define prime4 DI - -#define round(acc, x) \ - IMULQ prime2, x \ - ADDQ x, acc \ - ROLQ $31, acc \ - IMULQ prime1, acc - -// round0 performs the operation x = round(0, x). -#define round0(x) \ - IMULQ prime2, x \ - ROLQ $31, x \ - IMULQ prime1, x - -// mergeRound applies a merge round on the two registers acc and x. -// It assumes that prime1, prime2, and prime4 have been loaded. -#define mergeRound(acc, x) \ - round0(x) \ - XORQ x, acc \ - IMULQ prime1, acc \ - ADDQ prime4, acc - -// blockLoop processes as many 32-byte blocks as possible, -// updating v1, v2, v3, and v4. It assumes that there is at least one block -// to process. -#define blockLoop() \ -loop: \ - MOVQ +0(p), x \ - round(v1, x) \ - MOVQ +8(p), x \ - round(v2, x) \ - MOVQ +16(p), x \ - round(v3, x) \ - MOVQ +24(p), x \ - round(v4, x) \ - ADDQ $32, p \ - CMPQ p, end \ - JLE loop - -// func Sum64(b []byte) uint64 -TEXT ·Sum64(SB), NOSPLIT|NOFRAME, $0-32 - // Load fixed primes. - MOVQ ·primes+0(SB), prime1 - MOVQ ·primes+8(SB), prime2 - MOVQ ·primes+24(SB), prime4 - - // Load slice. - MOVQ b_base+0(FP), p - MOVQ b_len+8(FP), n - LEAQ (p)(n*1), end - - // The first loop limit will be len(b)-32. - SUBQ $32, end - - // Check whether we have at least one block. - CMPQ n, $32 - JLT noBlocks - - // Set up initial state (v1, v2, v3, v4). - MOVQ prime1, v1 - ADDQ prime2, v1 - MOVQ prime2, v2 - XORQ v3, v3 - XORQ v4, v4 - SUBQ prime1, v4 - - blockLoop() - - MOVQ v1, h - ROLQ $1, h - MOVQ v2, x - ROLQ $7, x - ADDQ x, h - MOVQ v3, x - ROLQ $12, x - ADDQ x, h - MOVQ v4, x - ROLQ $18, x - ADDQ x, h - - mergeRound(h, v1) - mergeRound(h, v2) - mergeRound(h, v3) - mergeRound(h, v4) - - JMP afterBlocks - -noBlocks: - MOVQ ·primes+32(SB), h - -afterBlocks: - ADDQ n, h - - ADDQ $24, end - CMPQ p, end - JG try4 - -loop8: - MOVQ (p), x - ADDQ $8, p - round0(x) - XORQ x, h - ROLQ $27, h - IMULQ prime1, h - ADDQ prime4, h - - CMPQ p, end - JLE loop8 - -try4: - ADDQ $4, end - CMPQ p, end - JG try1 - - MOVL (p), x - ADDQ $4, p - IMULQ prime1, x - XORQ x, h - - ROLQ $23, h - IMULQ prime2, h - ADDQ ·primes+16(SB), h - -try1: - ADDQ $4, end - CMPQ p, end - JGE finalize - -loop1: - MOVBQZX (p), x - ADDQ $1, p - IMULQ ·primes+32(SB), x - XORQ x, h - ROLQ $11, h - IMULQ prime1, h - - CMPQ p, end - JL loop1 - -finalize: - MOVQ h, x - SHRQ $33, x - XORQ x, h - IMULQ prime2, h - MOVQ h, x - SHRQ $29, x - XORQ x, h - IMULQ ·primes+16(SB), h - MOVQ h, x - SHRQ $32, x - XORQ x, h - - MOVQ h, ret+24(FP) - RET - -// func writeBlocks(d *Digest, b []byte) int -TEXT ·writeBlocks(SB), NOSPLIT|NOFRAME, $0-40 - // Load fixed primes needed for round. - MOVQ ·primes+0(SB), prime1 - MOVQ ·primes+8(SB), prime2 - - // Load slice. - MOVQ b_base+8(FP), p - MOVQ b_len+16(FP), n - LEAQ (p)(n*1), end - SUBQ $32, end - - // Load vN from d. - MOVQ s+0(FP), d - MOVQ 0(d), v1 - MOVQ 8(d), v2 - MOVQ 16(d), v3 - MOVQ 24(d), v4 - - // We don't need to check the loop condition here; this function is - // always called with at least one block of data to process. - blockLoop() - - // Copy vN back to d. - MOVQ v1, 0(d) - MOVQ v2, 8(d) - MOVQ v3, 16(d) - MOVQ v4, 24(d) - - // The number of bytes written is p minus the old base pointer. - SUBQ b_base+8(FP), p - MOVQ p, ret+32(FP) - - RET diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash_arm64.s b/vendor/github.com/cespare/xxhash/v2/xxhash_arm64.s deleted file mode 100644 index 7e3145a2218..00000000000 --- a/vendor/github.com/cespare/xxhash/v2/xxhash_arm64.s +++ /dev/null @@ -1,183 +0,0 @@ -//go:build !appengine && gc && !purego -// +build !appengine -// +build gc -// +build !purego - -#include "textflag.h" - -// Registers: -#define digest R1 -#define h R2 // return value -#define p R3 // input pointer -#define n R4 // input length -#define nblocks R5 // n / 32 -#define prime1 R7 -#define prime2 R8 -#define prime3 R9 -#define prime4 R10 -#define prime5 R11 -#define v1 R12 -#define v2 R13 -#define v3 R14 -#define v4 R15 -#define x1 R20 -#define x2 R21 -#define x3 R22 -#define x4 R23 - -#define round(acc, x) \ - MADD prime2, acc, x, acc \ - ROR $64-31, acc \ - MUL prime1, acc - -// round0 performs the operation x = round(0, x). -#define round0(x) \ - MUL prime2, x \ - ROR $64-31, x \ - MUL prime1, x - -#define mergeRound(acc, x) \ - round0(x) \ - EOR x, acc \ - MADD acc, prime4, prime1, acc - -// blockLoop processes as many 32-byte blocks as possible, -// updating v1, v2, v3, and v4. It assumes that n >= 32. -#define blockLoop() \ - LSR $5, n, nblocks \ - PCALIGN $16 \ - loop: \ - LDP.P 16(p), (x1, x2) \ - LDP.P 16(p), (x3, x4) \ - round(v1, x1) \ - round(v2, x2) \ - round(v3, x3) \ - round(v4, x4) \ - SUB $1, nblocks \ - CBNZ nblocks, loop - -// func Sum64(b []byte) uint64 -TEXT ·Sum64(SB), NOSPLIT|NOFRAME, $0-32 - LDP b_base+0(FP), (p, n) - - LDP ·primes+0(SB), (prime1, prime2) - LDP ·primes+16(SB), (prime3, prime4) - MOVD ·primes+32(SB), prime5 - - CMP $32, n - CSEL LT, prime5, ZR, h // if n < 32 { h = prime5 } else { h = 0 } - BLT afterLoop - - ADD prime1, prime2, v1 - MOVD prime2, v2 - MOVD $0, v3 - NEG prime1, v4 - - blockLoop() - - ROR $64-1, v1, x1 - ROR $64-7, v2, x2 - ADD x1, x2 - ROR $64-12, v3, x3 - ROR $64-18, v4, x4 - ADD x3, x4 - ADD x2, x4, h - - mergeRound(h, v1) - mergeRound(h, v2) - mergeRound(h, v3) - mergeRound(h, v4) - -afterLoop: - ADD n, h - - TBZ $4, n, try8 - LDP.P 16(p), (x1, x2) - - round0(x1) - - // NOTE: here and below, sequencing the EOR after the ROR (using a - // rotated register) is worth a small but measurable speedup for small - // inputs. - ROR $64-27, h - EOR x1 @> 64-27, h, h - MADD h, prime4, prime1, h - - round0(x2) - ROR $64-27, h - EOR x2 @> 64-27, h, h - MADD h, prime4, prime1, h - -try8: - TBZ $3, n, try4 - MOVD.P 8(p), x1 - - round0(x1) - ROR $64-27, h - EOR x1 @> 64-27, h, h - MADD h, prime4, prime1, h - -try4: - TBZ $2, n, try2 - MOVWU.P 4(p), x2 - - MUL prime1, x2 - ROR $64-23, h - EOR x2 @> 64-23, h, h - MADD h, prime3, prime2, h - -try2: - TBZ $1, n, try1 - MOVHU.P 2(p), x3 - AND $255, x3, x1 - LSR $8, x3, x2 - - MUL prime5, x1 - ROR $64-11, h - EOR x1 @> 64-11, h, h - MUL prime1, h - - MUL prime5, x2 - ROR $64-11, h - EOR x2 @> 64-11, h, h - MUL prime1, h - -try1: - TBZ $0, n, finalize - MOVBU (p), x4 - - MUL prime5, x4 - ROR $64-11, h - EOR x4 @> 64-11, h, h - MUL prime1, h - -finalize: - EOR h >> 33, h - MUL prime2, h - EOR h >> 29, h - MUL prime3, h - EOR h >> 32, h - - MOVD h, ret+24(FP) - RET - -// func writeBlocks(d *Digest, b []byte) int -TEXT ·writeBlocks(SB), NOSPLIT|NOFRAME, $0-40 - LDP ·primes+0(SB), (prime1, prime2) - - // Load state. Assume v[1-4] are stored contiguously. - MOVD d+0(FP), digest - LDP 0(digest), (v1, v2) - LDP 16(digest), (v3, v4) - - LDP b_base+8(FP), (p, n) - - blockLoop() - - // Store updated state. - STP (v1, v2), 0(digest) - STP (v3, v4), 16(digest) - - BIC $31, n - MOVD n, ret+32(FP) - RET diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash_asm.go b/vendor/github.com/cespare/xxhash/v2/xxhash_asm.go deleted file mode 100644 index 78f95f25610..00000000000 --- a/vendor/github.com/cespare/xxhash/v2/xxhash_asm.go +++ /dev/null @@ -1,15 +0,0 @@ -//go:build (amd64 || arm64) && !appengine && gc && !purego -// +build amd64 arm64 -// +build !appengine -// +build gc -// +build !purego - -package xxhash - -// Sum64 computes the 64-bit xxHash digest of b with a zero seed. -// -//go:noescape -func Sum64(b []byte) uint64 - -//go:noescape -func writeBlocks(d *Digest, b []byte) int diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash_other.go b/vendor/github.com/cespare/xxhash/v2/xxhash_other.go deleted file mode 100644 index 118e49e819e..00000000000 --- a/vendor/github.com/cespare/xxhash/v2/xxhash_other.go +++ /dev/null @@ -1,76 +0,0 @@ -//go:build (!amd64 && !arm64) || appengine || !gc || purego -// +build !amd64,!arm64 appengine !gc purego - -package xxhash - -// Sum64 computes the 64-bit xxHash digest of b with a zero seed. -func Sum64(b []byte) uint64 { - // A simpler version would be - // d := New() - // d.Write(b) - // return d.Sum64() - // but this is faster, particularly for small inputs. - - n := len(b) - var h uint64 - - if n >= 32 { - v1 := primes[0] + prime2 - v2 := prime2 - v3 := uint64(0) - v4 := -primes[0] - for len(b) >= 32 { - v1 = round(v1, u64(b[0:8:len(b)])) - v2 = round(v2, u64(b[8:16:len(b)])) - v3 = round(v3, u64(b[16:24:len(b)])) - v4 = round(v4, u64(b[24:32:len(b)])) - b = b[32:len(b):len(b)] - } - h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) - h = mergeRound(h, v1) - h = mergeRound(h, v2) - h = mergeRound(h, v3) - h = mergeRound(h, v4) - } else { - h = prime5 - } - - h += uint64(n) - - for ; len(b) >= 8; b = b[8:] { - k1 := round(0, u64(b[:8])) - h ^= k1 - h = rol27(h)*prime1 + prime4 - } - if len(b) >= 4 { - h ^= uint64(u32(b[:4])) * prime1 - h = rol23(h)*prime2 + prime3 - b = b[4:] - } - for ; len(b) > 0; b = b[1:] { - h ^= uint64(b[0]) * prime5 - h = rol11(h) * prime1 - } - - h ^= h >> 33 - h *= prime2 - h ^= h >> 29 - h *= prime3 - h ^= h >> 32 - - return h -} - -func writeBlocks(d *Digest, b []byte) int { - v1, v2, v3, v4 := d.v1, d.v2, d.v3, d.v4 - n := len(b) - for len(b) >= 32 { - v1 = round(v1, u64(b[0:8:len(b)])) - v2 = round(v2, u64(b[8:16:len(b)])) - v3 = round(v3, u64(b[16:24:len(b)])) - v4 = round(v4, u64(b[24:32:len(b)])) - b = b[32:len(b):len(b)] - } - d.v1, d.v2, d.v3, d.v4 = v1, v2, v3, v4 - return n - len(b) -} diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash_safe.go b/vendor/github.com/cespare/xxhash/v2/xxhash_safe.go deleted file mode 100644 index 05f5e7dfe7b..00000000000 --- a/vendor/github.com/cespare/xxhash/v2/xxhash_safe.go +++ /dev/null @@ -1,16 +0,0 @@ -//go:build appengine -// +build appengine - -// This file contains the safe implementations of otherwise unsafe-using code. - -package xxhash - -// Sum64String computes the 64-bit xxHash digest of s with a zero seed. -func Sum64String(s string) uint64 { - return Sum64([]byte(s)) -} - -// WriteString adds more data to d. It always returns len(s), nil. -func (d *Digest) WriteString(s string) (n int, err error) { - return d.Write([]byte(s)) -} diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go b/vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go deleted file mode 100644 index cf9d42aed53..00000000000 --- a/vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go +++ /dev/null @@ -1,58 +0,0 @@ -//go:build !appengine -// +build !appengine - -// This file encapsulates usage of unsafe. -// xxhash_safe.go contains the safe implementations. - -package xxhash - -import ( - "unsafe" -) - -// In the future it's possible that compiler optimizations will make these -// XxxString functions unnecessary by realizing that calls such as -// Sum64([]byte(s)) don't need to copy s. See https://go.dev/issue/2205. -// If that happens, even if we keep these functions they can be replaced with -// the trivial safe code. - -// NOTE: The usual way of doing an unsafe string-to-[]byte conversion is: -// -// var b []byte -// bh := (*reflect.SliceHeader)(unsafe.Pointer(&b)) -// bh.Data = (*reflect.StringHeader)(unsafe.Pointer(&s)).Data -// bh.Len = len(s) -// bh.Cap = len(s) -// -// Unfortunately, as of Go 1.15.3 the inliner's cost model assigns a high enough -// weight to this sequence of expressions that any function that uses it will -// not be inlined. Instead, the functions below use a different unsafe -// conversion designed to minimize the inliner weight and allow both to be -// inlined. There is also a test (TestInlining) which verifies that these are -// inlined. -// -// See https://github.com/golang/go/issues/42739 for discussion. - -// Sum64String computes the 64-bit xxHash digest of s with a zero seed. -// It may be faster than Sum64([]byte(s)) by avoiding a copy. -func Sum64String(s string) uint64 { - b := *(*[]byte)(unsafe.Pointer(&sliceHeader{s, len(s)})) - return Sum64(b) -} - -// WriteString adds more data to d. It always returns len(s), nil. -// It may be faster than Write([]byte(s)) by avoiding a copy. -func (d *Digest) WriteString(s string) (n int, err error) { - d.Write(*(*[]byte)(unsafe.Pointer(&sliceHeader{s, len(s)}))) - // d.Write always returns len(s), nil. - // Ignoring the return output and returning these fixed values buys a - // savings of 6 in the inliner's cost model. - return len(s), nil -} - -// sliceHeader is similar to reflect.SliceHeader, but it assumes that the layout -// of the first two words is the same as the layout of a string. -type sliceHeader struct { - s string - cap int -} diff --git a/vendor/github.com/cloudflare/backoff/.travis.yml b/vendor/github.com/cloudflare/backoff/.travis.yml deleted file mode 100644 index 3a1e1cb345b..00000000000 --- a/vendor/github.com/cloudflare/backoff/.travis.yml +++ /dev/null @@ -1,24 +0,0 @@ -sudo: false -language: go -go: - - 1.6 - - 1.7 - - tip - -before_script: - - go get github.com/GeertJohan/fgt - - go get github.com/golang/lint/golint - - go get golang.org/x/tools/cmd/goimports - - go get honnef.co/go/staticcheck/cmd/staticcheck - -script: - - find . -name \*.go | xargs fgt goimports -l - - fgt go vet ./... - - fgt golint ./... - - fgt staticcheck ./... - - go test ./... - -notifications: - email: - recipients: - - kyle@cloudflare.com diff --git a/vendor/github.com/cloudflare/backoff/LICENSE b/vendor/github.com/cloudflare/backoff/LICENSE deleted file mode 100644 index 965145f740f..00000000000 --- a/vendor/github.com/cloudflare/backoff/LICENSE +++ /dev/null @@ -1,24 +0,0 @@ -Copyright (c) 2016 CloudFlare Inc. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions -are met: - -Redistributions of source code must retain the above copyright notice, -this list of conditions and the following disclaimer. - -Redistributions in binary form must reproduce the above copyright notice, -this list of conditions and the following disclaimer in the documentation -and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/cloudflare/backoff/README.md b/vendor/github.com/cloudflare/backoff/README.md deleted file mode 100644 index e1fe9e594e2..00000000000 --- a/vendor/github.com/cloudflare/backoff/README.md +++ /dev/null @@ -1,83 +0,0 @@ -# backoff -## Go implementation of "Exponential Backoff And Jitter" - -This package implements the backoff strategy described in the AWS -Architecture Blog article -["Exponential Backoff And Jitter"](http://www.awsarchitectureblog.com/2015/03/backoff.html). Essentially, -the backoff has an interval `time.Duration`; the *nth* call -to backoff will return an a `time.Duration` that is *2 n * -interval*. If jitter is enabled (which is the default behaviour), the -duration is a random value between 0 and *2 n * interval*. -The backoff is configured with a maximum duration that will not be -exceeded; e.g., by default, the longest duration returned is -`backoff.DefaultMaxDuration`. - -## Usage - -A `Backoff` is initialised with a call to `New`. Using zero values -causes it to use `DefaultMaxDuration` and `DefaultInterval` as the -maximum duration and interval. - -``` -package something - -import "github.com/cloudflare/backoff" - -func retryable() { - b := backoff.New(0, 0) - for { - err := someOperation() - if err == nil { - break - } - - log.Printf("error in someOperation: %v", err) - <-time.After(b.Duration()) - } - - log.Printf("succeeded after %d tries", b.Tries()+1) - b.Reset() -} -``` - -It can also be used to rate limit code that should retry infinitely, but which does not -use `Backoff` itself. - -``` -package something - -import ( - "time" - - "github.com/cloudflare/backoff" -) - -func retryable() { - b := backoff.New(0, 0) - b.SetDecay(30 * time.Second) - - for { - // b will reset if someOperation returns later than - // the last call to b.Duration() + 30s. - err := someOperation() - if err == nil { - break - } - - log.Printf("error in someOperation: %v", err) - <-time.After(b.Duration()) - } -} -``` - -## Tunables - -* `NewWithoutJitter` creates a Backoff that doesn't use jitter. - -The default behaviour is controlled by two variables: - -* `DefaultInterval` sets the base interval for backoffs created with - the zero `time.Duration` value in the `Interval` field. -* `DefaultMaxDuration` sets the maximum duration for backoffs created - with the zero `time.Duration` value in the `MaxDuration` field. - diff --git a/vendor/github.com/cloudflare/backoff/backoff.go b/vendor/github.com/cloudflare/backoff/backoff.go deleted file mode 100644 index ee054e156e9..00000000000 --- a/vendor/github.com/cloudflare/backoff/backoff.go +++ /dev/null @@ -1,197 +0,0 @@ -// Package backoff contains an implementation of an intelligent backoff -// strategy. It is based on the approach in the AWS architecture blog -// article titled "Exponential Backoff And Jitter", which is found at -// http://www.awsarchitectureblog.com/2015/03/backoff.html. -// -// Essentially, the backoff has an interval `time.Duration`; the nth -// call to backoff will return a `time.Duration` that is 2^n * -// interval. If jitter is enabled (which is the default behaviour), -// the duration is a random value between 0 and 2^n * interval. The -// backoff is configured with a maximum duration that will not be -// exceeded. -// -// The `New` function will attempt to use the system's cryptographic -// random number generator to seed a Go math/rand random number -// source. If this fails, the package will panic on startup. -package backoff - -import ( - "crypto/rand" - "encoding/binary" - "io" - "math" - mrand "math/rand" - "sync" - "time" -) - -var prngMu sync.Mutex -var prng *mrand.Rand - -// DefaultInterval is used when a Backoff is initialised with a -// zero-value Interval. -var DefaultInterval = 5 * time.Minute - -// DefaultMaxDuration is maximum amount of time that the backoff will -// delay for. -var DefaultMaxDuration = 6 * time.Hour - -// A Backoff contains the information needed to intelligently backoff -// and retry operations using an exponential backoff algorithm. It should -// be initialised with a call to `New`. -// -// Only use a Backoff from a single goroutine, it is not safe for concurrent -// access. -type Backoff struct { - // maxDuration is the largest possible duration that can be - // returned from a call to Duration. - maxDuration time.Duration - - // interval controls the time step for backing off. - interval time.Duration - - // noJitter controls whether to use the "Full Jitter" - // improvement to attempt to smooth out spikes in a high - // contention scenario. If noJitter is set to true, no - // jitter will be introduced. - noJitter bool - - // decay controls the decay of n. If it is non-zero, n is - // reset if more than the last backoff + decay has elapsed since - // the last try. - decay time.Duration - - n uint64 - lastTry time.Time -} - -// New creates a new backoff with the specified max duration and -// interval. Zero values may be used to use the default values. -// -// Panics if either max or interval is negative. -func New(max time.Duration, interval time.Duration) *Backoff { - if max < 0 || interval < 0 { - panic("backoff: max or interval is negative") - } - - b := &Backoff{ - maxDuration: max, - interval: interval, - } - b.setup() - return b -} - -// NewWithoutJitter works similarly to New, except that the created -// Backoff will not use jitter. -func NewWithoutJitter(max time.Duration, interval time.Duration) *Backoff { - b := New(max, interval) - b.noJitter = true - return b -} - -func init() { - var buf [8]byte - var n int64 - - _, err := io.ReadFull(rand.Reader, buf[:]) - if err != nil { - panic(err.Error()) - } - - n = int64(binary.LittleEndian.Uint64(buf[:])) - - src := mrand.NewSource(n) - prng = mrand.New(src) -} - -func (b *Backoff) setup() { - if b.interval == 0 { - b.interval = DefaultInterval - } - - if b.maxDuration == 0 { - b.maxDuration = DefaultMaxDuration - } -} - -// Duration returns a time.Duration appropriate for the backoff, -// incrementing the attempt counter. -func (b *Backoff) Duration() time.Duration { - b.setup() - - b.decayN() - - t := b.duration(b.n) - - if b.n < math.MaxUint64 { - b.n++ - } - - if !b.noJitter { - prngMu.Lock() - t = time.Duration(prng.Int63n(int64(t))) - prngMu.Unlock() - } - - return t -} - -// requires b to be locked. -func (b *Backoff) duration(n uint64) (t time.Duration) { - // Saturate pow - pow := time.Duration(math.MaxInt64) - if n < 63 { - pow = 1 << n - } - - t = b.interval * pow - if t/pow != b.interval || t > b.maxDuration { - t = b.maxDuration - } - - return -} - -// Reset resets the attempt counter of a backoff. -// -// It should be called when the rate-limited action succeeds. -func (b *Backoff) Reset() { - b.lastTry = time.Time{} - b.n = 0 -} - -// SetDecay sets the duration after which the try counter will be reset. -// Panics if decay is smaller than 0. -// -// The decay only kicks in if at least the last backoff + decay has elapsed -// since the last try. -func (b *Backoff) SetDecay(decay time.Duration) { - if decay < 0 { - panic("backoff: decay < 0") - } - - b.decay = decay -} - -// requires b to be locked -func (b *Backoff) decayN() { - if b.decay == 0 { - return - } - - if b.lastTry.IsZero() { - b.lastTry = time.Now() - return - } - - lastDuration := b.duration(b.n - 1) - decayed := time.Since(b.lastTry) > lastDuration+b.decay - b.lastTry = time.Now() - - if !decayed { - return - } - - b.n = 0 -} diff --git a/vendor/github.com/coreos/go-oidc/v3/LICENSE b/vendor/github.com/coreos/go-oidc/v3/LICENSE deleted file mode 100644 index e06d2081865..00000000000 --- a/vendor/github.com/coreos/go-oidc/v3/LICENSE +++ /dev/null @@ -1,202 +0,0 @@ -Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "{}" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright {yyyy} {name of copyright owner} - - 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. - diff --git a/vendor/github.com/coreos/go-oidc/v3/NOTICE b/vendor/github.com/coreos/go-oidc/v3/NOTICE deleted file mode 100644 index b39ddfa5cbd..00000000000 --- a/vendor/github.com/coreos/go-oidc/v3/NOTICE +++ /dev/null @@ -1,5 +0,0 @@ -CoreOS Project -Copyright 2014 CoreOS, Inc - -This product includes software developed at CoreOS, Inc. -(http://www.coreos.com/). diff --git a/vendor/github.com/coreos/go-oidc/v3/oidc/jose.go b/vendor/github.com/coreos/go-oidc/v3/oidc/jose.go deleted file mode 100644 index f42d37d4812..00000000000 --- a/vendor/github.com/coreos/go-oidc/v3/oidc/jose.go +++ /dev/null @@ -1,32 +0,0 @@ -package oidc - -import jose "github.com/go-jose/go-jose/v4" - -// JOSE asymmetric signing algorithm values as defined by RFC 7518 -// -// see: https://tools.ietf.org/html/rfc7518#section-3.1 -const ( - RS256 = "RS256" // RSASSA-PKCS-v1.5 using SHA-256 - RS384 = "RS384" // RSASSA-PKCS-v1.5 using SHA-384 - RS512 = "RS512" // RSASSA-PKCS-v1.5 using SHA-512 - ES256 = "ES256" // ECDSA using P-256 and SHA-256 - ES384 = "ES384" // ECDSA using P-384 and SHA-384 - ES512 = "ES512" // ECDSA using P-521 and SHA-512 - PS256 = "PS256" // RSASSA-PSS using SHA256 and MGF1-SHA256 - PS384 = "PS384" // RSASSA-PSS using SHA384 and MGF1-SHA384 - PS512 = "PS512" // RSASSA-PSS using SHA512 and MGF1-SHA512 - EdDSA = "EdDSA" // Ed25519 using SHA-512 -) - -var allAlgs = []jose.SignatureAlgorithm{ - jose.RS256, - jose.RS384, - jose.RS512, - jose.ES256, - jose.ES384, - jose.ES512, - jose.PS256, - jose.PS384, - jose.PS512, - jose.EdDSA, -} diff --git a/vendor/github.com/coreos/go-oidc/v3/oidc/jwks.go b/vendor/github.com/coreos/go-oidc/v3/oidc/jwks.go deleted file mode 100644 index c5e4d787c8f..00000000000 --- a/vendor/github.com/coreos/go-oidc/v3/oidc/jwks.go +++ /dev/null @@ -1,263 +0,0 @@ -package oidc - -import ( - "context" - "crypto" - "crypto/ecdsa" - "crypto/ed25519" - "crypto/rsa" - "errors" - "fmt" - "io" - "net/http" - "sync" - - jose "github.com/go-jose/go-jose/v4" -) - -// StaticKeySet is a verifier that validates JWT against a static set of public keys. -type StaticKeySet struct { - // PublicKeys used to verify the JWT. Supported types are *rsa.PublicKey and - // *ecdsa.PublicKey. - PublicKeys []crypto.PublicKey -} - -// VerifySignature compares the signature against a static set of public keys. -func (s *StaticKeySet) VerifySignature(ctx context.Context, jwt string) ([]byte, error) { - // Algorithms are already checked by Verifier, so this parse method accepts - // any algorithm. - jws, err := jose.ParseSigned(jwt, allAlgs) - if err != nil { - return nil, fmt.Errorf("parsing jwt: %v", err) - } - for _, pub := range s.PublicKeys { - switch pub.(type) { - case *rsa.PublicKey: - case *ecdsa.PublicKey: - case ed25519.PublicKey: - default: - return nil, fmt.Errorf("invalid public key type provided: %T", pub) - } - payload, err := jws.Verify(pub) - if err != nil { - continue - } - return payload, nil - } - return nil, fmt.Errorf("no public keys able to verify jwt") -} - -// NewRemoteKeySet returns a KeySet that can validate JSON web tokens by using HTTP -// GETs to fetch JSON web token sets hosted at a remote URL. This is automatically -// used by NewProvider using the URLs returned by OpenID Connect discovery, but is -// exposed for providers that don't support discovery or to prevent round trips to the -// discovery URL. -// -// The returned KeySet is a long lived verifier that caches keys based on any -// keys change. Reuse a common remote key set instead of creating new ones as needed. -func NewRemoteKeySet(ctx context.Context, jwksURL string) *RemoteKeySet { - return newRemoteKeySet(ctx, jwksURL) -} - -func newRemoteKeySet(ctx context.Context, jwksURL string) *RemoteKeySet { - return &RemoteKeySet{ - jwksURL: jwksURL, - // For historical reasons, this package uses contexts for configuration, not just - // cancellation. In hindsight, this was a bad idea. - // - // Attemps to reason about how cancels should work with background requests have - // largely lead to confusion. Use the context here as a config bag-of-values and - // ignore the cancel function. - ctx: context.WithoutCancel(ctx), - } -} - -// RemoteKeySet is a KeySet implementation that validates JSON web tokens against -// a jwks_uri endpoint. -type RemoteKeySet struct { - jwksURL string - - // Used for configuration. Cancelation is ignored. - ctx context.Context - - // guard all other fields - mu sync.RWMutex - - // inflight suppresses parallel execution of updateKeys and allows - // multiple goroutines to wait for its result. - inflight *inflight - - // A set of cached keys. - cachedKeys []jose.JSONWebKey -} - -// inflight is used to wait on some in-flight request from multiple goroutines. -type inflight struct { - doneCh chan struct{} - - keys []jose.JSONWebKey - err error -} - -func newInflight() *inflight { - return &inflight{doneCh: make(chan struct{})} -} - -// wait returns a channel that multiple goroutines can receive on. Once it returns -// a value, the inflight request is done and result() can be inspected. -func (i *inflight) wait() <-chan struct{} { - return i.doneCh -} - -// done can only be called by a single goroutine. It records the result of the -// inflight request and signals other goroutines that the result is safe to -// inspect. -func (i *inflight) done(keys []jose.JSONWebKey, err error) { - i.keys = keys - i.err = err - close(i.doneCh) -} - -// result cannot be called until the wait() channel has returned a value. -func (i *inflight) result() ([]jose.JSONWebKey, error) { - return i.keys, i.err -} - -// paresdJWTKey is a context key that allows common setups to avoid parsing the -// JWT twice. It holds a *jose.JSONWebSignature value. -var parsedJWTKey contextKey - -// VerifySignature validates a payload against a signature from the jwks_uri. -// -// Users MUST NOT call this method directly and should use an IDTokenVerifier -// instead. This method skips critical validations such as 'alg' values and is -// only exported to implement the KeySet interface. -func (r *RemoteKeySet) VerifySignature(ctx context.Context, jwt string) ([]byte, error) { - jws, ok := ctx.Value(parsedJWTKey).(*jose.JSONWebSignature) - if !ok { - // The algorithm values are already enforced by the Validator, which also sets - // the context value above to pre-parsed signature. - // - // Practically, this codepath isn't called in normal use of this package, but - // if it is, the algorithms have already been checked. - var err error - jws, err = jose.ParseSigned(jwt, allAlgs) - if err != nil { - return nil, fmt.Errorf("oidc: malformed jwt: %v", err) - } - } - return r.verify(ctx, jws) -} - -func (r *RemoteKeySet) verify(ctx context.Context, jws *jose.JSONWebSignature) ([]byte, error) { - // We don't support JWTs signed with multiple signatures. - keyID := "" - for _, sig := range jws.Signatures { - keyID = sig.Header.KeyID - break - } - - keys := r.keysFromCache() - for _, key := range keys { - if keyID == "" || key.KeyID == keyID { - if payload, err := jws.Verify(&key); err == nil { - return payload, nil - } - } - } - - // If the kid doesn't match, check for new keys from the remote. This is the - // strategy recommended by the spec. - // - // https://openid.net/specs/openid-connect-core-1_0.html#RotateSigKeys - keys, err := r.keysFromRemote(ctx) - if err != nil { - return nil, fmt.Errorf("fetching keys %w", err) - } - - for _, key := range keys { - if keyID == "" || key.KeyID == keyID { - if payload, err := jws.Verify(&key); err == nil { - return payload, nil - } - } - } - return nil, errors.New("failed to verify id token signature") -} - -func (r *RemoteKeySet) keysFromCache() (keys []jose.JSONWebKey) { - r.mu.RLock() - defer r.mu.RUnlock() - return r.cachedKeys -} - -// keysFromRemote syncs the key set from the remote set, records the values in the -// cache, and returns the key set. -func (r *RemoteKeySet) keysFromRemote(ctx context.Context) ([]jose.JSONWebKey, error) { - // Need to lock to inspect the inflight request field. - r.mu.Lock() - // If there's not a current inflight request, create one. - if r.inflight == nil { - r.inflight = newInflight() - - // This goroutine has exclusive ownership over the current inflight - // request. It releases the resource by nil'ing the inflight field - // once the goroutine is done. - go func() { - // Sync keys and finish inflight when that's done. - keys, err := r.updateKeys() - - r.inflight.done(keys, err) - - // Lock to update the keys and indicate that there is no longer an - // inflight request. - r.mu.Lock() - defer r.mu.Unlock() - - if err == nil { - r.cachedKeys = keys - } - - // Free inflight so a different request can run. - r.inflight = nil - }() - } - inflight := r.inflight - r.mu.Unlock() - - select { - case <-ctx.Done(): - return nil, ctx.Err() - case <-inflight.wait(): - return inflight.result() - } -} - -func (r *RemoteKeySet) updateKeys() ([]jose.JSONWebKey, error) { - req, err := http.NewRequest("GET", r.jwksURL, nil) - if err != nil { - return nil, fmt.Errorf("oidc: can't create request: %v", err) - } - - resp, err := doRequest(r.ctx, req) - if err != nil { - return nil, fmt.Errorf("oidc: get keys failed %w", err) - } - defer resp.Body.Close() - - body, err := io.ReadAll(resp.Body) - if err != nil { - return nil, fmt.Errorf("unable to read response body: %v", err) - } - - if resp.StatusCode != http.StatusOK { - return nil, fmt.Errorf("oidc: get keys failed: %s %s", resp.Status, body) - } - - var keySet jose.JSONWebKeySet - err = unmarshalResp(resp, body, &keySet) - if err != nil { - return nil, fmt.Errorf("oidc: failed to decode keys: %v %s", err, body) - } - return keySet.Keys, nil -} diff --git a/vendor/github.com/coreos/go-oidc/v3/oidc/oidc.go b/vendor/github.com/coreos/go-oidc/v3/oidc/oidc.go deleted file mode 100644 index 2659518cc48..00000000000 --- a/vendor/github.com/coreos/go-oidc/v3/oidc/oidc.go +++ /dev/null @@ -1,584 +0,0 @@ -// Package oidc implements OpenID Connect client logic for the golang.org/x/oauth2 package. -package oidc - -import ( - "context" - "crypto/sha256" - "crypto/sha512" - "encoding/base64" - "encoding/json" - "errors" - "fmt" - "hash" - "io" - "mime" - "net/http" - "strings" - "sync" - "time" - - "golang.org/x/oauth2" -) - -const ( - // ScopeOpenID is the mandatory scope for all OpenID Connect OAuth2 requests. - ScopeOpenID = "openid" - - // ScopeOfflineAccess is an optional scope defined by OpenID Connect for requesting - // OAuth2 refresh tokens. - // - // Support for this scope differs between OpenID Connect providers. For instance - // Google rejects it, favoring appending "access_type=offline" as part of the - // authorization request instead. - // - // See: https://openid.net/specs/openid-connect-core-1_0.html#OfflineAccess - ScopeOfflineAccess = "offline_access" -) - -var ( - errNoAtHash = errors.New("id token did not have an access token hash") - errInvalidAtHash = errors.New("access token hash does not match value in ID token") -) - -type contextKey int - -var issuerURLKey contextKey - -// ClientContext returns a new Context that carries the provided HTTP client. -// -// This method sets the same context key used by the golang.org/x/oauth2 package, -// so the returned context works for that package too. -// -// myClient := &http.Client{} -// ctx := oidc.ClientContext(parentContext, myClient) -// -// // This will use the custom client -// provider, err := oidc.NewProvider(ctx, "https://accounts.example.com") -func ClientContext(ctx context.Context, client *http.Client) context.Context { - return context.WithValue(ctx, oauth2.HTTPClient, client) -} - -func getClient(ctx context.Context) *http.Client { - if c, ok := ctx.Value(oauth2.HTTPClient).(*http.Client); ok { - return c - } - return nil -} - -// InsecureIssuerURLContext allows discovery to work when the issuer_url reported -// by upstream is mismatched with the discovery URL. This is meant for integration -// with off-spec providers such as Azure. -// -// discoveryBaseURL := "https://login.microsoftonline.com/organizations/v2.0" -// issuerURL := "https://login.microsoftonline.com/my-tenantid/v2.0" -// -// ctx := oidc.InsecureIssuerURLContext(parentContext, issuerURL) -// -// // Provider will be discovered with the discoveryBaseURL, but use issuerURL -// // for future issuer validation. -// provider, err := oidc.NewProvider(ctx, discoveryBaseURL) -// -// This is insecure because validating the correct issuer is critical for multi-tenant -// providers. Any overrides here MUST be carefully reviewed. -func InsecureIssuerURLContext(ctx context.Context, issuerURL string) context.Context { - return context.WithValue(ctx, issuerURLKey, issuerURL) -} - -func doRequest(ctx context.Context, req *http.Request) (*http.Response, error) { - client := http.DefaultClient - if c := getClient(ctx); c != nil { - client = c - } - return client.Do(req.WithContext(ctx)) -} - -// Provider represents an OpenID Connect server's configuration. -type Provider struct { - issuer string - authURL string - tokenURL string - deviceAuthURL string - userInfoURL string - jwksURL string - algorithms []string - - // Raw claims returned by the server. - rawClaims []byte - - // Guards all of the following fields. - mu sync.Mutex - // HTTP client specified from the initial NewProvider request. This is used - // when creating the common key set. - client *http.Client - // A key set that uses context.Background() and is shared between all code paths - // that don't have a convinent way of supplying a unique context. - commonRemoteKeySet KeySet -} - -func (p *Provider) remoteKeySet() KeySet { - p.mu.Lock() - defer p.mu.Unlock() - if p.commonRemoteKeySet == nil { - ctx := context.Background() - if p.client != nil { - ctx = ClientContext(ctx, p.client) - } - p.commonRemoteKeySet = NewRemoteKeySet(ctx, p.jwksURL) - } - return p.commonRemoteKeySet -} - -type providerJSON struct { - Issuer string `json:"issuer"` - AuthURL string `json:"authorization_endpoint"` - TokenURL string `json:"token_endpoint"` - DeviceAuthURL string `json:"device_authorization_endpoint"` - JWKSURL string `json:"jwks_uri"` - UserInfoURL string `json:"userinfo_endpoint"` - Algorithms []string `json:"id_token_signing_alg_values_supported"` -} - -// supportedAlgorithms is a list of algorithms explicitly supported by this -// package. If a provider supports other algorithms, such as HS256 or none, -// those values won't be passed to the IDTokenVerifier. -var supportedAlgorithms = map[string]bool{ - RS256: true, - RS384: true, - RS512: true, - ES256: true, - ES384: true, - ES512: true, - PS256: true, - PS384: true, - PS512: true, - EdDSA: true, -} - -// ProviderConfig allows direct creation of a [Provider] from metadata -// configuration. This is intended for interop with providers that don't support -// discovery, or host the JSON discovery document at an off-spec path. -// -// The ProviderConfig struct specifies JSON struct tags to support document -// parsing. -// -// // Directly fetch the metadata document. -// resp, err := http.Get("https://login.example.com/custom-metadata-path") -// if err != nil { -// // ... -// } -// defer resp.Body.Close() -// -// // Parse config from JSON metadata. -// config := &oidc.ProviderConfig{} -// if err := json.NewDecoder(resp.Body).Decode(config); err != nil { -// // ... -// } -// p := config.NewProvider(context.Background()) -// -// For providers that implement discovery, use [NewProvider] instead. -// -// See: https://openid.net/specs/openid-connect-discovery-1_0.html -type ProviderConfig struct { - // IssuerURL is the identity of the provider, and the string it uses to sign - // ID tokens with. For example "https://accounts.google.com". This value MUST - // match ID tokens exactly. - IssuerURL string `json:"issuer"` - // AuthURL is the endpoint used by the provider to support the OAuth 2.0 - // authorization endpoint. - AuthURL string `json:"authorization_endpoint"` - // TokenURL is the endpoint used by the provider to support the OAuth 2.0 - // token endpoint. - TokenURL string `json:"token_endpoint"` - // DeviceAuthURL is the endpoint used by the provider to support the OAuth 2.0 - // device authorization endpoint. - DeviceAuthURL string `json:"device_authorization_endpoint"` - // UserInfoURL is the endpoint used by the provider to support the OpenID - // Connect UserInfo flow. - // - // https://openid.net/specs/openid-connect-core-1_0.html#UserInfo - UserInfoURL string `json:"userinfo_endpoint"` - // JWKSURL is the endpoint used by the provider to advertise public keys to - // verify issued ID tokens. This endpoint is polled as new keys are made - // available. - JWKSURL string `json:"jwks_uri"` - - // Algorithms, if provided, indicate a list of JWT algorithms allowed to sign - // ID tokens. If not provided, this defaults to the algorithms advertised by - // the JWK endpoint, then the set of algorithms supported by this package. - Algorithms []string `json:"id_token_signing_alg_values_supported"` -} - -// NewProvider initializes a provider from a set of endpoints, rather than -// through discovery. -// -// The provided context is only used for [http.Client] configuration through -// [ClientContext], not cancelation. -func (p *ProviderConfig) NewProvider(ctx context.Context) *Provider { - return &Provider{ - issuer: p.IssuerURL, - authURL: p.AuthURL, - tokenURL: p.TokenURL, - deviceAuthURL: p.DeviceAuthURL, - userInfoURL: p.UserInfoURL, - jwksURL: p.JWKSURL, - algorithms: p.Algorithms, - client: getClient(ctx), - } -} - -// NewProvider uses the OpenID Connect discovery mechanism to construct a Provider. -// The issuer is the URL identifier for the service. For example: "https://accounts.google.com" -// or "https://login.salesforce.com". -// -// OpenID Connect providers that don't implement discovery or host the discovery -// document at a non-spec complaint path (such as requiring a URL parameter), -// should use [ProviderConfig] instead. -// -// See: https://openid.net/specs/openid-connect-discovery-1_0.html -func NewProvider(ctx context.Context, issuer string) (*Provider, error) { - wellKnown := strings.TrimSuffix(issuer, "/") + "/.well-known/openid-configuration" - req, err := http.NewRequest("GET", wellKnown, nil) - if err != nil { - return nil, err - } - resp, err := doRequest(ctx, req) - if err != nil { - return nil, err - } - defer resp.Body.Close() - - body, err := io.ReadAll(resp.Body) - if err != nil { - return nil, fmt.Errorf("unable to read response body: %v", err) - } - - if resp.StatusCode != http.StatusOK { - return nil, fmt.Errorf("%s: %s", resp.Status, body) - } - - var p providerJSON - err = unmarshalResp(resp, body, &p) - if err != nil { - return nil, fmt.Errorf("oidc: failed to decode provider discovery object: %v", err) - } - - issuerURL, skipIssuerValidation := ctx.Value(issuerURLKey).(string) - if !skipIssuerValidation { - issuerURL = issuer - } - if p.Issuer != issuerURL && !skipIssuerValidation { - return nil, fmt.Errorf("oidc: issuer URL provided to client (%q) did not match the issuer URL returned by provider (%q)", issuer, p.Issuer) - } - var algs []string - for _, a := range p.Algorithms { - if supportedAlgorithms[a] { - algs = append(algs, a) - } - } - return &Provider{ - issuer: issuerURL, - authURL: p.AuthURL, - tokenURL: p.TokenURL, - deviceAuthURL: p.DeviceAuthURL, - userInfoURL: p.UserInfoURL, - jwksURL: p.JWKSURL, - algorithms: algs, - rawClaims: body, - client: getClient(ctx), - }, nil -} - -// Claims unmarshals raw fields returned by the server during discovery. -// -// var claims struct { -// ScopesSupported []string `json:"scopes_supported"` -// ClaimsSupported []string `json:"claims_supported"` -// } -// -// if err := provider.Claims(&claims); err != nil { -// // handle unmarshaling error -// } -// -// For a list of fields defined by the OpenID Connect spec see: -// https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderMetadata -func (p *Provider) Claims(v interface{}) error { - if p.rawClaims == nil { - return errors.New("oidc: claims not set") - } - return json.Unmarshal(p.rawClaims, v) -} - -// Endpoint returns the OAuth2 auth and token endpoints for the given provider. -func (p *Provider) Endpoint() oauth2.Endpoint { - return oauth2.Endpoint{AuthURL: p.authURL, DeviceAuthURL: p.deviceAuthURL, TokenURL: p.tokenURL} -} - -// UserInfoEndpoint returns the OpenID Connect userinfo endpoint for the given -// provider. -func (p *Provider) UserInfoEndpoint() string { - return p.userInfoURL -} - -// UserInfo represents the OpenID Connect userinfo claims. -type UserInfo struct { - Subject string `json:"sub"` - Profile string `json:"profile"` - Email string `json:"email"` - EmailVerified bool `json:"email_verified"` - - claims []byte -} - -type userInfoRaw struct { - Subject string `json:"sub"` - Profile string `json:"profile"` - Email string `json:"email"` - // Handle providers that return email_verified as a string - // https://forums.aws.amazon.com/thread.jspa?messageID=949441󧳁 and - // https://discuss.elastic.co/t/openid-error-after-authenticating-against-aws-cognito/206018/11 - EmailVerified stringAsBool `json:"email_verified"` -} - -// Claims unmarshals the raw JSON object claims into the provided object. -func (u *UserInfo) Claims(v interface{}) error { - if u.claims == nil { - return errors.New("oidc: claims not set") - } - return json.Unmarshal(u.claims, v) -} - -// UserInfo uses the token source to query the provider's user info endpoint. -func (p *Provider) UserInfo(ctx context.Context, tokenSource oauth2.TokenSource) (*UserInfo, error) { - if p.userInfoURL == "" { - return nil, errors.New("oidc: user info endpoint is not supported by this provider") - } - - req, err := http.NewRequest("GET", p.userInfoURL, nil) - if err != nil { - return nil, fmt.Errorf("oidc: create GET request: %v", err) - } - - token, err := tokenSource.Token() - if err != nil { - return nil, fmt.Errorf("oidc: get access token: %v", err) - } - token.SetAuthHeader(req) - - resp, err := doRequest(ctx, req) - if err != nil { - return nil, err - } - defer resp.Body.Close() - body, err := io.ReadAll(resp.Body) - if err != nil { - return nil, err - } - if resp.StatusCode != http.StatusOK { - return nil, fmt.Errorf("%s: %s", resp.Status, body) - } - - ct := resp.Header.Get("Content-Type") - mediaType, _, parseErr := mime.ParseMediaType(ct) - if parseErr == nil && mediaType == "application/jwt" { - payload, err := p.remoteKeySet().VerifySignature(ctx, string(body)) - if err != nil { - return nil, fmt.Errorf("oidc: invalid userinfo jwt signature %v", err) - } - body = payload - } - - var userInfo userInfoRaw - if err := json.Unmarshal(body, &userInfo); err != nil { - return nil, fmt.Errorf("oidc: failed to decode userinfo: %v", err) - } - return &UserInfo{ - Subject: userInfo.Subject, - Profile: userInfo.Profile, - Email: userInfo.Email, - EmailVerified: bool(userInfo.EmailVerified), - claims: body, - }, nil -} - -// IDToken is an OpenID Connect extension that provides a predictable representation -// of an authorization event. -// -// The ID Token only holds fields OpenID Connect requires. To access additional -// claims returned by the server, use the Claims method. -type IDToken struct { - // The URL of the server which issued this token. OpenID Connect - // requires this value always be identical to the URL used for - // initial discovery. - // - // Note: Because of a known issue with Google Accounts' implementation - // this value may differ when using Google. - // - // See: https://developers.google.com/identity/protocols/OpenIDConnect#obtainuserinfo - Issuer string - - // The client ID, or set of client IDs, that this token is issued for. For - // common uses, this is the client that initialized the auth flow. - // - // This package ensures the audience contains an expected value. - Audience []string - - // A unique string which identifies the end user. - Subject string - - // Expiry of the token. Ths package will not process tokens that have - // expired unless that validation is explicitly turned off. - Expiry time.Time - // When the token was issued by the provider. - IssuedAt time.Time - - // Initial nonce provided during the authentication redirect. - // - // This package does NOT provided verification on the value of this field - // and it's the user's responsibility to ensure it contains a valid value. - Nonce string - - // at_hash claim, if set in the ID token. Callers can verify an access token - // that corresponds to the ID token using the VerifyAccessToken method. - AccessTokenHash string - - // signature algorithm used for ID token, needed to compute a verification hash of an - // access token - sigAlgorithm string - - // Raw payload of the id_token. - claims []byte - - // Map of distributed claim names to claim sources - distributedClaims map[string]claimSource -} - -// Claims unmarshals the raw JSON payload of the ID Token into a provided struct. -// -// idToken, err := idTokenVerifier.Verify(rawIDToken) -// if err != nil { -// // handle error -// } -// var claims struct { -// Email string `json:"email"` -// EmailVerified bool `json:"email_verified"` -// } -// if err := idToken.Claims(&claims); err != nil { -// // handle error -// } -func (i *IDToken) Claims(v interface{}) error { - if i.claims == nil { - return errors.New("oidc: claims not set") - } - return json.Unmarshal(i.claims, v) -} - -// VerifyAccessToken verifies that the hash of the access token that corresponds to the iD token -// matches the hash in the id token. It returns an error if the hashes don't match. -// It is the caller's responsibility to ensure that the optional access token hash is present for the ID token -// before calling this method. See https://openid.net/specs/openid-connect-core-1_0.html#CodeIDToken -func (i *IDToken) VerifyAccessToken(accessToken string) error { - if i.AccessTokenHash == "" { - return errNoAtHash - } - var h hash.Hash - switch i.sigAlgorithm { - case RS256, ES256, PS256: - h = sha256.New() - case RS384, ES384, PS384: - h = sha512.New384() - case RS512, ES512, PS512, EdDSA: - h = sha512.New() - default: - return fmt.Errorf("oidc: unsupported signing algorithm %q", i.sigAlgorithm) - } - h.Write([]byte(accessToken)) // hash documents that Write will never return an error - sum := h.Sum(nil)[:h.Size()/2] - actual := base64.RawURLEncoding.EncodeToString(sum) - if actual != i.AccessTokenHash { - return errInvalidAtHash - } - return nil -} - -type idToken struct { - Issuer string `json:"iss"` - Subject string `json:"sub"` - Audience audience `json:"aud"` - Expiry jsonTime `json:"exp"` - IssuedAt jsonTime `json:"iat"` - NotBefore *jsonTime `json:"nbf"` - Nonce string `json:"nonce"` - AtHash string `json:"at_hash"` - ClaimNames map[string]string `json:"_claim_names"` - ClaimSources map[string]claimSource `json:"_claim_sources"` -} - -type claimSource struct { - Endpoint string `json:"endpoint"` - AccessToken string `json:"access_token"` -} - -type stringAsBool bool - -func (sb *stringAsBool) UnmarshalJSON(b []byte) error { - switch string(b) { - case "true", `"true"`: - *sb = true - case "false", `"false"`: - *sb = false - default: - return errors.New("invalid value for boolean") - } - return nil -} - -type audience []string - -func (a *audience) UnmarshalJSON(b []byte) error { - var s string - if json.Unmarshal(b, &s) == nil { - *a = audience{s} - return nil - } - var auds []string - if err := json.Unmarshal(b, &auds); err != nil { - return err - } - *a = auds - return nil -} - -type jsonTime time.Time - -func (j *jsonTime) UnmarshalJSON(b []byte) error { - var n json.Number - if err := json.Unmarshal(b, &n); err != nil { - return err - } - var unix int64 - - if t, err := n.Int64(); err == nil { - unix = t - } else { - f, err := n.Float64() - if err != nil { - return err - } - unix = int64(f) - } - *j = jsonTime(time.Unix(unix, 0)) - return nil -} - -func unmarshalResp(r *http.Response, body []byte, v interface{}) error { - err := json.Unmarshal(body, &v) - if err == nil { - return nil - } - ct := r.Header.Get("Content-Type") - mediaType, _, parseErr := mime.ParseMediaType(ct) - if parseErr == nil && mediaType == "application/json" { - return fmt.Errorf("got Content-Type = application/json, but could not unmarshal as JSON: %v", err) - } - return fmt.Errorf("expected Content-Type = application/json, got %q: %v", ct, err) -} diff --git a/vendor/github.com/coreos/go-oidc/v3/oidc/verify.go b/vendor/github.com/coreos/go-oidc/v3/oidc/verify.go deleted file mode 100644 index a8bf107d4a6..00000000000 --- a/vendor/github.com/coreos/go-oidc/v3/oidc/verify.go +++ /dev/null @@ -1,338 +0,0 @@ -package oidc - -import ( - "context" - "encoding/json" - "fmt" - "io" - "net/http" - "time" - - jose "github.com/go-jose/go-jose/v4" - "golang.org/x/oauth2" -) - -const ( - issuerGoogleAccounts = "https://accounts.google.com" - issuerGoogleAccountsNoScheme = "accounts.google.com" -) - -// TokenExpiredError indicates that Verify failed because the token was expired. This -// error does NOT indicate that the token is not also invalid for other reasons. Other -// checks might have failed if the expiration check had not failed. -type TokenExpiredError struct { - // Expiry is the time when the token expired. - Expiry time.Time -} - -func (e *TokenExpiredError) Error() string { - return fmt.Sprintf("oidc: token is expired (Token Expiry: %v)", e.Expiry) -} - -// KeySet is a set of publc JSON Web Keys that can be used to validate the signature -// of JSON web tokens. This is expected to be backed by a remote key set through -// provider metadata discovery or an in-memory set of keys delivered out-of-band. -type KeySet interface { - // VerifySignature parses the JSON web token, verifies the signature, and returns - // the raw payload. Header and claim fields are validated by other parts of the - // package. For example, the KeySet does not need to check values such as signature - // algorithm, issuer, and audience since the IDTokenVerifier validates these values - // independently. - // - // If VerifySignature makes HTTP requests to verify the token, it's expected to - // use any HTTP client associated with the context through ClientContext. - VerifySignature(ctx context.Context, jwt string) (payload []byte, err error) -} - -// IDTokenVerifier provides verification for ID Tokens. -type IDTokenVerifier struct { - keySet KeySet - config *Config - issuer string -} - -// NewVerifier returns a verifier manually constructed from a key set and issuer URL. -// -// It's easier to use provider discovery to construct an IDTokenVerifier than creating -// one directly. This method is intended to be used with provider that don't support -// metadata discovery, or avoiding round trips when the key set URL is already known. -// -// This constructor can be used to create a verifier directly using the issuer URL and -// JSON Web Key Set URL without using discovery: -// -// keySet := oidc.NewRemoteKeySet(ctx, "https://www.googleapis.com/oauth2/v3/certs") -// verifier := oidc.NewVerifier("https://accounts.google.com", keySet, config) -// -// Or a static key set (e.g. for testing): -// -// keySet := &oidc.StaticKeySet{PublicKeys: []crypto.PublicKey{pub1, pub2}} -// verifier := oidc.NewVerifier("https://accounts.google.com", keySet, config) -func NewVerifier(issuerURL string, keySet KeySet, config *Config) *IDTokenVerifier { - return &IDTokenVerifier{keySet: keySet, config: config, issuer: issuerURL} -} - -// Config is the configuration for an IDTokenVerifier. -type Config struct { - // Expected audience of the token. For a majority of the cases this is expected to be - // the ID of the client that initialized the login flow. It may occasionally differ if - // the provider supports the authorizing party (azp) claim. - // - // If not provided, users must explicitly set SkipClientIDCheck. - ClientID string - // If specified, only this set of algorithms may be used to sign the JWT. - // - // If the IDTokenVerifier is created from a provider with (*Provider).Verifier, this - // defaults to the set of algorithms the provider supports. Otherwise this values - // defaults to RS256. - SupportedSigningAlgs []string - - // If true, no ClientID check performed. Must be true if ClientID field is empty. - SkipClientIDCheck bool - // If true, token expiry is not checked. - SkipExpiryCheck bool - - // SkipIssuerCheck is intended for specialized cases where the the caller wishes to - // defer issuer validation. When enabled, callers MUST independently verify the Token's - // Issuer is a known good value. - // - // Mismatched issuers often indicate client mis-configuration. If mismatches are - // unexpected, evaluate if the provided issuer URL is incorrect instead of enabling - // this option. - SkipIssuerCheck bool - - // Time function to check Token expiry. Defaults to time.Now - Now func() time.Time - - // InsecureSkipSignatureCheck causes this package to skip JWT signature validation. - // It's intended for special cases where providers (such as Azure), use the "none" - // algorithm. - // - // This option can only be enabled safely when the ID Token is received directly - // from the provider after the token exchange. - // - // This option MUST NOT be used when receiving an ID Token from sources other - // than the token endpoint. - InsecureSkipSignatureCheck bool -} - -// VerifierContext returns an IDTokenVerifier that uses the provider's key set to -// verify JWTs. As opposed to Verifier, the context is used to configure requests -// to the upstream JWKs endpoint. The provided context's cancellation is ignored. -func (p *Provider) VerifierContext(ctx context.Context, config *Config) *IDTokenVerifier { - return p.newVerifier(NewRemoteKeySet(ctx, p.jwksURL), config) -} - -// Verifier returns an IDTokenVerifier that uses the provider's key set to verify JWTs. -// -// The returned verifier uses a background context for all requests to the upstream -// JWKs endpoint. To control that context, use VerifierContext instead. -func (p *Provider) Verifier(config *Config) *IDTokenVerifier { - return p.newVerifier(p.remoteKeySet(), config) -} - -func (p *Provider) newVerifier(keySet KeySet, config *Config) *IDTokenVerifier { - if len(config.SupportedSigningAlgs) == 0 && len(p.algorithms) > 0 { - // Make a copy so we don't modify the config values. - cp := &Config{} - *cp = *config - cp.SupportedSigningAlgs = p.algorithms - config = cp - } - return NewVerifier(p.issuer, keySet, config) -} - -func contains(sli []string, ele string) bool { - for _, s := range sli { - if s == ele { - return true - } - } - return false -} - -// Returns the Claims from the distributed JWT token -func resolveDistributedClaim(ctx context.Context, verifier *IDTokenVerifier, src claimSource) ([]byte, error) { - req, err := http.NewRequest("GET", src.Endpoint, nil) - if err != nil { - return nil, fmt.Errorf("malformed request: %v", err) - } - if src.AccessToken != "" { - req.Header.Set("Authorization", "Bearer "+src.AccessToken) - } - - resp, err := doRequest(ctx, req) - if err != nil { - return nil, fmt.Errorf("oidc: Request to endpoint failed: %v", err) - } - defer resp.Body.Close() - - body, err := io.ReadAll(resp.Body) - if err != nil { - return nil, fmt.Errorf("unable to read response body: %v", err) - } - - if resp.StatusCode != http.StatusOK { - return nil, fmt.Errorf("oidc: request failed: %v", resp.StatusCode) - } - - token, err := verifier.Verify(ctx, string(body)) - if err != nil { - return nil, fmt.Errorf("malformed response body: %v", err) - } - - return token.claims, nil -} - -// Verify parses a raw ID Token, verifies it's been signed by the provider, performs -// any additional checks depending on the Config, and returns the payload. -// -// Verify does NOT do nonce validation, which is the callers responsibility. -// -// See: https://openid.net/specs/openid-connect-core-1_0.html#IDTokenValidation -// -// oauth2Token, err := oauth2Config.Exchange(ctx, r.URL.Query().Get("code")) -// if err != nil { -// // handle error -// } -// -// // Extract the ID Token from oauth2 token. -// rawIDToken, ok := oauth2Token.Extra("id_token").(string) -// if !ok { -// // handle error -// } -// -// token, err := verifier.Verify(ctx, rawIDToken) -func (v *IDTokenVerifier) Verify(ctx context.Context, rawIDToken string) (*IDToken, error) { - var supportedSigAlgs []jose.SignatureAlgorithm - for _, alg := range v.config.SupportedSigningAlgs { - supportedSigAlgs = append(supportedSigAlgs, jose.SignatureAlgorithm(alg)) - } - if len(supportedSigAlgs) == 0 { - // If no algorithms were specified by both the config and discovery, default - // to the one mandatory algorithm "RS256". - supportedSigAlgs = []jose.SignatureAlgorithm{jose.RS256} - } - if v.config.InsecureSkipSignatureCheck { - // "none" is a required value to even parse a JWT with the "none" algorithm - // using go-jose. - supportedSigAlgs = append(supportedSigAlgs, "none") - } - - // Parse and verify the signature first. This at least forces the user to have - // a valid, signed ID token before we do any other processing. - jws, err := jose.ParseSigned(rawIDToken, supportedSigAlgs) - if err != nil { - return nil, fmt.Errorf("oidc: malformed jwt: %v", err) - } - switch len(jws.Signatures) { - case 0: - return nil, fmt.Errorf("oidc: id token not signed") - case 1: - default: - return nil, fmt.Errorf("oidc: multiple signatures on id token not supported") - } - sig := jws.Signatures[0] - - var payload []byte - if v.config.InsecureSkipSignatureCheck { - // Yolo mode. - payload = jws.UnsafePayloadWithoutVerification() - } else { - // The JWT is attached here for the happy path to avoid the verifier from - // having to parse the JWT twice. - ctx = context.WithValue(ctx, parsedJWTKey, jws) - payload, err = v.keySet.VerifySignature(ctx, rawIDToken) - if err != nil { - return nil, fmt.Errorf("failed to verify signature: %v", err) - } - } - var token idToken - if err := json.Unmarshal(payload, &token); err != nil { - return nil, fmt.Errorf("oidc: failed to unmarshal claims: %v", err) - } - - distributedClaims := make(map[string]claimSource) - - //step through the token to map claim names to claim sources" - for cn, src := range token.ClaimNames { - if src == "" { - return nil, fmt.Errorf("oidc: failed to obtain source from claim name") - } - s, ok := token.ClaimSources[src] - if !ok { - return nil, fmt.Errorf("oidc: source does not exist") - } - distributedClaims[cn] = s - } - - t := &IDToken{ - Issuer: token.Issuer, - Subject: token.Subject, - Audience: []string(token.Audience), - Expiry: time.Time(token.Expiry), - IssuedAt: time.Time(token.IssuedAt), - Nonce: token.Nonce, - AccessTokenHash: token.AtHash, - claims: payload, - distributedClaims: distributedClaims, - sigAlgorithm: sig.Header.Algorithm, - } - - // Check issuer. - if !v.config.SkipIssuerCheck && t.Issuer != v.issuer { - // Google sometimes returns "accounts.google.com" as the issuer claim instead of - // the required "https://accounts.google.com". Detect this case and allow it only - // for Google. - // - // We will not add hooks to let other providers go off spec like this. - if !(v.issuer == issuerGoogleAccounts && t.Issuer == issuerGoogleAccountsNoScheme) { - return nil, fmt.Errorf("oidc: id token issued by a different provider, expected %q got %q", v.issuer, t.Issuer) - } - } - - // If a client ID has been provided, make sure it's part of the audience. SkipClientIDCheck must be true if ClientID is empty. - // - // This check DOES NOT ensure that the ClientID is the party to which the ID Token was issued (i.e. Authorized party). - if !v.config.SkipClientIDCheck { - if v.config.ClientID != "" { - if !contains(t.Audience, v.config.ClientID) { - return nil, fmt.Errorf("oidc: expected audience %q got %q", v.config.ClientID, t.Audience) - } - } else { - return nil, fmt.Errorf("oidc: invalid configuration, clientID must be provided or SkipClientIDCheck must be set") - } - } - - // If a SkipExpiryCheck is false, make sure token is not expired. - if !v.config.SkipExpiryCheck { - now := time.Now - if v.config.Now != nil { - now = v.config.Now - } - nowTime := now() - - if t.Expiry.Before(nowTime) { - return nil, &TokenExpiredError{Expiry: t.Expiry} - } - - // If nbf claim is provided in token, ensure that it is indeed in the past. - if token.NotBefore != nil { - nbfTime := time.Time(*token.NotBefore) - // Set to 5 minutes since this is what other OpenID Connect providers do to deal with clock skew. - // https://github.com/AzureAD/azure-activedirectory-identitymodel-extensions-for-dotnet/blob/6.12.2/src/Microsoft.IdentityModel.Tokens/TokenValidationParameters.cs#L149-L153 - leeway := 5 * time.Minute - - if nowTime.Add(leeway).Before(nbfTime) { - return nil, fmt.Errorf("oidc: current time %v before the nbf (not before) time: %v", nowTime, nbfTime) - } - } - } - - return t, nil -} - -// Nonce returns an auth code option which requires the ID Token created by the -// OpenID Connect provider to contain the specified nonce. -func Nonce(nonce string) oauth2.AuthCodeOption { - return oauth2.SetAuthURLParam("nonce", nonce) -} diff --git a/vendor/github.com/coreos/go-systemd/v22/LICENSE b/vendor/github.com/coreos/go-systemd/v22/LICENSE deleted file mode 100644 index 37ec93a14fd..00000000000 --- a/vendor/github.com/coreos/go-systemd/v22/LICENSE +++ /dev/null @@ -1,191 +0,0 @@ -Apache License -Version 2.0, January 2004 -http://www.apache.org/licenses/ - -TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - -1. Definitions. - -"License" shall mean the terms and conditions for use, reproduction, and -distribution as defined by Sections 1 through 9 of this document. - -"Licensor" shall mean the copyright owner or entity authorized by the copyright -owner that is granting the License. - -"Legal Entity" shall mean the union of the acting entity and all other entities -that control, are controlled by, or are under common control with that entity. -For the purposes of this definition, "control" means (i) the power, direct or -indirect, to cause the direction or management of such entity, whether by -contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the -outstanding shares, or (iii) beneficial ownership of such entity. - -"You" (or "Your") shall mean an individual or Legal Entity exercising -permissions granted by this License. - -"Source" form shall mean the preferred form for making modifications, including -but not limited to software source code, documentation source, and configuration -files. - -"Object" form shall mean any form resulting from mechanical transformation or -translation of a Source form, including but not limited to compiled object code, -generated documentation, and conversions to other media types. - -"Work" shall mean the work of authorship, whether in Source or Object form, made -available under the License, as indicated by a copyright notice that is included -in or attached to the work (an example is provided in the Appendix below). - -"Derivative Works" shall mean any work, whether in Source or Object form, that -is based on (or derived from) the Work and for which the editorial revisions, -annotations, elaborations, or other modifications represent, as a whole, an -original work of authorship. For the purposes of this License, Derivative Works -shall not include works that remain separable from, or merely link (or bind by -name) to the interfaces of, the Work and Derivative Works thereof. - -"Contribution" shall mean any work of authorship, including the original version -of the Work and any modifications or additions to that Work or Derivative Works -thereof, that is intentionally submitted to Licensor for inclusion in the Work -by the copyright owner or by an individual or Legal Entity authorized to submit -on behalf of the copyright owner. For the purposes of this definition, -"submitted" means any form of electronic, verbal, or written communication sent -to the Licensor or its representatives, including but not limited to -communication on electronic mailing lists, source code control systems, and -issue tracking systems that are managed by, or on behalf of, the Licensor for -the purpose of discussing and improving the Work, but excluding communication -that is conspicuously marked or otherwise designated in writing by the copyright -owner as "Not a Contribution." - -"Contributor" shall mean Licensor and any individual or Legal Entity on behalf -of whom a Contribution has been received by Licensor and subsequently -incorporated within the Work. - -2. Grant of Copyright License. - -Subject to the terms and conditions of this License, each Contributor hereby -grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, -irrevocable copyright license to reproduce, prepare Derivative Works of, -publicly display, publicly perform, sublicense, and distribute the Work and such -Derivative Works in Source or Object form. - -3. Grant of Patent License. - -Subject to the terms and conditions of this License, each Contributor hereby -grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, -irrevocable (except as stated in this section) patent license to make, have -made, use, offer to sell, sell, import, and otherwise transfer the Work, where -such license applies only to those patent claims licensable by such Contributor -that are necessarily infringed by their Contribution(s) alone or by combination -of their Contribution(s) with the Work to which such Contribution(s) was -submitted. If You institute patent litigation against any entity (including a -cross-claim or counterclaim in a lawsuit) alleging that the Work or a -Contribution incorporated within the Work constitutes direct or contributory -patent infringement, then any patent licenses granted to You under this License -for that Work shall terminate as of the date such litigation is filed. - -4. Redistribution. - -You may reproduce and distribute copies of the Work or Derivative Works thereof -in any medium, with or without modifications, and in Source or Object form, -provided that You meet the following conditions: - -You must give any other recipients of the Work or Derivative Works a copy of -this License; and -You must cause any modified files to carry prominent notices stating that You -changed the files; and -You must retain, in the Source form of any Derivative Works that You distribute, -all copyright, patent, trademark, and attribution notices from the Source form -of the Work, excluding those notices that do not pertain to any part of the -Derivative Works; and -If the Work includes a "NOTICE" text file as part of its distribution, then any -Derivative Works that You distribute must include a readable copy of the -attribution notices contained within such NOTICE file, excluding those notices -that do not pertain to any part of the Derivative Works, in at least one of the -following places: within a NOTICE text file distributed as part of the -Derivative Works; within the Source form or documentation, if provided along -with the Derivative Works; or, within a display generated by the Derivative -Works, if and wherever such third-party notices normally appear. The contents of -the NOTICE file are for informational purposes only and do not modify the -License. You may add Your own attribution notices within Derivative Works that -You distribute, alongside or as an addendum to the NOTICE text from the Work, -provided that such additional attribution notices cannot be construed as -modifying the License. -You may add Your own copyright statement to Your modifications and may provide -additional or different license terms and conditions for use, reproduction, or -distribution of Your modifications, or for any such Derivative Works as a whole, -provided Your use, reproduction, and distribution of the Work otherwise complies -with the conditions stated in this License. - -5. Submission of Contributions. - -Unless You explicitly state otherwise, any Contribution intentionally submitted -for inclusion in the Work by You to the Licensor shall be under the terms and -conditions of this License, without any additional terms or conditions. -Notwithstanding the above, nothing herein shall supersede or modify the terms of -any separate license agreement you may have executed with Licensor regarding -such Contributions. - -6. Trademarks. - -This License does not grant permission to use the trade names, trademarks, -service marks, or product names of the Licensor, except as required for -reasonable and customary use in describing the origin of the Work and -reproducing the content of the NOTICE file. - -7. Disclaimer of Warranty. - -Unless required by applicable law or agreed to in writing, Licensor provides the -Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, -including, without limitation, any warranties or conditions of TITLE, -NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are -solely responsible for determining the appropriateness of using or -redistributing the Work and assume any risks associated with Your exercise of -permissions under this License. - -8. Limitation of Liability. - -In no event and under no legal theory, whether in tort (including negligence), -contract, or otherwise, unless required by applicable law (such as deliberate -and grossly negligent acts) or agreed to in writing, shall any Contributor be -liable to You for damages, including any direct, indirect, special, incidental, -or consequential damages of any character arising as a result of this License or -out of the use or inability to use the Work (including but not limited to -damages for loss of goodwill, work stoppage, computer failure or malfunction, or -any and all other commercial damages or losses), even if such Contributor has -been advised of the possibility of such damages. - -9. Accepting Warranty or Additional Liability. - -While redistributing the Work or Derivative Works thereof, You may choose to -offer, and charge a fee for, acceptance of support, warranty, indemnity, or -other liability obligations and/or rights consistent with this License. However, -in accepting such obligations, You may act only on Your own behalf and on Your -sole responsibility, not on behalf of any other Contributor, and only if You -agree to indemnify, defend, and hold each Contributor harmless for any liability -incurred by, or claims asserted against, such Contributor by reason of your -accepting any such warranty or additional liability. - -END OF TERMS AND CONDITIONS - -APPENDIX: How to apply the Apache License to your work - -To apply the Apache License to your work, attach the following boilerplate -notice, with the fields enclosed by brackets "[]" replaced with your own -identifying information. (Don't include the brackets!) The text should be -enclosed in the appropriate comment syntax for the file format. We also -recommend that a file or class name and description of purpose be included on -the same "printed page" as the copyright notice for easier identification within -third-party archives. - - Copyright [yyyy] [name of copyright owner] - - 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. diff --git a/vendor/github.com/coreos/go-systemd/v22/NOTICE b/vendor/github.com/coreos/go-systemd/v22/NOTICE deleted file mode 100644 index 23a0ada2fbb..00000000000 --- a/vendor/github.com/coreos/go-systemd/v22/NOTICE +++ /dev/null @@ -1,5 +0,0 @@ -CoreOS Project -Copyright 2018 CoreOS, Inc - -This product includes software developed at CoreOS, Inc. -(http://www.coreos.com/). diff --git a/vendor/github.com/coreos/go-systemd/v22/daemon/sdnotify.go b/vendor/github.com/coreos/go-systemd/v22/daemon/sdnotify.go deleted file mode 100644 index ba4ae31f19b..00000000000 --- a/vendor/github.com/coreos/go-systemd/v22/daemon/sdnotify.go +++ /dev/null @@ -1,84 +0,0 @@ -// Copyright 2014 Docker, Inc. -// Copyright 2015-2018 CoreOS, 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 daemon provides a Go implementation of the sd_notify protocol. -// It can be used to inform systemd of service start-up completion, watchdog -// events, and other status changes. -// -// https://www.freedesktop.org/software/systemd/man/sd_notify.html#Description -package daemon - -import ( - "net" - "os" -) - -const ( - // SdNotifyReady tells the service manager that service startup is finished - // or the service finished loading its configuration. - SdNotifyReady = "READY=1" - - // SdNotifyStopping tells the service manager that the service is beginning - // its shutdown. - SdNotifyStopping = "STOPPING=1" - - // SdNotifyReloading tells the service manager that this service is - // reloading its configuration. Note that you must call SdNotifyReady when - // it completed reloading. - SdNotifyReloading = "RELOADING=1" - - // SdNotifyWatchdog tells the service manager to update the watchdog - // timestamp for the service. - SdNotifyWatchdog = "WATCHDOG=1" -) - -// SdNotify sends a message to the init daemon. It is common to ignore the error. -// If `unsetEnvironment` is true, the environment variable `NOTIFY_SOCKET` -// will be unconditionally unset. -// -// It returns one of the following: -// (false, nil) - notification not supported (i.e. NOTIFY_SOCKET is unset) -// (false, err) - notification supported, but failure happened (e.g. error connecting to NOTIFY_SOCKET or while sending data) -// (true, nil) - notification supported, data has been sent -func SdNotify(unsetEnvironment bool, state string) (bool, error) { - socketAddr := &net.UnixAddr{ - Name: os.Getenv("NOTIFY_SOCKET"), - Net: "unixgram", - } - - // NOTIFY_SOCKET not set - if socketAddr.Name == "" { - return false, nil - } - - if unsetEnvironment { - if err := os.Unsetenv("NOTIFY_SOCKET"); err != nil { - return false, err - } - } - - conn, err := net.DialUnix(socketAddr.Net, nil, socketAddr) - // Error connecting to NOTIFY_SOCKET - if err != nil { - return false, err - } - defer conn.Close() - - if _, err = conn.Write([]byte(state)); err != nil { - return false, err - } - return true, nil -} diff --git a/vendor/github.com/coreos/go-systemd/v22/daemon/watchdog.go b/vendor/github.com/coreos/go-systemd/v22/daemon/watchdog.go deleted file mode 100644 index 25d9c1aa938..00000000000 --- a/vendor/github.com/coreos/go-systemd/v22/daemon/watchdog.go +++ /dev/null @@ -1,73 +0,0 @@ -// Copyright 2016 CoreOS, 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 daemon - -import ( - "fmt" - "os" - "strconv" - "time" -) - -// SdWatchdogEnabled returns watchdog information for a service. -// Processes should call daemon.SdNotify(false, daemon.SdNotifyWatchdog) every -// time / 2. -// If `unsetEnvironment` is true, the environment variables `WATCHDOG_USEC` and -// `WATCHDOG_PID` will be unconditionally unset. -// -// It returns one of the following: -// (0, nil) - watchdog isn't enabled or we aren't the watched PID. -// (0, err) - an error happened (e.g. error converting time). -// (time, nil) - watchdog is enabled and we can send ping. time is delay -// before inactive service will be killed. -func SdWatchdogEnabled(unsetEnvironment bool) (time.Duration, error) { - wusec := os.Getenv("WATCHDOG_USEC") - wpid := os.Getenv("WATCHDOG_PID") - if unsetEnvironment { - wusecErr := os.Unsetenv("WATCHDOG_USEC") - wpidErr := os.Unsetenv("WATCHDOG_PID") - if wusecErr != nil { - return 0, wusecErr - } - if wpidErr != nil { - return 0, wpidErr - } - } - - if wusec == "" { - return 0, nil - } - s, err := strconv.Atoi(wusec) - if err != nil { - return 0, fmt.Errorf("error converting WATCHDOG_USEC: %s", err) - } - if s <= 0 { - return 0, fmt.Errorf("error WATCHDOG_USEC must be a positive number") - } - interval := time.Duration(s) * time.Microsecond - - if wpid == "" { - return interval, nil - } - p, err := strconv.Atoi(wpid) - if err != nil { - return 0, fmt.Errorf("error converting WATCHDOG_PID: %s", err) - } - if os.Getpid() != p { - return 0, nil - } - - return interval, nil -} diff --git a/vendor/github.com/cpuguy83/go-md2man/v2/LICENSE.md b/vendor/github.com/cpuguy83/go-md2man/v2/LICENSE.md deleted file mode 100644 index 1cade6cef6a..00000000000 --- a/vendor/github.com/cpuguy83/go-md2man/v2/LICENSE.md +++ /dev/null @@ -1,21 +0,0 @@ -The MIT License (MIT) - -Copyright (c) 2014 Brian Goff - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/vendor/github.com/cpuguy83/go-md2man/v2/md2man/md2man.go b/vendor/github.com/cpuguy83/go-md2man/v2/md2man/md2man.go deleted file mode 100644 index b4800567345..00000000000 --- a/vendor/github.com/cpuguy83/go-md2man/v2/md2man/md2man.go +++ /dev/null @@ -1,14 +0,0 @@ -package md2man - -import ( - "github.com/russross/blackfriday/v2" -) - -// Render converts a markdown document into a roff formatted document. -func Render(doc []byte) []byte { - renderer := NewRoffRenderer() - - return blackfriday.Run(doc, - []blackfriday.Option{blackfriday.WithRenderer(renderer), - blackfriday.WithExtensions(renderer.GetExtensions())}...) -} diff --git a/vendor/github.com/cpuguy83/go-md2man/v2/md2man/roff.go b/vendor/github.com/cpuguy83/go-md2man/v2/md2man/roff.go deleted file mode 100644 index 0668a66cf70..00000000000 --- a/vendor/github.com/cpuguy83/go-md2man/v2/md2man/roff.go +++ /dev/null @@ -1,345 +0,0 @@ -package md2man - -import ( - "fmt" - "io" - "os" - "strings" - - "github.com/russross/blackfriday/v2" -) - -// roffRenderer implements the blackfriday.Renderer interface for creating -// roff format (manpages) from markdown text -type roffRenderer struct { - extensions blackfriday.Extensions - listCounters []int - firstHeader bool - defineTerm bool - listDepth int -} - -const ( - titleHeader = ".TH " - topLevelHeader = "\n\n.SH " - secondLevelHdr = "\n.SH " - otherHeader = "\n.SS " - crTag = "\n" - emphTag = "\\fI" - emphCloseTag = "\\fP" - strongTag = "\\fB" - strongCloseTag = "\\fP" - breakTag = "\n.br\n" - paraTag = "\n.PP\n" - hruleTag = "\n.ti 0\n\\l'\\n(.lu'\n" - linkTag = "\n\\[la]" - linkCloseTag = "\\[ra]" - codespanTag = "\\fB\\fC" - codespanCloseTag = "\\fR" - codeTag = "\n.PP\n.RS\n\n.nf\n" - codeCloseTag = "\n.fi\n.RE\n" - quoteTag = "\n.PP\n.RS\n" - quoteCloseTag = "\n.RE\n" - listTag = "\n.RS\n" - listCloseTag = "\n.RE\n" - arglistTag = "\n.TP\n" - tableStart = "\n.TS\nallbox;\n" - tableEnd = ".TE\n" - tableCellStart = "T{\n" - tableCellEnd = "\nT}\n" -) - -// NewRoffRenderer creates a new blackfriday Renderer for generating roff documents -// from markdown -func NewRoffRenderer() *roffRenderer { // nolint: golint - var extensions blackfriday.Extensions - - extensions |= blackfriday.NoIntraEmphasis - extensions |= blackfriday.Tables - extensions |= blackfriday.FencedCode - extensions |= blackfriday.SpaceHeadings - extensions |= blackfriday.Footnotes - extensions |= blackfriday.Titleblock - extensions |= blackfriday.DefinitionLists - return &roffRenderer{ - extensions: extensions, - } -} - -// GetExtensions returns the list of extensions used by this renderer implementation -func (r *roffRenderer) GetExtensions() blackfriday.Extensions { - return r.extensions -} - -// RenderHeader handles outputting the header at document start -func (r *roffRenderer) RenderHeader(w io.Writer, ast *blackfriday.Node) { - // disable hyphenation - out(w, ".nh\n") -} - -// RenderFooter handles outputting the footer at the document end; the roff -// renderer has no footer information -func (r *roffRenderer) RenderFooter(w io.Writer, ast *blackfriday.Node) { -} - -// RenderNode is called for each node in a markdown document; based on the node -// type the equivalent roff output is sent to the writer -func (r *roffRenderer) RenderNode(w io.Writer, node *blackfriday.Node, entering bool) blackfriday.WalkStatus { - - var walkAction = blackfriday.GoToNext - - switch node.Type { - case blackfriday.Text: - r.handleText(w, node, entering) - case blackfriday.Softbreak: - out(w, crTag) - case blackfriday.Hardbreak: - out(w, breakTag) - case blackfriday.Emph: - if entering { - out(w, emphTag) - } else { - out(w, emphCloseTag) - } - case blackfriday.Strong: - if entering { - out(w, strongTag) - } else { - out(w, strongCloseTag) - } - case blackfriday.Link: - if !entering { - out(w, linkTag+string(node.LinkData.Destination)+linkCloseTag) - } - case blackfriday.Image: - // ignore images - walkAction = blackfriday.SkipChildren - case blackfriday.Code: - out(w, codespanTag) - escapeSpecialChars(w, node.Literal) - out(w, codespanCloseTag) - case blackfriday.Document: - break - case blackfriday.Paragraph: - // roff .PP markers break lists - if r.listDepth > 0 { - return blackfriday.GoToNext - } - if entering { - out(w, paraTag) - } else { - out(w, crTag) - } - case blackfriday.BlockQuote: - if entering { - out(w, quoteTag) - } else { - out(w, quoteCloseTag) - } - case blackfriday.Heading: - r.handleHeading(w, node, entering) - case blackfriday.HorizontalRule: - out(w, hruleTag) - case blackfriday.List: - r.handleList(w, node, entering) - case blackfriday.Item: - r.handleItem(w, node, entering) - case blackfriday.CodeBlock: - out(w, codeTag) - escapeSpecialChars(w, node.Literal) - out(w, codeCloseTag) - case blackfriday.Table: - r.handleTable(w, node, entering) - case blackfriday.TableCell: - r.handleTableCell(w, node, entering) - case blackfriday.TableHead: - case blackfriday.TableBody: - case blackfriday.TableRow: - // no action as cell entries do all the nroff formatting - return blackfriday.GoToNext - default: - fmt.Fprintln(os.Stderr, "WARNING: go-md2man does not handle node type "+node.Type.String()) - } - return walkAction -} - -func (r *roffRenderer) handleText(w io.Writer, node *blackfriday.Node, entering bool) { - var ( - start, end string - ) - // handle special roff table cell text encapsulation - if node.Parent.Type == blackfriday.TableCell { - if len(node.Literal) > 30 { - start = tableCellStart - end = tableCellEnd - } else { - // end rows that aren't terminated by "tableCellEnd" with a cr if end of row - if node.Parent.Next == nil && !node.Parent.IsHeader { - end = crTag - } - } - } - out(w, start) - escapeSpecialChars(w, node.Literal) - out(w, end) -} - -func (r *roffRenderer) handleHeading(w io.Writer, node *blackfriday.Node, entering bool) { - if entering { - switch node.Level { - case 1: - if !r.firstHeader { - out(w, titleHeader) - r.firstHeader = true - break - } - out(w, topLevelHeader) - case 2: - out(w, secondLevelHdr) - default: - out(w, otherHeader) - } - } -} - -func (r *roffRenderer) handleList(w io.Writer, node *blackfriday.Node, entering bool) { - openTag := listTag - closeTag := listCloseTag - if node.ListFlags&blackfriday.ListTypeDefinition != 0 { - // tags for definition lists handled within Item node - openTag = "" - closeTag = "" - } - if entering { - r.listDepth++ - if node.ListFlags&blackfriday.ListTypeOrdered != 0 { - r.listCounters = append(r.listCounters, 1) - } - out(w, openTag) - } else { - if node.ListFlags&blackfriday.ListTypeOrdered != 0 { - r.listCounters = r.listCounters[:len(r.listCounters)-1] - } - out(w, closeTag) - r.listDepth-- - } -} - -func (r *roffRenderer) handleItem(w io.Writer, node *blackfriday.Node, entering bool) { - if entering { - if node.ListFlags&blackfriday.ListTypeOrdered != 0 { - out(w, fmt.Sprintf(".IP \"%3d.\" 5\n", r.listCounters[len(r.listCounters)-1])) - r.listCounters[len(r.listCounters)-1]++ - } else if node.ListFlags&blackfriday.ListTypeDefinition != 0 { - // state machine for handling terms and following definitions - // since blackfriday does not distinguish them properly, nor - // does it seperate them into separate lists as it should - if !r.defineTerm { - out(w, arglistTag) - r.defineTerm = true - } else { - r.defineTerm = false - } - } else { - out(w, ".IP \\(bu 2\n") - } - } else { - out(w, "\n") - } -} - -func (r *roffRenderer) handleTable(w io.Writer, node *blackfriday.Node, entering bool) { - if entering { - out(w, tableStart) - //call walker to count cells (and rows?) so format section can be produced - columns := countColumns(node) - out(w, strings.Repeat("l ", columns)+"\n") - out(w, strings.Repeat("l ", columns)+".\n") - } else { - out(w, tableEnd) - } -} - -func (r *roffRenderer) handleTableCell(w io.Writer, node *blackfriday.Node, entering bool) { - var ( - start, end string - ) - if node.IsHeader { - start = codespanTag - end = codespanCloseTag - } - if entering { - if node.Prev != nil && node.Prev.Type == blackfriday.TableCell { - out(w, "\t"+start) - } else { - out(w, start) - } - } else { - // need to carriage return if we are at the end of the header row - if node.IsHeader && node.Next == nil { - end = end + crTag - } - out(w, end) - } -} - -// because roff format requires knowing the column count before outputting any table -// data we need to walk a table tree and count the columns -func countColumns(node *blackfriday.Node) int { - var columns int - - node.Walk(func(node *blackfriday.Node, entering bool) blackfriday.WalkStatus { - switch node.Type { - case blackfriday.TableRow: - if !entering { - return blackfriday.Terminate - } - case blackfriday.TableCell: - if entering { - columns++ - } - default: - } - return blackfriday.GoToNext - }) - return columns -} - -func out(w io.Writer, output string) { - io.WriteString(w, output) // nolint: errcheck -} - -func needsBackslash(c byte) bool { - for _, r := range []byte("-_&\\~") { - if c == r { - return true - } - } - return false -} - -func escapeSpecialChars(w io.Writer, text []byte) { - for i := 0; i < len(text); i++ { - // escape initial apostrophe or period - if len(text) >= 1 && (text[0] == '\'' || text[0] == '.') { - out(w, "\\&") - } - - // directly copy normal characters - org := i - - for i < len(text) && !needsBackslash(text[i]) { - i++ - } - if i > org { - w.Write(text[org:i]) // nolint: errcheck - } - - // escape a character - if i >= len(text) { - break - } - - w.Write([]byte{'\\', text[i]}) // nolint: errcheck - } -} diff --git a/vendor/github.com/davecgh/go-spew/LICENSE b/vendor/github.com/davecgh/go-spew/LICENSE deleted file mode 100644 index bc52e96f2b0..00000000000 --- a/vendor/github.com/davecgh/go-spew/LICENSE +++ /dev/null @@ -1,15 +0,0 @@ -ISC License - -Copyright (c) 2012-2016 Dave Collins - -Permission to use, copy, modify, and/or distribute this software for any -purpose with or without fee is hereby granted, provided that the above -copyright notice and this permission notice appear in all copies. - -THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES -WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF -MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR -ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES -WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN -ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF -OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/vendor/github.com/davecgh/go-spew/spew/bypass.go b/vendor/github.com/davecgh/go-spew/spew/bypass.go deleted file mode 100644 index 792994785e3..00000000000 --- a/vendor/github.com/davecgh/go-spew/spew/bypass.go +++ /dev/null @@ -1,145 +0,0 @@ -// Copyright (c) 2015-2016 Dave Collins -// -// Permission to use, copy, modify, and distribute this software for any -// purpose with or without fee is hereby granted, provided that the above -// copyright notice and this permission notice appear in all copies. -// -// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES -// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF -// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR -// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES -// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN -// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF -// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -// NOTE: Due to the following build constraints, this file will only be compiled -// when the code is not running on Google App Engine, compiled by GopherJS, and -// "-tags safe" is not added to the go build command line. The "disableunsafe" -// tag is deprecated and thus should not be used. -// Go versions prior to 1.4 are disabled because they use a different layout -// for interfaces which make the implementation of unsafeReflectValue more complex. -// +build !js,!appengine,!safe,!disableunsafe,go1.4 - -package spew - -import ( - "reflect" - "unsafe" -) - -const ( - // UnsafeDisabled is a build-time constant which specifies whether or - // not access to the unsafe package is available. - UnsafeDisabled = false - - // ptrSize is the size of a pointer on the current arch. - ptrSize = unsafe.Sizeof((*byte)(nil)) -) - -type flag uintptr - -var ( - // flagRO indicates whether the value field of a reflect.Value - // is read-only. - flagRO flag - - // flagAddr indicates whether the address of the reflect.Value's - // value may be taken. - flagAddr flag -) - -// flagKindMask holds the bits that make up the kind -// part of the flags field. In all the supported versions, -// it is in the lower 5 bits. -const flagKindMask = flag(0x1f) - -// Different versions of Go have used different -// bit layouts for the flags type. This table -// records the known combinations. -var okFlags = []struct { - ro, addr flag -}{{ - // From Go 1.4 to 1.5 - ro: 1 << 5, - addr: 1 << 7, -}, { - // Up to Go tip. - ro: 1<<5 | 1<<6, - addr: 1 << 8, -}} - -var flagValOffset = func() uintptr { - field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag") - if !ok { - panic("reflect.Value has no flag field") - } - return field.Offset -}() - -// flagField returns a pointer to the flag field of a reflect.Value. -func flagField(v *reflect.Value) *flag { - return (*flag)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + flagValOffset)) -} - -// unsafeReflectValue converts the passed reflect.Value into a one that bypasses -// the typical safety restrictions preventing access to unaddressable and -// unexported data. It works by digging the raw pointer to the underlying -// value out of the protected value and generating a new unprotected (unsafe) -// reflect.Value to it. -// -// This allows us to check for implementations of the Stringer and error -// interfaces to be used for pretty printing ordinarily unaddressable and -// inaccessible values such as unexported struct fields. -func unsafeReflectValue(v reflect.Value) reflect.Value { - if !v.IsValid() || (v.CanInterface() && v.CanAddr()) { - return v - } - flagFieldPtr := flagField(&v) - *flagFieldPtr &^= flagRO - *flagFieldPtr |= flagAddr - return v -} - -// Sanity checks against future reflect package changes -// to the type or semantics of the Value.flag field. -func init() { - field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag") - if !ok { - panic("reflect.Value has no flag field") - } - if field.Type.Kind() != reflect.TypeOf(flag(0)).Kind() { - panic("reflect.Value flag field has changed kind") - } - type t0 int - var t struct { - A t0 - // t0 will have flagEmbedRO set. - t0 - // a will have flagStickyRO set - a t0 - } - vA := reflect.ValueOf(t).FieldByName("A") - va := reflect.ValueOf(t).FieldByName("a") - vt0 := reflect.ValueOf(t).FieldByName("t0") - - // Infer flagRO from the difference between the flags - // for the (otherwise identical) fields in t. - flagPublic := *flagField(&vA) - flagWithRO := *flagField(&va) | *flagField(&vt0) - flagRO = flagPublic ^ flagWithRO - - // Infer flagAddr from the difference between a value - // taken from a pointer and not. - vPtrA := reflect.ValueOf(&t).Elem().FieldByName("A") - flagNoPtr := *flagField(&vA) - flagPtr := *flagField(&vPtrA) - flagAddr = flagNoPtr ^ flagPtr - - // Check that the inferred flags tally with one of the known versions. - for _, f := range okFlags { - if flagRO == f.ro && flagAddr == f.addr { - return - } - } - panic("reflect.Value read-only flag has changed semantics") -} diff --git a/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go b/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go deleted file mode 100644 index 205c28d68c4..00000000000 --- a/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go +++ /dev/null @@ -1,38 +0,0 @@ -// Copyright (c) 2015-2016 Dave Collins -// -// Permission to use, copy, modify, and distribute this software for any -// purpose with or without fee is hereby granted, provided that the above -// copyright notice and this permission notice appear in all copies. -// -// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES -// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF -// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR -// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES -// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN -// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF -// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -// NOTE: Due to the following build constraints, this file will only be compiled -// when the code is running on Google App Engine, compiled by GopherJS, or -// "-tags safe" is added to the go build command line. The "disableunsafe" -// tag is deprecated and thus should not be used. -// +build js appengine safe disableunsafe !go1.4 - -package spew - -import "reflect" - -const ( - // UnsafeDisabled is a build-time constant which specifies whether or - // not access to the unsafe package is available. - UnsafeDisabled = true -) - -// unsafeReflectValue typically converts the passed reflect.Value into a one -// that bypasses the typical safety restrictions preventing access to -// unaddressable and unexported data. However, doing this relies on access to -// the unsafe package. This is a stub version which simply returns the passed -// reflect.Value when the unsafe package is not available. -func unsafeReflectValue(v reflect.Value) reflect.Value { - return v -} diff --git a/vendor/github.com/davecgh/go-spew/spew/common.go b/vendor/github.com/davecgh/go-spew/spew/common.go deleted file mode 100644 index 1be8ce94576..00000000000 --- a/vendor/github.com/davecgh/go-spew/spew/common.go +++ /dev/null @@ -1,341 +0,0 @@ -/* - * Copyright (c) 2013-2016 Dave Collins - * - * Permission to use, copy, modify, and distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -package spew - -import ( - "bytes" - "fmt" - "io" - "reflect" - "sort" - "strconv" -) - -// Some constants in the form of bytes to avoid string overhead. This mirrors -// the technique used in the fmt package. -var ( - panicBytes = []byte("(PANIC=") - plusBytes = []byte("+") - iBytes = []byte("i") - trueBytes = []byte("true") - falseBytes = []byte("false") - interfaceBytes = []byte("(interface {})") - commaNewlineBytes = []byte(",\n") - newlineBytes = []byte("\n") - openBraceBytes = []byte("{") - openBraceNewlineBytes = []byte("{\n") - closeBraceBytes = []byte("}") - asteriskBytes = []byte("*") - colonBytes = []byte(":") - colonSpaceBytes = []byte(": ") - openParenBytes = []byte("(") - closeParenBytes = []byte(")") - spaceBytes = []byte(" ") - pointerChainBytes = []byte("->") - nilAngleBytes = []byte("") - maxNewlineBytes = []byte("\n") - maxShortBytes = []byte("") - circularBytes = []byte("") - circularShortBytes = []byte("") - invalidAngleBytes = []byte("") - openBracketBytes = []byte("[") - closeBracketBytes = []byte("]") - percentBytes = []byte("%") - precisionBytes = []byte(".") - openAngleBytes = []byte("<") - closeAngleBytes = []byte(">") - openMapBytes = []byte("map[") - closeMapBytes = []byte("]") - lenEqualsBytes = []byte("len=") - capEqualsBytes = []byte("cap=") -) - -// hexDigits is used to map a decimal value to a hex digit. -var hexDigits = "0123456789abcdef" - -// catchPanic handles any panics that might occur during the handleMethods -// calls. -func catchPanic(w io.Writer, v reflect.Value) { - if err := recover(); err != nil { - w.Write(panicBytes) - fmt.Fprintf(w, "%v", err) - w.Write(closeParenBytes) - } -} - -// handleMethods attempts to call the Error and String methods on the underlying -// type the passed reflect.Value represents and outputes the result to Writer w. -// -// It handles panics in any called methods by catching and displaying the error -// as the formatted value. -func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) { - // We need an interface to check if the type implements the error or - // Stringer interface. However, the reflect package won't give us an - // interface on certain things like unexported struct fields in order - // to enforce visibility rules. We use unsafe, when it's available, - // to bypass these restrictions since this package does not mutate the - // values. - if !v.CanInterface() { - if UnsafeDisabled { - return false - } - - v = unsafeReflectValue(v) - } - - // Choose whether or not to do error and Stringer interface lookups against - // the base type or a pointer to the base type depending on settings. - // Technically calling one of these methods with a pointer receiver can - // mutate the value, however, types which choose to satisify an error or - // Stringer interface with a pointer receiver should not be mutating their - // state inside these interface methods. - if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() { - v = unsafeReflectValue(v) - } - if v.CanAddr() { - v = v.Addr() - } - - // Is it an error or Stringer? - switch iface := v.Interface().(type) { - case error: - defer catchPanic(w, v) - if cs.ContinueOnMethod { - w.Write(openParenBytes) - w.Write([]byte(iface.Error())) - w.Write(closeParenBytes) - w.Write(spaceBytes) - return false - } - - w.Write([]byte(iface.Error())) - return true - - case fmt.Stringer: - defer catchPanic(w, v) - if cs.ContinueOnMethod { - w.Write(openParenBytes) - w.Write([]byte(iface.String())) - w.Write(closeParenBytes) - w.Write(spaceBytes) - return false - } - w.Write([]byte(iface.String())) - return true - } - return false -} - -// printBool outputs a boolean value as true or false to Writer w. -func printBool(w io.Writer, val bool) { - if val { - w.Write(trueBytes) - } else { - w.Write(falseBytes) - } -} - -// printInt outputs a signed integer value to Writer w. -func printInt(w io.Writer, val int64, base int) { - w.Write([]byte(strconv.FormatInt(val, base))) -} - -// printUint outputs an unsigned integer value to Writer w. -func printUint(w io.Writer, val uint64, base int) { - w.Write([]byte(strconv.FormatUint(val, base))) -} - -// printFloat outputs a floating point value using the specified precision, -// which is expected to be 32 or 64bit, to Writer w. -func printFloat(w io.Writer, val float64, precision int) { - w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision))) -} - -// printComplex outputs a complex value using the specified float precision -// for the real and imaginary parts to Writer w. -func printComplex(w io.Writer, c complex128, floatPrecision int) { - r := real(c) - w.Write(openParenBytes) - w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision))) - i := imag(c) - if i >= 0 { - w.Write(plusBytes) - } - w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision))) - w.Write(iBytes) - w.Write(closeParenBytes) -} - -// printHexPtr outputs a uintptr formatted as hexadecimal with a leading '0x' -// prefix to Writer w. -func printHexPtr(w io.Writer, p uintptr) { - // Null pointer. - num := uint64(p) - if num == 0 { - w.Write(nilAngleBytes) - return - } - - // Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix - buf := make([]byte, 18) - - // It's simpler to construct the hex string right to left. - base := uint64(16) - i := len(buf) - 1 - for num >= base { - buf[i] = hexDigits[num%base] - num /= base - i-- - } - buf[i] = hexDigits[num] - - // Add '0x' prefix. - i-- - buf[i] = 'x' - i-- - buf[i] = '0' - - // Strip unused leading bytes. - buf = buf[i:] - w.Write(buf) -} - -// valuesSorter implements sort.Interface to allow a slice of reflect.Value -// elements to be sorted. -type valuesSorter struct { - values []reflect.Value - strings []string // either nil or same len and values - cs *ConfigState -} - -// newValuesSorter initializes a valuesSorter instance, which holds a set of -// surrogate keys on which the data should be sorted. It uses flags in -// ConfigState to decide if and how to populate those surrogate keys. -func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface { - vs := &valuesSorter{values: values, cs: cs} - if canSortSimply(vs.values[0].Kind()) { - return vs - } - if !cs.DisableMethods { - vs.strings = make([]string, len(values)) - for i := range vs.values { - b := bytes.Buffer{} - if !handleMethods(cs, &b, vs.values[i]) { - vs.strings = nil - break - } - vs.strings[i] = b.String() - } - } - if vs.strings == nil && cs.SpewKeys { - vs.strings = make([]string, len(values)) - for i := range vs.values { - vs.strings[i] = Sprintf("%#v", vs.values[i].Interface()) - } - } - return vs -} - -// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted -// directly, or whether it should be considered for sorting by surrogate keys -// (if the ConfigState allows it). -func canSortSimply(kind reflect.Kind) bool { - // This switch parallels valueSortLess, except for the default case. - switch kind { - case reflect.Bool: - return true - case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: - return true - case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: - return true - case reflect.Float32, reflect.Float64: - return true - case reflect.String: - return true - case reflect.Uintptr: - return true - case reflect.Array: - return true - } - return false -} - -// Len returns the number of values in the slice. It is part of the -// sort.Interface implementation. -func (s *valuesSorter) Len() int { - return len(s.values) -} - -// Swap swaps the values at the passed indices. It is part of the -// sort.Interface implementation. -func (s *valuesSorter) Swap(i, j int) { - s.values[i], s.values[j] = s.values[j], s.values[i] - if s.strings != nil { - s.strings[i], s.strings[j] = s.strings[j], s.strings[i] - } -} - -// valueSortLess returns whether the first value should sort before the second -// value. It is used by valueSorter.Less as part of the sort.Interface -// implementation. -func valueSortLess(a, b reflect.Value) bool { - switch a.Kind() { - case reflect.Bool: - return !a.Bool() && b.Bool() - case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: - return a.Int() < b.Int() - case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: - return a.Uint() < b.Uint() - case reflect.Float32, reflect.Float64: - return a.Float() < b.Float() - case reflect.String: - return a.String() < b.String() - case reflect.Uintptr: - return a.Uint() < b.Uint() - case reflect.Array: - // Compare the contents of both arrays. - l := a.Len() - for i := 0; i < l; i++ { - av := a.Index(i) - bv := b.Index(i) - if av.Interface() == bv.Interface() { - continue - } - return valueSortLess(av, bv) - } - } - return a.String() < b.String() -} - -// Less returns whether the value at index i should sort before the -// value at index j. It is part of the sort.Interface implementation. -func (s *valuesSorter) Less(i, j int) bool { - if s.strings == nil { - return valueSortLess(s.values[i], s.values[j]) - } - return s.strings[i] < s.strings[j] -} - -// sortValues is a sort function that handles both native types and any type that -// can be converted to error or Stringer. Other inputs are sorted according to -// their Value.String() value to ensure display stability. -func sortValues(values []reflect.Value, cs *ConfigState) { - if len(values) == 0 { - return - } - sort.Sort(newValuesSorter(values, cs)) -} diff --git a/vendor/github.com/davecgh/go-spew/spew/config.go b/vendor/github.com/davecgh/go-spew/spew/config.go deleted file mode 100644 index 2e3d22f3120..00000000000 --- a/vendor/github.com/davecgh/go-spew/spew/config.go +++ /dev/null @@ -1,306 +0,0 @@ -/* - * Copyright (c) 2013-2016 Dave Collins - * - * Permission to use, copy, modify, and distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -package spew - -import ( - "bytes" - "fmt" - "io" - "os" -) - -// ConfigState houses the configuration options used by spew to format and -// display values. There is a global instance, Config, that is used to control -// all top-level Formatter and Dump functionality. Each ConfigState instance -// provides methods equivalent to the top-level functions. -// -// The zero value for ConfigState provides no indentation. You would typically -// want to set it to a space or a tab. -// -// Alternatively, you can use NewDefaultConfig to get a ConfigState instance -// with default settings. See the documentation of NewDefaultConfig for default -// values. -type ConfigState struct { - // Indent specifies the string to use for each indentation level. The - // global config instance that all top-level functions use set this to a - // single space by default. If you would like more indentation, you might - // set this to a tab with "\t" or perhaps two spaces with " ". - Indent string - - // MaxDepth controls the maximum number of levels to descend into nested - // data structures. The default, 0, means there is no limit. - // - // NOTE: Circular data structures are properly detected, so it is not - // necessary to set this value unless you specifically want to limit deeply - // nested data structures. - MaxDepth int - - // DisableMethods specifies whether or not error and Stringer interfaces are - // invoked for types that implement them. - DisableMethods bool - - // DisablePointerMethods specifies whether or not to check for and invoke - // error and Stringer interfaces on types which only accept a pointer - // receiver when the current type is not a pointer. - // - // NOTE: This might be an unsafe action since calling one of these methods - // with a pointer receiver could technically mutate the value, however, - // in practice, types which choose to satisify an error or Stringer - // interface with a pointer receiver should not be mutating their state - // inside these interface methods. As a result, this option relies on - // access to the unsafe package, so it will not have any effect when - // running in environments without access to the unsafe package such as - // Google App Engine or with the "safe" build tag specified. - DisablePointerMethods bool - - // DisablePointerAddresses specifies whether to disable the printing of - // pointer addresses. This is useful when diffing data structures in tests. - DisablePointerAddresses bool - - // DisableCapacities specifies whether to disable the printing of capacities - // for arrays, slices, maps and channels. This is useful when diffing - // data structures in tests. - DisableCapacities bool - - // ContinueOnMethod specifies whether or not recursion should continue once - // a custom error or Stringer interface is invoked. The default, false, - // means it will print the results of invoking the custom error or Stringer - // interface and return immediately instead of continuing to recurse into - // the internals of the data type. - // - // NOTE: This flag does not have any effect if method invocation is disabled - // via the DisableMethods or DisablePointerMethods options. - ContinueOnMethod bool - - // SortKeys specifies map keys should be sorted before being printed. Use - // this to have a more deterministic, diffable output. Note that only - // native types (bool, int, uint, floats, uintptr and string) and types - // that support the error or Stringer interfaces (if methods are - // enabled) are supported, with other types sorted according to the - // reflect.Value.String() output which guarantees display stability. - SortKeys bool - - // SpewKeys specifies that, as a last resort attempt, map keys should - // be spewed to strings and sorted by those strings. This is only - // considered if SortKeys is true. - SpewKeys bool -} - -// Config is the active configuration of the top-level functions. -// The configuration can be changed by modifying the contents of spew.Config. -var Config = ConfigState{Indent: " "} - -// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were -// passed with a Formatter interface returned by c.NewFormatter. It returns -// the formatted string as a value that satisfies error. See NewFormatter -// for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b)) -func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) { - return fmt.Errorf(format, c.convertArgs(a)...) -} - -// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were -// passed with a Formatter interface returned by c.NewFormatter. It returns -// the number of bytes written and any write error encountered. See -// NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b)) -func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) { - return fmt.Fprint(w, c.convertArgs(a)...) -} - -// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were -// passed with a Formatter interface returned by c.NewFormatter. It returns -// the number of bytes written and any write error encountered. See -// NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b)) -func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) { - return fmt.Fprintf(w, format, c.convertArgs(a)...) -} - -// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it -// passed with a Formatter interface returned by c.NewFormatter. See -// NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b)) -func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) { - return fmt.Fprintln(w, c.convertArgs(a)...) -} - -// Print is a wrapper for fmt.Print that treats each argument as if it were -// passed with a Formatter interface returned by c.NewFormatter. It returns -// the number of bytes written and any write error encountered. See -// NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Print(c.NewFormatter(a), c.NewFormatter(b)) -func (c *ConfigState) Print(a ...interface{}) (n int, err error) { - return fmt.Print(c.convertArgs(a)...) -} - -// Printf is a wrapper for fmt.Printf that treats each argument as if it were -// passed with a Formatter interface returned by c.NewFormatter. It returns -// the number of bytes written and any write error encountered. See -// NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b)) -func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) { - return fmt.Printf(format, c.convertArgs(a)...) -} - -// Println is a wrapper for fmt.Println that treats each argument as if it were -// passed with a Formatter interface returned by c.NewFormatter. It returns -// the number of bytes written and any write error encountered. See -// NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Println(c.NewFormatter(a), c.NewFormatter(b)) -func (c *ConfigState) Println(a ...interface{}) (n int, err error) { - return fmt.Println(c.convertArgs(a)...) -} - -// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were -// passed with a Formatter interface returned by c.NewFormatter. It returns -// the resulting string. See NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b)) -func (c *ConfigState) Sprint(a ...interface{}) string { - return fmt.Sprint(c.convertArgs(a)...) -} - -// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were -// passed with a Formatter interface returned by c.NewFormatter. It returns -// the resulting string. See NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b)) -func (c *ConfigState) Sprintf(format string, a ...interface{}) string { - return fmt.Sprintf(format, c.convertArgs(a)...) -} - -// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it -// were passed with a Formatter interface returned by c.NewFormatter. It -// returns the resulting string. See NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b)) -func (c *ConfigState) Sprintln(a ...interface{}) string { - return fmt.Sprintln(c.convertArgs(a)...) -} - -/* -NewFormatter returns a custom formatter that satisfies the fmt.Formatter -interface. As a result, it integrates cleanly with standard fmt package -printing functions. The formatter is useful for inline printing of smaller data -types similar to the standard %v format specifier. - -The custom formatter only responds to the %v (most compact), %+v (adds pointer -addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb -combinations. Any other verbs such as %x and %q will be sent to the the -standard fmt package for formatting. In addition, the custom formatter ignores -the width and precision arguments (however they will still work on the format -specifiers not handled by the custom formatter). - -Typically this function shouldn't be called directly. It is much easier to make -use of the custom formatter by calling one of the convenience functions such as -c.Printf, c.Println, or c.Printf. -*/ -func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter { - return newFormatter(c, v) -} - -// Fdump formats and displays the passed arguments to io.Writer w. It formats -// exactly the same as Dump. -func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) { - fdump(c, w, a...) -} - -/* -Dump displays the passed parameters to standard out with newlines, customizable -indentation, and additional debug information such as complete types and all -pointer addresses used to indirect to the final value. It provides the -following features over the built-in printing facilities provided by the fmt -package: - - * Pointers are dereferenced and followed - * Circular data structures are detected and handled properly - * Custom Stringer/error interfaces are optionally invoked, including - on unexported types - * Custom types which only implement the Stringer/error interfaces via - a pointer receiver are optionally invoked when passing non-pointer - variables - * Byte arrays and slices are dumped like the hexdump -C command which - includes offsets, byte values in hex, and ASCII output - -The configuration options are controlled by modifying the public members -of c. See ConfigState for options documentation. - -See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to -get the formatted result as a string. -*/ -func (c *ConfigState) Dump(a ...interface{}) { - fdump(c, os.Stdout, a...) -} - -// Sdump returns a string with the passed arguments formatted exactly the same -// as Dump. -func (c *ConfigState) Sdump(a ...interface{}) string { - var buf bytes.Buffer - fdump(c, &buf, a...) - return buf.String() -} - -// convertArgs accepts a slice of arguments and returns a slice of the same -// length with each argument converted to a spew Formatter interface using -// the ConfigState associated with s. -func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) { - formatters = make([]interface{}, len(args)) - for index, arg := range args { - formatters[index] = newFormatter(c, arg) - } - return formatters -} - -// NewDefaultConfig returns a ConfigState with the following default settings. -// -// Indent: " " -// MaxDepth: 0 -// DisableMethods: false -// DisablePointerMethods: false -// ContinueOnMethod: false -// SortKeys: false -func NewDefaultConfig() *ConfigState { - return &ConfigState{Indent: " "} -} diff --git a/vendor/github.com/davecgh/go-spew/spew/doc.go b/vendor/github.com/davecgh/go-spew/spew/doc.go deleted file mode 100644 index aacaac6f1e1..00000000000 --- a/vendor/github.com/davecgh/go-spew/spew/doc.go +++ /dev/null @@ -1,211 +0,0 @@ -/* - * Copyright (c) 2013-2016 Dave Collins - * - * Permission to use, copy, modify, and distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -/* -Package spew implements a deep pretty printer for Go data structures to aid in -debugging. - -A quick overview of the additional features spew provides over the built-in -printing facilities for Go data types are as follows: - - * Pointers are dereferenced and followed - * Circular data structures are detected and handled properly - * Custom Stringer/error interfaces are optionally invoked, including - on unexported types - * Custom types which only implement the Stringer/error interfaces via - a pointer receiver are optionally invoked when passing non-pointer - variables - * Byte arrays and slices are dumped like the hexdump -C command which - includes offsets, byte values in hex, and ASCII output (only when using - Dump style) - -There are two different approaches spew allows for dumping Go data structures: - - * Dump style which prints with newlines, customizable indentation, - and additional debug information such as types and all pointer addresses - used to indirect to the final value - * A custom Formatter interface that integrates cleanly with the standard fmt - package and replaces %v, %+v, %#v, and %#+v to provide inline printing - similar to the default %v while providing the additional functionality - outlined above and passing unsupported format verbs such as %x and %q - along to fmt - -Quick Start - -This section demonstrates how to quickly get started with spew. See the -sections below for further details on formatting and configuration options. - -To dump a variable with full newlines, indentation, type, and pointer -information use Dump, Fdump, or Sdump: - spew.Dump(myVar1, myVar2, ...) - spew.Fdump(someWriter, myVar1, myVar2, ...) - str := spew.Sdump(myVar1, myVar2, ...) - -Alternatively, if you would prefer to use format strings with a compacted inline -printing style, use the convenience wrappers Printf, Fprintf, etc with -%v (most compact), %+v (adds pointer addresses), %#v (adds types), or -%#+v (adds types and pointer addresses): - spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2) - spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) - spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2) - spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) - -Configuration Options - -Configuration of spew is handled by fields in the ConfigState type. For -convenience, all of the top-level functions use a global state available -via the spew.Config global. - -It is also possible to create a ConfigState instance that provides methods -equivalent to the top-level functions. This allows concurrent configuration -options. See the ConfigState documentation for more details. - -The following configuration options are available: - * Indent - String to use for each indentation level for Dump functions. - It is a single space by default. A popular alternative is "\t". - - * MaxDepth - Maximum number of levels to descend into nested data structures. - There is no limit by default. - - * DisableMethods - Disables invocation of error and Stringer interface methods. - Method invocation is enabled by default. - - * DisablePointerMethods - Disables invocation of error and Stringer interface methods on types - which only accept pointer receivers from non-pointer variables. - Pointer method invocation is enabled by default. - - * DisablePointerAddresses - DisablePointerAddresses specifies whether to disable the printing of - pointer addresses. This is useful when diffing data structures in tests. - - * DisableCapacities - DisableCapacities specifies whether to disable the printing of - capacities for arrays, slices, maps and channels. This is useful when - diffing data structures in tests. - - * ContinueOnMethod - Enables recursion into types after invoking error and Stringer interface - methods. Recursion after method invocation is disabled by default. - - * SortKeys - Specifies map keys should be sorted before being printed. Use - this to have a more deterministic, diffable output. Note that - only native types (bool, int, uint, floats, uintptr and string) - and types which implement error or Stringer interfaces are - supported with other types sorted according to the - reflect.Value.String() output which guarantees display - stability. Natural map order is used by default. - - * SpewKeys - Specifies that, as a last resort attempt, map keys should be - spewed to strings and sorted by those strings. This is only - considered if SortKeys is true. - -Dump Usage - -Simply call spew.Dump with a list of variables you want to dump: - - spew.Dump(myVar1, myVar2, ...) - -You may also call spew.Fdump if you would prefer to output to an arbitrary -io.Writer. For example, to dump to standard error: - - spew.Fdump(os.Stderr, myVar1, myVar2, ...) - -A third option is to call spew.Sdump to get the formatted output as a string: - - str := spew.Sdump(myVar1, myVar2, ...) - -Sample Dump Output - -See the Dump example for details on the setup of the types and variables being -shown here. - - (main.Foo) { - unexportedField: (*main.Bar)(0xf84002e210)({ - flag: (main.Flag) flagTwo, - data: (uintptr) - }), - ExportedField: (map[interface {}]interface {}) (len=1) { - (string) (len=3) "one": (bool) true - } - } - -Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C -command as shown. - ([]uint8) (len=32 cap=32) { - 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 |............... | - 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 |!"#$%&'()*+,-./0| - 00000020 31 32 |12| - } - -Custom Formatter - -Spew provides a custom formatter that implements the fmt.Formatter interface -so that it integrates cleanly with standard fmt package printing functions. The -formatter is useful for inline printing of smaller data types similar to the -standard %v format specifier. - -The custom formatter only responds to the %v (most compact), %+v (adds pointer -addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb -combinations. Any other verbs such as %x and %q will be sent to the the -standard fmt package for formatting. In addition, the custom formatter ignores -the width and precision arguments (however they will still work on the format -specifiers not handled by the custom formatter). - -Custom Formatter Usage - -The simplest way to make use of the spew custom formatter is to call one of the -convenience functions such as spew.Printf, spew.Println, or spew.Printf. The -functions have syntax you are most likely already familiar with: - - spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2) - spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) - spew.Println(myVar, myVar2) - spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2) - spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) - -See the Index for the full list convenience functions. - -Sample Formatter Output - -Double pointer to a uint8: - %v: <**>5 - %+v: <**>(0xf8400420d0->0xf8400420c8)5 - %#v: (**uint8)5 - %#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5 - -Pointer to circular struct with a uint8 field and a pointer to itself: - %v: <*>{1 <*>} - %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)} - %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)} - %#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)} - -See the Printf example for details on the setup of variables being shown -here. - -Errors - -Since it is possible for custom Stringer/error interfaces to panic, spew -detects them and handles them internally by printing the panic information -inline with the output. Since spew is intended to provide deep pretty printing -capabilities on structures, it intentionally does not return any errors. -*/ -package spew diff --git a/vendor/github.com/davecgh/go-spew/spew/dump.go b/vendor/github.com/davecgh/go-spew/spew/dump.go deleted file mode 100644 index f78d89fc1f6..00000000000 --- a/vendor/github.com/davecgh/go-spew/spew/dump.go +++ /dev/null @@ -1,509 +0,0 @@ -/* - * Copyright (c) 2013-2016 Dave Collins - * - * Permission to use, copy, modify, and distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -package spew - -import ( - "bytes" - "encoding/hex" - "fmt" - "io" - "os" - "reflect" - "regexp" - "strconv" - "strings" -) - -var ( - // uint8Type is a reflect.Type representing a uint8. It is used to - // convert cgo types to uint8 slices for hexdumping. - uint8Type = reflect.TypeOf(uint8(0)) - - // cCharRE is a regular expression that matches a cgo char. - // It is used to detect character arrays to hexdump them. - cCharRE = regexp.MustCompile(`^.*\._Ctype_char$`) - - // cUnsignedCharRE is a regular expression that matches a cgo unsigned - // char. It is used to detect unsigned character arrays to hexdump - // them. - cUnsignedCharRE = regexp.MustCompile(`^.*\._Ctype_unsignedchar$`) - - // cUint8tCharRE is a regular expression that matches a cgo uint8_t. - // It is used to detect uint8_t arrays to hexdump them. - cUint8tCharRE = regexp.MustCompile(`^.*\._Ctype_uint8_t$`) -) - -// dumpState contains information about the state of a dump operation. -type dumpState struct { - w io.Writer - depth int - pointers map[uintptr]int - ignoreNextType bool - ignoreNextIndent bool - cs *ConfigState -} - -// indent performs indentation according to the depth level and cs.Indent -// option. -func (d *dumpState) indent() { - if d.ignoreNextIndent { - d.ignoreNextIndent = false - return - } - d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth)) -} - -// unpackValue returns values inside of non-nil interfaces when possible. -// This is useful for data types like structs, arrays, slices, and maps which -// can contain varying types packed inside an interface. -func (d *dumpState) unpackValue(v reflect.Value) reflect.Value { - if v.Kind() == reflect.Interface && !v.IsNil() { - v = v.Elem() - } - return v -} - -// dumpPtr handles formatting of pointers by indirecting them as necessary. -func (d *dumpState) dumpPtr(v reflect.Value) { - // Remove pointers at or below the current depth from map used to detect - // circular refs. - for k, depth := range d.pointers { - if depth >= d.depth { - delete(d.pointers, k) - } - } - - // Keep list of all dereferenced pointers to show later. - pointerChain := make([]uintptr, 0) - - // Figure out how many levels of indirection there are by dereferencing - // pointers and unpacking interfaces down the chain while detecting circular - // references. - nilFound := false - cycleFound := false - indirects := 0 - ve := v - for ve.Kind() == reflect.Ptr { - if ve.IsNil() { - nilFound = true - break - } - indirects++ - addr := ve.Pointer() - pointerChain = append(pointerChain, addr) - if pd, ok := d.pointers[addr]; ok && pd < d.depth { - cycleFound = true - indirects-- - break - } - d.pointers[addr] = d.depth - - ve = ve.Elem() - if ve.Kind() == reflect.Interface { - if ve.IsNil() { - nilFound = true - break - } - ve = ve.Elem() - } - } - - // Display type information. - d.w.Write(openParenBytes) - d.w.Write(bytes.Repeat(asteriskBytes, indirects)) - d.w.Write([]byte(ve.Type().String())) - d.w.Write(closeParenBytes) - - // Display pointer information. - if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 { - d.w.Write(openParenBytes) - for i, addr := range pointerChain { - if i > 0 { - d.w.Write(pointerChainBytes) - } - printHexPtr(d.w, addr) - } - d.w.Write(closeParenBytes) - } - - // Display dereferenced value. - d.w.Write(openParenBytes) - switch { - case nilFound: - d.w.Write(nilAngleBytes) - - case cycleFound: - d.w.Write(circularBytes) - - default: - d.ignoreNextType = true - d.dump(ve) - } - d.w.Write(closeParenBytes) -} - -// dumpSlice handles formatting of arrays and slices. Byte (uint8 under -// reflection) arrays and slices are dumped in hexdump -C fashion. -func (d *dumpState) dumpSlice(v reflect.Value) { - // Determine whether this type should be hex dumped or not. Also, - // for types which should be hexdumped, try to use the underlying data - // first, then fall back to trying to convert them to a uint8 slice. - var buf []uint8 - doConvert := false - doHexDump := false - numEntries := v.Len() - if numEntries > 0 { - vt := v.Index(0).Type() - vts := vt.String() - switch { - // C types that need to be converted. - case cCharRE.MatchString(vts): - fallthrough - case cUnsignedCharRE.MatchString(vts): - fallthrough - case cUint8tCharRE.MatchString(vts): - doConvert = true - - // Try to use existing uint8 slices and fall back to converting - // and copying if that fails. - case vt.Kind() == reflect.Uint8: - // We need an addressable interface to convert the type - // to a byte slice. However, the reflect package won't - // give us an interface on certain things like - // unexported struct fields in order to enforce - // visibility rules. We use unsafe, when available, to - // bypass these restrictions since this package does not - // mutate the values. - vs := v - if !vs.CanInterface() || !vs.CanAddr() { - vs = unsafeReflectValue(vs) - } - if !UnsafeDisabled { - vs = vs.Slice(0, numEntries) - - // Use the existing uint8 slice if it can be - // type asserted. - iface := vs.Interface() - if slice, ok := iface.([]uint8); ok { - buf = slice - doHexDump = true - break - } - } - - // The underlying data needs to be converted if it can't - // be type asserted to a uint8 slice. - doConvert = true - } - - // Copy and convert the underlying type if needed. - if doConvert && vt.ConvertibleTo(uint8Type) { - // Convert and copy each element into a uint8 byte - // slice. - buf = make([]uint8, numEntries) - for i := 0; i < numEntries; i++ { - vv := v.Index(i) - buf[i] = uint8(vv.Convert(uint8Type).Uint()) - } - doHexDump = true - } - } - - // Hexdump the entire slice as needed. - if doHexDump { - indent := strings.Repeat(d.cs.Indent, d.depth) - str := indent + hex.Dump(buf) - str = strings.Replace(str, "\n", "\n"+indent, -1) - str = strings.TrimRight(str, d.cs.Indent) - d.w.Write([]byte(str)) - return - } - - // Recursively call dump for each item. - for i := 0; i < numEntries; i++ { - d.dump(d.unpackValue(v.Index(i))) - if i < (numEntries - 1) { - d.w.Write(commaNewlineBytes) - } else { - d.w.Write(newlineBytes) - } - } -} - -// dump is the main workhorse for dumping a value. It uses the passed reflect -// value to figure out what kind of object we are dealing with and formats it -// appropriately. It is a recursive function, however circular data structures -// are detected and handled properly. -func (d *dumpState) dump(v reflect.Value) { - // Handle invalid reflect values immediately. - kind := v.Kind() - if kind == reflect.Invalid { - d.w.Write(invalidAngleBytes) - return - } - - // Handle pointers specially. - if kind == reflect.Ptr { - d.indent() - d.dumpPtr(v) - return - } - - // Print type information unless already handled elsewhere. - if !d.ignoreNextType { - d.indent() - d.w.Write(openParenBytes) - d.w.Write([]byte(v.Type().String())) - d.w.Write(closeParenBytes) - d.w.Write(spaceBytes) - } - d.ignoreNextType = false - - // Display length and capacity if the built-in len and cap functions - // work with the value's kind and the len/cap itself is non-zero. - valueLen, valueCap := 0, 0 - switch v.Kind() { - case reflect.Array, reflect.Slice, reflect.Chan: - valueLen, valueCap = v.Len(), v.Cap() - case reflect.Map, reflect.String: - valueLen = v.Len() - } - if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 { - d.w.Write(openParenBytes) - if valueLen != 0 { - d.w.Write(lenEqualsBytes) - printInt(d.w, int64(valueLen), 10) - } - if !d.cs.DisableCapacities && valueCap != 0 { - if valueLen != 0 { - d.w.Write(spaceBytes) - } - d.w.Write(capEqualsBytes) - printInt(d.w, int64(valueCap), 10) - } - d.w.Write(closeParenBytes) - d.w.Write(spaceBytes) - } - - // Call Stringer/error interfaces if they exist and the handle methods flag - // is enabled - if !d.cs.DisableMethods { - if (kind != reflect.Invalid) && (kind != reflect.Interface) { - if handled := handleMethods(d.cs, d.w, v); handled { - return - } - } - } - - switch kind { - case reflect.Invalid: - // Do nothing. We should never get here since invalid has already - // been handled above. - - case reflect.Bool: - printBool(d.w, v.Bool()) - - case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: - printInt(d.w, v.Int(), 10) - - case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: - printUint(d.w, v.Uint(), 10) - - case reflect.Float32: - printFloat(d.w, v.Float(), 32) - - case reflect.Float64: - printFloat(d.w, v.Float(), 64) - - case reflect.Complex64: - printComplex(d.w, v.Complex(), 32) - - case reflect.Complex128: - printComplex(d.w, v.Complex(), 64) - - case reflect.Slice: - if v.IsNil() { - d.w.Write(nilAngleBytes) - break - } - fallthrough - - case reflect.Array: - d.w.Write(openBraceNewlineBytes) - d.depth++ - if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) { - d.indent() - d.w.Write(maxNewlineBytes) - } else { - d.dumpSlice(v) - } - d.depth-- - d.indent() - d.w.Write(closeBraceBytes) - - case reflect.String: - d.w.Write([]byte(strconv.Quote(v.String()))) - - case reflect.Interface: - // The only time we should get here is for nil interfaces due to - // unpackValue calls. - if v.IsNil() { - d.w.Write(nilAngleBytes) - } - - case reflect.Ptr: - // Do nothing. We should never get here since pointers have already - // been handled above. - - case reflect.Map: - // nil maps should be indicated as different than empty maps - if v.IsNil() { - d.w.Write(nilAngleBytes) - break - } - - d.w.Write(openBraceNewlineBytes) - d.depth++ - if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) { - d.indent() - d.w.Write(maxNewlineBytes) - } else { - numEntries := v.Len() - keys := v.MapKeys() - if d.cs.SortKeys { - sortValues(keys, d.cs) - } - for i, key := range keys { - d.dump(d.unpackValue(key)) - d.w.Write(colonSpaceBytes) - d.ignoreNextIndent = true - d.dump(d.unpackValue(v.MapIndex(key))) - if i < (numEntries - 1) { - d.w.Write(commaNewlineBytes) - } else { - d.w.Write(newlineBytes) - } - } - } - d.depth-- - d.indent() - d.w.Write(closeBraceBytes) - - case reflect.Struct: - d.w.Write(openBraceNewlineBytes) - d.depth++ - if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) { - d.indent() - d.w.Write(maxNewlineBytes) - } else { - vt := v.Type() - numFields := v.NumField() - for i := 0; i < numFields; i++ { - d.indent() - vtf := vt.Field(i) - d.w.Write([]byte(vtf.Name)) - d.w.Write(colonSpaceBytes) - d.ignoreNextIndent = true - d.dump(d.unpackValue(v.Field(i))) - if i < (numFields - 1) { - d.w.Write(commaNewlineBytes) - } else { - d.w.Write(newlineBytes) - } - } - } - d.depth-- - d.indent() - d.w.Write(closeBraceBytes) - - case reflect.Uintptr: - printHexPtr(d.w, uintptr(v.Uint())) - - case reflect.UnsafePointer, reflect.Chan, reflect.Func: - printHexPtr(d.w, v.Pointer()) - - // There were not any other types at the time this code was written, but - // fall back to letting the default fmt package handle it in case any new - // types are added. - default: - if v.CanInterface() { - fmt.Fprintf(d.w, "%v", v.Interface()) - } else { - fmt.Fprintf(d.w, "%v", v.String()) - } - } -} - -// fdump is a helper function to consolidate the logic from the various public -// methods which take varying writers and config states. -func fdump(cs *ConfigState, w io.Writer, a ...interface{}) { - for _, arg := range a { - if arg == nil { - w.Write(interfaceBytes) - w.Write(spaceBytes) - w.Write(nilAngleBytes) - w.Write(newlineBytes) - continue - } - - d := dumpState{w: w, cs: cs} - d.pointers = make(map[uintptr]int) - d.dump(reflect.ValueOf(arg)) - d.w.Write(newlineBytes) - } -} - -// Fdump formats and displays the passed arguments to io.Writer w. It formats -// exactly the same as Dump. -func Fdump(w io.Writer, a ...interface{}) { - fdump(&Config, w, a...) -} - -// Sdump returns a string with the passed arguments formatted exactly the same -// as Dump. -func Sdump(a ...interface{}) string { - var buf bytes.Buffer - fdump(&Config, &buf, a...) - return buf.String() -} - -/* -Dump displays the passed parameters to standard out with newlines, customizable -indentation, and additional debug information such as complete types and all -pointer addresses used to indirect to the final value. It provides the -following features over the built-in printing facilities provided by the fmt -package: - - * Pointers are dereferenced and followed - * Circular data structures are detected and handled properly - * Custom Stringer/error interfaces are optionally invoked, including - on unexported types - * Custom types which only implement the Stringer/error interfaces via - a pointer receiver are optionally invoked when passing non-pointer - variables - * Byte arrays and slices are dumped like the hexdump -C command which - includes offsets, byte values in hex, and ASCII output - -The configuration options are controlled by an exported package global, -spew.Config. See ConfigState for options documentation. - -See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to -get the formatted result as a string. -*/ -func Dump(a ...interface{}) { - fdump(&Config, os.Stdout, a...) -} diff --git a/vendor/github.com/davecgh/go-spew/spew/format.go b/vendor/github.com/davecgh/go-spew/spew/format.go deleted file mode 100644 index b04edb7d7ac..00000000000 --- a/vendor/github.com/davecgh/go-spew/spew/format.go +++ /dev/null @@ -1,419 +0,0 @@ -/* - * Copyright (c) 2013-2016 Dave Collins - * - * Permission to use, copy, modify, and distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -package spew - -import ( - "bytes" - "fmt" - "reflect" - "strconv" - "strings" -) - -// supportedFlags is a list of all the character flags supported by fmt package. -const supportedFlags = "0-+# " - -// formatState implements the fmt.Formatter interface and contains information -// about the state of a formatting operation. The NewFormatter function can -// be used to get a new Formatter which can be used directly as arguments -// in standard fmt package printing calls. -type formatState struct { - value interface{} - fs fmt.State - depth int - pointers map[uintptr]int - ignoreNextType bool - cs *ConfigState -} - -// buildDefaultFormat recreates the original format string without precision -// and width information to pass in to fmt.Sprintf in the case of an -// unrecognized type. Unless new types are added to the language, this -// function won't ever be called. -func (f *formatState) buildDefaultFormat() (format string) { - buf := bytes.NewBuffer(percentBytes) - - for _, flag := range supportedFlags { - if f.fs.Flag(int(flag)) { - buf.WriteRune(flag) - } - } - - buf.WriteRune('v') - - format = buf.String() - return format -} - -// constructOrigFormat recreates the original format string including precision -// and width information to pass along to the standard fmt package. This allows -// automatic deferral of all format strings this package doesn't support. -func (f *formatState) constructOrigFormat(verb rune) (format string) { - buf := bytes.NewBuffer(percentBytes) - - for _, flag := range supportedFlags { - if f.fs.Flag(int(flag)) { - buf.WriteRune(flag) - } - } - - if width, ok := f.fs.Width(); ok { - buf.WriteString(strconv.Itoa(width)) - } - - if precision, ok := f.fs.Precision(); ok { - buf.Write(precisionBytes) - buf.WriteString(strconv.Itoa(precision)) - } - - buf.WriteRune(verb) - - format = buf.String() - return format -} - -// unpackValue returns values inside of non-nil interfaces when possible and -// ensures that types for values which have been unpacked from an interface -// are displayed when the show types flag is also set. -// This is useful for data types like structs, arrays, slices, and maps which -// can contain varying types packed inside an interface. -func (f *formatState) unpackValue(v reflect.Value) reflect.Value { - if v.Kind() == reflect.Interface { - f.ignoreNextType = false - if !v.IsNil() { - v = v.Elem() - } - } - return v -} - -// formatPtr handles formatting of pointers by indirecting them as necessary. -func (f *formatState) formatPtr(v reflect.Value) { - // Display nil if top level pointer is nil. - showTypes := f.fs.Flag('#') - if v.IsNil() && (!showTypes || f.ignoreNextType) { - f.fs.Write(nilAngleBytes) - return - } - - // Remove pointers at or below the current depth from map used to detect - // circular refs. - for k, depth := range f.pointers { - if depth >= f.depth { - delete(f.pointers, k) - } - } - - // Keep list of all dereferenced pointers to possibly show later. - pointerChain := make([]uintptr, 0) - - // Figure out how many levels of indirection there are by derferencing - // pointers and unpacking interfaces down the chain while detecting circular - // references. - nilFound := false - cycleFound := false - indirects := 0 - ve := v - for ve.Kind() == reflect.Ptr { - if ve.IsNil() { - nilFound = true - break - } - indirects++ - addr := ve.Pointer() - pointerChain = append(pointerChain, addr) - if pd, ok := f.pointers[addr]; ok && pd < f.depth { - cycleFound = true - indirects-- - break - } - f.pointers[addr] = f.depth - - ve = ve.Elem() - if ve.Kind() == reflect.Interface { - if ve.IsNil() { - nilFound = true - break - } - ve = ve.Elem() - } - } - - // Display type or indirection level depending on flags. - if showTypes && !f.ignoreNextType { - f.fs.Write(openParenBytes) - f.fs.Write(bytes.Repeat(asteriskBytes, indirects)) - f.fs.Write([]byte(ve.Type().String())) - f.fs.Write(closeParenBytes) - } else { - if nilFound || cycleFound { - indirects += strings.Count(ve.Type().String(), "*") - } - f.fs.Write(openAngleBytes) - f.fs.Write([]byte(strings.Repeat("*", indirects))) - f.fs.Write(closeAngleBytes) - } - - // Display pointer information depending on flags. - if f.fs.Flag('+') && (len(pointerChain) > 0) { - f.fs.Write(openParenBytes) - for i, addr := range pointerChain { - if i > 0 { - f.fs.Write(pointerChainBytes) - } - printHexPtr(f.fs, addr) - } - f.fs.Write(closeParenBytes) - } - - // Display dereferenced value. - switch { - case nilFound: - f.fs.Write(nilAngleBytes) - - case cycleFound: - f.fs.Write(circularShortBytes) - - default: - f.ignoreNextType = true - f.format(ve) - } -} - -// format is the main workhorse for providing the Formatter interface. It -// uses the passed reflect value to figure out what kind of object we are -// dealing with and formats it appropriately. It is a recursive function, -// however circular data structures are detected and handled properly. -func (f *formatState) format(v reflect.Value) { - // Handle invalid reflect values immediately. - kind := v.Kind() - if kind == reflect.Invalid { - f.fs.Write(invalidAngleBytes) - return - } - - // Handle pointers specially. - if kind == reflect.Ptr { - f.formatPtr(v) - return - } - - // Print type information unless already handled elsewhere. - if !f.ignoreNextType && f.fs.Flag('#') { - f.fs.Write(openParenBytes) - f.fs.Write([]byte(v.Type().String())) - f.fs.Write(closeParenBytes) - } - f.ignoreNextType = false - - // Call Stringer/error interfaces if they exist and the handle methods - // flag is enabled. - if !f.cs.DisableMethods { - if (kind != reflect.Invalid) && (kind != reflect.Interface) { - if handled := handleMethods(f.cs, f.fs, v); handled { - return - } - } - } - - switch kind { - case reflect.Invalid: - // Do nothing. We should never get here since invalid has already - // been handled above. - - case reflect.Bool: - printBool(f.fs, v.Bool()) - - case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: - printInt(f.fs, v.Int(), 10) - - case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: - printUint(f.fs, v.Uint(), 10) - - case reflect.Float32: - printFloat(f.fs, v.Float(), 32) - - case reflect.Float64: - printFloat(f.fs, v.Float(), 64) - - case reflect.Complex64: - printComplex(f.fs, v.Complex(), 32) - - case reflect.Complex128: - printComplex(f.fs, v.Complex(), 64) - - case reflect.Slice: - if v.IsNil() { - f.fs.Write(nilAngleBytes) - break - } - fallthrough - - case reflect.Array: - f.fs.Write(openBracketBytes) - f.depth++ - if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) { - f.fs.Write(maxShortBytes) - } else { - numEntries := v.Len() - for i := 0; i < numEntries; i++ { - if i > 0 { - f.fs.Write(spaceBytes) - } - f.ignoreNextType = true - f.format(f.unpackValue(v.Index(i))) - } - } - f.depth-- - f.fs.Write(closeBracketBytes) - - case reflect.String: - f.fs.Write([]byte(v.String())) - - case reflect.Interface: - // The only time we should get here is for nil interfaces due to - // unpackValue calls. - if v.IsNil() { - f.fs.Write(nilAngleBytes) - } - - case reflect.Ptr: - // Do nothing. We should never get here since pointers have already - // been handled above. - - case reflect.Map: - // nil maps should be indicated as different than empty maps - if v.IsNil() { - f.fs.Write(nilAngleBytes) - break - } - - f.fs.Write(openMapBytes) - f.depth++ - if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) { - f.fs.Write(maxShortBytes) - } else { - keys := v.MapKeys() - if f.cs.SortKeys { - sortValues(keys, f.cs) - } - for i, key := range keys { - if i > 0 { - f.fs.Write(spaceBytes) - } - f.ignoreNextType = true - f.format(f.unpackValue(key)) - f.fs.Write(colonBytes) - f.ignoreNextType = true - f.format(f.unpackValue(v.MapIndex(key))) - } - } - f.depth-- - f.fs.Write(closeMapBytes) - - case reflect.Struct: - numFields := v.NumField() - f.fs.Write(openBraceBytes) - f.depth++ - if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) { - f.fs.Write(maxShortBytes) - } else { - vt := v.Type() - for i := 0; i < numFields; i++ { - if i > 0 { - f.fs.Write(spaceBytes) - } - vtf := vt.Field(i) - if f.fs.Flag('+') || f.fs.Flag('#') { - f.fs.Write([]byte(vtf.Name)) - f.fs.Write(colonBytes) - } - f.format(f.unpackValue(v.Field(i))) - } - } - f.depth-- - f.fs.Write(closeBraceBytes) - - case reflect.Uintptr: - printHexPtr(f.fs, uintptr(v.Uint())) - - case reflect.UnsafePointer, reflect.Chan, reflect.Func: - printHexPtr(f.fs, v.Pointer()) - - // There were not any other types at the time this code was written, but - // fall back to letting the default fmt package handle it if any get added. - default: - format := f.buildDefaultFormat() - if v.CanInterface() { - fmt.Fprintf(f.fs, format, v.Interface()) - } else { - fmt.Fprintf(f.fs, format, v.String()) - } - } -} - -// Format satisfies the fmt.Formatter interface. See NewFormatter for usage -// details. -func (f *formatState) Format(fs fmt.State, verb rune) { - f.fs = fs - - // Use standard formatting for verbs that are not v. - if verb != 'v' { - format := f.constructOrigFormat(verb) - fmt.Fprintf(fs, format, f.value) - return - } - - if f.value == nil { - if fs.Flag('#') { - fs.Write(interfaceBytes) - } - fs.Write(nilAngleBytes) - return - } - - f.format(reflect.ValueOf(f.value)) -} - -// newFormatter is a helper function to consolidate the logic from the various -// public methods which take varying config states. -func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter { - fs := &formatState{value: v, cs: cs} - fs.pointers = make(map[uintptr]int) - return fs -} - -/* -NewFormatter returns a custom formatter that satisfies the fmt.Formatter -interface. As a result, it integrates cleanly with standard fmt package -printing functions. The formatter is useful for inline printing of smaller data -types similar to the standard %v format specifier. - -The custom formatter only responds to the %v (most compact), %+v (adds pointer -addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb -combinations. Any other verbs such as %x and %q will be sent to the the -standard fmt package for formatting. In addition, the custom formatter ignores -the width and precision arguments (however they will still work on the format -specifiers not handled by the custom formatter). - -Typically this function shouldn't be called directly. It is much easier to make -use of the custom formatter by calling one of the convenience functions such as -Printf, Println, or Fprintf. -*/ -func NewFormatter(v interface{}) fmt.Formatter { - return newFormatter(&Config, v) -} diff --git a/vendor/github.com/davecgh/go-spew/spew/spew.go b/vendor/github.com/davecgh/go-spew/spew/spew.go deleted file mode 100644 index 32c0e338825..00000000000 --- a/vendor/github.com/davecgh/go-spew/spew/spew.go +++ /dev/null @@ -1,148 +0,0 @@ -/* - * Copyright (c) 2013-2016 Dave Collins - * - * Permission to use, copy, modify, and distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -package spew - -import ( - "fmt" - "io" -) - -// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were -// passed with a default Formatter interface returned by NewFormatter. It -// returns the formatted string as a value that satisfies error. See -// NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b)) -func Errorf(format string, a ...interface{}) (err error) { - return fmt.Errorf(format, convertArgs(a)...) -} - -// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were -// passed with a default Formatter interface returned by NewFormatter. It -// returns the number of bytes written and any write error encountered. See -// NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b)) -func Fprint(w io.Writer, a ...interface{}) (n int, err error) { - return fmt.Fprint(w, convertArgs(a)...) -} - -// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were -// passed with a default Formatter interface returned by NewFormatter. It -// returns the number of bytes written and any write error encountered. See -// NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b)) -func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) { - return fmt.Fprintf(w, format, convertArgs(a)...) -} - -// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it -// passed with a default Formatter interface returned by NewFormatter. See -// NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b)) -func Fprintln(w io.Writer, a ...interface{}) (n int, err error) { - return fmt.Fprintln(w, convertArgs(a)...) -} - -// Print is a wrapper for fmt.Print that treats each argument as if it were -// passed with a default Formatter interface returned by NewFormatter. It -// returns the number of bytes written and any write error encountered. See -// NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b)) -func Print(a ...interface{}) (n int, err error) { - return fmt.Print(convertArgs(a)...) -} - -// Printf is a wrapper for fmt.Printf that treats each argument as if it were -// passed with a default Formatter interface returned by NewFormatter. It -// returns the number of bytes written and any write error encountered. See -// NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b)) -func Printf(format string, a ...interface{}) (n int, err error) { - return fmt.Printf(format, convertArgs(a)...) -} - -// Println is a wrapper for fmt.Println that treats each argument as if it were -// passed with a default Formatter interface returned by NewFormatter. It -// returns the number of bytes written and any write error encountered. See -// NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b)) -func Println(a ...interface{}) (n int, err error) { - return fmt.Println(convertArgs(a)...) -} - -// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were -// passed with a default Formatter interface returned by NewFormatter. It -// returns the resulting string. See NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b)) -func Sprint(a ...interface{}) string { - return fmt.Sprint(convertArgs(a)...) -} - -// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were -// passed with a default Formatter interface returned by NewFormatter. It -// returns the resulting string. See NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b)) -func Sprintf(format string, a ...interface{}) string { - return fmt.Sprintf(format, convertArgs(a)...) -} - -// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it -// were passed with a default Formatter interface returned by NewFormatter. It -// returns the resulting string. See NewFormatter for formatting details. -// -// This function is shorthand for the following syntax: -// -// fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b)) -func Sprintln(a ...interface{}) string { - return fmt.Sprintln(convertArgs(a)...) -} - -// convertArgs accepts a slice of arguments and returns a slice of the same -// length with each argument converted to a default spew Formatter interface. -func convertArgs(args []interface{}) (formatters []interface{}) { - formatters = make([]interface{}, len(args)) - for index, arg := range args { - formatters[index] = NewFormatter(arg) - } - return formatters -} diff --git a/vendor/github.com/ebitengine/purego/.gitignore b/vendor/github.com/ebitengine/purego/.gitignore deleted file mode 100644 index b25c15b81fa..00000000000 --- a/vendor/github.com/ebitengine/purego/.gitignore +++ /dev/null @@ -1 +0,0 @@ -*~ diff --git a/vendor/github.com/ebitengine/purego/LICENSE b/vendor/github.com/ebitengine/purego/LICENSE deleted file mode 100644 index 8dada3edaf5..00000000000 --- a/vendor/github.com/ebitengine/purego/LICENSE +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "{}" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright {yyyy} {name of copyright owner} - - 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. diff --git a/vendor/github.com/ebitengine/purego/README.md b/vendor/github.com/ebitengine/purego/README.md deleted file mode 100644 index 8fb85c2caf4..00000000000 --- a/vendor/github.com/ebitengine/purego/README.md +++ /dev/null @@ -1,119 +0,0 @@ -# purego -[![Go Reference](https://pkg.go.dev/badge/github.com/ebitengine/purego?GOOS=darwin.svg)](https://pkg.go.dev/github.com/ebitengine/purego?GOOS=darwin) - -A library for calling C functions from Go without Cgo. - -> This is beta software so expect bugs and potentially API breaking changes -> but each release will be tagged to avoid breaking people's code. -> Bug reports are encouraged. - -## Motivation - -The [Ebitengine](https://github.com/hajimehoshi/ebiten) game engine was ported to use only Go on Windows. This enabled -cross-compiling to Windows from any other operating system simply by setting `GOOS=windows`. The purego project was -born to bring that same vision to the other platforms supported by Ebitengine. - -## Benefits - -- **Simple Cross-Compilation**: No C means you can build for other platforms easily without a C compiler. -- **Faster Compilation**: Efficiently cache your entirely Go builds. -- **Smaller Binaries**: Using Cgo generates a C wrapper function for each C function called. Purego doesn't! -- **Dynamic Linking**: Load symbols at runtime and use it as a plugin system. -- **Foreign Function Interface**: Call into other languages that are compiled into shared objects. -- **Cgo Fallback**: Works even with CGO_ENABLED=1 so incremental porting is possible. -This also means unsupported GOARCHs (freebsd/riscv64, linux/mips, etc.) will still work -except for float arguments and return values. - -## Supported Platforms - -### Tier 1 - -Tier 1 platforms are the primary targets officially supported by PureGo. When a new version of PureGo is released, any critical bugs found on Tier 1 platforms are treated as release blockers. The release will be postponed until such issues are resolved. - -- **Android**: amd641, arm641 -- **iOS**: amd641, arm641 -- **Linux**: amd64, arm64 -- **macOS**: amd64, arm64 -- **Windows**: amd64, arm64 - -### Tier 2 - -Tier 2 platforms are supported by PureGo on a best-effort basis. Critical bugs on Tier 2 platforms do not block new PureGo releases. However, fixes contributed by external contributors are very welcome and encouraged. - -- **Android**: 3861, arm1 -- **FreeBSD**: amd642, arm642 -- **Linux**: 386, arm, loong64, ppc64le, riscv64, s390x1 -- **Windows**: 3863, arm3,4 - -#### Support Notes - -1. These architectures require CGO_ENABLED=1 to compile -2. These architectures require the special flag `-gcflags="github.com/ebitengine/purego/internal/fakecgo=-std"` to compile with CGO_ENABLED=0 -3. These architectures only support `SyscallN` and `NewCallback` -4. These architectures are no longer supported as of Go 1.26 - -## Example - -The example below only showcases purego use for macOS and Linux. The other platforms require special handling which can -be seen in the complete example at [examples/libc](https://github.com/ebitengine/purego/tree/main/examples/libc) which supports FreeBSD and Windows. - -```go -package main - -import ( - "fmt" - "runtime" - - "github.com/ebitengine/purego" -) - -func getSystemLibrary() string { - switch runtime.GOOS { - case "darwin": - return "/usr/lib/libSystem.B.dylib" - case "linux": - return "libc.so.6" - default: - panic(fmt.Errorf("GOOS=%s is not supported", runtime.GOOS)) - } -} - -func main() { - libc, err := purego.Dlopen(getSystemLibrary(), purego.RTLD_NOW|purego.RTLD_GLOBAL) - if err != nil { - panic(err) - } - var puts func(string) - purego.RegisterLibFunc(&puts, libc, "puts") - puts("Calling C from Go without Cgo!") -} -``` - -Then to run: `CGO_ENABLED=0 go run main.go` - -## Questions - -If you have questions about how to incorporate purego in your project or want to discuss -how it works join the [Discord](https://discord.gg/HzGZVD6BkY)! - -### External Code - -Purego uses code that originates from the Go runtime. These files are under the BSD-3 -License that can be found [in the Go Source](https://github.com/golang/go/blob/master/LICENSE). -This is a list of the copied files: - -* `abi_*.h` from package `runtime/cgo` -* `wincallback.go` from package `runtime` -* `zcallback_darwin_*.s` from package `runtime` -* `internal/fakecgo/abi_*.h` from package `runtime/cgo` -* `internal/fakecgo/asm_GOARCH.s` from package `runtime/cgo` -* `internal/fakecgo/callbacks.go` from package `runtime/cgo` -* `internal/fakecgo/iscgo.go` from package `runtime/cgo` -* `internal/fakecgo/setenv.go` from package `runtime/cgo` -* `internal/fakecgo/freebsd.go` from package `runtime/cgo` -* `internal/fakecgo/netbsd.go` from package `runtime/cgo` - -The `internal/fakecgo/go_GOOS.go` files were modified from `runtime/cgo/gcc_GOOS_GOARCH.go`. - -The files `abi_*.h` and `internal/fakecgo/abi_*.h` are the same because Bazel does not support cross-package use of -`#include` so we need each one once per package. (cf. [issue](https://github.com/bazelbuild/rules_go/issues/3636)) diff --git a/vendor/github.com/ebitengine/purego/abi_amd64.h b/vendor/github.com/ebitengine/purego/abi_amd64.h deleted file mode 100644 index 9949435fe9e..00000000000 --- a/vendor/github.com/ebitengine/purego/abi_amd64.h +++ /dev/null @@ -1,99 +0,0 @@ -// Copyright 2021 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. - -// Macros for transitioning from the host ABI to Go ABI0. -// -// These save the frame pointer, so in general, functions that use -// these should have zero frame size to suppress the automatic frame -// pointer, though it's harmless to not do this. - -#ifdef GOOS_windows - -// REGS_HOST_TO_ABI0_STACK is the stack bytes used by -// PUSH_REGS_HOST_TO_ABI0. -#define REGS_HOST_TO_ABI0_STACK (28*8 + 8) - -// PUSH_REGS_HOST_TO_ABI0 prepares for transitioning from -// the host ABI to Go ABI0 code. It saves all registers that are -// callee-save in the host ABI and caller-save in Go ABI0 and prepares -// for entry to Go. -// -// Save DI SI BP BX R12 R13 R14 R15 X6-X15 registers and the DF flag. -// Clear the DF flag for the Go ABI. -// MXCSR matches the Go ABI, so we don't have to set that, -// and Go doesn't modify it, so we don't have to save it. -#define PUSH_REGS_HOST_TO_ABI0() \ - PUSHFQ \ - CLD \ - ADJSP $(REGS_HOST_TO_ABI0_STACK - 8) \ - MOVQ DI, (0*0)(SP) \ - MOVQ SI, (1*8)(SP) \ - MOVQ BP, (2*8)(SP) \ - MOVQ BX, (3*8)(SP) \ - MOVQ R12, (4*8)(SP) \ - MOVQ R13, (5*8)(SP) \ - MOVQ R14, (6*8)(SP) \ - MOVQ R15, (7*8)(SP) \ - MOVUPS X6, (8*8)(SP) \ - MOVUPS X7, (10*8)(SP) \ - MOVUPS X8, (12*8)(SP) \ - MOVUPS X9, (14*8)(SP) \ - MOVUPS X10, (16*8)(SP) \ - MOVUPS X11, (18*8)(SP) \ - MOVUPS X12, (20*8)(SP) \ - MOVUPS X13, (22*8)(SP) \ - MOVUPS X14, (24*8)(SP) \ - MOVUPS X15, (26*8)(SP) - -#define POP_REGS_HOST_TO_ABI0() \ - MOVQ (0*0)(SP), DI \ - MOVQ (1*8)(SP), SI \ - MOVQ (2*8)(SP), BP \ - MOVQ (3*8)(SP), BX \ - MOVQ (4*8)(SP), R12 \ - MOVQ (5*8)(SP), R13 \ - MOVQ (6*8)(SP), R14 \ - MOVQ (7*8)(SP), R15 \ - MOVUPS (8*8)(SP), X6 \ - MOVUPS (10*8)(SP), X7 \ - MOVUPS (12*8)(SP), X8 \ - MOVUPS (14*8)(SP), X9 \ - MOVUPS (16*8)(SP), X10 \ - MOVUPS (18*8)(SP), X11 \ - MOVUPS (20*8)(SP), X12 \ - MOVUPS (22*8)(SP), X13 \ - MOVUPS (24*8)(SP), X14 \ - MOVUPS (26*8)(SP), X15 \ - ADJSP $-(REGS_HOST_TO_ABI0_STACK - 8) \ - POPFQ - -#else -// SysV ABI - -#define REGS_HOST_TO_ABI0_STACK (6*8) - -// SysV MXCSR matches the Go ABI, so we don't have to set that, -// and Go doesn't modify it, so we don't have to save it. -// Both SysV and Go require DF to be cleared, so that's already clear. -// The SysV and Go frame pointer conventions are compatible. -#define PUSH_REGS_HOST_TO_ABI0() \ - ADJSP $(REGS_HOST_TO_ABI0_STACK) \ - MOVQ BP, (5*8)(SP) \ - LEAQ (5*8)(SP), BP \ - MOVQ BX, (0*8)(SP) \ - MOVQ R12, (1*8)(SP) \ - MOVQ R13, (2*8)(SP) \ - MOVQ R14, (3*8)(SP) \ - MOVQ R15, (4*8)(SP) - -#define POP_REGS_HOST_TO_ABI0() \ - MOVQ (0*8)(SP), BX \ - MOVQ (1*8)(SP), R12 \ - MOVQ (2*8)(SP), R13 \ - MOVQ (3*8)(SP), R14 \ - MOVQ (4*8)(SP), R15 \ - MOVQ (5*8)(SP), BP \ - ADJSP $-(REGS_HOST_TO_ABI0_STACK) - -#endif diff --git a/vendor/github.com/ebitengine/purego/abi_arm64.h b/vendor/github.com/ebitengine/purego/abi_arm64.h deleted file mode 100644 index 5d5061ec1db..00000000000 --- a/vendor/github.com/ebitengine/purego/abi_arm64.h +++ /dev/null @@ -1,39 +0,0 @@ -// Copyright 2021 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. - -// Macros for transitioning from the host ABI to Go ABI0. -// -// These macros save and restore the callee-saved registers -// from the stack, but they don't adjust stack pointer, so -// the user should prepare stack space in advance. -// SAVE_R19_TO_R28(offset) saves R19 ~ R28 to the stack space -// of ((offset)+0*8)(RSP) ~ ((offset)+9*8)(RSP). -// -// SAVE_F8_TO_F15(offset) saves F8 ~ F15 to the stack space -// of ((offset)+0*8)(RSP) ~ ((offset)+7*8)(RSP). -// -// R29 is not saved because Go will save and restore it. - -#define SAVE_R19_TO_R28(offset) \ - STP (R19, R20), ((offset)+0*8)(RSP) \ - STP (R21, R22), ((offset)+2*8)(RSP) \ - STP (R23, R24), ((offset)+4*8)(RSP) \ - STP (R25, R26), ((offset)+6*8)(RSP) \ - STP (R27, g), ((offset)+8*8)(RSP) -#define RESTORE_R19_TO_R28(offset) \ - LDP ((offset)+0*8)(RSP), (R19, R20) \ - LDP ((offset)+2*8)(RSP), (R21, R22) \ - LDP ((offset)+4*8)(RSP), (R23, R24) \ - LDP ((offset)+6*8)(RSP), (R25, R26) \ - LDP ((offset)+8*8)(RSP), (R27, g) /* R28 */ -#define SAVE_F8_TO_F15(offset) \ - FSTPD (F8, F9), ((offset)+0*8)(RSP) \ - FSTPD (F10, F11), ((offset)+2*8)(RSP) \ - FSTPD (F12, F13), ((offset)+4*8)(RSP) \ - FSTPD (F14, F15), ((offset)+6*8)(RSP) -#define RESTORE_F8_TO_F15(offset) \ - FLDPD ((offset)+0*8)(RSP), (F8, F9) \ - FLDPD ((offset)+2*8)(RSP), (F10, F11) \ - FLDPD ((offset)+4*8)(RSP), (F12, F13) \ - FLDPD ((offset)+6*8)(RSP), (F14, F15) diff --git a/vendor/github.com/ebitengine/purego/abi_loong64.h b/vendor/github.com/ebitengine/purego/abi_loong64.h deleted file mode 100644 index b10d83732f1..00000000000 --- a/vendor/github.com/ebitengine/purego/abi_loong64.h +++ /dev/null @@ -1,60 +0,0 @@ -// Copyright 2022 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. - -// Macros for transitioning from the host ABI to Go ABI0. -// -// These macros save and restore the callee-saved registers -// from the stack, but they don't adjust stack pointer, so -// the user should prepare stack space in advance. -// SAVE_R22_TO_R31(offset) saves R22 ~ R31 to the stack space -// of ((offset)+0*8)(R3) ~ ((offset)+9*8)(R3). -// -// SAVE_F24_TO_F31(offset) saves F24 ~ F31 to the stack space -// of ((offset)+0*8)(R3) ~ ((offset)+7*8)(R3). -// -// Note: g is R22 - -#define SAVE_R22_TO_R31(offset) \ - MOVV g, ((offset)+(0*8))(R3) \ - MOVV R23, ((offset)+(1*8))(R3) \ - MOVV R24, ((offset)+(2*8))(R3) \ - MOVV R25, ((offset)+(3*8))(R3) \ - MOVV R26, ((offset)+(4*8))(R3) \ - MOVV R27, ((offset)+(5*8))(R3) \ - MOVV R28, ((offset)+(6*8))(R3) \ - MOVV R29, ((offset)+(7*8))(R3) \ - MOVV R30, ((offset)+(8*8))(R3) \ - MOVV R31, ((offset)+(9*8))(R3) - -#define SAVE_F24_TO_F31(offset) \ - MOVD F24, ((offset)+(0*8))(R3) \ - MOVD F25, ((offset)+(1*8))(R3) \ - MOVD F26, ((offset)+(2*8))(R3) \ - MOVD F27, ((offset)+(3*8))(R3) \ - MOVD F28, ((offset)+(4*8))(R3) \ - MOVD F29, ((offset)+(5*8))(R3) \ - MOVD F30, ((offset)+(6*8))(R3) \ - MOVD F31, ((offset)+(7*8))(R3) - -#define RESTORE_R22_TO_R31(offset) \ - MOVV ((offset)+(0*8))(R3), g \ - MOVV ((offset)+(1*8))(R3), R23 \ - MOVV ((offset)+(2*8))(R3), R24 \ - MOVV ((offset)+(3*8))(R3), R25 \ - MOVV ((offset)+(4*8))(R3), R26 \ - MOVV ((offset)+(5*8))(R3), R27 \ - MOVV ((offset)+(6*8))(R3), R28 \ - MOVV ((offset)+(7*8))(R3), R29 \ - MOVV ((offset)+(8*8))(R3), R30 \ - MOVV ((offset)+(9*8))(R3), R31 - -#define RESTORE_F24_TO_F31(offset) \ - MOVD ((offset)+(0*8))(R3), F24 \ - MOVD ((offset)+(1*8))(R3), F25 \ - MOVD ((offset)+(2*8))(R3), F26 \ - MOVD ((offset)+(3*8))(R3), F27 \ - MOVD ((offset)+(4*8))(R3), F28 \ - MOVD ((offset)+(5*8))(R3), F29 \ - MOVD ((offset)+(6*8))(R3), F30 \ - MOVD ((offset)+(7*8))(R3), F31 diff --git a/vendor/github.com/ebitengine/purego/cgo.go b/vendor/github.com/ebitengine/purego/cgo.go deleted file mode 100644 index b6def570c28..00000000000 --- a/vendor/github.com/ebitengine/purego/cgo.go +++ /dev/null @@ -1,19 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build cgo && (darwin || freebsd || linux || netbsd) - -package purego - -// if CGO_ENABLED=1 import the Cgo runtime to ensure that it is set up properly. -// This is required since some frameworks need TLS setup the C way which Go doesn't do. -// We currently don't support ios in fakecgo mode so force Cgo or fail. -// Even if CGO_ENABLED=1 the Cgo runtime is not imported unless `import "C"` is used, -// which will import this package automatically. Normally this isn't an issue since it -// usually isn't possible to call into C without using that import. However, with purego -// it is since we don't use `import "C"`! -import ( - _ "runtime/cgo" - - _ "github.com/ebitengine/purego/internal/cgo" -) diff --git a/vendor/github.com/ebitengine/purego/dlerror.go b/vendor/github.com/ebitengine/purego/dlerror.go deleted file mode 100644 index ad52b436cdf..00000000000 --- a/vendor/github.com/ebitengine/purego/dlerror.go +++ /dev/null @@ -1,17 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2023 The Ebitengine Authors - -//go:build darwin || freebsd || linux || netbsd - -package purego - -// Dlerror represents an error value returned from Dlopen, Dlsym, or Dlclose. -// -// This type is not available on Windows as there is no counterpart to it on Windows. -type Dlerror struct { - s string -} - -func (e Dlerror) Error() string { - return e.s -} diff --git a/vendor/github.com/ebitengine/purego/dlfcn.go b/vendor/github.com/ebitengine/purego/dlfcn.go deleted file mode 100644 index 2730d82cde6..00000000000 --- a/vendor/github.com/ebitengine/purego/dlfcn.go +++ /dev/null @@ -1,99 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build (darwin || freebsd || linux || netbsd) && !android && !faketime - -package purego - -import ( - "unsafe" -) - -// Unix Specification for dlfcn.h: https://pubs.opengroup.org/onlinepubs/7908799/xsh/dlfcn.h.html - -var ( - fnDlopen func(path string, mode int) uintptr - fnDlsym func(handle uintptr, name string) uintptr - fnDlerror func() string - fnDlclose func(handle uintptr) bool -) - -func init() { - RegisterFunc(&fnDlopen, dlopenABI0) - RegisterFunc(&fnDlsym, dlsymABI0) - RegisterFunc(&fnDlerror, dlerrorABI0) - RegisterFunc(&fnDlclose, dlcloseABI0) -} - -// Dlopen examines the dynamic library or bundle file specified by path. If the file is compatible -// with the current process and has not already been loaded into the -// current process, it is loaded and linked. After being linked, if it contains -// any initializer functions, they are called, before Dlopen -// returns. It returns a handle that can be used with Dlsym and Dlclose. -// A second call to Dlopen with the same path will return the same handle, but the internal -// reference count for the handle will be incremented. Therefore, all -// Dlopen calls should be balanced with a Dlclose call. -// -// This function is not available on Windows. -// Use [golang.org/x/sys/windows.LoadLibrary], [golang.org/x/sys/windows.LoadLibraryEx], -// [golang.org/x/sys/windows.NewLazyDLL], or [golang.org/x/sys/windows.NewLazySystemDLL] for Windows instead. -func Dlopen(path string, mode int) (uintptr, error) { - u := fnDlopen(path, mode) - if u == 0 { - return 0, Dlerror{fnDlerror()} - } - return u, nil -} - -// Dlsym takes a "handle" of a dynamic library returned by Dlopen and the symbol name. -// It returns the address where that symbol is loaded into memory. If the symbol is not found, -// in the specified library or any of the libraries that were automatically loaded by Dlopen -// when that library was loaded, Dlsym returns zero. -// -// This function is not available on Windows. -// Use [golang.org/x/sys/windows.GetProcAddress] for Windows instead. -func Dlsym(handle uintptr, name string) (uintptr, error) { - u := fnDlsym(handle, name) - if u == 0 { - return 0, Dlerror{fnDlerror()} - } - return u, nil -} - -// Dlclose decrements the reference count on the dynamic library handle. -// If the reference count drops to zero and no other loaded libraries -// use symbols in it, then the dynamic library is unloaded. -// -// This function is not available on Windows. -// Use [golang.org/x/sys/windows.FreeLibrary] for Windows instead. -func Dlclose(handle uintptr) error { - if fnDlclose(handle) { - return Dlerror{fnDlerror()} - } - return nil -} - -func loadSymbol(handle uintptr, name string) (uintptr, error) { - return Dlsym(handle, name) -} - -// these functions exist in dlfcn_stubs.s and are calling C functions linked to in dlfcn_GOOS.go -// the indirection is necessary because a function is actually a pointer to the pointer to the code. -// sadly, I do not know of anyway to remove the assembly stubs entirely because //go:linkname doesn't -// appear to work if you link directly to the C function on darwin arm64. - -//go:linkname dlopen dlopen -var dlopen uint8 -var dlopenABI0 = uintptr(unsafe.Pointer(&dlopen)) - -//go:linkname dlsym dlsym -var dlsym uint8 -var dlsymABI0 = uintptr(unsafe.Pointer(&dlsym)) - -//go:linkname dlclose dlclose -var dlclose uint8 -var dlcloseABI0 = uintptr(unsafe.Pointer(&dlclose)) - -//go:linkname dlerror dlerror -var dlerror uint8 -var dlerrorABI0 = uintptr(unsafe.Pointer(&dlerror)) diff --git a/vendor/github.com/ebitengine/purego/dlfcn_android.go b/vendor/github.com/ebitengine/purego/dlfcn_android.go deleted file mode 100644 index 0d5341764ed..00000000000 --- a/vendor/github.com/ebitengine/purego/dlfcn_android.go +++ /dev/null @@ -1,34 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2024 The Ebitengine Authors - -package purego - -import "github.com/ebitengine/purego/internal/cgo" - -// Source for constants: https://android.googlesource.com/platform/bionic/+/refs/heads/main/libc/include/dlfcn.h - -const ( - is64bit = 1 << (^uintptr(0) >> 63) / 2 - is32bit = 1 - is64bit - RTLD_DEFAULT = is32bit * 0xffffffff - RTLD_LAZY = 0x00000001 - RTLD_NOW = is64bit * 0x00000002 - RTLD_LOCAL = 0x00000000 - RTLD_GLOBAL = is64bit*0x00100 | is32bit*0x00000002 -) - -func Dlopen(path string, mode int) (uintptr, error) { - return cgo.Dlopen(path, mode) -} - -func Dlsym(handle uintptr, name string) (uintptr, error) { - return cgo.Dlsym(handle, name) -} - -func Dlclose(handle uintptr) error { - return cgo.Dlclose(handle) -} - -func loadSymbol(handle uintptr, name string) (uintptr, error) { - return Dlsym(handle, name) -} diff --git a/vendor/github.com/ebitengine/purego/dlfcn_darwin.go b/vendor/github.com/ebitengine/purego/dlfcn_darwin.go deleted file mode 100644 index 5dd44468da2..00000000000 --- a/vendor/github.com/ebitengine/purego/dlfcn_darwin.go +++ /dev/null @@ -1,20 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -package purego - -// Source for constants: https://opensource.apple.com/source/dyld/dyld-360.14/include/dlfcn.h.auto.html - -const ( - RTLD_DEFAULT = 1<<64 - 2 // Pseudo-handle for dlsym so search for any loaded symbol - RTLD_LAZY = 0x1 // Relocations are performed at an implementation-dependent time. - RTLD_NOW = 0x2 // Relocations are performed when the object is loaded. - RTLD_LOCAL = 0x4 // All symbols are not made available for relocation processing by other modules. - RTLD_GLOBAL = 0x8 // All symbols are available for relocation processing of other modules. -) - -//go:cgo_import_dynamic purego_dlopen dlopen "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_dlsym dlsym "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_dlerror dlerror "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_dlclose dlclose "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_error __error "/usr/lib/libSystem.B.dylib" diff --git a/vendor/github.com/ebitengine/purego/dlfcn_freebsd.go b/vendor/github.com/ebitengine/purego/dlfcn_freebsd.go deleted file mode 100644 index 6b371620d96..00000000000 --- a/vendor/github.com/ebitengine/purego/dlfcn_freebsd.go +++ /dev/null @@ -1,14 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -package purego - -// Constants as defined in https://github.com/freebsd/freebsd-src/blob/main/include/dlfcn.h -const ( - intSize = 32 << (^uint(0) >> 63) // 32 or 64 - RTLD_DEFAULT = 1<> 63) // 32 or 64 - RTLD_DEFAULT = 1< C) -// -// string <=> char* -// bool <=> _Bool -// uintptr <=> uintptr_t -// uint <=> uint32_t or uint64_t -// uint8 <=> uint8_t -// uint16 <=> uint16_t -// uint32 <=> uint32_t -// uint64 <=> uint64_t -// int <=> int32_t or int64_t -// int8 <=> int8_t -// int16 <=> int16_t -// int32 <=> int32_t -// int64 <=> int64_t -// float32 <=> float -// float64 <=> double -// struct <=> struct (darwin amd64/arm64, linux amd64/arm64) -// func <=> C function -// unsafe.Pointer, *T <=> void* -// []T => void* -// -// There is a special case when the last argument of fptr is a variadic interface (or []interface} -// it will be expanded into a call to the C function as if it had the arguments in that slice. -// This means that using arg ...any is like a cast to the function with the arguments inside arg. -// This is not the same as C variadic. -// -// # Memory -// -// In general it is not possible for purego to guarantee the lifetimes of objects returned or received from -// calling functions using RegisterFunc. For arguments to a C function it is important that the C function doesn't -// hold onto a reference to Go memory. This is the same as the [Cgo rules]. -// -// However, there are some special cases. When passing a string as an argument if the string does not end in a null -// terminated byte (\x00) then the string will be copied into memory maintained by purego. The memory is only valid for -// that specific call. Therefore, if the C code keeps a reference to that string it may become invalid at some -// undefined time. However, if the string does already contain a null-terminated byte then no copy is done. -// It is then the responsibility of the caller to ensure the string stays alive as long as it's needed in C memory. -// This can be done using runtime.KeepAlive or allocating the string in C memory using malloc. When a C function -// returns a null-terminated pointer to char a Go string can be used. Purego will allocate a new string in Go memory -// and copy the data over. This string will be garbage collected whenever Go decides it's no longer referenced. -// This C created string will not be freed by purego. If the pointer to char is not null-terminated or must continue -// to point to C memory (because it's a buffer for example) then use a pointer to byte and then convert that to a slice -// using unsafe.Slice. Doing this means that it becomes the responsibility of the caller to care about the lifetime -// of the pointer -// -// # Structs -// -// Purego can handle the most common structs that have fields of builtin types like int8, uint16, float32, etc. However, -// it does not support aligning fields properly. It is therefore the responsibility of the caller to ensure -// that all padding is added to the Go struct to match the C one. See `BoolStructFn` in struct_test.go for an example. -// -// On Darwin ARM64, purego handles proper alignment of struct arguments when passing them on the stack, -// following the C ABI's byte-level packing rules. -// -// # Example -// -// All functions below call this C function: -// -// char *foo(char *str); -// -// // Let purego convert types -// var foo func(s string) string -// goString := foo("copied") -// // Go will garbage collect this string -// -// // Manually, handle allocations -// var foo2 func(b string) *byte -// mustFree := foo2("not copied\x00") -// defer free(mustFree) -// -// [Cgo rules]: https://pkg.go.dev/cmd/cgo#hdr-Go_references_to_C -func RegisterFunc(fptr any, cfn uintptr) { - const is32bit = unsafe.Sizeof(uintptr(0)) == 4 - fn := reflect.ValueOf(fptr).Elem() - ty := fn.Type() - if ty.Kind() != reflect.Func { - panic("purego: fptr must be a function pointer") - } - if ty.NumOut() > 1 { - panic("purego: function can only return zero or one values") - } - if cfn == 0 { - panic("purego: cfn is nil") - } - if ty.NumOut() == 1 && (ty.Out(0).Kind() == reflect.Float32 || ty.Out(0).Kind() == reflect.Float64) && - runtime.GOARCH != "arm" && runtime.GOARCH != "arm64" && runtime.GOARCH != "386" && runtime.GOARCH != "amd64" && runtime.GOARCH != "loong64" && runtime.GOARCH != "ppc64le" && runtime.GOARCH != "riscv64" && runtime.GOARCH != "s390x" { - panic("purego: float returns are not supported") - } - { - // this code checks how many registers and stack this function will use - // to avoid crashing with too many arguments - var ints int - var floats int - var stack int - for i := 0; i < ty.NumIn(); i++ { - arg := ty.In(i) - switch arg.Kind() { - case reflect.Func: - // This only does preliminary testing to ensure the CDecl argument - // is the first argument. Full testing is done when the callback is actually - // created in NewCallback. - for j := 0; j < arg.NumIn(); j++ { - in := arg.In(j) - if !in.AssignableTo(reflect.TypeOf(CDecl{})) { - continue - } - if j != 0 { - panic("purego: CDecl must be the first argument") - } - } - case reflect.String, reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, - reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Ptr, reflect.UnsafePointer, - reflect.Slice, reflect.Bool: - if ints < numOfIntegerRegisters() { - ints++ - } else { - stack++ - } - case reflect.Float32, reflect.Float64: - if floats < numOfFloatRegisters() { - floats++ - } else { - stack++ - } - case reflect.Struct: - ensureStructSupportedForRegisterFunc() - if arg.Size() == 0 { - continue - } - addInt := func(u uintptr) { - ints++ - } - addFloat := func(u uintptr) { - floats++ - } - addStack := func(u uintptr) { - stack++ - } - _ = addStruct(reflect.New(arg).Elem(), &ints, &floats, &stack, addInt, addFloat, addStack, nil) - default: - panic("purego: unsupported kind " + arg.Kind().String()) - } - } - if ty.NumOut() == 1 && ty.Out(0).Kind() == reflect.Struct { - ensureStructSupportedForRegisterFunc() - outType := ty.Out(0) - checkStructFieldsSupported(outType) - if runtime.GOARCH == "amd64" && outType.Size() > maxRegAllocStructSize { - // on amd64 if struct is bigger than 16 bytes allocate the return struct - // and pass it in as a hidden first argument. - ints++ - } - } - - sizeOfStack := maxArgs - numOfIntegerRegisters() - // On Darwin ARM64, use byte-based validation since arguments pack efficiently. - // See https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms - if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" { - stackBytes := estimateStackBytes(ty) - maxStackBytes := sizeOfStack * 8 - if stackBytes > maxStackBytes { - panic("purego: too many stack arguments") - } - } else { - if stack > sizeOfStack { - panic("purego: too many stack arguments") - } - } - } - - v := reflect.MakeFunc(ty, func(args []reflect.Value) (results []reflect.Value) { - var sysargs [maxArgs]uintptr - // Use maxArgs instead of numOfFloatRegisters() to keep this code path allocation-free, - // since numOfFloatRegisters() is a function call, not a constant. - // maxArgs is always greater than or equal to numOfFloatRegisters() so this is safe. - var floats [maxArgs]uintptr - var numInts int - var numFloats int - var numStack int - var addStack, addInt, addFloat func(x uintptr) - if runtime.GOARCH == "arm64" || runtime.GOOS != "windows" { - // Windows arm64 uses the same calling convention as macOS and Linux - addStack = func(x uintptr) { - sysargs[numOfIntegerRegisters()+numStack] = x - numStack++ - } - addInt = func(x uintptr) { - if numInts >= numOfIntegerRegisters() { - addStack(x) - } else { - sysargs[numInts] = x - numInts++ - } - } - addFloat = func(x uintptr) { - if numFloats < numOfFloatRegisters() { - floats[numFloats] = x - numFloats++ - } else { - addStack(x) - } - } - } else { - // On Windows amd64 the arguments are passed in the numbered registered. - // So the first int is in the first integer register and the first float - // is in the second floating register if there is already a first int. - // This is in contrast to how macOS and Linux pass arguments which - // tries to use as many registers as possible in the calling convention. - addStack = func(x uintptr) { - sysargs[numStack] = x - numStack++ - } - addInt = addStack - addFloat = addStack - } - - var keepAlive []any - defer func() { - runtime.KeepAlive(keepAlive) - runtime.KeepAlive(args) - }() - - var arm64_r8 uintptr - if ty.NumOut() == 1 && ty.Out(0).Kind() == reflect.Struct { - outType := ty.Out(0) - if (runtime.GOARCH == "amd64" || runtime.GOARCH == "loong64" || runtime.GOARCH == "ppc64le" || runtime.GOARCH == "riscv64" || runtime.GOARCH == "s390x") && outType.Size() > maxRegAllocStructSize { - val := reflect.New(outType) - keepAlive = append(keepAlive, val) - addInt(val.Pointer()) - } else if runtime.GOARCH == "arm64" && outType.Size() > maxRegAllocStructSize { - isAllFloats, numFields := isAllSameFloat(outType) - if !isAllFloats || numFields > 4 { - val := reflect.New(outType) - keepAlive = append(keepAlive, val) - arm64_r8 = val.Pointer() - } - } - } - for i, v := range args { - if variadic, ok := xreflect.TypeAssert[[]any](args[i]); ok { - if i != len(args)-1 { - panic("purego: can only expand last parameter") - } - for _, x := range variadic { - keepAlive = addValue(reflect.ValueOf(x), keepAlive, addInt, addFloat, addStack, &numInts, &numFloats, &numStack) - } - continue - } - // Check if we need to start Darwin ARM64 C-style stack packing - if runtime.GOARCH == "arm64" && runtime.GOOS == "darwin" && shouldBundleStackArgs(v, numInts, numFloats) { - // Collect and separate remaining args into register vs stack - stackArgs, newKeepAlive := collectStackArgs(args, i, numInts, numFloats, - keepAlive, addInt, addFloat, addStack, &numInts, &numFloats, &numStack) - keepAlive = newKeepAlive - - // Bundle stack arguments with C-style packing - bundleStackArgs(stackArgs, addStack) - break - } - keepAlive = addValue(v, keepAlive, addInt, addFloat, addStack, &numInts, &numFloats, &numStack) - } - - syscall := thePool.Get().(*syscall15Args) - defer thePool.Put(syscall) - - if runtime.GOARCH == "loong64" || runtime.GOARCH == "ppc64le" || runtime.GOARCH == "riscv64" || runtime.GOARCH == "s390x" { - syscall.Set(cfn, sysargs[:], floats[:], 0) - runtime_cgocall(syscall15XABI0, unsafe.Pointer(syscall)) - } else if runtime.GOARCH == "arm64" || runtime.GOOS != "windows" { - // Use the normal arm64 calling convention even on Windows - syscall.Set(cfn, sysargs[:], floats[:], arm64_r8) - runtime_cgocall(syscall15XABI0, unsafe.Pointer(syscall)) - } else { - *syscall = syscall15Args{} - // This is a fallback for Windows amd64, 386, and arm. Note this may not support floats - syscall.a1, syscall.a2, _ = syscall_syscall15X(cfn, sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4], - sysargs[5], sysargs[6], sysargs[7], sysargs[8], sysargs[9], sysargs[10], sysargs[11], - sysargs[12], sysargs[13], sysargs[14]) - syscall.f1 = syscall.a2 // on amd64 a2 stores the float return. On 32bit platforms floats aren't support - } - if ty.NumOut() == 0 { - return nil - } - outType := ty.Out(0) - v := reflect.New(outType).Elem() - switch outType.Kind() { - case reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - v.SetUint(uint64(syscall.a1)) - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - v.SetInt(int64(syscall.a1)) - case reflect.Bool: - v.SetBool(byte(syscall.a1) != 0) - case reflect.UnsafePointer: - // We take the address and then dereference it to trick go vet from creating a possible miss-use of unsafe.Pointer - v.SetPointer(*(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1))) - case reflect.Ptr: - v = reflect.NewAt(outType, unsafe.Pointer(&syscall.a1)).Elem() - case reflect.Func: - // wrap this C function in a nicely typed Go function - v = reflect.New(outType) - RegisterFunc(v.Interface(), syscall.a1) - case reflect.String: - v.SetString(strings.GoString(syscall.a1)) - case reflect.Float32: - // NOTE: syscall.r2 is only the floating return value on 64bit platforms. - // On 32bit platforms syscall.r2 is the upper part of a 64bit return. - // On 386, x87 FPU returns floats as float64 in ST(0), so we read as float64 and convert. - // On PPC64LE, C ABI converts float32 to double in FPR, so we read as float64. - // On S390X (big-endian), float32 is in upper 32 bits of the 64-bit FP register. - switch runtime.GOARCH { - case "386": - v.SetFloat(math.Float64frombits(uint64(syscall.f1) | (uint64(syscall.f2) << 32))) - case "ppc64le": - v.SetFloat(math.Float64frombits(uint64(syscall.f1))) - case "s390x": - // S390X is big-endian: float32 in upper 32 bits of 64-bit register - v.SetFloat(float64(math.Float32frombits(uint32(syscall.f1 >> 32)))) - default: - v.SetFloat(float64(math.Float32frombits(uint32(syscall.f1)))) - } - case reflect.Float64: - // NOTE: syscall.r2 is only the floating return value on 64bit platforms. - // On 32bit platforms syscall.r2 is the upper part of a 64bit return. - if is32bit { - v.SetFloat(math.Float64frombits(uint64(syscall.f1) | (uint64(syscall.f2) << 32))) - } else { - v.SetFloat(math.Float64frombits(uint64(syscall.f1))) - } - case reflect.Struct: - v = getStruct(outType, *syscall) - default: - panic("purego: unsupported return kind: " + outType.Kind().String()) - } - if len(args) > 0 { - // reuse args slice instead of allocating one when possible - args[0] = v - return args[:1] - } else { - return []reflect.Value{v} - } - }) - fn.Set(v) -} - -func addValue(v reflect.Value, keepAlive []any, addInt func(x uintptr), addFloat func(x uintptr), addStack func(x uintptr), numInts *int, numFloats *int, numStack *int) []any { - const is32bit = unsafe.Sizeof(uintptr(0)) == 4 - switch v.Kind() { - case reflect.String: - ptr := strings.CString(v.String()) - keepAlive = append(keepAlive, ptr) - addInt(uintptr(unsafe.Pointer(ptr))) - case reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - addInt(uintptr(v.Uint())) - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - addInt(uintptr(v.Int())) - case reflect.Ptr, reflect.UnsafePointer, reflect.Slice: - // There is no need to keepAlive this pointer separately because it is kept alive in the args variable - addInt(v.Pointer()) - case reflect.Func: - addInt(NewCallback(v.Interface())) - case reflect.Bool: - if v.Bool() { - addInt(1) - } else { - addInt(0) - } - case reflect.Float32: - // On S390X big-endian, float32 goes in upper 32 bits of 64-bit FP register - if runtime.GOARCH == "s390x" { - addFloat(uintptr(math.Float32bits(float32(v.Float()))) << 32) - } else { - addFloat(uintptr(math.Float32bits(float32(v.Float())))) - } - case reflect.Float64: - if is32bit { - bits := math.Float64bits(v.Float()) - addFloat(uintptr(bits)) - addFloat(uintptr(bits >> 32)) - } else { - addFloat(uintptr(math.Float64bits(v.Float()))) - } - case reflect.Struct: - keepAlive = addStruct(v, numInts, numFloats, numStack, addInt, addFloat, addStack, keepAlive) - default: - panic("purego: unsupported kind: " + v.Kind().String()) - } - return keepAlive -} - -// maxRegAllocStructSize is the biggest a struct can be while still fitting in registers. -// if it is bigger than this than enough space must be allocated on the heap and then passed into -// the function as the first parameter on amd64 or in R8 on arm64. -// -// If you change this make sure to update it in objc_runtime_darwin.go -const maxRegAllocStructSize = 16 - -func isAllSameFloat(ty reflect.Type) (allFloats bool, numFields int) { - allFloats = true - root := ty.Field(0).Type - for root.Kind() == reflect.Struct { - root = root.Field(0).Type - } - first := root.Kind() - if first != reflect.Float32 && first != reflect.Float64 { - allFloats = false - } - for i := 0; i < ty.NumField(); i++ { - f := ty.Field(i).Type - if f.Kind() == reflect.Struct { - var structNumFields int - allFloats, structNumFields = isAllSameFloat(f) - numFields += structNumFields - continue - } - numFields++ - if f.Kind() != first { - allFloats = false - } - } - return allFloats, numFields -} - -func checkStructFieldsSupported(ty reflect.Type) { - for i := 0; i < ty.NumField(); i++ { - f := ty.Field(i).Type - if f.Kind() == reflect.Array { - f = f.Elem() - } else if f.Kind() == reflect.Struct { - checkStructFieldsSupported(f) - continue - } - switch f.Kind() { - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, - reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, - reflect.Uintptr, reflect.Ptr, reflect.UnsafePointer, reflect.Float64, reflect.Float32, - reflect.Bool: - default: - panic(fmt.Sprintf("purego: struct field type %s is not supported", f)) - } - } -} - -func ensureStructSupportedForRegisterFunc() { - if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" { - panic("purego: struct arguments are only supported on amd64 and arm64") - } - if runtime.GOOS != "darwin" && runtime.GOOS != "linux" { - panic("purego: struct arguments are only supported on darwin and linux") - } -} - -func roundUpTo8(val uintptr) uintptr { - return (val + align8ByteMask) &^ align8ByteMask -} - -func numOfFloatRegisters() int { - switch runtime.GOARCH { - case "amd64", "arm64", "loong64", "ppc64le", "riscv64": - return 8 - case "s390x": - return 4 - case "arm": - return 16 - case "386": - // i386 SysV ABI passes all arguments on the stack, including floats - return 0 - default: - // since this platform isn't supported and can therefore only access - // integer registers it is safest to return 8 - return 8 - } -} - -func numOfIntegerRegisters() int { - switch runtime.GOARCH { - case "arm64", "loong64", "ppc64le", "riscv64": - return 8 - case "amd64": - return 6 - case "s390x": - // S390X uses R2-R6 for integer arguments - return 5 - case "arm": - return 4 - case "386": - // i386 SysV ABI passes all arguments on the stack - return 0 - default: - // since this platform isn't supported and can therefore only access - // integer registers it is fine to return the maxArgs - return maxArgs - } -} - -// estimateStackBytes estimates stack bytes needed for Darwin ARM64 validation. -// This is a conservative estimate used only for early error detection. -func estimateStackBytes(ty reflect.Type) int { - var numInts, numFloats int - var stackBytes int - - for i := 0; i < ty.NumIn(); i++ { - arg := ty.In(i) - size := int(arg.Size()) - - // Check if this goes to register or stack - usesInt := arg.Kind() != reflect.Float32 && arg.Kind() != reflect.Float64 - if usesInt && numInts < numOfIntegerRegisters() { - numInts++ - } else if !usesInt && numFloats < numOfFloatRegisters() { - numFloats++ - } else { - // Goes to stack - accumulate total bytes - stackBytes += size - } - } - // Round total to 8-byte boundary - if stackBytes > 0 && stackBytes%align8ByteSize != 0 { - stackBytes = int(roundUpTo8(uintptr(stackBytes))) - } - return stackBytes -} diff --git a/vendor/github.com/ebitengine/purego/gen.go b/vendor/github.com/ebitengine/purego/gen.go deleted file mode 100644 index 9cb7c45356d..00000000000 --- a/vendor/github.com/ebitengine/purego/gen.go +++ /dev/null @@ -1,6 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2025 The Ebitengine Authors - -package purego - -//go:generate go run wincallback.go diff --git a/vendor/github.com/ebitengine/purego/go_runtime.go b/vendor/github.com/ebitengine/purego/go_runtime.go deleted file mode 100644 index b327f786918..00000000000 --- a/vendor/github.com/ebitengine/purego/go_runtime.go +++ /dev/null @@ -1,13 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build darwin || freebsd || linux || netbsd || windows - -package purego - -import ( - "unsafe" -) - -//go:linkname runtime_cgocall runtime.cgocall -func runtime_cgocall(fn uintptr, arg unsafe.Pointer) int32 // from runtime/sys_libc.go diff --git a/vendor/github.com/ebitengine/purego/internal/cgo/dlfcn_cgo_unix.go b/vendor/github.com/ebitengine/purego/internal/cgo/dlfcn_cgo_unix.go deleted file mode 100644 index 6d0571abbd0..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/cgo/dlfcn_cgo_unix.go +++ /dev/null @@ -1,56 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2024 The Ebitengine Authors - -//go:build freebsd || linux || netbsd - -package cgo - -/* -#cgo !netbsd LDFLAGS: -ldl - -#include -#include -*/ -import "C" - -import ( - "errors" - "unsafe" -) - -func Dlopen(filename string, flag int) (uintptr, error) { - cfilename := C.CString(filename) - defer C.free(unsafe.Pointer(cfilename)) - handle := C.dlopen(cfilename, C.int(flag)) - if handle == nil { - return 0, errors.New(C.GoString(C.dlerror())) - } - return uintptr(handle), nil -} - -func Dlsym(handle uintptr, symbol string) (uintptr, error) { - csymbol := C.CString(symbol) - defer C.free(unsafe.Pointer(csymbol)) - symbolAddr := C.dlsym(*(*unsafe.Pointer)(unsafe.Pointer(&handle)), csymbol) - if symbolAddr == nil { - return 0, errors.New(C.GoString(C.dlerror())) - } - return uintptr(symbolAddr), nil -} - -func Dlclose(handle uintptr) error { - result := C.dlclose(*(*unsafe.Pointer)(unsafe.Pointer(&handle))) - if result != 0 { - return errors.New(C.GoString(C.dlerror())) - } - return nil -} - -// all that is needed is to assign each dl function because then its -// symbol will then be made available to the linker and linked to inside dlfcn.go -var ( - _ = C.dlopen - _ = C.dlsym - _ = C.dlerror - _ = C.dlclose -) diff --git a/vendor/github.com/ebitengine/purego/internal/cgo/empty.go b/vendor/github.com/ebitengine/purego/internal/cgo/empty.go deleted file mode 100644 index 1d7cffe2a7e..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/cgo/empty.go +++ /dev/null @@ -1,6 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2024 The Ebitengine Authors - -package cgo - -// Empty so that importing this package doesn't cause issue for certain platforms. diff --git a/vendor/github.com/ebitengine/purego/internal/cgo/syscall_cgo_unix.go b/vendor/github.com/ebitengine/purego/internal/cgo/syscall_cgo_unix.go deleted file mode 100644 index 1e39de3b678..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/cgo/syscall_cgo_unix.go +++ /dev/null @@ -1,55 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build freebsd || (linux && !(386 || amd64 || arm || arm64 || loong64 || ppc64le || riscv64)) || netbsd - -package cgo - -// this file is placed inside internal/cgo and not package purego -// because Cgo and assembly files can't be in the same package. - -/* -#cgo !netbsd LDFLAGS: -ldl - -#include -#include -#include -#include - -typedef struct syscall15Args { - uintptr_t fn; - uintptr_t a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15; - uintptr_t f1, f2, f3, f4, f5, f6, f7, f8; - uintptr_t err; -} syscall15Args; - -void syscall15(struct syscall15Args *args) { - assert((args->f1|args->f2|args->f3|args->f4|args->f5|args->f6|args->f7|args->f8) == 0); - uintptr_t (*func_name)(uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6, - uintptr_t a7, uintptr_t a8, uintptr_t a9, uintptr_t a10, uintptr_t a11, uintptr_t a12, - uintptr_t a13, uintptr_t a14, uintptr_t a15); - *(void**)(&func_name) = (void*)(args->fn); - uintptr_t r1 = func_name(args->a1,args->a2,args->a3,args->a4,args->a5,args->a6,args->a7,args->a8,args->a9, - args->a10,args->a11,args->a12,args->a13,args->a14,args->a15); - args->a1 = r1; - args->err = errno; -} - -*/ -import "C" -import "unsafe" - -// assign purego.syscall15XABI0 to the C version of this function. -var Syscall15XABI0 = unsafe.Pointer(C.syscall15) - -//go:nosplit -func Syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) { - args := C.syscall15Args{ - C.uintptr_t(fn), C.uintptr_t(a1), C.uintptr_t(a2), C.uintptr_t(a3), - C.uintptr_t(a4), C.uintptr_t(a5), C.uintptr_t(a6), - C.uintptr_t(a7), C.uintptr_t(a8), C.uintptr_t(a9), C.uintptr_t(a10), C.uintptr_t(a11), C.uintptr_t(a12), - C.uintptr_t(a13), C.uintptr_t(a14), C.uintptr_t(a15), 0, 0, 0, 0, 0, 0, 0, 0, 0, - } - C.syscall15(&args) - return uintptr(args.a1), 0, uintptr(args.err) -} diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/abi_amd64.h b/vendor/github.com/ebitengine/purego/internal/fakecgo/abi_amd64.h deleted file mode 100644 index 9949435fe9e..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/abi_amd64.h +++ /dev/null @@ -1,99 +0,0 @@ -// Copyright 2021 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. - -// Macros for transitioning from the host ABI to Go ABI0. -// -// These save the frame pointer, so in general, functions that use -// these should have zero frame size to suppress the automatic frame -// pointer, though it's harmless to not do this. - -#ifdef GOOS_windows - -// REGS_HOST_TO_ABI0_STACK is the stack bytes used by -// PUSH_REGS_HOST_TO_ABI0. -#define REGS_HOST_TO_ABI0_STACK (28*8 + 8) - -// PUSH_REGS_HOST_TO_ABI0 prepares for transitioning from -// the host ABI to Go ABI0 code. It saves all registers that are -// callee-save in the host ABI and caller-save in Go ABI0 and prepares -// for entry to Go. -// -// Save DI SI BP BX R12 R13 R14 R15 X6-X15 registers and the DF flag. -// Clear the DF flag for the Go ABI. -// MXCSR matches the Go ABI, so we don't have to set that, -// and Go doesn't modify it, so we don't have to save it. -#define PUSH_REGS_HOST_TO_ABI0() \ - PUSHFQ \ - CLD \ - ADJSP $(REGS_HOST_TO_ABI0_STACK - 8) \ - MOVQ DI, (0*0)(SP) \ - MOVQ SI, (1*8)(SP) \ - MOVQ BP, (2*8)(SP) \ - MOVQ BX, (3*8)(SP) \ - MOVQ R12, (4*8)(SP) \ - MOVQ R13, (5*8)(SP) \ - MOVQ R14, (6*8)(SP) \ - MOVQ R15, (7*8)(SP) \ - MOVUPS X6, (8*8)(SP) \ - MOVUPS X7, (10*8)(SP) \ - MOVUPS X8, (12*8)(SP) \ - MOVUPS X9, (14*8)(SP) \ - MOVUPS X10, (16*8)(SP) \ - MOVUPS X11, (18*8)(SP) \ - MOVUPS X12, (20*8)(SP) \ - MOVUPS X13, (22*8)(SP) \ - MOVUPS X14, (24*8)(SP) \ - MOVUPS X15, (26*8)(SP) - -#define POP_REGS_HOST_TO_ABI0() \ - MOVQ (0*0)(SP), DI \ - MOVQ (1*8)(SP), SI \ - MOVQ (2*8)(SP), BP \ - MOVQ (3*8)(SP), BX \ - MOVQ (4*8)(SP), R12 \ - MOVQ (5*8)(SP), R13 \ - MOVQ (6*8)(SP), R14 \ - MOVQ (7*8)(SP), R15 \ - MOVUPS (8*8)(SP), X6 \ - MOVUPS (10*8)(SP), X7 \ - MOVUPS (12*8)(SP), X8 \ - MOVUPS (14*8)(SP), X9 \ - MOVUPS (16*8)(SP), X10 \ - MOVUPS (18*8)(SP), X11 \ - MOVUPS (20*8)(SP), X12 \ - MOVUPS (22*8)(SP), X13 \ - MOVUPS (24*8)(SP), X14 \ - MOVUPS (26*8)(SP), X15 \ - ADJSP $-(REGS_HOST_TO_ABI0_STACK - 8) \ - POPFQ - -#else -// SysV ABI - -#define REGS_HOST_TO_ABI0_STACK (6*8) - -// SysV MXCSR matches the Go ABI, so we don't have to set that, -// and Go doesn't modify it, so we don't have to save it. -// Both SysV and Go require DF to be cleared, so that's already clear. -// The SysV and Go frame pointer conventions are compatible. -#define PUSH_REGS_HOST_TO_ABI0() \ - ADJSP $(REGS_HOST_TO_ABI0_STACK) \ - MOVQ BP, (5*8)(SP) \ - LEAQ (5*8)(SP), BP \ - MOVQ BX, (0*8)(SP) \ - MOVQ R12, (1*8)(SP) \ - MOVQ R13, (2*8)(SP) \ - MOVQ R14, (3*8)(SP) \ - MOVQ R15, (4*8)(SP) - -#define POP_REGS_HOST_TO_ABI0() \ - MOVQ (0*8)(SP), BX \ - MOVQ (1*8)(SP), R12 \ - MOVQ (2*8)(SP), R13 \ - MOVQ (3*8)(SP), R14 \ - MOVQ (4*8)(SP), R15 \ - MOVQ (5*8)(SP), BP \ - ADJSP $-(REGS_HOST_TO_ABI0_STACK) - -#endif diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/abi_arm64.h b/vendor/github.com/ebitengine/purego/internal/fakecgo/abi_arm64.h deleted file mode 100644 index 5d5061ec1db..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/abi_arm64.h +++ /dev/null @@ -1,39 +0,0 @@ -// Copyright 2021 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. - -// Macros for transitioning from the host ABI to Go ABI0. -// -// These macros save and restore the callee-saved registers -// from the stack, but they don't adjust stack pointer, so -// the user should prepare stack space in advance. -// SAVE_R19_TO_R28(offset) saves R19 ~ R28 to the stack space -// of ((offset)+0*8)(RSP) ~ ((offset)+9*8)(RSP). -// -// SAVE_F8_TO_F15(offset) saves F8 ~ F15 to the stack space -// of ((offset)+0*8)(RSP) ~ ((offset)+7*8)(RSP). -// -// R29 is not saved because Go will save and restore it. - -#define SAVE_R19_TO_R28(offset) \ - STP (R19, R20), ((offset)+0*8)(RSP) \ - STP (R21, R22), ((offset)+2*8)(RSP) \ - STP (R23, R24), ((offset)+4*8)(RSP) \ - STP (R25, R26), ((offset)+6*8)(RSP) \ - STP (R27, g), ((offset)+8*8)(RSP) -#define RESTORE_R19_TO_R28(offset) \ - LDP ((offset)+0*8)(RSP), (R19, R20) \ - LDP ((offset)+2*8)(RSP), (R21, R22) \ - LDP ((offset)+4*8)(RSP), (R23, R24) \ - LDP ((offset)+6*8)(RSP), (R25, R26) \ - LDP ((offset)+8*8)(RSP), (R27, g) /* R28 */ -#define SAVE_F8_TO_F15(offset) \ - FSTPD (F8, F9), ((offset)+0*8)(RSP) \ - FSTPD (F10, F11), ((offset)+2*8)(RSP) \ - FSTPD (F12, F13), ((offset)+4*8)(RSP) \ - FSTPD (F14, F15), ((offset)+6*8)(RSP) -#define RESTORE_F8_TO_F15(offset) \ - FLDPD ((offset)+0*8)(RSP), (F8, F9) \ - FLDPD ((offset)+2*8)(RSP), (F10, F11) \ - FLDPD ((offset)+4*8)(RSP), (F12, F13) \ - FLDPD ((offset)+6*8)(RSP), (F14, F15) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/abi_loong64.h b/vendor/github.com/ebitengine/purego/internal/fakecgo/abi_loong64.h deleted file mode 100644 index b10d83732f1..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/abi_loong64.h +++ /dev/null @@ -1,60 +0,0 @@ -// Copyright 2022 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. - -// Macros for transitioning from the host ABI to Go ABI0. -// -// These macros save and restore the callee-saved registers -// from the stack, but they don't adjust stack pointer, so -// the user should prepare stack space in advance. -// SAVE_R22_TO_R31(offset) saves R22 ~ R31 to the stack space -// of ((offset)+0*8)(R3) ~ ((offset)+9*8)(R3). -// -// SAVE_F24_TO_F31(offset) saves F24 ~ F31 to the stack space -// of ((offset)+0*8)(R3) ~ ((offset)+7*8)(R3). -// -// Note: g is R22 - -#define SAVE_R22_TO_R31(offset) \ - MOVV g, ((offset)+(0*8))(R3) \ - MOVV R23, ((offset)+(1*8))(R3) \ - MOVV R24, ((offset)+(2*8))(R3) \ - MOVV R25, ((offset)+(3*8))(R3) \ - MOVV R26, ((offset)+(4*8))(R3) \ - MOVV R27, ((offset)+(5*8))(R3) \ - MOVV R28, ((offset)+(6*8))(R3) \ - MOVV R29, ((offset)+(7*8))(R3) \ - MOVV R30, ((offset)+(8*8))(R3) \ - MOVV R31, ((offset)+(9*8))(R3) - -#define SAVE_F24_TO_F31(offset) \ - MOVD F24, ((offset)+(0*8))(R3) \ - MOVD F25, ((offset)+(1*8))(R3) \ - MOVD F26, ((offset)+(2*8))(R3) \ - MOVD F27, ((offset)+(3*8))(R3) \ - MOVD F28, ((offset)+(4*8))(R3) \ - MOVD F29, ((offset)+(5*8))(R3) \ - MOVD F30, ((offset)+(6*8))(R3) \ - MOVD F31, ((offset)+(7*8))(R3) - -#define RESTORE_R22_TO_R31(offset) \ - MOVV ((offset)+(0*8))(R3), g \ - MOVV ((offset)+(1*8))(R3), R23 \ - MOVV ((offset)+(2*8))(R3), R24 \ - MOVV ((offset)+(3*8))(R3), R25 \ - MOVV ((offset)+(4*8))(R3), R26 \ - MOVV ((offset)+(5*8))(R3), R27 \ - MOVV ((offset)+(6*8))(R3), R28 \ - MOVV ((offset)+(7*8))(R3), R29 \ - MOVV ((offset)+(8*8))(R3), R30 \ - MOVV ((offset)+(9*8))(R3), R31 - -#define RESTORE_F24_TO_F31(offset) \ - MOVD ((offset)+(0*8))(R3), F24 \ - MOVD ((offset)+(1*8))(R3), F25 \ - MOVD ((offset)+(2*8))(R3), F26 \ - MOVD ((offset)+(3*8))(R3), F27 \ - MOVD ((offset)+(4*8))(R3), F28 \ - MOVD ((offset)+(5*8))(R3), F29 \ - MOVD ((offset)+(6*8))(R3), F30 \ - MOVD ((offset)+(7*8))(R3), F31 diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/abi_ppc64x.h b/vendor/github.com/ebitengine/purego/internal/fakecgo/abi_ppc64x.h deleted file mode 100644 index 245a5266f6e..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/abi_ppc64x.h +++ /dev/null @@ -1,195 +0,0 @@ -// Copyright 2023 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. - -// Macros for transitioning from the host ABI to Go ABI -// -// On PPC64/ELFv2 targets, the following registers are callee -// saved when called from C. They must be preserved before -// calling into Go which does not preserve any of them. -// -// R14-R31 -// CR2-4 -// VR20-31 -// F14-F31 -// -// xcoff(aix) and ELFv1 are similar, but may only require a -// subset of these. -// -// These macros assume a 16 byte aligned stack pointer. This -// is required by ELFv1, ELFv2, and AIX PPC64. - -#define SAVE_GPR_SIZE (18*8) -#define SAVE_GPR(offset) \ - MOVD R14, (offset+8*0)(R1) \ - MOVD R15, (offset+8*1)(R1) \ - MOVD R16, (offset+8*2)(R1) \ - MOVD R17, (offset+8*3)(R1) \ - MOVD R18, (offset+8*4)(R1) \ - MOVD R19, (offset+8*5)(R1) \ - MOVD R20, (offset+8*6)(R1) \ - MOVD R21, (offset+8*7)(R1) \ - MOVD R22, (offset+8*8)(R1) \ - MOVD R23, (offset+8*9)(R1) \ - MOVD R24, (offset+8*10)(R1) \ - MOVD R25, (offset+8*11)(R1) \ - MOVD R26, (offset+8*12)(R1) \ - MOVD R27, (offset+8*13)(R1) \ - MOVD R28, (offset+8*14)(R1) \ - MOVD R29, (offset+8*15)(R1) \ - MOVD g, (offset+8*16)(R1) \ - MOVD R31, (offset+8*17)(R1) - -#define RESTORE_GPR(offset) \ - MOVD (offset+8*0)(R1), R14 \ - MOVD (offset+8*1)(R1), R15 \ - MOVD (offset+8*2)(R1), R16 \ - MOVD (offset+8*3)(R1), R17 \ - MOVD (offset+8*4)(R1), R18 \ - MOVD (offset+8*5)(R1), R19 \ - MOVD (offset+8*6)(R1), R20 \ - MOVD (offset+8*7)(R1), R21 \ - MOVD (offset+8*8)(R1), R22 \ - MOVD (offset+8*9)(R1), R23 \ - MOVD (offset+8*10)(R1), R24 \ - MOVD (offset+8*11)(R1), R25 \ - MOVD (offset+8*12)(R1), R26 \ - MOVD (offset+8*13)(R1), R27 \ - MOVD (offset+8*14)(R1), R28 \ - MOVD (offset+8*15)(R1), R29 \ - MOVD (offset+8*16)(R1), g \ - MOVD (offset+8*17)(R1), R31 - -#define SAVE_FPR_SIZE (18*8) -#define SAVE_FPR(offset) \ - FMOVD F14, (offset+8*0)(R1) \ - FMOVD F15, (offset+8*1)(R1) \ - FMOVD F16, (offset+8*2)(R1) \ - FMOVD F17, (offset+8*3)(R1) \ - FMOVD F18, (offset+8*4)(R1) \ - FMOVD F19, (offset+8*5)(R1) \ - FMOVD F20, (offset+8*6)(R1) \ - FMOVD F21, (offset+8*7)(R1) \ - FMOVD F22, (offset+8*8)(R1) \ - FMOVD F23, (offset+8*9)(R1) \ - FMOVD F24, (offset+8*10)(R1) \ - FMOVD F25, (offset+8*11)(R1) \ - FMOVD F26, (offset+8*12)(R1) \ - FMOVD F27, (offset+8*13)(R1) \ - FMOVD F28, (offset+8*14)(R1) \ - FMOVD F29, (offset+8*15)(R1) \ - FMOVD F30, (offset+8*16)(R1) \ - FMOVD F31, (offset+8*17)(R1) - -#define RESTORE_FPR(offset) \ - FMOVD (offset+8*0)(R1), F14 \ - FMOVD (offset+8*1)(R1), F15 \ - FMOVD (offset+8*2)(R1), F16 \ - FMOVD (offset+8*3)(R1), F17 \ - FMOVD (offset+8*4)(R1), F18 \ - FMOVD (offset+8*5)(R1), F19 \ - FMOVD (offset+8*6)(R1), F20 \ - FMOVD (offset+8*7)(R1), F21 \ - FMOVD (offset+8*8)(R1), F22 \ - FMOVD (offset+8*9)(R1), F23 \ - FMOVD (offset+8*10)(R1), F24 \ - FMOVD (offset+8*11)(R1), F25 \ - FMOVD (offset+8*12)(R1), F26 \ - FMOVD (offset+8*13)(R1), F27 \ - FMOVD (offset+8*14)(R1), F28 \ - FMOVD (offset+8*15)(R1), F29 \ - FMOVD (offset+8*16)(R1), F30 \ - FMOVD (offset+8*17)(R1), F31 - -// Save and restore VR20-31 (aka VSR56-63). These -// macros must point to a 16B aligned offset. -#define SAVE_VR_SIZE (12*16) -#define SAVE_VR(offset, rtmp) \ - MOVD $(offset+16*0), rtmp \ - STVX V20, (rtmp)(R1) \ - MOVD $(offset+16*1), rtmp \ - STVX V21, (rtmp)(R1) \ - MOVD $(offset+16*2), rtmp \ - STVX V22, (rtmp)(R1) \ - MOVD $(offset+16*3), rtmp \ - STVX V23, (rtmp)(R1) \ - MOVD $(offset+16*4), rtmp \ - STVX V24, (rtmp)(R1) \ - MOVD $(offset+16*5), rtmp \ - STVX V25, (rtmp)(R1) \ - MOVD $(offset+16*6), rtmp \ - STVX V26, (rtmp)(R1) \ - MOVD $(offset+16*7), rtmp \ - STVX V27, (rtmp)(R1) \ - MOVD $(offset+16*8), rtmp \ - STVX V28, (rtmp)(R1) \ - MOVD $(offset+16*9), rtmp \ - STVX V29, (rtmp)(R1) \ - MOVD $(offset+16*10), rtmp \ - STVX V30, (rtmp)(R1) \ - MOVD $(offset+16*11), rtmp \ - STVX V31, (rtmp)(R1) - -#define RESTORE_VR(offset, rtmp) \ - MOVD $(offset+16*0), rtmp \ - LVX (rtmp)(R1), V20 \ - MOVD $(offset+16*1), rtmp \ - LVX (rtmp)(R1), V21 \ - MOVD $(offset+16*2), rtmp \ - LVX (rtmp)(R1), V22 \ - MOVD $(offset+16*3), rtmp \ - LVX (rtmp)(R1), V23 \ - MOVD $(offset+16*4), rtmp \ - LVX (rtmp)(R1), V24 \ - MOVD $(offset+16*5), rtmp \ - LVX (rtmp)(R1), V25 \ - MOVD $(offset+16*6), rtmp \ - LVX (rtmp)(R1), V26 \ - MOVD $(offset+16*7), rtmp \ - LVX (rtmp)(R1), V27 \ - MOVD $(offset+16*8), rtmp \ - LVX (rtmp)(R1), V28 \ - MOVD $(offset+16*9), rtmp \ - LVX (rtmp)(R1), V29 \ - MOVD $(offset+16*10), rtmp \ - LVX (rtmp)(R1), V30 \ - MOVD $(offset+16*11), rtmp \ - LVX (rtmp)(R1), V31 - -// LR and CR are saved in the caller's frame. The callee must -// make space for all other callee-save registers. -#define SAVE_ALL_REG_SIZE (SAVE_GPR_SIZE+SAVE_FPR_SIZE+SAVE_VR_SIZE) - -// Stack a frame and save all callee-save registers following the -// host OS's ABI. Fortunately, this is identical for AIX, ELFv1, and -// ELFv2. All host ABIs require the stack pointer to maintain 16 byte -// alignment, and save the callee-save registers in the same places. -// -// To restate, R1 is assumed to be aligned when this macro is used. -// This assumes the caller's frame is compliant with the host ABI. -// CR and LR are saved into the caller's frame per the host ABI. -// R0 is initialized to $0 as expected by Go. -#define STACK_AND_SAVE_HOST_TO_GO_ABI(extra) \ - MOVD LR, R0 \ - MOVD R0, 16(R1) \ - MOVW CR, R0 \ - MOVD R0, 8(R1) \ - MOVDU R1, -(extra)-FIXED_FRAME-SAVE_ALL_REG_SIZE(R1) \ - SAVE_GPR(extra+FIXED_FRAME) \ - SAVE_FPR(extra+FIXED_FRAME+SAVE_GPR_SIZE) \ - SAVE_VR(extra+FIXED_FRAME+SAVE_GPR_SIZE+SAVE_FPR_SIZE, R0) \ - MOVD $0, R0 - -// This unstacks the frame, restoring all callee-save registers -// as saved by STACK_AND_SAVE_HOST_TO_GO_ABI. -// -// R0 is not guaranteed to contain $0 after this macro. -#define UNSTACK_AND_RESTORE_GO_TO_HOST_ABI(extra) \ - RESTORE_GPR(extra+FIXED_FRAME) \ - RESTORE_FPR(extra+FIXED_FRAME+SAVE_GPR_SIZE) \ - RESTORE_VR(extra+FIXED_FRAME+SAVE_GPR_SIZE+SAVE_FPR_SIZE, R0) \ - ADD $(extra+FIXED_FRAME+SAVE_ALL_REG_SIZE), R1 \ - MOVD 16(R1), R0 \ - MOVD R0, LR \ - MOVD 8(R1), R0 \ - MOVW R0, CR diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_386.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_386.s deleted file mode 100644 index 7475ec8a0b2..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_386.s +++ /dev/null @@ -1,29 +0,0 @@ -// Copyright 2009 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. - -#include "textflag.h" - -// Called by C code generated by cmd/cgo. -// func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr) -// Saves C callee-saved registers and calls cgocallback with three arguments. -// fn is the PC of a func(a unsafe.Pointer) function. -TEXT crosscall2(SB), NOSPLIT, $28-16 - MOVL BP, 24(SP) - MOVL BX, 20(SP) - MOVL SI, 16(SP) - MOVL DI, 12(SP) - - MOVL ctxt+12(FP), AX - MOVL AX, 8(SP) - MOVL a+4(FP), AX - MOVL AX, 4(SP) - MOVL fn+0(FP), AX - MOVL AX, 0(SP) - CALL runtime·cgocallback(SB) - - MOVL 12(SP), DI - MOVL 16(SP), SI - MOVL 20(SP), BX - MOVL 24(SP), BP - RET diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_amd64.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_amd64.s deleted file mode 100644 index 2b7eb57f8ae..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_amd64.s +++ /dev/null @@ -1,39 +0,0 @@ -// Copyright 2009 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. - -#include "textflag.h" -#include "abi_amd64.h" - -// Called by C code generated by cmd/cgo. -// func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr) -// Saves C callee-saved registers and calls cgocallback with three arguments. -// fn is the PC of a func(a unsafe.Pointer) function. -// This signature is known to SWIG, so we can't change it. -TEXT crosscall2(SB), NOSPLIT, $0-0 - PUSH_REGS_HOST_TO_ABI0() - - // Make room for arguments to cgocallback. - ADJSP $0x18 - -#ifndef GOOS_windows - MOVQ DI, 0x0(SP) // fn - MOVQ SI, 0x8(SP) // arg - - // Skip n in DX. - MOVQ CX, 0x10(SP) // ctxt - -#else - MOVQ CX, 0x0(SP) // fn - MOVQ DX, 0x8(SP) // arg - - // Skip n in R8. - MOVQ R9, 0x10(SP) // ctxt - -#endif - - CALL runtime·cgocallback(SB) - - ADJSP $-0x18 - POP_REGS_HOST_TO_ABI0() - RET diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_arm.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_arm.s deleted file mode 100644 index 68034e6035a..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_arm.s +++ /dev/null @@ -1,52 +0,0 @@ -// Copyright 2012 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. - -#include "textflag.h" - -// Called by C code generated by cmd/cgo. -// func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr) -// Saves C callee-saved registers and calls cgocallback with three arguments. -// fn is the PC of a func(a unsafe.Pointer) function. -TEXT crosscall2(SB), NOSPLIT|NOFRAME, $0 - SUB $(8*9), R13 // Reserve space for the floating point registers. - - // The C arguments arrive in R0, R1, R2, and R3. We want to - // pass R0, R1, and R3 to Go, so we push those on the stack. - // Also, save C callee-save registers R4-R12. - MOVM.WP [R0, R1, R3, R4, R5, R6, R7, R8, R9, g, R11, R12], (R13) - - // Finally, save the link register R14. This also puts the - // arguments we pushed for cgocallback where they need to be, - // starting at 4(R13). - MOVW.W R14, -4(R13) - - // Save VFP callee-saved registers D8-D15 (same as S16-S31). - // Note: We always save these since we target hard-float ABI. - MOVD F8, (13*4+8*1)(R13) - MOVD F9, (13*4+8*2)(R13) - MOVD F10, (13*4+8*3)(R13) - MOVD F11, (13*4+8*4)(R13) - MOVD F12, (13*4+8*5)(R13) - MOVD F13, (13*4+8*6)(R13) - MOVD F14, (13*4+8*7)(R13) - MOVD F15, (13*4+8*8)(R13) - - BL runtime·load_g(SB) - - // We set up the arguments to cgocallback when saving registers above. - BL runtime·cgocallback(SB) - - MOVD (13*4+8*1)(R13), F8 - MOVD (13*4+8*2)(R13), F9 - MOVD (13*4+8*3)(R13), F10 - MOVD (13*4+8*4)(R13), F11 - MOVD (13*4+8*5)(R13), F12 - MOVD (13*4+8*6)(R13), F13 - MOVD (13*4+8*7)(R13), F14 - MOVD (13*4+8*8)(R13), F15 - - MOVW.P 4(R13), R14 - MOVM.IAW (R13), [R0, R1, R3, R4, R5, R6, R7, R8, R9, g, R11, R12] - ADD $(8*9), R13 - MOVW R14, R15 diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_arm64.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_arm64.s deleted file mode 100644 index 50e5261d922..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_arm64.s +++ /dev/null @@ -1,36 +0,0 @@ -// Copyright 2015 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. - -#include "textflag.h" -#include "abi_arm64.h" - -// Called by C code generated by cmd/cgo. -// func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr) -// Saves C callee-saved registers and calls cgocallback with three arguments. -// fn is the PC of a func(a unsafe.Pointer) function. -TEXT crosscall2(SB), NOSPLIT|NOFRAME, $0 -/* - * We still need to save all callee save register as before, and then - * push 3 args for fn (R0, R1, R3), skipping R2. - * Also note that at procedure entry in gc world, 8(RSP) will be the - * first arg. - */ - SUB $(8*24), RSP - STP (R0, R1), (8*1)(RSP) - MOVD R3, (8*3)(RSP) - - SAVE_R19_TO_R28(8*4) - SAVE_F8_TO_F15(8*14) - STP (R29, R30), (8*22)(RSP) - - // Initialize Go ABI environment - BL runtime·load_g(SB) - BL runtime·cgocallback(SB) - - RESTORE_R19_TO_R28(8*4) - RESTORE_F8_TO_F15(8*14) - LDP (8*22)(RSP), (R29, R30) - - ADD $(8*24), RSP - RET diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_loong64.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_loong64.s deleted file mode 100644 index e81df86a56e..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_loong64.s +++ /dev/null @@ -1,40 +0,0 @@ -// Copyright 2022 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. - -#include "textflag.h" -#include "abi_loong64.h" - -// Called by C code generated by cmd/cgo. -// func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr) -// Saves C callee-saved registers and calls cgocallback with three arguments. -// fn is the PC of a func(a unsafe.Pointer) function. -TEXT crosscall2(SB), NOSPLIT|NOFRAME, $0 -/* - * We still need to save all callee save register as before, and then - * push 3 args for fn (R4, R5, R7), skipping R6. - * Also note that at procedure entry in gc world, 8(R29) will be the - * first arg. - */ - - ADDV $(-23*8), R3 - MOVV R4, (1*8)(R3) // fn unsafe.Pointer - MOVV R5, (2*8)(R3) // a unsafe.Pointer - MOVV R7, (3*8)(R3) // ctxt uintptr - - SAVE_R22_TO_R31((4*8)) - SAVE_F24_TO_F31((14*8)) - MOVV R1, (22*8)(R3) - - // Initialize Go ABI environment - JAL runtime·load_g(SB) - - JAL runtime·cgocallback(SB) - - RESTORE_R22_TO_R31((4*8)) - RESTORE_F24_TO_F31((14*8)) - MOVV (22*8)(R3), R1 - - ADDV $(23*8), R3 - - RET diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_ppc64le.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_ppc64le.s deleted file mode 100644 index 6d1938cd8d8..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_ppc64le.s +++ /dev/null @@ -1,82 +0,0 @@ -// Copyright 2014 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. - -#include "textflag.h" -#include "abi_ppc64x.h" - -// Called by C code generated by cmd/cgo. -// func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr) -// Saves C callee-saved registers and calls cgocallback with three arguments. -// fn is the PC of a func(a unsafe.Pointer) function. -// -// This is a simplified version that only saves GPR and FPR registers, -// not vector registers. This keeps the stack frame smaller to avoid -// exceeding the nosplit stack limit. -// -// On PPC64LE ELFv2, callee-save registers are: -// R14-R31 (18 GPRs = 144 bytes) -// F14-F31 (18 FPRs = 144 bytes) -// CR2-CR4 (saved in CR field) -// -// Stack layout (must be 16-byte aligned): -// 32 (FIXED_FRAME) + 24 (args) + 144 (GPR) + 144 (FPR) = 344 -// Rounded to 352 for 16-byte alignment. - -#define FIXED_FRAME 32 -#define SAVE_SIZE 352 -#define GPR_OFFSET (FIXED_FRAME+24) -#define FPR_OFFSET (GPR_OFFSET+SAVE_GPR_SIZE) - -TEXT crosscall2(SB), NOSPLIT|NOFRAME, $0 - // Save LR and CR in caller's frame per ELFv2 ABI - MOVD LR, R0 - MOVD R0, 16(R1) - MOVW CR, R0 - MOVD R0, 8(R1) - - // Allocate our stack frame - MOVDU R1, -SAVE_SIZE(R1) - - // Save TOC (R2) in case needed - MOVD R2, 24(R1) - - // Save callee-save GPRs - SAVE_GPR(GPR_OFFSET) - - // Save callee-save FPRs - SAVE_FPR(FPR_OFFSET) - - // Initialize R0 to 0 as expected by Go - MOVD $0, R0 - - // Load the current g. - BL runtime·load_g(SB) - - // Set up arguments for cgocallback - MOVD R3, FIXED_FRAME+0(R1) // fn unsafe.Pointer - MOVD R4, FIXED_FRAME+8(R1) // a unsafe.Pointer - - // Skip R5 = n uint32 - MOVD R6, FIXED_FRAME+16(R1) // ctxt uintptr - BL runtime·cgocallback(SB) - - // Restore callee-save FPRs - RESTORE_FPR(FPR_OFFSET) - - // Restore callee-save GPRs - RESTORE_GPR(GPR_OFFSET) - - // Restore TOC - MOVD 24(R1), R2 - - // Deallocate stack frame - ADD $SAVE_SIZE, R1 - - // Restore LR and CR from caller's frame - MOVD 16(R1), R0 - MOVD R0, LR - MOVD 8(R1), R0 - MOVW R0, CR - - RET diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_riscv64.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_riscv64.s deleted file mode 100644 index acf82c1b5ae..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_riscv64.s +++ /dev/null @@ -1,78 +0,0 @@ -// Copyright 2020 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. - -#include "textflag.h" - -// Called by C code generated by cmd/cgo. -// func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr) -// Saves C callee-saved registers and calls cgocallback with three arguments. -// fn is the PC of a func(a unsafe.Pointer) function. -TEXT crosscall2(SB), NOSPLIT|NOFRAME, $0 -/* - * Push arguments for fn (X10, X11, X13), along with all callee-save - * registers. Note that at procedure entry the first argument is at - * 8(X2). - */ - ADD $(-8*29), X2 - MOV X10, (8*1)(X2) // fn unsafe.Pointer - MOV X11, (8*2)(X2) // a unsafe.Pointer - MOV X13, (8*3)(X2) // ctxt uintptr - MOV X8, (8*4)(X2) - MOV X9, (8*5)(X2) - MOV X18, (8*6)(X2) - MOV X19, (8*7)(X2) - MOV X20, (8*8)(X2) - MOV X21, (8*9)(X2) - MOV X22, (8*10)(X2) - MOV X23, (8*11)(X2) - MOV X24, (8*12)(X2) - MOV X25, (8*13)(X2) - MOV X26, (8*14)(X2) - MOV g, (8*15)(X2) - MOV X1, (8*16)(X2) - MOVD F8, (8*17)(X2) - MOVD F9, (8*18)(X2) - MOVD F18, (8*19)(X2) - MOVD F19, (8*20)(X2) - MOVD F20, (8*21)(X2) - MOVD F21, (8*22)(X2) - MOVD F22, (8*23)(X2) - MOVD F23, (8*24)(X2) - MOVD F24, (8*25)(X2) - MOVD F25, (8*26)(X2) - MOVD F26, (8*27)(X2) - MOVD F27, (8*28)(X2) - - // Initialize Go ABI environment - CALL runtime·load_g(SB) - CALL runtime·cgocallback(SB) - - MOV (8*4)(X2), X8 - MOV (8*5)(X2), X9 - MOV (8*6)(X2), X18 - MOV (8*7)(X2), X19 - MOV (8*8)(X2), X20 - MOV (8*9)(X2), X21 - MOV (8*10)(X2), X22 - MOV (8*11)(X2), X23 - MOV (8*12)(X2), X24 - MOV (8*13)(X2), X25 - MOV (8*14)(X2), X26 - MOV (8*15)(X2), g - MOV (8*16)(X2), X1 - MOVD (8*17)(X2), F8 - MOVD (8*18)(X2), F9 - MOVD (8*19)(X2), F18 - MOVD (8*20)(X2), F19 - MOVD (8*21)(X2), F20 - MOVD (8*22)(X2), F21 - MOVD (8*23)(X2), F22 - MOVD (8*24)(X2), F23 - MOVD (8*25)(X2), F24 - MOVD (8*26)(X2), F25 - MOVD (8*27)(X2), F26 - MOVD (8*28)(X2), F27 - ADD $(8*29), X2 - - RET diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_s390x.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_s390x.s deleted file mode 100644 index b64466501de..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/asm_s390x.s +++ /dev/null @@ -1,55 +0,0 @@ -// Copyright 2016 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. - -#include "textflag.h" - -// Called by C code generated by cmd/cgo. -// func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr) -// Saves C callee-saved registers and calls cgocallback with three arguments. -// fn is the PC of a func(a unsafe.Pointer) function. -TEXT crosscall2(SB), NOSPLIT|NOFRAME, $0 - // Start with standard C stack frame layout and linkage. - - // Save R6-R15 in the register save area of the calling function. - STMG R6, R15, 48(R15) - - // Allocate 96 bytes on the stack. - MOVD $-96(R15), R15 - - // Save F8-F15 in our stack frame. - FMOVD F8, 32(R15) - FMOVD F9, 40(R15) - FMOVD F10, 48(R15) - FMOVD F11, 56(R15) - FMOVD F12, 64(R15) - FMOVD F13, 72(R15) - FMOVD F14, 80(R15) - FMOVD F15, 88(R15) - - // Initialize Go ABI environment. - BL runtime·load_g(SB) - - MOVD R2, 8(R15) // fn unsafe.Pointer - MOVD R3, 16(R15) // a unsafe.Pointer - - // Skip R4 = n uint32 - MOVD R5, 24(R15) // ctxt uintptr - BL runtime·cgocallback(SB) - - FMOVD 32(R15), F8 - FMOVD 40(R15), F9 - FMOVD 48(R15), F10 - FMOVD 56(R15), F11 - FMOVD 64(R15), F12 - FMOVD 72(R15), F13 - FMOVD 80(R15), F14 - FMOVD 88(R15), F15 - - // De-allocate stack frame. - MOVD $96(R15), R15 - - // Restore R6-R15. - LMG 48(R15), R6, R15 - - RET diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/callbacks.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/callbacks.go deleted file mode 100644 index 27d4c98c8c8..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/callbacks.go +++ /dev/null @@ -1,93 +0,0 @@ -// Copyright 2011 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. - -//go:build !cgo && (darwin || freebsd || linux || netbsd) - -package fakecgo - -import ( - _ "unsafe" -) - -// TODO: decide if we need _runtime_cgo_panic_internal - -//go:linkname x_cgo_init_trampoline x_cgo_init_trampoline -//go:linkname _cgo_init _cgo_init -var x_cgo_init_trampoline byte -var _cgo_init = &x_cgo_init_trampoline - -// Creates a new system thread without updating any Go state. -// -// This method is invoked during shared library loading to create a new OS -// thread to perform the runtime initialization. This method is similar to -// _cgo_sys_thread_start except that it doesn't update any Go state. - -//go:linkname x_cgo_thread_start_trampoline x_cgo_thread_start_trampoline -//go:linkname _cgo_thread_start _cgo_thread_start -var x_cgo_thread_start_trampoline byte -var _cgo_thread_start = &x_cgo_thread_start_trampoline - -// Notifies that the runtime has been initialized. -// -// We currently block at every CGO entry point (via _cgo_wait_runtime_init_done) -// to ensure that the runtime has been initialized before the CGO call is -// executed. This is necessary for shared libraries where we kickoff runtime -// initialization in a separate thread and return without waiting for this -// thread to complete the init. - -//go:linkname x_cgo_notify_runtime_init_done_trampoline x_cgo_notify_runtime_init_done_trampoline -//go:linkname _cgo_notify_runtime_init_done _cgo_notify_runtime_init_done -var x_cgo_notify_runtime_init_done_trampoline byte -var _cgo_notify_runtime_init_done = &x_cgo_notify_runtime_init_done_trampoline - -// Indicates whether a dummy thread key has been created or not. -// -// When calling go exported function from C, we register a destructor -// callback, for a dummy thread key, by using pthread_key_create. - -//go:linkname _cgo_pthread_key_created _cgo_pthread_key_created -var x_cgo_pthread_key_created uintptr -var _cgo_pthread_key_created = &x_cgo_pthread_key_created - -// Set the x_crosscall2_ptr C function pointer variable point to crosscall2. -// It's for the runtime package to call at init time. -func set_crosscall2() { - // nothing needs to be done here for fakecgo - // because it's possible to just call cgocallback directly -} - -//go:linkname _set_crosscall2 runtime.set_crosscall2 -var _set_crosscall2 = set_crosscall2 - -// Store the g into the thread-specific value. -// So that pthread_key_destructor will dropm when the thread is exiting. - -//go:linkname x_cgo_bindm_trampoline x_cgo_bindm_trampoline -//go:linkname _cgo_bindm _cgo_bindm -var x_cgo_bindm_trampoline byte -var _cgo_bindm = &x_cgo_bindm_trampoline - -// TODO: decide if we need x_cgo_set_context_function -// TODO: decide if we need _cgo_yield - -var ( - // In Go 1.20 the race detector was rewritten to pure Go - // on darwin. This means that when CGO_ENABLED=0 is set - // fakecgo is built with race detector code. This is not - // good since this code is pretending to be C. The go:norace - // pragma is not enough, since it only applies to the native - // ABIInternal function. The ABIO wrapper (which is necessary, - // since all references to text symbols from assembly will use it) - // does not inherit the go:norace pragma, so it will still be - // instrumented by the race detector. - // - // To circumvent this issue, using closure calls in the - // assembly, which forces the compiler to use the ABIInternal - // native implementation (which has go:norace) instead. - threadentry_call = threadentry - x_cgo_init_call = x_cgo_init - x_cgo_setenv_call = x_cgo_setenv - x_cgo_unsetenv_call = x_cgo_unsetenv - x_cgo_thread_start_call = x_cgo_thread_start -) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/doc.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/doc.go deleted file mode 100644 index e482c120c64..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/doc.go +++ /dev/null @@ -1,32 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo && (darwin || freebsd || linux || netbsd) - -// Package fakecgo implements the Cgo runtime (runtime/cgo) entirely in Go. -// This allows code that calls into C to function properly when CGO_ENABLED=0. -// -// # Goals -// -// fakecgo attempts to replicate the same naming structure as in the runtime. -// For example, functions that have the prefix "gcc_*" are named "go_*". -// This makes it easier to port other GOOSs and GOARCHs as well as to keep -// it in sync with runtime/cgo. -// -// # Support -// -// Currently, fakecgo only supports macOS on amd64 & arm64. It also cannot -// be used with -buildmode=c-archive because that requires special initialization -// that fakecgo does not implement at the moment. -// -// # Usage -// -// Using fakecgo is easy just import _ "github.com/ebitengine/purego" and then -// set the environment variable CGO_ENABLED=0. -// The recommended usage for fakecgo is to prefer using runtime/cgo if possible -// but if cross-compiling or fast build times are important fakecgo is available. -// Purego will pick which ever Cgo runtime is available and prefer the one that -// comes with Go (runtime/cgo). -package fakecgo - -//go:generate go run gen.go diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/fakecgo.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/fakecgo.go deleted file mode 100644 index 384dab2a69a..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/fakecgo.go +++ /dev/null @@ -1,14 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2025 The Ebitengine Authors - -//go:build !cgo && (darwin || freebsd || linux || netbsd) - -package fakecgo - -import _ "unsafe" - -// setg_trampoline calls setg with the G provided -func setg_trampoline(setg uintptr, G uintptr) - -// call5 takes fn the C function and 5 arguments and calls the function with those arguments -func call5(fn, a1, a2, a3, a4, a5 uintptr) uintptr diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/freebsd.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/freebsd.go deleted file mode 100644 index bb73a709e69..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/freebsd.go +++ /dev/null @@ -1,27 +0,0 @@ -// Copyright 2010 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. - -//go:build freebsd && !cgo - -package fakecgo - -import _ "unsafe" // for go:linkname - -// Supply environ and __progname, because we don't -// link against the standard FreeBSD crt0.o and the -// libc dynamic library needs them. - -// Note: when building with cross-compiling or CGO_ENABLED=0, add -// the following argument to `go` so that these symbols are defined by -// making fakecgo the Cgo. -// -gcflags="github.com/ebitengine/purego/internal/fakecgo=-std" - -//go:linkname _environ environ -//go:linkname _progname __progname - -//go:cgo_export_dynamic environ -//go:cgo_export_dynamic __progname - -var _environ uintptr -var _progname uintptr diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_darwin.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_darwin.go deleted file mode 100644 index d0868f0f790..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_darwin.go +++ /dev/null @@ -1,88 +0,0 @@ -// Copyright 2011 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. - -//go:build !cgo - -package fakecgo - -import "unsafe" - -//go:nosplit -//go:norace -func _cgo_sys_thread_start(ts *ThreadStart) { - var attr pthread_attr_t - var ign, oset sigset_t - var p pthread_t - var size size_t - var err int - - sigfillset(&ign) - pthread_sigmask(SIG_SETMASK, &ign, &oset) - - size = pthread_get_stacksize_np(pthread_self()) - pthread_attr_init(&attr) - pthread_attr_setstacksize(&attr, size) - // Leave stacklo=0 and set stackhi=size; mstart will do the rest. - ts.g.stackhi = uintptr(size) - - err = _cgo_try_pthread_create(&p, &attr, unsafe.Pointer(threadentry_trampolineABI0), ts) - - pthread_sigmask(SIG_SETMASK, &oset, nil) - - if err != 0 { - print("fakecgo: pthread_create failed: ") - println(err) - abort() - } -} - -// threadentry_trampolineABI0 maps the C ABI to Go ABI then calls the Go function -// -//go:linkname x_threadentry_trampoline threadentry_trampoline -var x_threadentry_trampoline byte -var threadentry_trampolineABI0 = &x_threadentry_trampoline - -//go:nosplit -//go:norace -func threadentry(v unsafe.Pointer) unsafe.Pointer { - ts := *(*ThreadStart)(v) - free(v) - - // TODO: support ios - //#if TARGET_OS_IPHONE - // darwin_arm_init_thread_exception_port(); - //#endif - setg_trampoline(setg_func, uintptr(unsafe.Pointer(ts.g))) - - // faking funcs in go is a bit a... involved - but the following works :) - fn := uintptr(unsafe.Pointer(&ts.fn)) - (*(*func())(unsafe.Pointer(&fn)))() - - return nil -} - -// here we will store a pointer to the provided setg func -var setg_func uintptr - -// x_cgo_init(G *g, void (*setg)(void*)) (runtime/cgo/gcc_linux_amd64.c) -// This get's called during startup, adjusts stacklo, and provides a pointer to setg_gcc for us -// Additionally, if we set _cgo_init to non-null, go won't do it's own TLS setup -// This function can't be go:systemstack since go is not in a state where the systemcheck would work. -// -//go:nosplit -//go:norace -func x_cgo_init(g *G, setg uintptr) { - var size size_t - - setg_func = setg - size = pthread_get_stacksize_np(pthread_self()) - g.stacklo = uintptr(unsafe.Add(unsafe.Pointer(&size), -size+4096)) - - //TODO: support ios - //#if TARGET_OS_IPHONE - // darwin_arm_init_mach_exception_handler(); - // darwin_arm_init_thread_exception_port(); - // init_working_dir(); - //#endif -} diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_freebsd.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_freebsd.go deleted file mode 100644 index a3ba6bc8228..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_freebsd.go +++ /dev/null @@ -1,100 +0,0 @@ -// Copyright 2011 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. - -//go:build !cgo - -package fakecgo - -import "unsafe" - -//go:nosplit -func _cgo_sys_thread_start(ts *ThreadStart) { - var attr pthread_attr_t - var ign, oset sigset_t - var p pthread_t - var size size_t - var err int - - // fprintf(stderr, "runtime/cgo: _cgo_sys_thread_start: fn=%p, g=%p\n", ts->fn, ts->g); // debug - sigfillset(&ign) - pthread_sigmask(SIG_SETMASK, &ign, &oset) - - pthread_attr_init(&attr) - pthread_attr_getstacksize(&attr, &size) - // Leave stacklo=0 and set stackhi=size; mstart will do the rest. - ts.g.stackhi = uintptr(size) - - err = _cgo_try_pthread_create(&p, &attr, unsafe.Pointer(threadentry_trampolineABI0), ts) - - pthread_sigmask(SIG_SETMASK, &oset, nil) - - if err != 0 { - print("fakecgo: pthread_create failed: ") - println(err) - abort() - } -} - -// threadentry_trampolineABI0 maps the C ABI to Go ABI then calls the Go function -// -//go:linkname x_threadentry_trampoline threadentry_trampoline -var x_threadentry_trampoline byte -var threadentry_trampolineABI0 = &x_threadentry_trampoline - -//go:nosplit -func threadentry(v unsafe.Pointer) unsafe.Pointer { - ts := *(*ThreadStart)(v) - free(v) - - setg_trampoline(setg_func, uintptr(unsafe.Pointer(ts.g))) - - // faking funcs in go is a bit a... involved - but the following works :) - fn := uintptr(unsafe.Pointer(&ts.fn)) - (*(*func())(unsafe.Pointer(&fn)))() - - return nil -} - -// here we will store a pointer to the provided setg func -var setg_func uintptr - -// x_cgo_init(G *g, void (*setg)(void*)) (runtime/cgo/gcc_linux_amd64.c) -// This get's called during startup, adjusts stacklo, and provides a pointer to setg_gcc for us -// Additionally, if we set _cgo_init to non-null, go won't do it's own TLS setup -// This function can't be go:systemstack since go is not in a state where the systemcheck would work. -// -//go:nosplit -func x_cgo_init(g *G, setg uintptr) { - var size size_t - var attr *pthread_attr_t - - /* The memory sanitizer distributed with versions of clang - before 3.8 has a bug: if you call mmap before malloc, mmap - may return an address that is later overwritten by the msan - library. Avoid this problem by forcing a call to malloc - here, before we ever call malloc. - - This is only required for the memory sanitizer, so it's - unfortunate that we always run it. It should be possible - to remove this when we no longer care about versions of - clang before 3.8. The test for this is - misc/cgo/testsanitizers. - - GCC works hard to eliminate a seemingly unnecessary call to - malloc, so we actually use the memory we allocate. */ - - setg_func = setg - attr = (*pthread_attr_t)(malloc(unsafe.Sizeof(*attr))) - if attr == nil { - println("fakecgo: malloc failed") - abort() - } - pthread_attr_init(attr) - pthread_attr_getstacksize(attr, &size) - // runtime/cgo uses __builtin_frame_address(0) instead of `uintptr(unsafe.Pointer(&size))` - // but this should be OK since we are taking the address of the first variable in this function. - g.stacklo = uintptr(unsafe.Pointer(&size)) - uintptr(size) + 4096 - pthread_attr_destroy(attr) - free(unsafe.Pointer(attr)) -} diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_libinit.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_libinit.go deleted file mode 100644 index 0c463066973..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_libinit.go +++ /dev/null @@ -1,72 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo && (darwin || freebsd || linux || netbsd) - -package fakecgo - -import ( - "syscall" - "unsafe" -) - -var ( - pthread_g pthread_key_t - - runtime_init_cond = PTHREAD_COND_INITIALIZER - runtime_init_mu = PTHREAD_MUTEX_INITIALIZER - runtime_init_done int -) - -//go:nosplit -//go:norace -func x_cgo_notify_runtime_init_done() { - pthread_mutex_lock(&runtime_init_mu) - runtime_init_done = 1 - pthread_cond_broadcast(&runtime_init_cond) - pthread_mutex_unlock(&runtime_init_mu) -} - -// Store the g into a thread-specific value associated with the pthread key pthread_g. -// And pthread_key_destructor will dropm when the thread is exiting. -// -//go:norace -func x_cgo_bindm(g unsafe.Pointer) { - // We assume this will always succeed, otherwise, there might be extra M leaking, - // when a C thread exits after a cgo call. - // We only invoke this function once per thread in runtime.needAndBindM, - // and the next calls just reuse the bound m. - pthread_setspecific(pthread_g, g) -} - -// _cgo_try_pthread_create retries pthread_create if it fails with -// EAGAIN. -// -//go:nosplit -//go:norace -func _cgo_try_pthread_create(thread *pthread_t, attr *pthread_attr_t, pfn unsafe.Pointer, arg *ThreadStart) int { - var ts syscall.Timespec - // tries needs to be the same type as syscall.Timespec.Nsec - // but the fields are int32 on 32bit and int64 on 64bit. - // tries is assigned to syscall.Timespec.Nsec in order to match its type. - tries := ts.Nsec - var err int - - for tries = 0; tries < 20; tries++ { - // inlined this call because it ran out of stack when inlining was disabled - err = int(call5(pthread_createABI0, uintptr(unsafe.Pointer(thread)), uintptr(unsafe.Pointer(attr)), uintptr(pfn), uintptr(unsafe.Pointer(arg)), 0)) - if err == 0 { - // inlined this call because it ran out of stack when inlining was disabled - call5(pthread_detachABI0, uintptr(*thread), 0, 0, 0, 0) - return 0 - } - if err != int(syscall.EAGAIN) { - return err - } - ts.Sec = 0 - ts.Nsec = (tries + 1) * 1000 * 1000 // Milliseconds. - // inlined this call because it ran out of stack when inlining was disabled - call5(nanosleepABI0, uintptr(unsafe.Pointer(&ts)), 0, 0, 0, 0) - } - return int(syscall.EAGAIN) -} diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_linux.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_linux.go deleted file mode 100644 index 9f380c1b431..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_linux.go +++ /dev/null @@ -1,100 +0,0 @@ -// Copyright 2011 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. - -//go:build !cgo - -package fakecgo - -import "unsafe" - -//go:nosplit -func _cgo_sys_thread_start(ts *ThreadStart) { - var attr pthread_attr_t - var ign, oset sigset_t - var p pthread_t - var size size_t - var err int - - //fprintf(stderr, "runtime/cgo: _cgo_sys_thread_start: fn=%p, g=%p\n", ts->fn, ts->g); // debug - sigfillset(&ign) - pthread_sigmask(SIG_SETMASK, &ign, &oset) - - pthread_attr_init(&attr) - pthread_attr_getstacksize(&attr, &size) - // Leave stacklo=0 and set stackhi=size; mstart will do the rest. - ts.g.stackhi = uintptr(size) - - err = _cgo_try_pthread_create(&p, &attr, unsafe.Pointer(threadentry_trampolineABI0), ts) - - pthread_sigmask(SIG_SETMASK, &oset, nil) - - if err != 0 { - print("fakecgo: pthread_create failed: ") - println(err) - abort() - } -} - -// threadentry_trampolineABI0 maps the C ABI to Go ABI then calls the Go function -// -//go:linkname x_threadentry_trampoline threadentry_trampoline -var x_threadentry_trampoline byte -var threadentry_trampolineABI0 = &x_threadentry_trampoline - -//go:nosplit -func threadentry(v unsafe.Pointer) unsafe.Pointer { - ts := *(*ThreadStart)(v) - free(v) - - setg_trampoline(setg_func, uintptr(unsafe.Pointer(ts.g))) - - // faking funcs in go is a bit a... involved - but the following works :) - fn := uintptr(unsafe.Pointer(&ts.fn)) - (*(*func())(unsafe.Pointer(&fn)))() - - return nil -} - -// here we will store a pointer to the provided setg func -var setg_func uintptr - -// x_cgo_init(G *g, void (*setg)(void*)) (runtime/cgo/gcc_linux_amd64.c) -// This get's called during startup, adjusts stacklo, and provides a pointer to setg_gcc for us -// Additionally, if we set _cgo_init to non-null, go won't do it's own TLS setup -// This function can't be go:systemstack since go is not in a state where the systemcheck would work. -// -//go:nosplit -func x_cgo_init(g *G, setg uintptr) { - var size size_t - var attr *pthread_attr_t - - /* The memory sanitizer distributed with versions of clang - before 3.8 has a bug: if you call mmap before malloc, mmap - may return an address that is later overwritten by the msan - library. Avoid this problem by forcing a call to malloc - here, before we ever call malloc. - - This is only required for the memory sanitizer, so it's - unfortunate that we always run it. It should be possible - to remove this when we no longer care about versions of - clang before 3.8. The test for this is - misc/cgo/testsanitizers. - - GCC works hard to eliminate a seemingly unnecessary call to - malloc, so we actually use the memory we allocate. */ - - setg_func = setg - attr = (*pthread_attr_t)(malloc(unsafe.Sizeof(*attr))) - if attr == nil { - println("fakecgo: malloc failed") - abort() - } - pthread_attr_init(attr) - pthread_attr_getstacksize(attr, &size) - // runtime/cgo uses __builtin_frame_address(0) instead of `uintptr(unsafe.Pointer(&size))` - // but this should be OK since we are taking the address of the first variable in this function. - g.stacklo = uintptr(unsafe.Pointer(&size)) - uintptr(size) + 4096 - pthread_attr_destroy(attr) - free(unsafe.Pointer(attr)) -} diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_netbsd.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_netbsd.go deleted file mode 100644 index 935a334f220..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_netbsd.go +++ /dev/null @@ -1,106 +0,0 @@ -// Copyright 2011 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. - -//go:build !cgo && (amd64 || arm64) - -package fakecgo - -import "unsafe" - -//go:nosplit -func _cgo_sys_thread_start(ts *ThreadStart) { - var attr pthread_attr_t - var ign, oset sigset_t - var p pthread_t - var size size_t - var err int - - // fprintf(stderr, "runtime/cgo: _cgo_sys_thread_start: fn=%p, g=%p\n", ts->fn, ts->g); // debug - sigfillset(&ign) - pthread_sigmask(SIG_SETMASK, &ign, &oset) - - pthread_attr_init(&attr) - pthread_attr_getstacksize(&attr, &size) - // Leave stacklo=0 and set stackhi=size; mstart will do the rest. - ts.g.stackhi = uintptr(size) - - err = _cgo_try_pthread_create(&p, &attr, unsafe.Pointer(threadentry_trampolineABI0), ts) - - pthread_sigmask(SIG_SETMASK, &oset, nil) - - if err != 0 { - print("fakecgo: pthread_create failed: ") - println(err) - abort() - } -} - -// threadentry_trampolineABI0 maps the C ABI to Go ABI then calls the Go function -// -//go:linkname x_threadentry_trampoline threadentry_trampoline -var x_threadentry_trampoline byte -var threadentry_trampolineABI0 = &x_threadentry_trampoline - -//go:nosplit -func threadentry(v unsafe.Pointer) unsafe.Pointer { - var ss stack_t - ts := *(*ThreadStart)(v) - free(v) - - // On NetBSD, a new thread inherits the signal stack of the - // creating thread. That confuses minit, so we remove that - // signal stack here before calling the regular mstart. It's - // a bit baroque to remove a signal stack here only to add one - // in minit, but it's a simple change that keeps NetBSD - // working like other OS's. At this point all signals are - // blocked, so there is no race. - ss.ss_flags = SS_DISABLE - sigaltstack(&ss, nil) - - setg_trampoline(setg_func, uintptr(unsafe.Pointer(ts.g))) - - // faking funcs in go is a bit a... involved - but the following works :) - fn := uintptr(unsafe.Pointer(&ts.fn)) - (*(*func())(unsafe.Pointer(&fn)))() - - return nil -} - -// here we will store a pointer to the provided setg func -var setg_func uintptr - -//go:nosplit -func x_cgo_init(g *G, setg uintptr) { - var size size_t - var attr *pthread_attr_t - - /* The memory sanitizer distributed with versions of clang - before 3.8 has a bug: if you call mmap before malloc, mmap - may return an address that is later overwritten by the msan - library. Avoid this problem by forcing a call to malloc - here, before we ever call malloc. - - This is only required for the memory sanitizer, so it's - unfortunate that we always run it. It should be possible - to remove this when we no longer care about versions of - clang before 3.8. The test for this is - misc/cgo/testsanitizers. - - GCC works hard to eliminate a seemingly unnecessary call to - malloc, so we actually use the memory we allocate. */ - - setg_func = setg - attr = (*pthread_attr_t)(malloc(unsafe.Sizeof(*attr))) - if attr == nil { - println("fakecgo: malloc failed") - abort() - } - pthread_attr_init(attr) - pthread_attr_getstacksize(attr, &size) - // runtime/cgo uses __builtin_frame_address(0) instead of `uintptr(unsafe.Pointer(&size))` - // but this should be OK since we are taking the address of the first variable in this function. - g.stacklo = uintptr(unsafe.Pointer(&size)) - uintptr(size) + 4096 - pthread_attr_destroy(attr) - free(unsafe.Pointer(attr)) -} diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_setenv.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_setenv.go deleted file mode 100644 index dfc6629e4d2..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_setenv.go +++ /dev/null @@ -1,18 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo && (darwin || freebsd || linux || netbsd) - -package fakecgo - -//go:nosplit -//go:norace -func x_cgo_setenv(arg *[2]*byte) { - setenv(arg[0], arg[1], 1) -} - -//go:nosplit -//go:norace -func x_cgo_unsetenv(arg *[1]*byte) { - unsetenv(arg[0]) -} diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_util.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/go_util.go deleted file mode 100644 index ee993baae4e..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/go_util.go +++ /dev/null @@ -1,38 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo && (darwin || freebsd || linux || netbsd) - -package fakecgo - -import "unsafe" - -// _cgo_thread_start is split into three parts in cgo since only one part is system dependent (keep it here for easier handling) - -// _cgo_thread_start(ThreadStart *arg) (runtime/cgo/gcc_util.c) -// This get's called instead of the go code for creating new threads -// -> pthread_* stuff is used, so threads are setup correctly for C -// If this is missing, TLS is only setup correctly on thread 1! -// This function should be go:systemstack instead of go:nosplit (but that requires runtime) -// -//go:nosplit -//go:norace -func x_cgo_thread_start(arg *ThreadStart) { - var ts *ThreadStart - // Make our own copy that can persist after we return. - // _cgo_tsan_acquire(); - ts = (*ThreadStart)(malloc(unsafe.Sizeof(*ts))) - // _cgo_tsan_release(); - if ts == nil { - println("fakecgo: out of memory in thread_start") - abort() - } - // *ts = *arg would cause a writebarrier so copy using slices - const ptrSize = unsafe.Sizeof(uintptr(0)) - s1 := unsafe.Slice((*uintptr)(unsafe.Pointer(ts)), unsafe.Sizeof(*ts)/ptrSize) - s2 := unsafe.Slice((*uintptr)(unsafe.Pointer(arg)), unsafe.Sizeof(*arg)/ptrSize) - for i := range s2 { - s1[i] = s2[i] - } - _cgo_sys_thread_start(ts) // OS-dependent half -} diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/iscgo.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/iscgo.go deleted file mode 100644 index 12e52147032..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/iscgo.go +++ /dev/null @@ -1,19 +0,0 @@ -// Copyright 2010 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. - -//go:build !cgo && (darwin || freebsd || linux || netbsd) - -// The runtime package contains an uninitialized definition -// for runtime·iscgo. Override it to tell the runtime we're here. -// There are various function pointers that should be set too, -// but those depend on dynamic linker magic to get initialized -// correctly, and sometimes they break. This variable is a -// backup: it depends only on old C style static linking rules. - -package fakecgo - -import _ "unsafe" // for go:linkname - -//go:linkname _iscgo runtime.iscgo -var _iscgo bool = true diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo.go deleted file mode 100644 index 94fd8beabc7..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo.go +++ /dev/null @@ -1,39 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo && (darwin || freebsd || linux || netbsd) - -package fakecgo - -type ( - size_t uintptr - // Sources: - // Darwin (32 bytes) - https://github.com/apple/darwin-xnu/blob/2ff845c2e033bd0ff64b5b6aa6063a1f8f65aa32/bsd/sys/_types.h#L74 - // FreeBSD (32 bytes) - https://github.com/DoctorWkt/xv6-freebsd/blob/d2a294c2a984baed27676068b15ed9a29b06ab6f/include/signal.h#L98C9-L98C21 - // Linux (128 bytes) - https://github.com/torvalds/linux/blob/ab75170520d4964f3acf8bb1f91d34cbc650688e/arch/x86/include/asm/signal.h#L25 - sigset_t [128]byte - pthread_attr_t [64]byte - pthread_t int - pthread_key_t uint64 -) - -// for pthread_sigmask: - -type sighow int32 - -const ( - SIG_BLOCK sighow = 0 - SIG_UNBLOCK sighow = 1 - SIG_SETMASK sighow = 2 -) - -type G struct { - stacklo uintptr - stackhi uintptr -} - -type ThreadStart struct { - g *G - tls *uintptr - fn uintptr -} diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_darwin.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_darwin.go deleted file mode 100644 index ecdcb2e7852..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_darwin.go +++ /dev/null @@ -1,26 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo - -package fakecgo - -type ( - pthread_mutex_t struct { - sig int64 - opaque [56]byte - } - pthread_cond_t struct { - sig int64 - opaque [40]byte - } -) - -var ( - PTHREAD_COND_INITIALIZER = pthread_cond_t{sig: 0x3CB0B1BB} - PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t{sig: 0x32AAABA7} -) - -type stack_t struct { - /* not implemented */ -} diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_freebsd.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_freebsd.go deleted file mode 100644 index 4bfb70c3d5e..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_freebsd.go +++ /dev/null @@ -1,20 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo - -package fakecgo - -type ( - pthread_cond_t uintptr - pthread_mutex_t uintptr -) - -var ( - PTHREAD_COND_INITIALIZER = pthread_cond_t(0) - PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t(0) -) - -type stack_t struct { - /* not implemented */ -} diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_linux.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_linux.go deleted file mode 100644 index b08a44a1001..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_linux.go +++ /dev/null @@ -1,20 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo - -package fakecgo - -type ( - pthread_cond_t [48]byte - pthread_mutex_t [48]byte -) - -var ( - PTHREAD_COND_INITIALIZER = pthread_cond_t{} - PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t{} -) - -type stack_t struct { - /* not implemented */ -} diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_netbsd.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_netbsd.go deleted file mode 100644 index 650f6953e3d..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_netbsd.go +++ /dev/null @@ -1,26 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2025 The Ebitengine Authors - -//go:build !cgo - -package fakecgo - -type ( - pthread_cond_t uintptr - pthread_mutex_t uintptr -) - -var ( - PTHREAD_COND_INITIALIZER = pthread_cond_t(0) - PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t(0) -) - -// Source: https://github.com/NetBSD/src/blob/613e27c65223fd2283b6ed679da1197e12f50e27/sys/compat/linux/arch/m68k/linux_signal.h#L133 -type stack_t struct { - ss_sp uintptr - ss_flags int32 - ss_size uintptr -} - -// Source: https://github.com/NetBSD/src/blob/613e27c65223fd2283b6ed679da1197e12f50e27/sys/sys/signal.h#L261 -const SS_DISABLE = 0x004 diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/netbsd.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/netbsd.go deleted file mode 100644 index 2d499814f3c..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/netbsd.go +++ /dev/null @@ -1,23 +0,0 @@ -// Copyright 2010 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. - -//go:build netbsd - -package fakecgo - -import _ "unsafe" // for go:linkname - -// Supply environ and __progname, because we don't -// link against the standard NetBSD crt0.o and the -// libc dynamic library needs them. - -//go:linkname _environ environ -//go:linkname _progname __progname -//go:linkname ___ps_strings __ps_strings - -var ( - _environ uintptr - _progname uintptr - ___ps_strings uintptr -) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/setenv.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/setenv.go deleted file mode 100644 index 82308b8cac3..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/setenv.go +++ /dev/null @@ -1,19 +0,0 @@ -// Copyright 2011 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. - -//go:build !cgo && (darwin || freebsd || linux || netbsd) - -package fakecgo - -import _ "unsafe" // for go:linkname - -//go:linkname x_cgo_setenv_trampoline x_cgo_setenv_trampoline -//go:linkname _cgo_setenv runtime._cgo_setenv -var x_cgo_setenv_trampoline byte -var _cgo_setenv = &x_cgo_setenv_trampoline - -//go:linkname x_cgo_unsetenv_trampoline x_cgo_unsetenv_trampoline -//go:linkname _cgo_unsetenv runtime._cgo_unsetenv -var x_cgo_unsetenv_trampoline byte -var _cgo_unsetenv = &x_cgo_unsetenv_trampoline diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_386.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_386.s deleted file mode 100644 index cd3492ea772..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_386.s +++ /dev/null @@ -1,107 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -//go:build !cgo && (freebsd || linux) - -#include "textflag.h" -#include "go_asm.h" - -// These trampolines map the gcc ABI to Go ABI0 and then call into the Go equivalent functions. -// On i386, both GCC and Go use stack-based calling conventions. -// -// When C calls a function, the stack looks like: -// 0(SP) = return address -// 4(SP) = arg1 -// 8(SP) = arg2 -// ... -// -// When we declare a Go function with frame size $N-0, Go's prologue -// effectively does SUB $N, SP, so the C arguments shift up by N bytes: -// N+0(SP) = return address -// N+4(SP) = arg1 -// N+8(SP) = arg2 -// -// Go ABI0 on 386 expects arguments starting at 0(FP) which equals N+4(SP) -// after the prologue (where N is the local frame size). - -TEXT x_cgo_init_trampoline(SB), NOSPLIT, $8-0 - // C args at 12(SP) and 16(SP) after frame setup (8 bytes local + 4 bytes ret addr) - // Go function expects args at 0(SP) and 4(SP) in local frame - MOVL 12(SP), AX // first C arg - MOVL 16(SP), BX // second C arg - MOVL AX, 0(SP) // Go arg 1 - MOVL BX, 4(SP) // Go arg 2 - MOVL ·x_cgo_init_call(SB), CX - MOVL (CX), CX - CALL CX - RET - -TEXT x_cgo_thread_start_trampoline(SB), NOSPLIT, $4-0 - // C args at 8(SP) after frame setup (4 bytes local + 4 bytes ret addr) - MOVL 8(SP), AX // first C arg - MOVL AX, 0(SP) // Go arg 1 - MOVL ·x_cgo_thread_start_call(SB), CX - MOVL (CX), CX - CALL CX - RET - -TEXT x_cgo_setenv_trampoline(SB), NOSPLIT, $4-0 - MOVL 8(SP), AX // first C arg - MOVL AX, 0(SP) // Go arg 1 - MOVL ·x_cgo_setenv_call(SB), CX - MOVL (CX), CX - CALL CX - RET - -TEXT x_cgo_unsetenv_trampoline(SB), NOSPLIT, $4-0 - MOVL 8(SP), AX // first C arg - MOVL AX, 0(SP) // Go arg 1 - MOVL ·x_cgo_unsetenv_call(SB), CX - MOVL (CX), CX - CALL CX - RET - -TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT, $0-0 - CALL ·x_cgo_notify_runtime_init_done(SB) - RET - -TEXT x_cgo_bindm_trampoline(SB), NOSPLIT, $0 - CALL ·x_cgo_bindm(SB) - RET - -// func setg_trampoline(setg uintptr, g uintptr) -// This is called from Go, so args are at normal FP positions -TEXT ·setg_trampoline(SB), NOSPLIT, $4-8 - MOVL g+4(FP), AX - MOVL setg+0(FP), BX - - // setg expects g in 0(SP) - MOVL AX, 0(SP) - CALL BX - RET - -TEXT threadentry_trampoline(SB), NOSPLIT, $4-0 - MOVL 8(SP), AX // first C arg - MOVL AX, 0(SP) // Go arg 1 - MOVL ·threadentry_call(SB), CX - MOVL (CX), CX - CALL CX - RET - -TEXT ·call5(SB), NOSPLIT, $20-28 - MOVL fn+0(FP), AX - MOVL a1+4(FP), BX - MOVL a2+8(FP), CX - MOVL a3+12(FP), DX - MOVL a4+16(FP), SI - MOVL a5+20(FP), DI - - // Place arguments on local stack frame for C calling convention - MOVL BX, 0(SP) // a1 - MOVL CX, 4(SP) // a2 - MOVL DX, 8(SP) // a3 - MOVL SI, 12(SP) // a4 - MOVL DI, 16(SP) // a5 - CALL AX - MOVL AX, r1+24(FP) - RET diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_amd64.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_amd64.s deleted file mode 100644 index e4e4c75a374..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_amd64.s +++ /dev/null @@ -1,107 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo && (darwin || linux || freebsd) - -/* -trampoline for emulating required C functions for cgo in go (see cgo.go) -(we convert cdecl calling convention to go and vice-versa) - -C Calling convention cdecl used here (we only need integer args): -1. arg: DI -2. arg: SI -3. arg: DX -4. arg: CX -5. arg: R8 -6. arg: R9 -We don't need floats with these functions -> AX=0 -return value will be in AX -temporary register is R11 -*/ -#include "textflag.h" -#include "go_asm.h" -#include "abi_amd64.h" - -// these trampolines map the gcc ABI to Go ABI and then calls into the Go equivalent functions. - -TEXT x_cgo_init_trampoline(SB), NOSPLIT, $16 - MOVQ DI, AX - MOVQ SI, BX - MOVQ ·x_cgo_init_call(SB), R11 - MOVQ (R11), R11 - CALL R11 - RET - -TEXT x_cgo_thread_start_trampoline(SB), NOSPLIT, $8 - MOVQ DI, AX - MOVQ ·x_cgo_thread_start_call(SB), R11 - MOVQ (R11), R11 - CALL R11 - RET - -TEXT x_cgo_setenv_trampoline(SB), NOSPLIT, $8 - MOVQ DI, AX - MOVQ ·x_cgo_setenv_call(SB), R11 - MOVQ (R11), R11 - CALL R11 - RET - -TEXT x_cgo_unsetenv_trampoline(SB), NOSPLIT, $8 - MOVQ DI, AX - MOVQ ·x_cgo_unsetenv_call(SB), R11 - MOVQ (R11), R11 - CALL R11 - RET - -TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT, $0 - JMP ·x_cgo_notify_runtime_init_done(SB) - -TEXT x_cgo_bindm_trampoline(SB), NOSPLIT, $0 - JMP ·x_cgo_bindm(SB) - -// func setg_trampoline(setg uintptr, g uintptr) -TEXT ·setg_trampoline(SB), NOSPLIT, $0-16 - MOVQ G+8(FP), DI - MOVQ setg+0(FP), R11 - XORL AX, AX - CALL R11 - RET - -TEXT threadentry_trampoline(SB), NOSPLIT, $0 - // See crosscall2. - PUSH_REGS_HOST_TO_ABI0() - - // X15 is designated by Go as a fixed zero register. - // Calling directly into ABIInternal, ensure it is zero. - PXOR X15, X15 - - MOVQ DI, AX - MOVQ ·threadentry_call(SB), R11 - MOVQ (R11), R11 - CALL R11 - - POP_REGS_HOST_TO_ABI0() - RET - -TEXT ·call5(SB), NOSPLIT, $0-56 - MOVQ fn+0(FP), R11 - MOVQ a1+8(FP), DI - MOVQ a2+16(FP), SI - MOVQ a3+24(FP), DX - MOVQ a4+32(FP), CX - MOVQ a5+40(FP), R8 - - XORL AX, AX // no floats - - PUSHQ BP // save BP - MOVQ SP, BP // save SP inside BP bc BP is callee-saved - SUBQ $16, SP // allocate space for alignment - ANDQ $-16, SP // align on 16 bytes for SSE - - CALL R11 - - MOVQ BP, SP // get SP back - POPQ BP // restore BP - - MOVQ AX, ret+48(FP) - RET diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_arm.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_arm.s deleted file mode 100644 index 00b3177ef43..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_arm.s +++ /dev/null @@ -1,81 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -//go:build !cgo && (freebsd || linux) - -#include "textflag.h" -#include "go_asm.h" - -// These trampolines map the gcc ABI to Go ABI0 and then call into the Go equivalent functions. -// On ARM32, Go ABI0 uses stack-based calling convention. -// Arguments are placed on the stack starting at 4(SP) after the prologue. - -TEXT x_cgo_init_trampoline(SB), NOSPLIT, $8-0 - MOVW R0, 4(R13) - MOVW R1, 8(R13) - MOVW ·x_cgo_init_call(SB), R12 - MOVW (R12), R12 - CALL (R12) - RET - -TEXT x_cgo_thread_start_trampoline(SB), NOSPLIT, $8-0 - MOVW R0, 4(R13) - MOVW ·x_cgo_thread_start_call(SB), R12 - MOVW (R12), R12 - CALL (R12) - RET - -TEXT x_cgo_setenv_trampoline(SB), NOSPLIT, $8-0 - MOVW R0, 4(R13) - MOVW ·x_cgo_setenv_call(SB), R12 - MOVW (R12), R12 - CALL (R12) - RET - -TEXT x_cgo_unsetenv_trampoline(SB), NOSPLIT, $8-0 - MOVW R0, 4(R13) - MOVW ·x_cgo_unsetenv_call(SB), R12 - MOVW (R12), R12 - CALL (R12) - RET - -TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT, $0-0 - CALL ·x_cgo_notify_runtime_init_done(SB) - RET - -TEXT x_cgo_bindm_trampoline(SB), NOSPLIT, $0 - CALL ·x_cgo_bindm(SB) - RET - -// func setg_trampoline(setg uintptr, g uintptr) -TEXT ·setg_trampoline(SB), NOSPLIT, $0-8 - MOVW G+4(FP), R0 - MOVW setg+0(FP), R12 - BL (R12) - RET - -TEXT threadentry_trampoline(SB), NOSPLIT, $8-0 - // See crosscall2. - MOVW R0, 4(R13) - MOVW ·threadentry_call(SB), R12 - MOVW (R12), R12 - CALL (R12) - RET - -TEXT ·call5(SB), NOSPLIT, $8-28 - MOVW fn+0(FP), R12 - MOVW a1+4(FP), R0 - MOVW a2+8(FP), R1 - MOVW a3+12(FP), R2 - MOVW a4+16(FP), R3 - MOVW a5+20(FP), R4 - - // Store 5th arg below SP (in local frame area) - MOVW R4, arg5-8(SP) - - // Align SP to 8 bytes for call (required by ARM AAPCS) - SUB $8, R13 - CALL (R12) - ADD $8, R13 - MOVW R0, r1+24(FP) - RET diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_arm64.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_arm64.s deleted file mode 100644 index dceb1cac6e8..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_arm64.s +++ /dev/null @@ -1,84 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo && (darwin || freebsd || linux) - -#include "textflag.h" -#include "go_asm.h" -#include "abi_arm64.h" - -// These trampolines map the gcc ABI to Go ABIInternal and then calls into the Go equivalent functions. -// Note that C arguments are passed in R0-R7, which matches Go ABIInternal for the first eight arguments. -// R9 is used as a temporary register. - -TEXT x_cgo_init_trampoline(SB), NOSPLIT, $0-0 - MOVD ·x_cgo_init_call(SB), R9 - MOVD (R9), R9 - CALL R9 - RET - -TEXT x_cgo_thread_start_trampoline(SB), NOSPLIT, $0-0 - MOVD ·x_cgo_thread_start_call(SB), R9 - MOVD (R9), R9 - CALL R9 - RET - -TEXT x_cgo_setenv_trampoline(SB), NOSPLIT, $0-0 - MOVD ·x_cgo_setenv_call(SB), R9 - MOVD (R9), R9 - CALL R9 - RET - -TEXT x_cgo_unsetenv_trampoline(SB), NOSPLIT, $0-0 - MOVD ·x_cgo_unsetenv_call(SB), R9 - MOVD (R9), R9 - CALL R9 - RET - -TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT, $0-0 - CALL ·x_cgo_notify_runtime_init_done(SB) - RET - -TEXT x_cgo_bindm_trampoline(SB), NOSPLIT, $0 - CALL ·x_cgo_bindm(SB) - RET - -// func setg_trampoline(setg uintptr, g uintptr) -TEXT ·setg_trampoline(SB), NOSPLIT, $0-16 - MOVD G+8(FP), R0 - MOVD setg+0(FP), R9 - CALL R9 - RET - -TEXT threadentry_trampoline(SB), NOSPLIT, $0-0 - // See crosscall2. - SUB $(8*24), RSP - STP (R0, R1), (8*1)(RSP) - MOVD R3, (8*3)(RSP) - - SAVE_R19_TO_R28(8*4) - SAVE_F8_TO_F15(8*14) - STP (R29, R30), (8*22)(RSP) - - MOVD ·threadentry_call(SB), R9 - MOVD (R9), R9 - CALL R9 - MOVD $0, R0 // TODO: get the return value from threadentry - - RESTORE_R19_TO_R28(8*4) - RESTORE_F8_TO_F15(8*14) - LDP (8*22)(RSP), (R29, R30) - - ADD $(8*24), RSP - RET - -TEXT ·call5(SB), NOSPLIT, $0-0 - MOVD fn+0(FP), R9 - MOVD a1+8(FP), R0 - MOVD a2+16(FP), R1 - MOVD a3+24(FP), R2 - MOVD a4+32(FP), R3 - MOVD a5+40(FP), R4 - CALL R9 - MOVD R0, ret+48(FP) - RET diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_loong64.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_loong64.s deleted file mode 100644 index 7596f0da162..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_loong64.s +++ /dev/null @@ -1,88 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2025 The Ebitengine Authors - -//go:build !cgo && linux - -#include "textflag.h" -#include "go_asm.h" -#include "abi_loong64.h" - -// these trampolines map the gcc ABI to Go ABI and then calls into the Go equivalent functions. -// R23 is used as temporary register. - -TEXT x_cgo_init_trampoline(SB), NOSPLIT, $16 - MOVV R4, 8(R3) - MOVV R5, 16(R3) - MOVV ·x_cgo_init_call(SB), R23 - MOVV (R23), R23 - CALL (R23) - RET - -TEXT x_cgo_thread_start_trampoline(SB), NOSPLIT, $8 - MOVV R4, 8(R3) - MOVV ·x_cgo_thread_start_call(SB), R23 - MOVV (R23), R23 - CALL (R23) - RET - -TEXT x_cgo_setenv_trampoline(SB), NOSPLIT, $8 - MOVV R4, 8(R3) - MOVV ·x_cgo_setenv_call(SB), R23 - MOVV (R23), R23 - CALL (R23) - RET - -TEXT x_cgo_unsetenv_trampoline(SB), NOSPLIT, $8 - MOVV R4, 8(R3) - MOVV ·x_cgo_unsetenv_call(SB), R23 - MOVV (R23), R23 - CALL (R23) - RET - -TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT, $0 - CALL ·x_cgo_notify_runtime_init_done(SB) - RET - -TEXT x_cgo_bindm_trampoline(SB), NOSPLIT, $0 - CALL ·x_cgo_bindm(SB) - RET - -// func setg_trampoline(setg uintptr, g uintptr) -TEXT ·setg_trampoline(SB), NOSPLIT, $0 - MOVV G+8(FP), R4 - MOVV setg+0(FP), R23 - CALL (R23) - RET - -TEXT threadentry_trampoline(SB), NOSPLIT, $0 - // See crosscall2. - ADDV $(-23*8), R3 - MOVV R4, (1*8)(R3) // fn unsafe.Pointer - MOVV R5, (2*8)(R3) // a unsafe.Pointer - MOVV R7, (3*8)(R3) // ctxt uintptr - - SAVE_R22_TO_R31((4*8)) - SAVE_F24_TO_F31((14*8)) - MOVV R1, (22*8)(R3) - - MOVV ·threadentry_call(SB), R23 - MOVV (R23), R23 - CALL (R23) - - RESTORE_R22_TO_R31((4*8)) - RESTORE_F24_TO_F31((14*8)) - MOVV (22*8)(R3), R1 - - ADDV $(23*8), R3 - RET - -TEXT ·call5(SB), NOSPLIT, $0-0 - MOVV fn+0(FP), R23 - MOVV a1+8(FP), R4 - MOVV a2+16(FP), R5 - MOVV a3+24(FP), R6 - MOVV a4+32(FP), R7 - MOVV a5+40(FP), R8 - CALL (R23) - MOVV R4, ret+48(FP) - RET diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_ppc64le.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_ppc64le.s deleted file mode 100644 index 85f895564dd..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_ppc64le.s +++ /dev/null @@ -1,227 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -//go:build !cgo && linux - -#include "textflag.h" -#include "go_asm.h" - -// These trampolines map the C ABI to Go ABI and call into the Go equivalent functions. -// -// PPC64LE ELFv2 ABI stack frame layout: -// 0(R1) = backchain (pointer to caller's frame) -// 8(R1) = CR save area -// 16(R1) = LR save area -// 24(R1) = reserved -// 32(R1) = parameter save area (minimum 64 bytes for 8 args) -// -// Two patterns are used depending on call direction: -// -// C→Go trampolines: The C caller already provides a 32-byte linkage area. -// Save LR/CR into caller's frame at 16(R1)/8(R1) BEFORE allocating, -// then use MOVDU to allocate and set backchain atomically. -// -// Go→C trampolines: Go callers don't provide ELFv2 linkage area. -// Allocate frame first with MOVDU, then save LR/CR into OUR frame. - -TEXT x_cgo_init_trampoline(SB), NOSPLIT|NOFRAME, $0-0 - MOVD LR, 16(R1) - MOVW CR, R0 - MOVD R0, 8(R1) - - MOVDU R1, -32(R1) - - // R3, R4 already have the arguments - MOVD ·x_cgo_init_call(SB), R12 - MOVD (R12), R12 - MOVD R12, CTR - CALL CTR - - ADD $32, R1 - - MOVD 16(R1), LR - MOVD 8(R1), R0 - MOVW R0, CR - RET - -TEXT x_cgo_thread_start_trampoline(SB), NOSPLIT|NOFRAME, $0-0 - MOVD LR, 16(R1) - MOVW CR, R0 - MOVD R0, 8(R1) - - MOVDU R1, -32(R1) - - MOVD ·x_cgo_thread_start_call(SB), R12 - MOVD (R12), R12 - MOVD R12, CTR - CALL CTR - - ADD $32, R1 - - MOVD 16(R1), LR - MOVD 8(R1), R0 - MOVW R0, CR - RET - -// void (*_cgo_setenv)(char**) -// C arg: R3 = pointer to env -// This is C→Go: caller is C ABI. -TEXT x_cgo_setenv_trampoline(SB), NOSPLIT|NOFRAME, $0-0 - MOVD LR, 16(R1) - MOVW CR, R0 - MOVD R0, 8(R1) - - MOVDU R1, -32(R1) - - MOVD ·x_cgo_setenv_call(SB), R12 - MOVD (R12), R12 - MOVD R12, CTR - CALL CTR - - ADD $32, R1 - - MOVD 16(R1), LR - MOVD 8(R1), R0 - MOVW R0, CR - RET - -TEXT x_cgo_unsetenv_trampoline(SB), NOSPLIT|NOFRAME, $0-0 - MOVD LR, 16(R1) - MOVW CR, R0 - MOVD R0, 8(R1) - - MOVDU R1, -32(R1) - - MOVD ·x_cgo_unsetenv_call(SB), R12 - MOVD (R12), R12 - MOVD R12, CTR - CALL CTR - - ADD $32, R1 - - MOVD 16(R1), LR - MOVD 8(R1), R0 - MOVW R0, CR - RET - -TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT|NOFRAME, $0-0 - MOVD LR, 16(R1) - MOVW CR, R0 - MOVD R0, 8(R1) - - MOVDU R1, -32(R1) - - CALL ·x_cgo_notify_runtime_init_done(SB) - - ADD $32, R1 - - MOVD 16(R1), LR - MOVD 8(R1), R0 - MOVW R0, CR - RET - -TEXT x_cgo_bindm_trampoline(SB), NOSPLIT|NOFRAME, $0-0 - MOVD LR, 16(R1) - MOVW CR, R0 - MOVD R0, 8(R1) - - MOVDU R1, -32(R1) - - CALL ·x_cgo_bindm(SB) - - ADD $32, R1 - - MOVD 16(R1), LR - MOVD 8(R1), R0 - MOVW R0, CR - RET - -TEXT ·setg_trampoline(SB), NOSPLIT|NOFRAME, $0-16 - // Save LR, CR, and R31 to non-volatile registers (C ABI preserves R14-R31) - MOVD LR, R20 - MOVW CR, R21 - MOVD R31, R22 // save R31 because load_g clobbers it - - // Load arguments from Go stack - MOVD 32(R1), R12 // setg function pointer - MOVD 40(R1), R3 // g pointer → first C arg - - // Allocate ELFv2 frame for the C callee (32 bytes minimum) - MOVDU R1, -32(R1) - - // Call setg_gcc which stores g to TLS - MOVD R12, CTR - CALL CTR - - // setg_gcc stored g to TLS but restored old g in R30. - // Call load_g to reload g from TLS into R30. - // Note: load_g clobbers R31 - CALL runtime·load_g(SB) - - // Deallocate frame - ADD $32, R1 - - // Clear R0 before returning to Go code. - // Go uses R0 as a constant 0 for things like "std r0,X(r1)" to zero stack locations. - // C/assembly functions may leave garbage in R0. - XOR R0, R0, R0 - - // Restore LR, CR, and R31 from non-volatile registers - MOVD R22, R31 // restore R31 - MOVD R20, LR - MOVW R21, CR - RET - -TEXT threadentry_trampoline(SB), NOSPLIT|NOFRAME, $0-0 - MOVD LR, 16(R1) - MOVW CR, R0 - MOVD R0, 8(R1) - - MOVDU R1, -32(R1) - - MOVD ·threadentry_call(SB), R12 - MOVD (R12), R12 - MOVD R12, CTR - CALL CTR - - ADD $32, R1 - - MOVD 16(R1), LR - MOVD 8(R1), R0 - MOVW R0, CR - RET - -TEXT ·call5(SB), NOSPLIT|NOFRAME, $0-56 - MOVD LR, R20 - MOVW CR, R21 - - // Load arguments from Go stack into C argument registers - // Go placed args at 32(R1), 40(R1), etc. - MOVD 32(R1), R12 // fn - MOVD 40(R1), R3 // a1 → first C arg - MOVD 48(R1), R4 // a2 → second C arg - MOVD 56(R1), R5 // a3 → third C arg - MOVD 64(R1), R6 // a4 → fourth C arg - MOVD 72(R1), R7 // a5 → fifth C arg - - MOVDU R1, -32(R1) - - MOVD R12, CTR - CALL CTR - - // Store return value - // After MOVDU -32, original 80(R1) is now at 80+32=112(R1) - MOVD R3, (80+32)(R1) - - // Deallocate frame - ADD $32, R1 - - // Clear R0 before returning to Go code. - // Go uses R0 as a constant 0 register for things like "std r0,X(r1)" - // to zero stack locations. C functions may leave garbage in R0. - XOR R0, R0, R0 - - // Restore LR/CR from non-volatile registers - MOVD R20, LR - MOVW R21, CR - RET diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_riscv64.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_riscv64.s deleted file mode 100644 index 9298f8c71a0..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_riscv64.s +++ /dev/null @@ -1,72 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -//go:build !cgo && linux - -#include "textflag.h" -#include "go_asm.h" - -// these trampolines map the gcc ABI to Go ABI and then calls into the Go equivalent functions. -// X5 is used as temporary register. - -TEXT x_cgo_init_trampoline(SB), NOSPLIT, $16 - MOV X10, 8(SP) - MOV X11, 16(SP) - MOV ·x_cgo_init_call(SB), X5 - MOV (X5), X5 - CALL X5 - RET - -TEXT x_cgo_thread_start_trampoline(SB), NOSPLIT, $8 - MOV X10, 8(SP) - MOV ·x_cgo_thread_start_call(SB), X5 - MOV (X5), X5 - CALL X5 - RET - -TEXT x_cgo_setenv_trampoline(SB), NOSPLIT, $8 - MOV X10, 8(SP) - MOV ·x_cgo_setenv_call(SB), X5 - MOV (X5), X5 - CALL X5 - RET - -TEXT x_cgo_unsetenv_trampoline(SB), NOSPLIT, $8 - MOV X10, 8(SP) - MOV ·x_cgo_unsetenv_call(SB), X5 - MOV (X5), X5 - CALL X5 - RET - -TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT, $0 - CALL ·x_cgo_notify_runtime_init_done(SB) - RET - -TEXT x_cgo_bindm_trampoline(SB), NOSPLIT, $0 - CALL ·x_cgo_bindm(SB) - RET - -// func setg_trampoline(setg uintptr, g uintptr) -TEXT ·setg_trampoline(SB), NOSPLIT, $0 - MOV gp+8(FP), X10 - MOV setg+0(FP), X5 - CALL X5 - RET - -TEXT threadentry_trampoline(SB), NOSPLIT, $16 - MOV X10, 8(SP) - MOV ·threadentry_call(SB), X5 - MOV (X5), X5 - CALL X5 - RET - -TEXT ·call5(SB), NOSPLIT, $0-48 - MOV fn+0(FP), X5 - MOV a1+8(FP), X10 - MOV a2+16(FP), X11 - MOV a3+24(FP), X12 - MOV a4+32(FP), X13 - MOV a5+40(FP), X14 - CALL X5 - MOV X10, ret+48(FP) - RET diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols.go deleted file mode 100644 index cc552e7d308..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols.go +++ /dev/null @@ -1,165 +0,0 @@ -// Code generated by 'go generate' with gen.go. DO NOT EDIT. - -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo && (darwin || freebsd || linux || netbsd) - -package fakecgo - -import ( - "syscall" - "unsafe" -) - -//go:nosplit -//go:norace -func malloc(size uintptr) unsafe.Pointer { - ret := call5(mallocABI0, uintptr(size), 0, 0, 0, 0) - // this indirection is to avoid go vet complaining about possible misuse of unsafe.Pointer - return *(*unsafe.Pointer)(unsafe.Pointer(&ret)) -} - -//go:nosplit -//go:norace -func free(ptr unsafe.Pointer) { - call5(freeABI0, uintptr(ptr), 0, 0, 0, 0) -} - -//go:nosplit -//go:norace -func setenv(name *byte, value *byte, overwrite int32) int32 { - return int32(call5(setenvABI0, uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(value)), uintptr(overwrite), 0, 0)) -} - -//go:nosplit -//go:norace -func unsetenv(name *byte) int32 { - return int32(call5(unsetenvABI0, uintptr(unsafe.Pointer(name)), 0, 0, 0, 0)) -} - -//go:nosplit -//go:norace -func sigfillset(set *sigset_t) int32 { - return int32(call5(sigfillsetABI0, uintptr(unsafe.Pointer(set)), 0, 0, 0, 0)) -} - -//go:nosplit -//go:norace -func nanosleep(ts *syscall.Timespec, rem *syscall.Timespec) int32 { - return int32(call5(nanosleepABI0, uintptr(unsafe.Pointer(ts)), uintptr(unsafe.Pointer(rem)), 0, 0, 0)) -} - -//go:nosplit -//go:norace -func abort() { - call5(abortABI0, 0, 0, 0, 0, 0) -} - -//go:nosplit -//go:norace -func pthread_attr_init(attr *pthread_attr_t) int32 { - return int32(call5(pthread_attr_initABI0, uintptr(unsafe.Pointer(attr)), 0, 0, 0, 0)) -} - -//go:nosplit -//go:norace -func pthread_create(thread *pthread_t, attr *pthread_attr_t, start unsafe.Pointer, arg unsafe.Pointer) int32 { - return int32(call5(pthread_createABI0, uintptr(unsafe.Pointer(thread)), uintptr(unsafe.Pointer(attr)), uintptr(start), uintptr(arg), 0)) -} - -//go:nosplit -//go:norace -func pthread_detach(thread pthread_t) int32 { - return int32(call5(pthread_detachABI0, uintptr(thread), 0, 0, 0, 0)) -} - -//go:nosplit -//go:norace -func pthread_sigmask(how sighow, ign *sigset_t, oset *sigset_t) int32 { - return int32(call5(pthread_sigmaskABI0, uintptr(how), uintptr(unsafe.Pointer(ign)), uintptr(unsafe.Pointer(oset)), 0, 0)) -} - -//go:nosplit -//go:norace -func pthread_mutex_lock(mutex *pthread_mutex_t) int32 { - return int32(call5(pthread_mutex_lockABI0, uintptr(unsafe.Pointer(mutex)), 0, 0, 0, 0)) -} - -//go:nosplit -//go:norace -func pthread_mutex_unlock(mutex *pthread_mutex_t) int32 { - return int32(call5(pthread_mutex_unlockABI0, uintptr(unsafe.Pointer(mutex)), 0, 0, 0, 0)) -} - -//go:nosplit -//go:norace -func pthread_cond_broadcast(cond *pthread_cond_t) int32 { - return int32(call5(pthread_cond_broadcastABI0, uintptr(unsafe.Pointer(cond)), 0, 0, 0, 0)) -} - -//go:nosplit -//go:norace -func pthread_setspecific(key pthread_key_t, value unsafe.Pointer) int32 { - return int32(call5(pthread_setspecificABI0, uintptr(key), uintptr(value), 0, 0, 0)) -} - -//go:linkname _malloc _malloc -var _malloc uint8 -var mallocABI0 = uintptr(unsafe.Pointer(&_malloc)) - -//go:linkname _free _free -var _free uint8 -var freeABI0 = uintptr(unsafe.Pointer(&_free)) - -//go:linkname _setenv _setenv -var _setenv uint8 -var setenvABI0 = uintptr(unsafe.Pointer(&_setenv)) - -//go:linkname _unsetenv _unsetenv -var _unsetenv uint8 -var unsetenvABI0 = uintptr(unsafe.Pointer(&_unsetenv)) - -//go:linkname _sigfillset _sigfillset -var _sigfillset uint8 -var sigfillsetABI0 = uintptr(unsafe.Pointer(&_sigfillset)) - -//go:linkname _nanosleep _nanosleep -var _nanosleep uint8 -var nanosleepABI0 = uintptr(unsafe.Pointer(&_nanosleep)) - -//go:linkname _abort _abort -var _abort uint8 -var abortABI0 = uintptr(unsafe.Pointer(&_abort)) - -//go:linkname _pthread_attr_init _pthread_attr_init -var _pthread_attr_init uint8 -var pthread_attr_initABI0 = uintptr(unsafe.Pointer(&_pthread_attr_init)) - -//go:linkname _pthread_create _pthread_create -var _pthread_create uint8 -var pthread_createABI0 = uintptr(unsafe.Pointer(&_pthread_create)) - -//go:linkname _pthread_detach _pthread_detach -var _pthread_detach uint8 -var pthread_detachABI0 = uintptr(unsafe.Pointer(&_pthread_detach)) - -//go:linkname _pthread_sigmask _pthread_sigmask -var _pthread_sigmask uint8 -var pthread_sigmaskABI0 = uintptr(unsafe.Pointer(&_pthread_sigmask)) - -//go:linkname _pthread_mutex_lock _pthread_mutex_lock -var _pthread_mutex_lock uint8 -var pthread_mutex_lockABI0 = uintptr(unsafe.Pointer(&_pthread_mutex_lock)) - -//go:linkname _pthread_mutex_unlock _pthread_mutex_unlock -var _pthread_mutex_unlock uint8 -var pthread_mutex_unlockABI0 = uintptr(unsafe.Pointer(&_pthread_mutex_unlock)) - -//go:linkname _pthread_cond_broadcast _pthread_cond_broadcast -var _pthread_cond_broadcast uint8 -var pthread_cond_broadcastABI0 = uintptr(unsafe.Pointer(&_pthread_cond_broadcast)) - -//go:linkname _pthread_setspecific _pthread_setspecific -var _pthread_setspecific uint8 -var pthread_setspecificABI0 = uintptr(unsafe.Pointer(&_pthread_setspecific)) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_darwin.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_darwin.go deleted file mode 100644 index 960f8168eb8..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_darwin.go +++ /dev/null @@ -1,59 +0,0 @@ -// Code generated by 'go generate' with gen.go. DO NOT EDIT. - -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo - -package fakecgo - -import "unsafe" - -//go:cgo_import_dynamic purego_malloc malloc "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_free free "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_setenv setenv "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_unsetenv unsetenv "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_sigfillset sigfillset "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_nanosleep nanosleep "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_abort abort "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_pthread_attr_init pthread_attr_init "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_pthread_create pthread_create "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_pthread_detach pthread_detach "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_pthread_sigmask pthread_sigmask "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_pthread_mutex_lock pthread_mutex_lock "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_pthread_mutex_unlock pthread_mutex_unlock "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_pthread_cond_broadcast pthread_cond_broadcast "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_pthread_setspecific pthread_setspecific "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_pthread_self pthread_self "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_pthread_get_stacksize_np pthread_get_stacksize_np "/usr/lib/libSystem.B.dylib" -//go:cgo_import_dynamic purego_pthread_attr_setstacksize pthread_attr_setstacksize "/usr/lib/libSystem.B.dylib" - -//go:nosplit -//go:norace -func pthread_self() pthread_t { - return pthread_t(call5(pthread_selfABI0, 0, 0, 0, 0, 0)) -} - -//go:nosplit -//go:norace -func pthread_get_stacksize_np(thread pthread_t) size_t { - return size_t(call5(pthread_get_stacksize_npABI0, uintptr(thread), 0, 0, 0, 0)) -} - -//go:nosplit -//go:norace -func pthread_attr_setstacksize(attr *pthread_attr_t, size size_t) int32 { - return int32(call5(pthread_attr_setstacksizeABI0, uintptr(unsafe.Pointer(attr)), uintptr(size), 0, 0, 0)) -} - -//go:linkname _pthread_self _pthread_self -var _pthread_self uint8 -var pthread_selfABI0 = uintptr(unsafe.Pointer(&_pthread_self)) - -//go:linkname _pthread_get_stacksize_np _pthread_get_stacksize_np -var _pthread_get_stacksize_np uint8 -var pthread_get_stacksize_npABI0 = uintptr(unsafe.Pointer(&_pthread_get_stacksize_np)) - -//go:linkname _pthread_attr_setstacksize _pthread_attr_setstacksize -var _pthread_attr_setstacksize uint8 -var pthread_attr_setstacksizeABI0 = uintptr(unsafe.Pointer(&_pthread_attr_setstacksize)) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_freebsd.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_freebsd.go deleted file mode 100644 index d69775596fd..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_freebsd.go +++ /dev/null @@ -1,48 +0,0 @@ -// Code generated by 'go generate' with gen.go. DO NOT EDIT. - -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo - -package fakecgo - -import "unsafe" - -//go:cgo_import_dynamic purego_malloc malloc "libc.so.7" -//go:cgo_import_dynamic purego_free free "libc.so.7" -//go:cgo_import_dynamic purego_setenv setenv "libc.so.7" -//go:cgo_import_dynamic purego_unsetenv unsetenv "libc.so.7" -//go:cgo_import_dynamic purego_sigfillset sigfillset "libc.so.7" -//go:cgo_import_dynamic purego_nanosleep nanosleep "libc.so.7" -//go:cgo_import_dynamic purego_abort abort "libc.so.7" -//go:cgo_import_dynamic purego_pthread_attr_init pthread_attr_init "libpthread.so" -//go:cgo_import_dynamic purego_pthread_create pthread_create "libpthread.so" -//go:cgo_import_dynamic purego_pthread_detach pthread_detach "libpthread.so" -//go:cgo_import_dynamic purego_pthread_sigmask pthread_sigmask "libpthread.so" -//go:cgo_import_dynamic purego_pthread_mutex_lock pthread_mutex_lock "libpthread.so" -//go:cgo_import_dynamic purego_pthread_mutex_unlock pthread_mutex_unlock "libpthread.so" -//go:cgo_import_dynamic purego_pthread_cond_broadcast pthread_cond_broadcast "libpthread.so" -//go:cgo_import_dynamic purego_pthread_setspecific pthread_setspecific "libpthread.so" -//go:cgo_import_dynamic purego_pthread_attr_getstacksize pthread_attr_getstacksize "libpthread.so" -//go:cgo_import_dynamic purego_pthread_attr_destroy pthread_attr_destroy "libpthread.so" - -//go:nosplit -//go:norace -func pthread_attr_getstacksize(attr *pthread_attr_t, stacksize *size_t) int32 { - return int32(call5(pthread_attr_getstacksizeABI0, uintptr(unsafe.Pointer(attr)), uintptr(unsafe.Pointer(stacksize)), 0, 0, 0)) -} - -//go:nosplit -//go:norace -func pthread_attr_destroy(attr *pthread_attr_t) int32 { - return int32(call5(pthread_attr_destroyABI0, uintptr(unsafe.Pointer(attr)), 0, 0, 0, 0)) -} - -//go:linkname _pthread_attr_getstacksize _pthread_attr_getstacksize -var _pthread_attr_getstacksize uint8 -var pthread_attr_getstacksizeABI0 = uintptr(unsafe.Pointer(&_pthread_attr_getstacksize)) - -//go:linkname _pthread_attr_destroy _pthread_attr_destroy -var _pthread_attr_destroy uint8 -var pthread_attr_destroyABI0 = uintptr(unsafe.Pointer(&_pthread_attr_destroy)) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_linux.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_linux.go deleted file mode 100644 index f6bad22c340..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_linux.go +++ /dev/null @@ -1,48 +0,0 @@ -// Code generated by 'go generate' with gen.go. DO NOT EDIT. - -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo - -package fakecgo - -import "unsafe" - -//go:cgo_import_dynamic purego_malloc malloc "libc.so.6" -//go:cgo_import_dynamic purego_free free "libc.so.6" -//go:cgo_import_dynamic purego_setenv setenv "libc.so.6" -//go:cgo_import_dynamic purego_unsetenv unsetenv "libc.so.6" -//go:cgo_import_dynamic purego_sigfillset sigfillset "libc.so.6" -//go:cgo_import_dynamic purego_nanosleep nanosleep "libc.so.6" -//go:cgo_import_dynamic purego_abort abort "libc.so.6" -//go:cgo_import_dynamic purego_pthread_attr_init pthread_attr_init "libpthread.so.0" -//go:cgo_import_dynamic purego_pthread_create pthread_create "libpthread.so.0" -//go:cgo_import_dynamic purego_pthread_detach pthread_detach "libpthread.so.0" -//go:cgo_import_dynamic purego_pthread_sigmask pthread_sigmask "libpthread.so.0" -//go:cgo_import_dynamic purego_pthread_mutex_lock pthread_mutex_lock "libpthread.so.0" -//go:cgo_import_dynamic purego_pthread_mutex_unlock pthread_mutex_unlock "libpthread.so.0" -//go:cgo_import_dynamic purego_pthread_cond_broadcast pthread_cond_broadcast "libpthread.so.0" -//go:cgo_import_dynamic purego_pthread_setspecific pthread_setspecific "libpthread.so.0" -//go:cgo_import_dynamic purego_pthread_attr_getstacksize pthread_attr_getstacksize "libpthread.so.0" -//go:cgo_import_dynamic purego_pthread_attr_destroy pthread_attr_destroy "libpthread.so.0" - -//go:nosplit -//go:norace -func pthread_attr_getstacksize(attr *pthread_attr_t, stacksize *size_t) int32 { - return int32(call5(pthread_attr_getstacksizeABI0, uintptr(unsafe.Pointer(attr)), uintptr(unsafe.Pointer(stacksize)), 0, 0, 0)) -} - -//go:nosplit -//go:norace -func pthread_attr_destroy(attr *pthread_attr_t) int32 { - return int32(call5(pthread_attr_destroyABI0, uintptr(unsafe.Pointer(attr)), 0, 0, 0, 0)) -} - -//go:linkname _pthread_attr_getstacksize _pthread_attr_getstacksize -var _pthread_attr_getstacksize uint8 -var pthread_attr_getstacksizeABI0 = uintptr(unsafe.Pointer(&_pthread_attr_getstacksize)) - -//go:linkname _pthread_attr_destroy _pthread_attr_destroy -var _pthread_attr_destroy uint8 -var pthread_attr_destroyABI0 = uintptr(unsafe.Pointer(&_pthread_attr_destroy)) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_netbsd.go b/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_netbsd.go deleted file mode 100644 index 774402cfb8b..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/zsymbols_netbsd.go +++ /dev/null @@ -1,59 +0,0 @@ -// Code generated by 'go generate' with gen.go. DO NOT EDIT. - -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo - -package fakecgo - -import "unsafe" - -//go:cgo_import_dynamic purego_malloc malloc "libc.so" -//go:cgo_import_dynamic purego_free free "libc.so" -//go:cgo_import_dynamic purego_setenv setenv "libc.so" -//go:cgo_import_dynamic purego_unsetenv unsetenv "libc.so" -//go:cgo_import_dynamic purego_sigfillset sigfillset "libc.so" -//go:cgo_import_dynamic purego_nanosleep nanosleep "libc.so" -//go:cgo_import_dynamic purego_abort abort "libc.so" -//go:cgo_import_dynamic purego_sigaltstack sigaltstack "libc.so" -//go:cgo_import_dynamic purego_pthread_attr_init pthread_attr_init "libpthread.so" -//go:cgo_import_dynamic purego_pthread_create pthread_create "libpthread.so" -//go:cgo_import_dynamic purego_pthread_detach pthread_detach "libpthread.so" -//go:cgo_import_dynamic purego_pthread_sigmask pthread_sigmask "libpthread.so" -//go:cgo_import_dynamic purego_pthread_mutex_lock pthread_mutex_lock "libpthread.so" -//go:cgo_import_dynamic purego_pthread_mutex_unlock pthread_mutex_unlock "libpthread.so" -//go:cgo_import_dynamic purego_pthread_cond_broadcast pthread_cond_broadcast "libpthread.so" -//go:cgo_import_dynamic purego_pthread_setspecific pthread_setspecific "libpthread.so" -//go:cgo_import_dynamic purego_pthread_attr_getstacksize pthread_attr_getstacksize "libpthread.so" -//go:cgo_import_dynamic purego_pthread_attr_destroy pthread_attr_destroy "libpthread.so" - -//go:nosplit -//go:norace -func sigaltstack(ss *stack_t, old_ss *stack_t) int32 { - return int32(call5(sigaltstackABI0, uintptr(unsafe.Pointer(ss)), uintptr(unsafe.Pointer(old_ss)), 0, 0, 0)) -} - -//go:nosplit -//go:norace -func pthread_attr_getstacksize(attr *pthread_attr_t, stacksize *size_t) int32 { - return int32(call5(pthread_attr_getstacksizeABI0, uintptr(unsafe.Pointer(attr)), uintptr(unsafe.Pointer(stacksize)), 0, 0, 0)) -} - -//go:nosplit -//go:norace -func pthread_attr_destroy(attr *pthread_attr_t) int32 { - return int32(call5(pthread_attr_destroyABI0, uintptr(unsafe.Pointer(attr)), 0, 0, 0, 0)) -} - -//go:linkname _sigaltstack _sigaltstack -var _sigaltstack uint8 -var sigaltstackABI0 = uintptr(unsafe.Pointer(&_sigaltstack)) - -//go:linkname _pthread_attr_getstacksize _pthread_attr_getstacksize -var _pthread_attr_getstacksize uint8 -var pthread_attr_getstacksizeABI0 = uintptr(unsafe.Pointer(&_pthread_attr_getstacksize)) - -//go:linkname _pthread_attr_destroy _pthread_attr_destroy -var _pthread_attr_destroy uint8 -var pthread_attr_destroyABI0 = uintptr(unsafe.Pointer(&_pthread_attr_destroy)) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_darwin.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_darwin.s deleted file mode 100644 index 35ef7ac11cb..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_darwin.s +++ /dev/null @@ -1,19 +0,0 @@ -// Code generated by 'go generate' with gen.go. DO NOT EDIT. - -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo - -#include "textflag.h" - -// these stubs are here because it is not possible to go:linkname directly the C functions - -TEXT _pthread_self(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_self(SB) - -TEXT _pthread_get_stacksize_np(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_get_stacksize_np(SB) - -TEXT _pthread_attr_setstacksize(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_attr_setstacksize(SB) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_freebsd.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_freebsd.s deleted file mode 100644 index da07005c0bc..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_freebsd.s +++ /dev/null @@ -1,16 +0,0 @@ -// Code generated by 'go generate' with gen.go. DO NOT EDIT. - -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo - -#include "textflag.h" - -// these stubs are here because it is not possible to go:linkname directly the C functions - -TEXT _pthread_attr_getstacksize(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_attr_getstacksize(SB) - -TEXT _pthread_attr_destroy(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_attr_destroy(SB) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_linux.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_linux.s deleted file mode 100644 index da07005c0bc..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_linux.s +++ /dev/null @@ -1,16 +0,0 @@ -// Code generated by 'go generate' with gen.go. DO NOT EDIT. - -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo - -#include "textflag.h" - -// these stubs are here because it is not possible to go:linkname directly the C functions - -TEXT _pthread_attr_getstacksize(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_attr_getstacksize(SB) - -TEXT _pthread_attr_destroy(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_attr_destroy(SB) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_netbsd.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_netbsd.s deleted file mode 100644 index 81ef76f59c0..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_netbsd.s +++ /dev/null @@ -1,19 +0,0 @@ -// Code generated by 'go generate' with gen.go. DO NOT EDIT. - -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo - -#include "textflag.h" - -// these stubs are here because it is not possible to go:linkname directly the C functions - -TEXT _sigaltstack(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_sigaltstack(SB) - -TEXT _pthread_attr_getstacksize(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_attr_getstacksize(SB) - -TEXT _pthread_attr_destroy(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_attr_destroy(SB) diff --git a/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_stubs.s b/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_stubs.s deleted file mode 100644 index 8e1afff734b..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/fakecgo/ztrampolines_stubs.s +++ /dev/null @@ -1,55 +0,0 @@ -// Code generated by 'go generate' with gen.go. DO NOT EDIT. - -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo && (darwin || freebsd || linux || netbsd) - -#include "textflag.h" - -// these stubs are here because it is not possible to go:linkname directly the C functions - -TEXT _malloc(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_malloc(SB) - -TEXT _free(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_free(SB) - -TEXT _setenv(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_setenv(SB) - -TEXT _unsetenv(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_unsetenv(SB) - -TEXT _sigfillset(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_sigfillset(SB) - -TEXT _nanosleep(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_nanosleep(SB) - -TEXT _abort(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_abort(SB) - -TEXT _pthread_attr_init(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_attr_init(SB) - -TEXT _pthread_create(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_create(SB) - -TEXT _pthread_detach(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_detach(SB) - -TEXT _pthread_sigmask(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_sigmask(SB) - -TEXT _pthread_mutex_lock(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_mutex_lock(SB) - -TEXT _pthread_mutex_unlock(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_mutex_unlock(SB) - -TEXT _pthread_cond_broadcast(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_cond_broadcast(SB) - -TEXT _pthread_setspecific(SB), NOSPLIT|NOFRAME, $0-0 - JMP purego_pthread_setspecific(SB) diff --git a/vendor/github.com/ebitengine/purego/internal/strings/strings.go b/vendor/github.com/ebitengine/purego/internal/strings/strings.go deleted file mode 100644 index 5b0d2522554..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/strings/strings.go +++ /dev/null @@ -1,40 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -package strings - -import ( - "unsafe" -) - -// hasSuffix tests whether the string s ends with suffix. -func hasSuffix(s, suffix string) bool { - return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix -} - -// CString converts a go string to *byte that can be passed to C code. -func CString(name string) *byte { - if hasSuffix(name, "\x00") { - return &(*(*[]byte)(unsafe.Pointer(&name)))[0] - } - b := make([]byte, len(name)+1) - copy(b, name) - return &b[0] -} - -// GoString copies a null-terminated char* to a Go string. -func GoString(c uintptr) string { - // We take the address and then dereference it to trick go vet from creating a possible misuse of unsafe.Pointer - ptr := *(*unsafe.Pointer)(unsafe.Pointer(&c)) - if ptr == nil { - return "" - } - var length int - for { - if *(*byte)(unsafe.Add(ptr, uintptr(length))) == '\x00' { - break - } - length++ - } - return string(unsafe.Slice((*byte)(ptr), length)) -} diff --git a/vendor/github.com/ebitengine/purego/internal/xreflect/reflect_go124.go b/vendor/github.com/ebitengine/purego/internal/xreflect/reflect_go124.go deleted file mode 100644 index 5eb0580e02a..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/xreflect/reflect_go124.go +++ /dev/null @@ -1,15 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2025 The Ebitengine Authors - -//go:build !go1.25 - -package xreflect - -import "reflect" - -// TODO: remove this and use Go 1.25's reflect.TypeAssert when minimum go.mod version is 1.25 - -func TypeAssert[T any](v reflect.Value) (T, bool) { - v2, ok := v.Interface().(T) - return v2, ok -} diff --git a/vendor/github.com/ebitengine/purego/internal/xreflect/reflect_go125.go b/vendor/github.com/ebitengine/purego/internal/xreflect/reflect_go125.go deleted file mode 100644 index 62ee13d6c35..00000000000 --- a/vendor/github.com/ebitengine/purego/internal/xreflect/reflect_go125.go +++ /dev/null @@ -1,12 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2025 The Ebitengine Authors - -//go:build go1.25 - -package xreflect - -import "reflect" - -func TypeAssert[T any](v reflect.Value) (T, bool) { - return reflect.TypeAssert[T](v) -} diff --git a/vendor/github.com/ebitengine/purego/is_ios.go b/vendor/github.com/ebitengine/purego/is_ios.go deleted file mode 100644 index ed31da97824..00000000000 --- a/vendor/github.com/ebitengine/purego/is_ios.go +++ /dev/null @@ -1,13 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo - -package purego - -// if you are getting this error it means that you have -// CGO_ENABLED=0 while trying to build for ios. -// purego does not support this mode yet. -// the fix is to set CGO_ENABLED=1 which will require -// a C compiler. -var _ = _PUREGO_REQUIRES_CGO_ON_IOS diff --git a/vendor/github.com/ebitengine/purego/nocgo.go b/vendor/github.com/ebitengine/purego/nocgo.go deleted file mode 100644 index b91b9796b9b..00000000000 --- a/vendor/github.com/ebitengine/purego/nocgo.go +++ /dev/null @@ -1,25 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !cgo && (darwin || freebsd || linux || netbsd) - -package purego - -// if CGO_ENABLED=0 import fakecgo to setup the Cgo runtime correctly. -// This is required since some frameworks need TLS setup the C way which Go doesn't do. -// We currently don't support ios in fakecgo mode so force Cgo or fail -// -// The way that the Cgo runtime (runtime/cgo) works is by setting some variables found -// in runtime with non-null GCC compiled functions. The variables that are replaced are -// var ( -// iscgo bool // in runtime/cgo.go -// _cgo_init unsafe.Pointer // in runtime/cgo.go -// _cgo_thread_start unsafe.Pointer // in runtime/cgo.go -// _cgo_notify_runtime_init_done unsafe.Pointer // in runtime/cgo.go -// _cgo_setenv unsafe.Pointer // in runtime/env_posix.go -// _cgo_unsetenv unsafe.Pointer // in runtime/env_posix.go -// ) -// importing fakecgo will set these (using //go:linkname) with functions written -// entirely in Go (except for some assembly trampolines to change GCC ABI to Go ABI). -// Doing so makes it possible to build applications that call into C without CGO_ENABLED=1. -import _ "github.com/ebitengine/purego/internal/fakecgo" diff --git a/vendor/github.com/ebitengine/purego/struct_386.go b/vendor/github.com/ebitengine/purego/struct_386.go deleted file mode 100644 index 02c8ac45cef..00000000000 --- a/vendor/github.com/ebitengine/purego/struct_386.go +++ /dev/null @@ -1,41 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2025 The Ebitengine Authors - -package purego - -import "reflect" - -func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any { - panic("purego: struct arguments are not supported") -} - -func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) { - panic("purego: struct returns are not supported") -} - -func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) { - panic("purego: placeRegisters not implemented on 386") -} - -// shouldBundleStackArgs always returns false on 386 -// since C-style stack argument bundling is only needed on Darwin ARM64. -func shouldBundleStackArgs(v reflect.Value, numInts, numFloats int) bool { - return false -} - -// structFitsInRegisters is not used on 386. -func structFitsInRegisters(val reflect.Value, tempNumInts, tempNumFloats int) (bool, int, int) { - panic("purego: structFitsInRegisters should not be called on 386") -} - -// collectStackArgs is not used on 386. -func collectStackArgs(args []reflect.Value, startIdx int, numInts, numFloats int, - keepAlive []any, addInt, addFloat, addStack func(uintptr), - pNumInts, pNumFloats, pNumStack *int) ([]reflect.Value, []any) { - panic("purego: collectStackArgs should not be called on 386") -} - -// bundleStackArgs is not used on 386. -func bundleStackArgs(stackArgs []reflect.Value, addStack func(uintptr)) { - panic("purego: bundleStackArgs should not be called on 386") -} diff --git a/vendor/github.com/ebitengine/purego/struct_amd64.go b/vendor/github.com/ebitengine/purego/struct_amd64.go deleted file mode 100644 index c56f957af24..00000000000 --- a/vendor/github.com/ebitengine/purego/struct_amd64.go +++ /dev/null @@ -1,286 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2024 The Ebitengine Authors - -package purego - -import ( - "math" - "reflect" - "unsafe" -) - -func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) { - outSize := outType.Size() - switch { - case outSize == 0: - return reflect.New(outType).Elem() - case outSize <= 8: - if isAllFloats(outType) { - // 2 float32s or 1 float64s are return in the float register - return reflect.NewAt(outType, unsafe.Pointer(&struct{ a uintptr }{syscall.f1})).Elem() - } - // up to 8 bytes is returned in RAX - return reflect.NewAt(outType, unsafe.Pointer(&struct{ a uintptr }{syscall.a1})).Elem() - case outSize <= 16: - r1, r2 := syscall.a1, syscall.a2 - if isAllFloats(outType) { - r1 = syscall.f1 - r2 = syscall.f2 - } else { - // check first 8 bytes if it's floats - hasFirstFloat := false - f1 := outType.Field(0).Type - if f1.Kind() == reflect.Float64 || f1.Kind() == reflect.Float32 && outType.Field(1).Type.Kind() == reflect.Float32 { - r1 = syscall.f1 - hasFirstFloat = true - } - - // find index of the field that starts the second 8 bytes - var i int - for i = 0; i < outType.NumField(); i++ { - if outType.Field(i).Offset == 8 { - break - } - } - - // check last 8 bytes if they are floats - f1 = outType.Field(i).Type - if f1.Kind() == reflect.Float64 || f1.Kind() == reflect.Float32 && i+1 == outType.NumField() { - r2 = syscall.f1 - } else if hasFirstFloat { - // if the first field was a float then that means the second integer field - // comes from the first integer register - r2 = syscall.a1 - } - } - return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b uintptr }{r1, r2})).Elem() - default: - // create struct from the Go pointer created above - // weird pointer dereference to circumvent go vet - return reflect.NewAt(outType, *(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1))).Elem() - } -} - -func isAllFloats(ty reflect.Type) bool { - for i := 0; i < ty.NumField(); i++ { - f := ty.Field(i) - switch f.Type.Kind() { - case reflect.Float64, reflect.Float32: - default: - return false - } - } - return true -} - -// https://refspecs.linuxbase.org/elf/x86_64-abi-0.99.pdf -// https://gitlab.com/x86-psABIs/x86-64-ABI -// Class determines where the 8 byte value goes. -// Higher value classes win over lower value classes -const ( - _NO_CLASS = 0b0000 - _SSE = 0b0001 - _X87 = 0b0011 // long double not used in Go - _INTEGER = 0b0111 - _MEMORY = 0b1111 -) - -func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any { - if v.Type().Size() == 0 { - return keepAlive - } - - // if greater than 64 bytes place on stack - if v.Type().Size() > 8*8 { - placeStack(v, addStack) - return keepAlive - } - var ( - savedNumFloats = *numFloats - savedNumInts = *numInts - savedNumStack = *numStack - ) - placeOnStack := postMerger(v.Type()) || !tryPlaceRegister(v, addFloat, addInt) - if placeOnStack { - // reset any values placed in registers - *numFloats = savedNumFloats - *numInts = savedNumInts - *numStack = savedNumStack - placeStack(v, addStack) - } - return keepAlive -} - -func postMerger(t reflect.Type) (passInMemory bool) { - // (c) If the size of the aggregate exceeds two eightbytes and the first eight- byte isn’t SSE or any other - // eightbyte isn’t SSEUP, the whole argument is passed in memory. - if t.Kind() != reflect.Struct { - return false - } - if t.Size() <= 2*8 { - return false - } - return true // Go does not have an SSE/SSEUP type so this is always true -} - -func tryPlaceRegister(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) (ok bool) { - ok = true - var val uint64 - var shift byte // # of bits to shift - var flushed bool - class := _NO_CLASS - flushIfNeeded := func() { - if flushed { - return - } - flushed = true - if class == _SSE { - addFloat(uintptr(val)) - } else { - addInt(uintptr(val)) - } - val = 0 - shift = 0 - class = _NO_CLASS - } - var place func(v reflect.Value) - place = func(v reflect.Value) { - var numFields int - if v.Kind() == reflect.Struct { - numFields = v.Type().NumField() - } else { - numFields = v.Type().Len() - } - - for i := 0; i < numFields; i++ { - flushed = false - var f reflect.Value - if v.Kind() == reflect.Struct { - f = v.Field(i) - } else { - f = v.Index(i) - } - switch f.Kind() { - case reflect.Struct: - place(f) - case reflect.Bool: - if f.Bool() { - val |= 1 << shift - } - shift += 8 - class |= _INTEGER - case reflect.Pointer, reflect.UnsafePointer: - val = uint64(f.Pointer()) - shift = 64 - class = _INTEGER - case reflect.Int8: - val |= uint64(f.Int()&0xFF) << shift - shift += 8 - class |= _INTEGER - case reflect.Int16: - val |= uint64(f.Int()&0xFFFF) << shift - shift += 16 - class |= _INTEGER - case reflect.Int32: - val |= uint64(f.Int()&0xFFFF_FFFF) << shift - shift += 32 - class |= _INTEGER - case reflect.Int64, reflect.Int: - val = uint64(f.Int()) - shift = 64 - class = _INTEGER - case reflect.Uint8: - val |= f.Uint() << shift - shift += 8 - class |= _INTEGER - case reflect.Uint16: - val |= f.Uint() << shift - shift += 16 - class |= _INTEGER - case reflect.Uint32: - val |= f.Uint() << shift - shift += 32 - class |= _INTEGER - case reflect.Uint64, reflect.Uint, reflect.Uintptr: - val = f.Uint() - shift = 64 - class = _INTEGER - case reflect.Float32: - val |= uint64(math.Float32bits(float32(f.Float()))) << shift - shift += 32 - class |= _SSE - case reflect.Float64: - if v.Type().Size() > 16 { - ok = false - return - } - val = uint64(math.Float64bits(f.Float())) - shift = 64 - class = _SSE - case reflect.Array: - place(f) - default: - panic("purego: unsupported kind " + f.Kind().String()) - } - - if shift == 64 { - flushIfNeeded() - } else if shift > 64 { - // Should never happen, but may if we forget to reset shift after flush (or forget to flush), - // better fall apart here, than corrupt arguments. - panic("purego: tryPlaceRegisters shift > 64") - } - } - } - - place(v) - flushIfNeeded() - return ok -} - -func placeStack(v reflect.Value, addStack func(uintptr)) { - // Copy the struct as a contiguous block of memory in eightbyte (8-byte) - // chunks. The x86-64 ABI requires structs passed on the stack to be - // laid out exactly as in memory, including padding and field packing - // within eightbytes. Decomposing field-by-field would place each field - // as a separate stack slot, breaking structs with mixed-type fields - // that share an eightbyte (e.g. int32 + float32). - if !v.CanAddr() { - tmp := reflect.New(v.Type()).Elem() - tmp.Set(v) - v = tmp - } - ptr := v.Addr().UnsafePointer() - size := v.Type().Size() - for off := uintptr(0); off < size; off += 8 { - chunk := *(*uintptr)(unsafe.Add(ptr, off)) - addStack(chunk) - } -} - -func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) { - panic("purego: placeRegisters not implemented on amd64") -} - -// shouldBundleStackArgs always returns false on non-Darwin platforms -// since C-style stack argument bundling is only needed on Darwin ARM64. -func shouldBundleStackArgs(v reflect.Value, numInts, numFloats int) bool { - return false -} - -// structFitsInRegisters is not used on amd64. -func structFitsInRegisters(val reflect.Value, tempNumInts, tempNumFloats int) (bool, int, int) { - panic("purego: structFitsInRegisters should not be called on amd64") -} - -// collectStackArgs is not used on amd64. -func collectStackArgs(args []reflect.Value, startIdx int, numInts, numFloats int, - keepAlive []any, addInt, addFloat, addStack func(uintptr), - pNumInts, pNumFloats, pNumStack *int) ([]reflect.Value, []any) { - panic("purego: collectStackArgs should not be called on amd64") -} - -// bundleStackArgs is not used on amd64. -func bundleStackArgs(stackArgs []reflect.Value, addStack func(uintptr)) { - panic("purego: bundleStackArgs should not be called on amd64") -} diff --git a/vendor/github.com/ebitengine/purego/struct_arm.go b/vendor/github.com/ebitengine/purego/struct_arm.go deleted file mode 100644 index 1b580585d3d..00000000000 --- a/vendor/github.com/ebitengine/purego/struct_arm.go +++ /dev/null @@ -1,85 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2025 The Ebitengine Authors - -package purego - -import ( - "reflect" - "unsafe" -) - -func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any { - size := v.Type().Size() - if size == 0 { - return keepAlive - } - - // TODO: ARM EABI: small structs are passed in registers or on stack - // For simplicity, pass by pointer for now - ptr := v.Addr().UnsafePointer() - keepAlive = append(keepAlive, ptr) - if *numInts < 4 { - addInt(uintptr(ptr)) - *numInts++ - } else { - addStack(uintptr(ptr)) - *numStack++ - } - return keepAlive -} - -func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) { - outSize := outType.Size() - if outSize == 0 { - return reflect.New(outType).Elem() - } - if outSize <= 4 { - // Fits in one register - return reflect.NewAt(outType, unsafe.Pointer(&struct{ a uintptr }{syscall.a1})).Elem() - } - if outSize <= 8 { - // Fits in two registers - return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b uintptr }{syscall.a1, syscall.a2})).Elem() - } - // Larger structs returned via pointer in a1 - return reflect.NewAt(outType, *(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1))).Elem() -} - -func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) { - // TODO: For ARM32, just pass the struct data directly - // This is a simplified implementation - size := v.Type().Size() - if size == 0 { - return - } - ptr := unsafe.Pointer(v.UnsafeAddr()) - if size <= 4 { - addInt(*(*uintptr)(ptr)) - } else if size <= 8 { - addInt(*(*uintptr)(ptr)) - addInt(*(*uintptr)(unsafe.Add(ptr, 4))) - } -} - -// shouldBundleStackArgs always returns false on arm -// since C-style stack argument bundling is only needed on Darwin ARM64. -func shouldBundleStackArgs(v reflect.Value, numInts, numFloats int) bool { - return false -} - -// structFitsInRegisters is not used on arm. -func structFitsInRegisters(val reflect.Value, tempNumInts, tempNumFloats int) (bool, int, int) { - panic("purego: structFitsInRegisters should not be called on arm") -} - -// collectStackArgs is not used on arm. -func collectStackArgs(args []reflect.Value, startIdx int, numInts, numFloats int, - keepAlive []any, addInt, addFloat, addStack func(uintptr), - pNumInts, pNumFloats, pNumStack *int) ([]reflect.Value, []any) { - panic("purego: collectStackArgs should not be called on arm") -} - -// bundleStackArgs is not used on arm. -func bundleStackArgs(stackArgs []reflect.Value, addStack func(uintptr)) { - panic("purego: bundleStackArgs should not be called on arm") -} diff --git a/vendor/github.com/ebitengine/purego/struct_arm64.go b/vendor/github.com/ebitengine/purego/struct_arm64.go deleted file mode 100644 index 5f347c83d00..00000000000 --- a/vendor/github.com/ebitengine/purego/struct_arm64.go +++ /dev/null @@ -1,549 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2024 The Ebitengine Authors - -package purego - -import ( - "math" - "reflect" - "runtime" - "strconv" - stdstrings "strings" - "unsafe" - - "github.com/ebitengine/purego/internal/strings" -) - -func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) { - outSize := outType.Size() - switch { - case outSize == 0: - return reflect.New(outType).Elem() - case outSize <= 8: - r1 := syscall.a1 - if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats { - r1 = syscall.f1 - if numFields == 2 { - r1 = syscall.f2<<32 | syscall.f1 - } - } - return reflect.NewAt(outType, unsafe.Pointer(&struct{ a uintptr }{r1})).Elem() - case outSize <= 16: - r1, r2 := syscall.a1, syscall.a2 - if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats { - switch numFields { - case 4: - r1 = syscall.f2<<32 | syscall.f1 - r2 = syscall.f4<<32 | syscall.f3 - case 3: - r1 = syscall.f2<<32 | syscall.f1 - r2 = syscall.f3 - case 2: - r1 = syscall.f1 - r2 = syscall.f2 - default: - panic("unreachable") - } - } - return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b uintptr }{r1, r2})).Elem() - default: - if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats && numFields <= 4 { - switch numFields { - case 4: - return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b, c, d uintptr }{syscall.f1, syscall.f2, syscall.f3, syscall.f4})).Elem() - case 3: - return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b, c uintptr }{syscall.f1, syscall.f2, syscall.f3})).Elem() - default: - panic("unreachable") - } - } - // create struct from the Go pointer created in arm64_r8 - // weird pointer dereference to circumvent go vet - return reflect.NewAt(outType, *(*unsafe.Pointer)(unsafe.Pointer(&syscall.arm64_r8))).Elem() - } -} - -// https://github.com/ARM-software/abi-aa/blob/main/sysvabi64/sysvabi64.rst -const ( - _NO_CLASS = 0b00 - _FLOAT = 0b01 - _INT = 0b11 -) - -func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any { - if v.Type().Size() == 0 { - return keepAlive - } - - if hva, hfa, size := isHVA(v.Type()), isHFA(v.Type()), v.Type().Size(); hva || hfa || size <= 16 { - // if this doesn't fit entirely in registers then - // each element goes onto the stack - if hfa && *numFloats+v.NumField() > numOfFloatRegisters() { - *numFloats = numOfFloatRegisters() - } else if hva && *numInts+v.NumField() > numOfIntegerRegisters() { - *numInts = numOfIntegerRegisters() - } - - placeRegisters(v, addFloat, addInt) - } else { - keepAlive = placeStack(v, keepAlive, addInt) - } - return keepAlive // the struct was allocated so don't panic -} - -func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) { - if runtime.GOOS == "darwin" { - placeRegistersDarwin(v, addFloat, addInt) - return - } - placeRegistersArm64(v, addFloat, addInt) -} - -func placeRegistersArm64(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) { - var val uint64 - var shift byte - var flushed bool - class := _NO_CLASS - var place func(v reflect.Value) - place = func(v reflect.Value) { - var numFields int - if v.Kind() == reflect.Struct { - numFields = v.Type().NumField() - } else { - numFields = v.Type().Len() - } - for k := 0; k < numFields; k++ { - flushed = false - var f reflect.Value - if v.Kind() == reflect.Struct { - f = v.Field(k) - } else { - f = v.Index(k) - } - align := byte(f.Type().Align()*8 - 1) - shift = (shift + align) &^ align - if shift >= 64 { - shift = 0 - flushed = true - if class == _FLOAT { - addFloat(uintptr(val)) - } else { - addInt(uintptr(val)) - } - val = 0 - class = _NO_CLASS - } - switch f.Type().Kind() { - case reflect.Struct: - place(f) - case reflect.Bool: - if f.Bool() { - val |= 1 << shift - } - shift += 8 - class |= _INT - case reflect.Uint8: - val |= f.Uint() << shift - shift += 8 - class |= _INT - case reflect.Uint16: - val |= f.Uint() << shift - shift += 16 - class |= _INT - case reflect.Uint32: - val |= f.Uint() << shift - shift += 32 - class |= _INT - case reflect.Uint64, reflect.Uint, reflect.Uintptr: - addInt(uintptr(f.Uint())) - shift = 0 - flushed = true - class = _NO_CLASS - case reflect.Int8: - val |= uint64(f.Int()&0xFF) << shift - shift += 8 - class |= _INT - case reflect.Int16: - val |= uint64(f.Int()&0xFFFF) << shift - shift += 16 - class |= _INT - case reflect.Int32: - val |= uint64(f.Int()&0xFFFF_FFFF) << shift - shift += 32 - class |= _INT - case reflect.Int64, reflect.Int: - addInt(uintptr(f.Int())) - shift = 0 - flushed = true - class = _NO_CLASS - case reflect.Float32: - if class == _FLOAT { - addFloat(uintptr(val)) - val = 0 - shift = 0 - } - val |= uint64(math.Float32bits(float32(f.Float()))) << shift - shift += 32 - class |= _FLOAT - case reflect.Float64: - addFloat(uintptr(math.Float64bits(float64(f.Float())))) - shift = 0 - flushed = true - class = _NO_CLASS - case reflect.Ptr, reflect.UnsafePointer: - addInt(f.Pointer()) - shift = 0 - flushed = true - class = _NO_CLASS - case reflect.Array: - place(f) - default: - panic("purego: unsupported kind " + f.Kind().String()) - } - } - } - place(v) - if !flushed { - if class == _FLOAT { - addFloat(uintptr(val)) - } else { - addInt(uintptr(val)) - } - } -} - -func placeStack(v reflect.Value, keepAlive []any, addInt func(uintptr)) []any { - // Struct is too big to be placed in registers. - // Copy to heap and place the pointer in register - ptrStruct := reflect.New(v.Type()) - ptrStruct.Elem().Set(v) - ptr := ptrStruct.Elem().Addr().UnsafePointer() - keepAlive = append(keepAlive, ptr) - addInt(uintptr(ptr)) - return keepAlive -} - -// isHFA reports a Homogeneous Floating-point Aggregate (HFA) which is a Fundamental Data Type that is a -// Floating-Point type and at most four uniquely addressable members (5.9.5.1 in [Arm64 Calling Convention]). -// This type of struct will be placed more compactly than the individual fields. -// -// [Arm64 Calling Convention]: https://github.com/ARM-software/abi-aa/blob/main/sysvabi64/sysvabi64.rst -func isHFA(t reflect.Type) bool { - // round up struct size to nearest 8 see section B.4 - structSize := roundUpTo8(t.Size()) - if structSize == 0 || t.NumField() > 4 { - return false - } - first := t.Field(0) - switch first.Type.Kind() { - case reflect.Float32, reflect.Float64: - firstKind := first.Type.Kind() - for i := 0; i < t.NumField(); i++ { - if t.Field(i).Type.Kind() != firstKind { - return false - } - } - return true - case reflect.Array: - switch first.Type.Elem().Kind() { - case reflect.Float32, reflect.Float64: - return true - default: - return false - } - case reflect.Struct: - for i := 0; i < first.Type.NumField(); i++ { - if !isHFA(first.Type) { - return false - } - } - return true - default: - return false - } -} - -// isHVA reports a Homogeneous Aggregate with a Fundamental Data Type that is a Short-Vector type -// and at most four uniquely addressable members (5.9.5.2 in [Arm64 Calling Convention]). -// A short vector is a machine type that is composed of repeated instances of one fundamental integral or -// floating-point type. It may be 8 or 16 bytes in total size (5.4 in [Arm64 Calling Convention]). -// This type of struct will be placed more compactly than the individual fields. -// -// [Arm64 Calling Convention]: https://github.com/ARM-software/abi-aa/blob/main/sysvabi64/sysvabi64.rst -func isHVA(t reflect.Type) bool { - // round up struct size to nearest 8 see section B.4 - structSize := roundUpTo8(t.Size()) - if structSize == 0 || (structSize != 8 && structSize != 16) { - return false - } - first := t.Field(0) - switch first.Type.Kind() { - case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Int8, reflect.Int16, reflect.Int32: - firstKind := first.Type.Kind() - for i := 0; i < t.NumField(); i++ { - if t.Field(i).Type.Kind() != firstKind { - return false - } - } - return true - case reflect.Array: - switch first.Type.Elem().Kind() { - case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Int8, reflect.Int16, reflect.Int32: - return true - default: - return false - } - default: - return false - } -} - -// copyStruct8ByteChunks copies struct memory in 8-byte chunks to the provided callback. -// This is used for Darwin ARM64's byte-level packing of non-HFA/HVA structs. -func copyStruct8ByteChunks(ptr unsafe.Pointer, size uintptr, addChunk func(uintptr)) { - if runtime.GOOS != "darwin" { - panic("purego: should only be called on darwin") - } - for offset := uintptr(0); offset < size; offset += 8 { - var chunk uintptr - remaining := size - offset - if remaining >= 8 { - chunk = *(*uintptr)(unsafe.Add(ptr, offset)) - } else { - // Read byte-by-byte to avoid reading beyond allocation - for i := uintptr(0); i < remaining; i++ { - b := *(*byte)(unsafe.Add(ptr, offset+i)) - chunk |= uintptr(b) << (i * 8) - } - } - addChunk(chunk) - } -} - -// placeRegisters implements Darwin ARM64 calling convention for struct arguments. -// -// For HFA/HVA structs, each element must go in a separate register (or stack slot for elements -// that don't fit in registers). We use placeRegistersArm64 for this. -// -// For non-HFA/HVA structs, Darwin uses byte-level packing. We copy the struct memory in -// 8-byte chunks, which works correctly for both register and stack placement. -func placeRegistersDarwin(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) { - if runtime.GOOS != "darwin" { - panic("purego: placeRegistersDarwin should only be called on darwin") - } - // Check if this is an HFA/HVA - hfa := isHFA(v.Type()) - hva := isHVA(v.Type()) - - // For HFA/HVA structs, use the standard ARM64 logic which places each element separately - if hfa || hva { - placeRegistersArm64(v, addFloat, addInt) - return - } - - // For non-HFA/HVA structs, use byte-level copying - // If the value is not addressable, create an addressable copy - if !v.CanAddr() { - addressable := reflect.New(v.Type()).Elem() - addressable.Set(v) - v = addressable - } - ptr := unsafe.Pointer(v.Addr().Pointer()) - size := v.Type().Size() - copyStruct8ByteChunks(ptr, size, addInt) -} - -// shouldBundleStackArgs determines if we need to start C-style packing for -// Darwin ARM64 stack arguments. This happens when registers are exhausted. -func shouldBundleStackArgs(v reflect.Value, numInts, numFloats int) bool { - if runtime.GOOS != "darwin" { - return false - } - - kind := v.Kind() - isFloat := kind == reflect.Float32 || kind == reflect.Float64 - isInt := !isFloat && kind != reflect.Struct - primitiveOnStack := - (isInt && numInts >= numOfIntegerRegisters()) || - (isFloat && numFloats >= numOfFloatRegisters()) - if primitiveOnStack { - return true - } - if kind != reflect.Struct { - return false - } - hfa := isHFA(v.Type()) - hva := isHVA(v.Type()) - size := v.Type().Size() - eligible := hfa || hva || size <= 16 - if !eligible { - return false - } - - if hfa { - need := v.NumField() - return numFloats+need > numOfFloatRegisters() - } - - if hva { - need := v.NumField() - return numInts+need > numOfIntegerRegisters() - } - - slotsNeeded := int((size + align8ByteMask) / align8ByteSize) - return numInts+slotsNeeded > numOfIntegerRegisters() -} - -// structFitsInRegisters determines if a struct can still fit in remaining -// registers, used during stack argument bundling to decide if a struct -// should go through normal register allocation or be bundled with stack args. -func structFitsInRegisters(val reflect.Value, tempNumInts, tempNumFloats int) (bool, int, int) { - if runtime.GOOS != "darwin" { - panic("purego: structFitsInRegisters should only be called on darwin") - } - hfa := isHFA(val.Type()) - hva := isHVA(val.Type()) - size := val.Type().Size() - - if hfa { - // HFA: check if elements fit in float registers - if tempNumFloats+val.NumField() <= numOfFloatRegisters() { - return true, tempNumInts, tempNumFloats + val.NumField() - } - } else if hva { - // HVA: check if elements fit in int registers - if tempNumInts+val.NumField() <= numOfIntegerRegisters() { - return true, tempNumInts + val.NumField(), tempNumFloats - } - } else if size <= 16 { - // Non-HFA/HVA small structs use int registers for byte-packing - slotsNeeded := int((size + align8ByteMask) / align8ByteSize) - if tempNumInts+slotsNeeded <= numOfIntegerRegisters() { - return true, tempNumInts + slotsNeeded, tempNumFloats - } - } - - return false, tempNumInts, tempNumFloats -} - -// collectStackArgs separates remaining arguments into those that fit in registers vs those that go on stack. -// It returns the stack arguments and processes register arguments through addValue. -func collectStackArgs(args []reflect.Value, startIdx int, numInts, numFloats int, - keepAlive []any, addInt, addFloat, addStack func(uintptr), - pNumInts, pNumFloats, pNumStack *int) ([]reflect.Value, []any) { - if runtime.GOOS != "darwin" { - panic("purego: collectStackArgs should only be called on darwin") - } - - var stackArgs []reflect.Value - tempNumInts := numInts - tempNumFloats := numFloats - - for j, val := range args[startIdx:] { - // Determine if this argument goes to register or stack - var fitsInRegister bool - var newNumInts, newNumFloats int - - if val.Kind() == reflect.Struct { - // Check if struct still fits in remaining registers - fitsInRegister, newNumInts, newNumFloats = structFitsInRegisters(val, tempNumInts, tempNumFloats) - } else { - // Primitive argument - isFloat := val.Kind() == reflect.Float32 || val.Kind() == reflect.Float64 - if isFloat { - fitsInRegister = tempNumFloats < numOfFloatRegisters() - newNumFloats = tempNumFloats + 1 - newNumInts = tempNumInts - } else { - fitsInRegister = tempNumInts < numOfIntegerRegisters() - newNumInts = tempNumInts + 1 - newNumFloats = tempNumFloats - } - } - - if fitsInRegister { - // Process through normal register allocation - tempNumInts = newNumInts - tempNumFloats = newNumFloats - keepAlive = addValue(val, keepAlive, addInt, addFloat, addStack, pNumInts, pNumFloats, pNumStack) - } else { - // Convert strings to C strings before bundling - if val.Kind() == reflect.String { - ptr := strings.CString(val.String()) - keepAlive = append(keepAlive, ptr) - val = reflect.ValueOf(ptr) - args[startIdx+j] = val - } - stackArgs = append(stackArgs, val) - } - } - - return stackArgs, keepAlive -} - -const ( - paddingFieldPrefix = "Pad" -) - -// bundleStackArgs bundles remaining arguments for Darwin ARM64 C-style stack packing. -// It creates a packed struct with proper alignment and copies it to the stack in 8-byte chunks. -func bundleStackArgs(stackArgs []reflect.Value, addStack func(uintptr)) { - if runtime.GOOS != "darwin" { - panic("purego: bundleStackArgs should only be called on darwin") - } - if len(stackArgs) == 0 { - return - } - - // Build struct fields with proper C alignment and padding - var fields []reflect.StructField - currentOffset := uintptr(0) - fieldIndex := 0 - - for j, val := range stackArgs { - valSize := val.Type().Size() - valAlign := val.Type().Align() - - // ARM64 requires 8-byte alignment for 8-byte or larger structs - if val.Kind() == reflect.Struct && valSize >= 8 { - valAlign = 8 - } - - // Add padding field if needed for alignment - if currentOffset%uintptr(valAlign) != 0 { - paddingNeeded := uintptr(valAlign) - (currentOffset % uintptr(valAlign)) - fields = append(fields, reflect.StructField{ - Name: paddingFieldPrefix + strconv.Itoa(fieldIndex), - Type: reflect.ArrayOf(int(paddingNeeded), reflect.TypeOf(byte(0))), - }) - currentOffset += paddingNeeded - fieldIndex++ - } - - fields = append(fields, reflect.StructField{ - Name: "X" + strconv.Itoa(j), - Type: val.Type(), - }) - currentOffset += valSize - fieldIndex++ - } - - // Create and populate the packed struct - structType := reflect.StructOf(fields) - structInstance := reflect.New(structType).Elem() - - // Set values (skip padding fields) - argIndex := 0 - for j := 0; j < structInstance.NumField(); j++ { - fieldName := structType.Field(j).Name - if stdstrings.HasPrefix(fieldName, paddingFieldPrefix) { - continue - } - structInstance.Field(j).Set(stackArgs[argIndex]) - argIndex++ - } - - ptr := unsafe.Pointer(structInstance.Addr().Pointer()) - size := structType.Size() - copyStruct8ByteChunks(ptr, size, addStack) -} diff --git a/vendor/github.com/ebitengine/purego/struct_loong64.go b/vendor/github.com/ebitengine/purego/struct_loong64.go deleted file mode 100644 index e5891401c93..00000000000 --- a/vendor/github.com/ebitengine/purego/struct_loong64.go +++ /dev/null @@ -1,213 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2025 The Ebitengine Authors - -package purego - -import ( - "math" - "reflect" - "unsafe" -) - -func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) { - outSize := outType.Size() - switch { - case outSize == 0: - return reflect.New(outType).Elem() - case outSize <= 8: - r1 := syscall.a1 - if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats { - r1 = syscall.f1 - if numFields == 2 { - r1 = syscall.f2<<32 | syscall.f1 - } - } - return reflect.NewAt(outType, unsafe.Pointer(&struct{ a uintptr }{r1})).Elem() - case outSize <= 16: - r1, r2 := syscall.a1, syscall.a2 - if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats { - switch numFields { - case 4: - r1 = syscall.f2<<32 | syscall.f1 - r2 = syscall.f4<<32 | syscall.f3 - case 3: - r1 = syscall.f2<<32 | syscall.f1 - r2 = syscall.f3 - case 2: - r1 = syscall.f1 - r2 = syscall.f2 - default: - panic("unreachable") - } - } - return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b uintptr }{r1, r2})).Elem() - default: - // create struct from the Go pointer created above - // weird pointer dereference to circumvent go vet - return reflect.NewAt(outType, *(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1))).Elem() - } -} - -const ( - _NO_CLASS = 0b00 - _FLOAT = 0b01 - _INT = 0b11 -) - -func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any { - if v.Type().Size() == 0 { - return keepAlive - } - - if size := v.Type().Size(); size <= 16 { - placeRegisters(v, addFloat, addInt) - } else { - keepAlive = placeStack(v, keepAlive, addInt) - } - return keepAlive // the struct was allocated so don't panic -} - -func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) { - var val uint64 - var shift byte - var flushed bool - class := _NO_CLASS - var place func(v reflect.Value) - place = func(v reflect.Value) { - var numFields int - if v.Kind() == reflect.Struct { - numFields = v.Type().NumField() - } else { - numFields = v.Type().Len() - } - for k := 0; k < numFields; k++ { - flushed = false - var f reflect.Value - if v.Kind() == reflect.Struct { - f = v.Field(k) - } else { - f = v.Index(k) - } - align := byte(f.Type().Align()*8 - 1) - shift = (shift + align) &^ align - if shift >= 64 { - shift = 0 - flushed = true - if class == _FLOAT { - addFloat(uintptr(val)) - } else { - addInt(uintptr(val)) - } - } - switch f.Type().Kind() { - case reflect.Struct: - place(f) - case reflect.Bool: - if f.Bool() { - val |= 1 << shift - } - shift += 8 - class |= _INT - case reflect.Uint8: - val |= f.Uint() << shift - shift += 8 - class |= _INT - case reflect.Uint16: - val |= f.Uint() << shift - shift += 16 - class |= _INT - case reflect.Uint32: - val |= f.Uint() << shift - shift += 32 - class |= _INT - case reflect.Uint64, reflect.Uint, reflect.Uintptr: - addInt(uintptr(f.Uint())) - shift = 0 - flushed = true - class = _NO_CLASS - case reflect.Int8: - val |= uint64(f.Int()&0xFF) << shift - shift += 8 - class |= _INT - case reflect.Int16: - val |= uint64(f.Int()&0xFFFF) << shift - shift += 16 - class |= _INT - case reflect.Int32: - val |= uint64(f.Int()&0xFFFF_FFFF) << shift - shift += 32 - class |= _INT - case reflect.Int64, reflect.Int: - addInt(uintptr(f.Int())) - shift = 0 - flushed = true - class = _NO_CLASS - case reflect.Float32: - if class == _FLOAT { - addFloat(uintptr(val)) - val = 0 - shift = 0 - } - val |= uint64(math.Float32bits(float32(f.Float()))) << shift - shift += 32 - class |= _FLOAT - case reflect.Float64: - addFloat(uintptr(math.Float64bits(float64(f.Float())))) - shift = 0 - flushed = true - class = _NO_CLASS - case reflect.Ptr, reflect.UnsafePointer: - addInt(f.Pointer()) - shift = 0 - flushed = true - class = _NO_CLASS - case reflect.Array: - place(f) - default: - panic("purego: unsupported kind " + f.Kind().String()) - } - } - } - place(v) - if !flushed { - if class == _FLOAT { - addFloat(uintptr(val)) - } else { - addInt(uintptr(val)) - } - } -} - -func placeStack(v reflect.Value, keepAlive []any, addInt func(uintptr)) []any { - // Struct is too big to be placed in registers. - // Copy to heap and place the pointer in register - ptrStruct := reflect.New(v.Type()) - ptrStruct.Elem().Set(v) - ptr := ptrStruct.Elem().Addr().UnsafePointer() - keepAlive = append(keepAlive, ptr) - addInt(uintptr(ptr)) - return keepAlive -} - -// shouldBundleStackArgs always returns false on loong64 -// since C-style stack argument bundling is only needed on Darwin ARM64. -func shouldBundleStackArgs(v reflect.Value, numInts, numFloats int) bool { - return false -} - -// structFitsInRegisters is not used on loong64. -func structFitsInRegisters(val reflect.Value, tempNumInts, tempNumFloats int) (bool, int, int) { - panic("purego: structFitsInRegisters should not be called on loong64") -} - -// collectStackArgs is not used on loong64. -func collectStackArgs(args []reflect.Value, startIdx int, numInts, numFloats int, - keepAlive []any, addInt, addFloat, addStack func(uintptr), - pNumInts, pNumFloats, pNumStack *int) ([]reflect.Value, []any) { - panic("purego: collectStackArgs should not be called on loong64") -} - -// bundleStackArgs is not used on loong64. -func bundleStackArgs(stackArgs []reflect.Value, addStack func(uintptr)) { - panic("purego: bundleStackArgs should not be called on loong64") -} diff --git a/vendor/github.com/ebitengine/purego/struct_ppc64le.go b/vendor/github.com/ebitengine/purego/struct_ppc64le.go deleted file mode 100644 index 7c50dcbba9a..00000000000 --- a/vendor/github.com/ebitengine/purego/struct_ppc64le.go +++ /dev/null @@ -1,143 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -package purego - -import ( - "reflect" - "unsafe" -) - -func getStruct(outType reflect.Type, syscall syscall15Args) reflect.Value { - outSize := outType.Size() - - switch { - case outSize == 0: - return reflect.New(outType).Elem() - - case outSize <= 16: - // Reconstruct from registers by copying raw bytes - var buf [16]byte - - // Integer registers - *(*uintptr)(unsafe.Pointer(&buf[0])) = syscall.a1 - if outSize > 8 { - *(*uintptr)(unsafe.Pointer(&buf[8])) = syscall.a2 - } - - // Homogeneous float aggregates override integer regs - if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats { - if outType.Field(0).Type.Kind() == reflect.Float32 { - // float32 values in FP regs - f := []uintptr{syscall.f1, syscall.f2, syscall.f3, syscall.f4} - for i := 0; i < numFields; i++ { - *(*uint32)(unsafe.Pointer(&buf[i*4])) = uint32(f[i]) - } - } else { - // float64: whole register value is valid - *(*uintptr)(unsafe.Pointer(&buf[0])) = syscall.f1 - if outSize > 8 { - *(*uintptr)(unsafe.Pointer(&buf[8])) = syscall.f2 - } - } - } - - return reflect.NewAt(outType, unsafe.Pointer(&buf[0])).Elem() - - default: - // Returned indirectly via pointer in a1 - ptr := *(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1)) - return reflect.NewAt(outType, ptr).Elem() - } -} - -func addStruct( - v reflect.Value, - numInts, numFloats, numStack *int, - addInt, addFloat, addStack func(uintptr), - keepAlive []any, -) []any { - size := v.Type().Size() - if size == 0 { - return keepAlive - } - - if size <= 16 { - return placeSmallAggregatePPC64LE(v, addFloat, addInt, keepAlive) - } - - return placeStack(v, keepAlive, addInt) -} - -func placeSmallAggregatePPC64LE( - v reflect.Value, - addFloat, addInt func(uintptr), - keepAlive []any, -) []any { - size := v.Type().Size() - - var ptr unsafe.Pointer - if v.CanAddr() { - ptr = v.Addr().UnsafePointer() - } else { - tmp := reflect.New(v.Type()) - tmp.Elem().Set(v) - ptr = tmp.UnsafePointer() - keepAlive = append(keepAlive, tmp.Interface()) - } - - var buf [16]byte - src := unsafe.Slice((*byte)(ptr), size) - copy(buf[:], src) - - w0 := *(*uintptr)(unsafe.Pointer(&buf[0])) - w1 := uintptr(0) - if size > 8 { - w1 = *(*uintptr)(unsafe.Pointer(&buf[8])) - } - - if isFloats, _ := isAllSameFloat(v.Type()); isFloats { - addFloat(w0) - if size > 8 { - addFloat(w1) - } - } else { - addInt(w0) - if size > 8 { - addInt(w1) - } - } - - return keepAlive -} - -// placeStack is a fallback for structs that are too large to fit in registers -func placeStack(v reflect.Value, keepAlive []any, addInt func(uintptr)) []any { - if v.CanAddr() { - addInt(v.Addr().Pointer()) - return keepAlive - } - ptr := reflect.New(v.Type()) - ptr.Elem().Set(v) - addInt(ptr.Pointer()) - return append(keepAlive, ptr.Interface()) -} - -func shouldBundleStackArgs(v reflect.Value, numInts, numFloats int) bool { - // PPC64LE does not bundle stack args - return false -} - -func collectStackArgs( - args []reflect.Value, - i, numInts, numFloats int, - keepAlive []any, - addInt, addFloat, addStack func(uintptr), - numIntsPtr, numFloatsPtr, numStackPtr *int, -) ([]reflect.Value, []any) { - return nil, keepAlive -} - -func bundleStackArgs(stackArgs []reflect.Value, addStack func(uintptr)) { - panic("bundleStackArgs not supported on PPC64LE") -} diff --git a/vendor/github.com/ebitengine/purego/struct_riscv64.go b/vendor/github.com/ebitengine/purego/struct_riscv64.go deleted file mode 100644 index eac0b880231..00000000000 --- a/vendor/github.com/ebitengine/purego/struct_riscv64.go +++ /dev/null @@ -1,143 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -package purego - -import ( - "reflect" - "unsafe" -) - -func getStruct(outType reflect.Type, syscall syscall15Args) reflect.Value { - outSize := outType.Size() - - switch { - case outSize == 0: - return reflect.New(outType).Elem() - - case outSize <= 16: - // Reconstruct from registers by copying raw bytes - var buf [16]byte - - // Integer registers - *(*uintptr)(unsafe.Pointer(&buf[0])) = syscall.a1 - if outSize > 8 { - *(*uintptr)(unsafe.Pointer(&buf[8])) = syscall.a2 - } - - // Homogeneous float aggregates override integer regs - if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats { - if outType.Field(0).Type.Kind() == reflect.Float32 { - // float32 values are NaN-boxed in FP regs; use low 32 bits only - f := []uintptr{syscall.f1, syscall.f2, syscall.f3, syscall.f4} - for i := 0; i < numFields; i++ { - *(*uint32)(unsafe.Pointer(&buf[i*4])) = uint32(f[i]) - } - } else { - // float64: whole register value is valid - *(*uintptr)(unsafe.Pointer(&buf[0])) = syscall.f1 - if outSize > 8 { - *(*uintptr)(unsafe.Pointer(&buf[8])) = syscall.f2 - } - } - } - - return reflect.NewAt(outType, unsafe.Pointer(&buf[0])).Elem() - - default: - // Returned indirectly via pointer in a1 - ptr := *(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1)) - return reflect.NewAt(outType, ptr).Elem() - } -} - -func addStruct( - v reflect.Value, - numInts, numFloats, numStack *int, - addInt, addFloat, addStack func(uintptr), - keepAlive []any, -) []any { - size := v.Type().Size() - if size == 0 { - return keepAlive - } - - if size <= 16 { - return placeSmallAggregateRISCV64(v, addFloat, addInt, keepAlive) - } - - return placeStack(v, keepAlive, addInt) -} - -func placeSmallAggregateRISCV64( - v reflect.Value, - addFloat, addInt func(uintptr), - keepAlive []any, -) []any { - size := v.Type().Size() - - var ptr unsafe.Pointer - if v.CanAddr() { - ptr = v.Addr().UnsafePointer() - } else { - tmp := reflect.New(v.Type()) - tmp.Elem().Set(v) - ptr = tmp.UnsafePointer() - keepAlive = append(keepAlive, tmp.Interface()) - } - - var buf [16]byte - src := unsafe.Slice((*byte)(ptr), size) - copy(buf[:], src) - - w0 := *(*uintptr)(unsafe.Pointer(&buf[0])) - w1 := uintptr(0) - if size > 8 { - w1 = *(*uintptr)(unsafe.Pointer(&buf[8])) - } - - if isFloats, _ := isAllSameFloat(v.Type()); isFloats { - addFloat(w0) - if size > 8 { - addFloat(w1) - } - } else { - addInt(w0) - if size > 8 { - addInt(w1) - } - } - - return keepAlive -} - -// placeStack is a fallback for structs that are too large to fit in registers -func placeStack(v reflect.Value, keepAlive []any, addInt func(uintptr)) []any { - if v.CanAddr() { - addInt(v.Addr().Pointer()) - return keepAlive - } - ptr := reflect.New(v.Type()) - ptr.Elem().Set(v) - addInt(ptr.Pointer()) - return append(keepAlive, ptr.Interface()) -} - -func shouldBundleStackArgs(v reflect.Value, numInts, numFloats int) bool { - // RISCV64 does not bundle stack args - return false -} - -func collectStackArgs( - args []reflect.Value, - i, numInts, numFloats int, - keepAlive []any, - addInt, addFloat, addStack func(uintptr), - numIntsPtr, numFloatsPtr, numStackPtr *int, -) ([]reflect.Value, []any) { - return nil, keepAlive -} - -func bundleStackArgs(stackArgs []reflect.Value, addStack func(uintptr)) { - panic("bundleStackArgs not supported on RISCV64") -} diff --git a/vendor/github.com/ebitengine/purego/struct_s390x.go b/vendor/github.com/ebitengine/purego/struct_s390x.go deleted file mode 100644 index 7ec5e813cf6..00000000000 --- a/vendor/github.com/ebitengine/purego/struct_s390x.go +++ /dev/null @@ -1,143 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -package purego - -import ( - "reflect" - "unsafe" -) - -func getStruct(outType reflect.Type, syscall syscall15Args) reflect.Value { - outSize := outType.Size() - - switch { - case outSize == 0: - return reflect.New(outType).Elem() - - case outSize <= 16: - // Reconstruct from registers by copying raw bytes - var buf [16]byte - - // Integer registers - *(*uintptr)(unsafe.Pointer(&buf[0])) = syscall.a1 - if outSize > 8 { - *(*uintptr)(unsafe.Pointer(&buf[8])) = syscall.a2 - } - - // Homogeneous float aggregates override integer regs - if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats { - if outType.Field(0).Type.Kind() == reflect.Float32 { - // float32 values in FP regs - f := []uintptr{syscall.f1, syscall.f2, syscall.f3, syscall.f4} - for i := 0; i < numFields; i++ { - *(*uint32)(unsafe.Pointer(&buf[i*4])) = uint32(f[i]) - } - } else { - // float64: whole register value is valid - *(*uintptr)(unsafe.Pointer(&buf[0])) = syscall.f1 - if outSize > 8 { - *(*uintptr)(unsafe.Pointer(&buf[8])) = syscall.f2 - } - } - } - - return reflect.NewAt(outType, unsafe.Pointer(&buf[0])).Elem() - - default: - // Returned indirectly via pointer in a1 - ptr := *(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1)) - return reflect.NewAt(outType, ptr).Elem() - } -} - -func addStruct( - v reflect.Value, - numInts, numFloats, numStack *int, - addInt, addFloat, addStack func(uintptr), - keepAlive []any, -) []any { - size := v.Type().Size() - if size == 0 { - return keepAlive - } - - if size <= 16 { - return placeSmallAggregateS390X(v, addFloat, addInt, keepAlive) - } - - return placeStack(v, keepAlive, addInt) -} - -func placeSmallAggregateS390X( - v reflect.Value, - addFloat, addInt func(uintptr), - keepAlive []any, -) []any { - size := v.Type().Size() - - var ptr unsafe.Pointer - if v.CanAddr() { - ptr = v.Addr().UnsafePointer() - } else { - tmp := reflect.New(v.Type()) - tmp.Elem().Set(v) - ptr = tmp.UnsafePointer() - keepAlive = append(keepAlive, tmp.Interface()) - } - - var buf [16]byte - src := unsafe.Slice((*byte)(ptr), size) - copy(buf[:], src) - - w0 := *(*uintptr)(unsafe.Pointer(&buf[0])) - w1 := uintptr(0) - if size > 8 { - w1 = *(*uintptr)(unsafe.Pointer(&buf[8])) - } - - if isFloats, _ := isAllSameFloat(v.Type()); isFloats { - addFloat(w0) - if size > 8 { - addFloat(w1) - } - } else { - addInt(w0) - if size > 8 { - addInt(w1) - } - } - - return keepAlive -} - -// placeStack is a fallback for structs that are too large to fit in registers -func placeStack(v reflect.Value, keepAlive []any, addInt func(uintptr)) []any { - if v.CanAddr() { - addInt(v.Addr().Pointer()) - return keepAlive - } - ptr := reflect.New(v.Type()) - ptr.Elem().Set(v) - addInt(ptr.Pointer()) - return append(keepAlive, ptr.Interface()) -} - -func shouldBundleStackArgs(v reflect.Value, numInts, numFloats int) bool { - // S390X does not bundle stack args - return false -} - -func collectStackArgs( - args []reflect.Value, - i, numInts, numFloats int, - keepAlive []any, - addInt, addFloat, addStack func(uintptr), - numIntsPtr, numFloatsPtr, numStackPtr *int, -) ([]reflect.Value, []any) { - return nil, keepAlive -} - -func bundleStackArgs(stackArgs []reflect.Value, addStack func(uintptr)) { - panic("bundleStackArgs not supported on S390X") -} diff --git a/vendor/github.com/ebitengine/purego/sys_386.s b/vendor/github.com/ebitengine/purego/sys_386.s deleted file mode 100644 index 82931413e04..00000000000 --- a/vendor/github.com/ebitengine/purego/sys_386.s +++ /dev/null @@ -1,147 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -//go:build linux - -#include "textflag.h" -#include "go_asm.h" -#include "funcdata.h" - -#define STACK_SIZE 160 -#define PTR_ADDRESS (STACK_SIZE - 4) - -// syscall15X calls a function in libc on behalf of the syscall package. -// syscall15X takes a pointer to a struct like: -// struct { -// fn uintptr -// a1 uintptr -// ... -// a32 uintptr -// f1 uintptr -// ... -// f16 uintptr -// arm64_r8 uintptr -// } -// syscall15X must be called on the g0 stack with the -// C calling convention (use libcCall). -// -// On i386 System V ABI, all arguments are passed on the stack. -// Return value is in EAX (and EDX for 64-bit values). -GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $4 -DATA ·syscall15XABI0(SB)/4, $syscall15X(SB) -TEXT syscall15X(SB), NOSPLIT|NOFRAME, $0-0 - // Called via C calling convention: argument pointer at 4(SP) - // NOT via Go calling convention - // On i386, the first argument is at 4(SP) after CALL pushes return address - MOVL 4(SP), AX // get pointer to syscall15Args - - // Save callee-saved registers - PUSHL BP - PUSHL BX - PUSHL SI - PUSHL DI - - MOVL AX, BX // save args pointer in BX - - // Allocate stack space for C function arguments - // i386 SysV: all 32 args on stack = 32 * 4 = 128 bytes - // Plus 16 bytes for alignment and local storage - SUBL $STACK_SIZE, SP - MOVL BX, PTR_ADDRESS(SP) // save args pointer - - // Load function pointer - MOVL syscall15Args_fn(BX), AX - MOVL AX, (PTR_ADDRESS-4)(SP) // save fn pointer - - // Push all integer arguments onto the stack (a1-a32) - // i386 SysV ABI: arguments pushed right-to-left, but we're - // setting up the stack from low to high addresses - MOVL syscall15Args_a1(BX), AX - MOVL AX, 0(SP) - MOVL syscall15Args_a2(BX), AX - MOVL AX, 4(SP) - MOVL syscall15Args_a3(BX), AX - MOVL AX, 8(SP) - MOVL syscall15Args_a4(BX), AX - MOVL AX, 12(SP) - MOVL syscall15Args_a5(BX), AX - MOVL AX, 16(SP) - MOVL syscall15Args_a6(BX), AX - MOVL AX, 20(SP) - MOVL syscall15Args_a7(BX), AX - MOVL AX, 24(SP) - MOVL syscall15Args_a8(BX), AX - MOVL AX, 28(SP) - MOVL syscall15Args_a9(BX), AX - MOVL AX, 32(SP) - MOVL syscall15Args_a10(BX), AX - MOVL AX, 36(SP) - MOVL syscall15Args_a11(BX), AX - MOVL AX, 40(SP) - MOVL syscall15Args_a12(BX), AX - MOVL AX, 44(SP) - MOVL syscall15Args_a13(BX), AX - MOVL AX, 48(SP) - MOVL syscall15Args_a14(BX), AX - MOVL AX, 52(SP) - MOVL syscall15Args_a15(BX), AX - MOVL AX, 56(SP) - MOVL syscall15Args_a16(BX), AX - MOVL AX, 60(SP) - MOVL syscall15Args_a17(BX), AX - MOVL AX, 64(SP) - MOVL syscall15Args_a18(BX), AX - MOVL AX, 68(SP) - MOVL syscall15Args_a19(BX), AX - MOVL AX, 72(SP) - MOVL syscall15Args_a20(BX), AX - MOVL AX, 76(SP) - MOVL syscall15Args_a21(BX), AX - MOVL AX, 80(SP) - MOVL syscall15Args_a22(BX), AX - MOVL AX, 84(SP) - MOVL syscall15Args_a23(BX), AX - MOVL AX, 88(SP) - MOVL syscall15Args_a24(BX), AX - MOVL AX, 92(SP) - MOVL syscall15Args_a25(BX), AX - MOVL AX, 96(SP) - MOVL syscall15Args_a26(BX), AX - MOVL AX, 100(SP) - MOVL syscall15Args_a27(BX), AX - MOVL AX, 104(SP) - MOVL syscall15Args_a28(BX), AX - MOVL AX, 108(SP) - MOVL syscall15Args_a29(BX), AX - MOVL AX, 112(SP) - MOVL syscall15Args_a30(BX), AX - MOVL AX, 116(SP) - MOVL syscall15Args_a31(BX), AX - MOVL AX, 120(SP) - MOVL syscall15Args_a32(BX), AX - MOVL AX, 124(SP) - - // Call the C function - MOVL (PTR_ADDRESS-4)(SP), AX - CALL AX - - // Get args pointer back and save results - MOVL PTR_ADDRESS(SP), BX - MOVL AX, syscall15Args_a1(BX) // return value r1 - MOVL DX, syscall15Args_a2(BX) // return value r2 (for 64-bit returns) - - // Save x87 FPU return value (ST0) to f1 field - // On i386 System V ABI, float/double returns are in ST(0) - // We save as float64 (8 bytes) to preserve precision - FMOVDP F0, syscall15Args_f1(BX) - - // Clean up stack - ADDL $STACK_SIZE, SP - - // Restore callee-saved registers - POPL DI - POPL SI - POPL BX - POPL BP - - RET diff --git a/vendor/github.com/ebitengine/purego/sys_amd64.s b/vendor/github.com/ebitengine/purego/sys_amd64.s deleted file mode 100644 index 15b24dd2967..00000000000 --- a/vendor/github.com/ebitengine/purego/sys_amd64.s +++ /dev/null @@ -1,170 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build darwin || freebsd || linux || netbsd - -#include "textflag.h" -#include "abi_amd64.h" -#include "go_asm.h" -#include "funcdata.h" - -#define STACK_SIZE 80 -#define PTR_ADDRESS (STACK_SIZE - 8) - -// syscall15X calls a function in libc on behalf of the syscall package. -// syscall15X takes a pointer to a struct like: -// struct { -// fn uintptr -// a1 uintptr -// a2 uintptr -// a3 uintptr -// a4 uintptr -// a5 uintptr -// a6 uintptr -// a7 uintptr -// a8 uintptr -// a9 uintptr -// a10 uintptr -// a11 uintptr -// a12 uintptr -// a13 uintptr -// a14 uintptr -// a15 uintptr -// r1 uintptr -// r2 uintptr -// err uintptr -// } -// syscall15X must be called on the g0 stack with the -// C calling convention (use libcCall). -GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8 -DATA ·syscall15XABI0(SB)/8, $syscall15X(SB) -TEXT syscall15X(SB), NOSPLIT|NOFRAME, $0 - PUSHQ BP - MOVQ SP, BP - SUBQ $STACK_SIZE, SP - MOVQ DI, PTR_ADDRESS(BP) // save the pointer - MOVQ DI, R11 - - MOVQ syscall15Args_f1(R11), X0 // f1 - MOVQ syscall15Args_f2(R11), X1 // f2 - MOVQ syscall15Args_f3(R11), X2 // f3 - MOVQ syscall15Args_f4(R11), X3 // f4 - MOVQ syscall15Args_f5(R11), X4 // f5 - MOVQ syscall15Args_f6(R11), X5 // f6 - MOVQ syscall15Args_f7(R11), X6 // f7 - MOVQ syscall15Args_f8(R11), X7 // f8 - - MOVQ syscall15Args_a1(R11), DI // a1 - MOVQ syscall15Args_a2(R11), SI // a2 - MOVQ syscall15Args_a3(R11), DX // a3 - MOVQ syscall15Args_a4(R11), CX // a4 - MOVQ syscall15Args_a5(R11), R8 // a5 - MOVQ syscall15Args_a6(R11), R9 // a6 - - // push the remaining paramters onto the stack - MOVQ syscall15Args_a7(R11), R12 - MOVQ R12, 0(SP) // push a7 - MOVQ syscall15Args_a8(R11), R12 - MOVQ R12, 8(SP) // push a8 - MOVQ syscall15Args_a9(R11), R12 - MOVQ R12, 16(SP) // push a9 - MOVQ syscall15Args_a10(R11), R12 - MOVQ R12, 24(SP) // push a10 - MOVQ syscall15Args_a11(R11), R12 - MOVQ R12, 32(SP) // push a11 - MOVQ syscall15Args_a12(R11), R12 - MOVQ R12, 40(SP) // push a12 - MOVQ syscall15Args_a13(R11), R12 - MOVQ R12, 48(SP) // push a13 - MOVQ syscall15Args_a14(R11), R12 - MOVQ R12, 56(SP) // push a14 - MOVQ syscall15Args_a15(R11), R12 - MOVQ R12, 64(SP) // push a15 - XORL AX, AX // vararg: say "no float args" - - MOVQ syscall15Args_fn(R11), R10 // fn - CALL R10 - - MOVQ PTR_ADDRESS(BP), DI // get the pointer back - MOVQ AX, syscall15Args_a1(DI) // r1 - MOVQ DX, syscall15Args_a2(DI) // r3 - MOVQ X0, syscall15Args_f1(DI) // f1 - MOVQ X1, syscall15Args_f2(DI) // f2 - -#ifdef GOOS_darwin - CALL purego_error(SB) - MOVD (AX), AX - MOVD AX, syscall15Args_a3(DI) // save errno -#endif - - XORL AX, AX // no error (it's ignored anyway) - ADDQ $STACK_SIZE, SP - MOVQ BP, SP - POPQ BP - RET - -TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0 - MOVQ 0(SP), AX // save the return address to calculate the cb index - MOVQ 8(SP), R10 // get the return SP so that we can align register args with stack args - ADDQ $8, SP // remove return address from stack, we are not returning to callbackasm, but to its caller. - - // make space for first six int and 8 float arguments below the frame - ADJSP $14*8, SP - MOVSD X0, (1*8)(SP) - MOVSD X1, (2*8)(SP) - MOVSD X2, (3*8)(SP) - MOVSD X3, (4*8)(SP) - MOVSD X4, (5*8)(SP) - MOVSD X5, (6*8)(SP) - MOVSD X6, (7*8)(SP) - MOVSD X7, (8*8)(SP) - MOVQ DI, (9*8)(SP) - MOVQ SI, (10*8)(SP) - MOVQ DX, (11*8)(SP) - MOVQ CX, (12*8)(SP) - MOVQ R8, (13*8)(SP) - MOVQ R9, (14*8)(SP) - LEAQ 8(SP), R8 // R8 = address of args vector - - PUSHQ R10 // push the stack pointer below registers - - // Switch from the host ABI to the Go ABI. - PUSH_REGS_HOST_TO_ABI0() - - // determine index into runtime·cbs table - MOVQ $callbackasm(SB), DX - SUBQ DX, AX - MOVQ $0, DX - MOVQ $5, CX // divide by 5 because each call instruction in ·callbacks is 5 bytes long - DIVL CX - SUBQ $1, AX // subtract 1 because return PC is to the next slot - - // Create a struct callbackArgs on our stack to be passed as - // the "frame" to cgocallback and on to callbackWrap. - // $24 to make enough room for the arguments to runtime.cgocallback - SUBQ $(24+callbackArgs__size), SP - MOVQ AX, (24+callbackArgs_index)(SP) // callback index - MOVQ R8, (24+callbackArgs_args)(SP) // address of args vector - MOVQ $0, (24+callbackArgs_result)(SP) // result - LEAQ 24(SP), AX // take the address of callbackArgs - - // Call cgocallback, which will call callbackWrap(frame). - MOVQ ·callbackWrap_call(SB), DI // Get the ABIInternal function pointer - MOVQ (DI), DI // without by using a closure. - MOVQ AX, SI // frame (address of callbackArgs) - MOVQ $0, CX // context - - CALL crosscall2(SB) // runtime.cgocallback(fn, frame, ctxt uintptr) - - // Get callback result. - MOVQ (24+callbackArgs_result)(SP), AX - ADDQ $(24+callbackArgs__size), SP // remove callbackArgs struct - - POP_REGS_HOST_TO_ABI0() - - POPQ R10 // get the SP back - ADJSP $-14*8, SP // remove arguments - - MOVQ R10, 0(SP) - - RET diff --git a/vendor/github.com/ebitengine/purego/sys_arm.s b/vendor/github.com/ebitengine/purego/sys_arm.s deleted file mode 100644 index 3a8ce0d0d3e..00000000000 --- a/vendor/github.com/ebitengine/purego/sys_arm.s +++ /dev/null @@ -1,142 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -//go:build linux - -#include "textflag.h" -#include "go_asm.h" -#include "funcdata.h" - -#define STACK_SIZE 128 -#define PTR_ADDRESS (STACK_SIZE - 4) - -// syscall15X calls a function in libc on behalf of the syscall package. -// syscall15X takes a pointer to a struct like: -// struct { -// fn uintptr -// a1 uintptr -// ... -// a32 uintptr -// f1 uintptr -// ... -// f16 uintptr -// arm64_r8 uintptr -// } -// syscall15X must be called on the g0 stack with the -// C calling convention (use libcCall). -GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $4 -DATA ·syscall15XABI0(SB)/4, $syscall15X(SB) -TEXT syscall15X(SB), NOSPLIT|NOFRAME, $0-0 - // Called via C calling convention: R0 = pointer to syscall15Args - // NOT via Go calling convention - // Save link register and callee-saved registers first - MOVW.W R14, -4(R13) // save LR (decrement and store) - MOVM.DB.W [R4, R5, R6, R7, R8, R9, R11], (R13) // save callee-saved regs - - MOVW R0, R8 - SUB $STACK_SIZE, R13 - MOVW R8, PTR_ADDRESS(R13) - - // Load function pointer first (before anything can corrupt R8) - MOVW syscall15Args_fn(R8), R5 - MOVW R5, (PTR_ADDRESS-4)(R13) // save fn at offset 56 - - // Load floating point arguments - // Each float64 spans 2 uintptr slots (8 bytes) on ARM32, so we skip by 2 - MOVD syscall15Args_f1(R8), F0 // f1+f2 -> D0 - MOVD syscall15Args_f3(R8), F1 // f3+f4 -> D1 - MOVD syscall15Args_f5(R8), F2 // f5+f6 -> D2 - MOVD syscall15Args_f7(R8), F3 // f7+f8 -> D3 - MOVD syscall15Args_f9(R8), F4 // f9+f10 -> D4 - MOVD syscall15Args_f11(R8), F5 // f11+f12 -> D5 - MOVD syscall15Args_f13(R8), F6 // f13+f14 -> D6 - MOVD syscall15Args_f15(R8), F7 // f15+f16 -> D7 - - // Load integer arguments into registers (R0-R3 for ARM EABI) - MOVW syscall15Args_a1(R8), R0 // a1 - MOVW syscall15Args_a2(R8), R1 // a2 - MOVW syscall15Args_a3(R8), R2 // a3 - MOVW syscall15Args_a4(R8), R3 // a4 - - // push a5-a32 onto stack - MOVW syscall15Args_a5(R8), R4 - MOVW R4, 0(R13) - MOVW syscall15Args_a6(R8), R4 - MOVW R4, 4(R13) - MOVW syscall15Args_a7(R8), R4 - MOVW R4, 8(R13) - MOVW syscall15Args_a8(R8), R4 - MOVW R4, 12(R13) - MOVW syscall15Args_a9(R8), R4 - MOVW R4, 16(R13) - MOVW syscall15Args_a10(R8), R4 - MOVW R4, 20(R13) - MOVW syscall15Args_a11(R8), R4 - MOVW R4, 24(R13) - MOVW syscall15Args_a12(R8), R4 - MOVW R4, 28(R13) - MOVW syscall15Args_a13(R8), R4 - MOVW R4, 32(R13) - MOVW syscall15Args_a14(R8), R4 - MOVW R4, 36(R13) - MOVW syscall15Args_a15(R8), R4 - MOVW R4, 40(R13) - MOVW syscall15Args_a16(R8), R4 - MOVW R4, 44(R13) - MOVW syscall15Args_a17(R8), R4 - MOVW R4, 48(R13) - MOVW syscall15Args_a18(R8), R4 - MOVW R4, 52(R13) - MOVW syscall15Args_a19(R8), R4 - MOVW R4, 56(R13) - MOVW syscall15Args_a20(R8), R4 - MOVW R4, 60(R13) - MOVW syscall15Args_a21(R8), R4 - MOVW R4, 64(R13) - MOVW syscall15Args_a22(R8), R4 - MOVW R4, 68(R13) - MOVW syscall15Args_a23(R8), R4 - MOVW R4, 72(R13) - MOVW syscall15Args_a24(R8), R4 - MOVW R4, 76(R13) - MOVW syscall15Args_a25(R8), R4 - MOVW R4, 80(R13) - MOVW syscall15Args_a26(R8), R4 - MOVW R4, 84(R13) - MOVW syscall15Args_a27(R8), R4 - MOVW R4, 88(R13) - MOVW syscall15Args_a28(R8), R4 - MOVW R4, 92(R13) - MOVW syscall15Args_a29(R8), R4 - MOVW R4, 96(R13) - MOVW syscall15Args_a30(R8), R4 - MOVW R4, 100(R13) - MOVW syscall15Args_a31(R8), R4 - MOVW R4, 104(R13) - MOVW syscall15Args_a32(R8), R4 - MOVW R4, 108(R13) - - // Load saved function pointer and call - MOVW (PTR_ADDRESS-4)(R13), R4 - - // Use BLX for Thumb interworking - Go assembler doesn't support BLX Rn - // BLX R4 = 0xE12FFF34 (ARM encoding, always condition) - WORD $0xE12FFF34 // blx r4 - - // pop structure pointer - MOVW PTR_ADDRESS(R13), R8 - ADD $STACK_SIZE, R13 - - // save R0, R1 - MOVW R0, syscall15Args_a1(R8) - MOVW R1, syscall15Args_a2(R8) - - // save f0-f3 (each float64 spans 2 uintptr slots on ARM32) - MOVD F0, syscall15Args_f1(R8) - MOVD F1, syscall15Args_f3(R8) - MOVD F2, syscall15Args_f5(R8) - MOVD F3, syscall15Args_f7(R8) - - // Restore callee-saved registers and return - MOVM.IA.W (R13), [R4, R5, R6, R7, R8, R9, R11] - MOVW.P 4(R13), R15 // pop LR into PC (return) diff --git a/vendor/github.com/ebitengine/purego/sys_arm64.s b/vendor/github.com/ebitengine/purego/sys_arm64.s deleted file mode 100644 index 40a2f4c1dbd..00000000000 --- a/vendor/github.com/ebitengine/purego/sys_arm64.s +++ /dev/null @@ -1,97 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build darwin || freebsd || linux || netbsd || windows - -#include "textflag.h" -#include "go_asm.h" -#include "funcdata.h" - -#define STACK_SIZE 64 -#define PTR_ADDRESS (STACK_SIZE - 8) - -// syscall15X calls a function in libc on behalf of the syscall package. -// syscall15X takes a pointer to a struct like: -// struct { -// fn uintptr -// a1 uintptr -// a2 uintptr -// a3 uintptr -// a4 uintptr -// a5 uintptr -// a6 uintptr -// a7 uintptr -// a8 uintptr -// a9 uintptr -// a10 uintptr -// a11 uintptr -// a12 uintptr -// a13 uintptr -// a14 uintptr -// a15 uintptr -// r1 uintptr -// r2 uintptr -// err uintptr -// } -// syscall15X must be called on the g0 stack with the -// C calling convention (use libcCall). -GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8 -DATA ·syscall15XABI0(SB)/8, $syscall15X(SB) -TEXT syscall15X(SB), NOSPLIT, $0 - SUB $STACK_SIZE, RSP // push structure pointer - MOVD R0, PTR_ADDRESS(RSP) - MOVD R0, R9 - - FMOVD syscall15Args_f1(R9), F0 // f1 - FMOVD syscall15Args_f2(R9), F1 // f2 - FMOVD syscall15Args_f3(R9), F2 // f3 - FMOVD syscall15Args_f4(R9), F3 // f4 - FMOVD syscall15Args_f5(R9), F4 // f5 - FMOVD syscall15Args_f6(R9), F5 // f6 - FMOVD syscall15Args_f7(R9), F6 // f7 - FMOVD syscall15Args_f8(R9), F7 // f8 - - MOVD syscall15Args_a1(R9), R0 // a1 - MOVD syscall15Args_a2(R9), R1 // a2 - MOVD syscall15Args_a3(R9), R2 // a3 - MOVD syscall15Args_a4(R9), R3 // a4 - MOVD syscall15Args_a5(R9), R4 // a5 - MOVD syscall15Args_a6(R9), R5 // a6 - MOVD syscall15Args_a7(R9), R6 // a7 - MOVD syscall15Args_a8(R9), R7 // a8 - MOVD syscall15Args_arm64_r8(R9), R8 // r8 - - MOVD syscall15Args_a9(R9), R10 - MOVD R10, 0(RSP) // push a9 onto stack - MOVD syscall15Args_a10(R9), R10 - MOVD R10, 8(RSP) // push a10 onto stack - MOVD syscall15Args_a11(R9), R10 - MOVD R10, 16(RSP) // push a11 onto stack - MOVD syscall15Args_a12(R9), R10 - MOVD R10, 24(RSP) // push a12 onto stack - MOVD syscall15Args_a13(R9), R10 - MOVD R10, 32(RSP) // push a13 onto stack - MOVD syscall15Args_a14(R9), R10 - MOVD R10, 40(RSP) // push a14 onto stack - MOVD syscall15Args_a15(R9), R10 - MOVD R10, 48(RSP) // push a15 onto stack - - MOVD syscall15Args_fn(R9), R10 // fn - BL (R10) - - MOVD PTR_ADDRESS(RSP), R2 // pop structure pointer - ADD $STACK_SIZE, RSP - - MOVD R0, syscall15Args_a1(R2) // save r1 - MOVD R1, syscall15Args_a2(R2) // save r3 - FMOVD F0, syscall15Args_f1(R2) // save f0 - FMOVD F1, syscall15Args_f2(R2) // save f1 - FMOVD F2, syscall15Args_f3(R2) // save f2 - FMOVD F3, syscall15Args_f4(R2) // save f3 - -#ifdef GOOS_darwin - BL purego_error(SB) - MOVD (R0), R0 - MOVD R0, syscall15Args_a3(R2) // save errno -#endif - RET diff --git a/vendor/github.com/ebitengine/purego/sys_loong64.s b/vendor/github.com/ebitengine/purego/sys_loong64.s deleted file mode 100644 index 420b855c234..00000000000 --- a/vendor/github.com/ebitengine/purego/sys_loong64.s +++ /dev/null @@ -1,96 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2025 The Ebitengine Authors - -//go:build linux - -#include "textflag.h" -#include "go_asm.h" -#include "funcdata.h" - -#define STACK_SIZE 64 -#define PTR_ADDRESS (STACK_SIZE - 8) - -// syscall15X calls a function in libc on behalf of the syscall package. -// syscall15X takes a pointer to a struct like: -// struct { -// fn uintptr -// a1 uintptr -// a2 uintptr -// a3 uintptr -// a4 uintptr -// a5 uintptr -// a6 uintptr -// a7 uintptr -// a8 uintptr -// a9 uintptr -// a10 uintptr -// a11 uintptr -// a12 uintptr -// a13 uintptr -// a14 uintptr -// a15 uintptr -// r1 uintptr -// r2 uintptr -// err uintptr -// } -// syscall15X must be called on the g0 stack with the -// C calling convention (use libcCall). -GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8 -DATA ·syscall15XABI0(SB)/8, $syscall15X(SB) -TEXT syscall15X(SB), NOSPLIT, $0 - // push structure pointer - SUBV $STACK_SIZE, R3 - MOVV R4, PTR_ADDRESS(R3) - MOVV R4, R13 - - MOVD syscall15Args_f1(R13), F0 // f1 - MOVD syscall15Args_f2(R13), F1 // f2 - MOVD syscall15Args_f3(R13), F2 // f3 - MOVD syscall15Args_f4(R13), F3 // f4 - MOVD syscall15Args_f5(R13), F4 // f5 - MOVD syscall15Args_f6(R13), F5 // f6 - MOVD syscall15Args_f7(R13), F6 // f7 - MOVD syscall15Args_f8(R13), F7 // f8 - - MOVV syscall15Args_a1(R13), R4 // a1 - MOVV syscall15Args_a2(R13), R5 // a2 - MOVV syscall15Args_a3(R13), R6 // a3 - MOVV syscall15Args_a4(R13), R7 // a4 - MOVV syscall15Args_a5(R13), R8 // a5 - MOVV syscall15Args_a6(R13), R9 // a6 - MOVV syscall15Args_a7(R13), R10 // a7 - MOVV syscall15Args_a8(R13), R11 // a8 - - // push a9-a15 onto stack - MOVV syscall15Args_a9(R13), R12 - MOVV R12, 0(R3) - MOVV syscall15Args_a10(R13), R12 - MOVV R12, 8(R3) - MOVV syscall15Args_a11(R13), R12 - MOVV R12, 16(R3) - MOVV syscall15Args_a12(R13), R12 - MOVV R12, 24(R3) - MOVV syscall15Args_a13(R13), R12 - MOVV R12, 32(R3) - MOVV syscall15Args_a14(R13), R12 - MOVV R12, 40(R3) - MOVV syscall15Args_a15(R13), R12 - MOVV R12, 48(R3) - - MOVV syscall15Args_fn(R13), R12 - JAL (R12) - - // pop structure pointer - MOVV PTR_ADDRESS(R3), R13 - ADDV $STACK_SIZE, R3 - - // save R4, R5 - MOVV R4, syscall15Args_a1(R13) - MOVV R5, syscall15Args_a2(R13) - - // save f0-f3 - MOVD F0, syscall15Args_f1(R13) - MOVD F1, syscall15Args_f2(R13) - MOVD F2, syscall15Args_f3(R13) - MOVD F3, syscall15Args_f4(R13) - RET diff --git a/vendor/github.com/ebitengine/purego/sys_ppc64le.s b/vendor/github.com/ebitengine/purego/sys_ppc64le.s deleted file mode 100644 index 391b30a9580..00000000000 --- a/vendor/github.com/ebitengine/purego/sys_ppc64le.s +++ /dev/null @@ -1,120 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -//go:build linux - -#include "textflag.h" -#include "go_asm.h" -#include "funcdata.h" - -// PPC64LE ELFv2 ABI: -// - Integer args: R3-R10 (8 registers) -// - Float args: F1-F8 (8 registers) -// - Return: R3 (integer), F1 (float) -// - Stack pointer: R1 -// - Link register: LR (special) -// - TOC pointer: R2 (must preserve) - -// Stack layout for ELFv2 ABI (aligned to 16 bytes): -// From callee's perspective when we call BL (CTR): -// 0(R1) - back chain (our old R1) -// 8(R1) - CR save word (optional) -// 16(R1) - LR save (optional, we save it) -// 24(R1) - Reserved (compilers) -// 32(R1) - Parameter save area start (8 * 8 = 64 bytes for R3-R10) -// 96(R1) - First stack arg (a9) - this is where callee looks -// 104(R1) - Second stack arg (a10) -// 112-152 - Stack args a11-a15 (5 * 8 = 40 bytes) -// 160(R1) - TOC save (we put it here, outside param save area) -// 168(R1) - saved args pointer -// 176(R1) - padding for 16-byte alignment -// Total: 176 bytes - -#define STACK_SIZE 176 -#define LR_SAVE 16 -#define TOC_SAVE 160 -#define ARGP_SAVE 168 - -GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8 -DATA ·syscall15XABI0(SB)/8, $syscall15X(SB) - -TEXT syscall15X(SB), NOSPLIT, $0 - // Prologue: create stack frame - // R3 contains the args pointer on entry - MOVD R1, R12 // save old SP - SUB $STACK_SIZE, R1 // allocate stack frame - MOVD R12, 0(R1) // save back chain - MOVD LR, R12 - MOVD R12, LR_SAVE(R1) // save LR - MOVD R2, TOC_SAVE(R1) // save TOC - - // Save args pointer (in R3) - MOVD R3, ARGP_SAVE(R1) - - // R11 := args pointer (syscall15Args*) - MOVD R3, R11 - - // Load float args into F1-F8 - FMOVD syscall15Args_f1(R11), F1 - FMOVD syscall15Args_f2(R11), F2 - FMOVD syscall15Args_f3(R11), F3 - FMOVD syscall15Args_f4(R11), F4 - FMOVD syscall15Args_f5(R11), F5 - FMOVD syscall15Args_f6(R11), F6 - FMOVD syscall15Args_f7(R11), F7 - FMOVD syscall15Args_f8(R11), F8 - - // Load integer args into R3-R10 - MOVD syscall15Args_a1(R11), R3 - MOVD syscall15Args_a2(R11), R4 - MOVD syscall15Args_a3(R11), R5 - MOVD syscall15Args_a4(R11), R6 - MOVD syscall15Args_a5(R11), R7 - MOVD syscall15Args_a6(R11), R8 - MOVD syscall15Args_a7(R11), R9 - MOVD syscall15Args_a8(R11), R10 - - // Spill a9-a15 onto the stack (stack parameters start at 96(R1)) - // Per ELFv2: parameter save area is 32-95, stack args start at 96 - MOVD ARGP_SAVE(R1), R11 // reload args pointer - MOVD syscall15Args_a9(R11), R12 - MOVD R12, 96(R1) // a9 at 96(R1) - MOVD syscall15Args_a10(R11), R12 - MOVD R12, 104(R1) // a10 at 104(R1) - MOVD syscall15Args_a11(R11), R12 - MOVD R12, 112(R1) // a11 at 112(R1) - MOVD syscall15Args_a12(R11), R12 - MOVD R12, 120(R1) // a12 at 120(R1) - MOVD syscall15Args_a13(R11), R12 - MOVD R12, 128(R1) // a13 at 128(R1) - MOVD syscall15Args_a14(R11), R12 - MOVD R12, 136(R1) // a14 at 136(R1) - MOVD syscall15Args_a15(R11), R12 - MOVD R12, 144(R1) // a15 at 144(R1) - - // Call function: load fn and call - MOVD syscall15Args_fn(R11), R12 - MOVD R12, CTR - BL (CTR) - - // Restore TOC after call - MOVD TOC_SAVE(R1), R2 - - // Restore args pointer for storing results - MOVD ARGP_SAVE(R1), R11 - - // Store integer results back (R3, R4) - MOVD R3, syscall15Args_a1(R11) - MOVD R4, syscall15Args_a2(R11) - - // Store float return values (F1-F4) - FMOVD F1, syscall15Args_f1(R11) - FMOVD F2, syscall15Args_f2(R11) - FMOVD F3, syscall15Args_f3(R11) - FMOVD F4, syscall15Args_f4(R11) - - // Epilogue: restore and return - MOVD LR_SAVE(R1), R12 - MOVD R12, LR - ADD $STACK_SIZE, R1 - RET diff --git a/vendor/github.com/ebitengine/purego/sys_riscv64.s b/vendor/github.com/ebitengine/purego/sys_riscv64.s deleted file mode 100644 index e7e887e1554..00000000000 --- a/vendor/github.com/ebitengine/purego/sys_riscv64.s +++ /dev/null @@ -1,101 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -//go:build linux - -#include "textflag.h" -#include "go_asm.h" -#include "funcdata.h" - -// Stack usage: -// 0(SP) - 56(SP): stack args a9-a15 (7 * 8 bytes = 56) -// 56(SP) - 64(SP): saved RA (x1) -// 64(SP) - 72(SP): saved X9 (s1) -// 72(SP) - 80(SP): saved X18 (s2) -// 80(SP) - 88(SP): saved args pointer (original X10) -// 88(SP) - 96(SP): padding -#define STACK_SIZE 96 -#define SAVE_RA 56 -#define SAVE_X9 64 -#define SAVE_X18 72 -#define SAVE_ARGP 80 - -GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8 -DATA ·syscall15XABI0(SB)/8, $syscall15X(SB) - -TEXT syscall15X(SB), NOSPLIT, $0 - // Allocate stack frame (keeps 16-byte alignment) - SUB $STACK_SIZE, SP - - // Save callee-saved regs we clobber + return address - MOV X1, SAVE_RA(SP) - MOV X9, SAVE_X9(SP) - MOV X18, SAVE_X18(SP) - - // Save original args pointer (in a0/X10) - MOV X10, SAVE_ARGP(SP) - - // X9 := args pointer (syscall15Args*) - MOV X10, X9 - - // Load float args into fa0-fa7 (F10-F17) - MOVD syscall15Args_f1(X9), F10 - MOVD syscall15Args_f2(X9), F11 - MOVD syscall15Args_f3(X9), F12 - MOVD syscall15Args_f4(X9), F13 - MOVD syscall15Args_f5(X9), F14 - MOVD syscall15Args_f6(X9), F15 - MOVD syscall15Args_f7(X9), F16 - MOVD syscall15Args_f8(X9), F17 - - // Load integer args into a0-a7 (X10-X17) - MOV syscall15Args_a1(X9), X10 - MOV syscall15Args_a2(X9), X11 - MOV syscall15Args_a3(X9), X12 - MOV syscall15Args_a4(X9), X13 - MOV syscall15Args_a5(X9), X14 - MOV syscall15Args_a6(X9), X15 - MOV syscall15Args_a7(X9), X16 - MOV syscall15Args_a8(X9), X17 - - // Spill a9-a15 onto the stack (C ABI) - MOV syscall15Args_a9(X9), X18 - MOV X18, 0(SP) - MOV syscall15Args_a10(X9), X18 - MOV X18, 8(SP) - MOV syscall15Args_a11(X9), X18 - MOV X18, 16(SP) - MOV syscall15Args_a12(X9), X18 - MOV X18, 24(SP) - MOV syscall15Args_a13(X9), X18 - MOV X18, 32(SP) - MOV syscall15Args_a14(X9), X18 - MOV X18, 40(SP) - MOV syscall15Args_a15(X9), X18 - MOV X18, 48(SP) - - // Call fn - // IMPORTANT: preserve RA across this call (we saved it above) - MOV syscall15Args_fn(X9), X18 - CALL X18 - - // Restore args pointer (syscall15Args*) for storing results - MOV SAVE_ARGP(SP), X9 - - // Store results back - MOV X10, syscall15Args_a1(X9) - MOV X11, syscall15Args_a2(X9) - - // Store back float return regs if used by your ABI contract - MOVD F10, syscall15Args_f1(X9) - MOVD F11, syscall15Args_f2(X9) - MOVD F12, syscall15Args_f3(X9) - MOVD F13, syscall15Args_f4(X9) - - // Restore callee-saved regs and return address - MOV SAVE_X18(SP), X18 - MOV SAVE_X9(SP), X9 - MOV SAVE_RA(SP), X1 - - ADD $STACK_SIZE, SP - RET diff --git a/vendor/github.com/ebitengine/purego/sys_s390x.s b/vendor/github.com/ebitengine/purego/sys_s390x.s deleted file mode 100644 index a044e34d330..00000000000 --- a/vendor/github.com/ebitengine/purego/sys_s390x.s +++ /dev/null @@ -1,114 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -//go:build linux - -#include "textflag.h" -#include "go_asm.h" -#include "funcdata.h" - -// S390X ELF ABI: -// - Integer args: R2-R6 (5 registers) -// - Float args: F0, F2, F4, F6 (4 registers, even-numbered) -// - Return: R2 (integer), F0 (float) -// - Stack pointer: R15 -// - Link register: R14 -// - Callee-saved: R6-R13, F8-F15 (but R6 is also used for 5th param) -// -// Stack frame layout (aligned to 8 bytes): -// 0(R15) - back chain -// 8(R15) - reserved -// 16(R15) - reserved -// ... - register save area (R6-R15 at 48(R15)) -// 160(R15) - parameter area start (args beyond registers) -// -// We need space for: -// - 160 bytes standard frame (with register save area) -// - Stack args a6-a15 (10 * 8 = 80 bytes) -// - Saved args pointer (8 bytes) -// - Padding for alignment -// Total: 264 bytes (rounded to 8-byte alignment) - -#define STACK_SIZE 264 -#define STACK_ARGS 160 -#define ARGP_SAVE 248 - -GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8 -DATA ·syscall15XABI0(SB)/8, $syscall15X(SB) - -TEXT syscall15X(SB), NOSPLIT, $0 - // On entry, R2 contains the args pointer - // Save callee-saved registers in caller's frame (per ABI) - STMG R6, R15, 48(R15) - - // Allocate our stack frame - MOVD R15, R1 - SUB $STACK_SIZE, R15 - MOVD R1, 0(R15) // back chain - - // Save args pointer - MOVD R2, ARGP_SAVE(R15) - - // R9 := args pointer (syscall15Args*) - MOVD R2, R9 - - // Load float args into F0, F2, F4, F6 (s390x uses even-numbered FPRs) - FMOVD syscall15Args_f1(R9), F0 - FMOVD syscall15Args_f2(R9), F2 - FMOVD syscall15Args_f3(R9), F4 - FMOVD syscall15Args_f4(R9), F6 - - // Load integer args into R2-R6 (5 registers) - MOVD syscall15Args_a1(R9), R2 - MOVD syscall15Args_a2(R9), R3 - MOVD syscall15Args_a3(R9), R4 - MOVD syscall15Args_a4(R9), R5 - MOVD syscall15Args_a5(R9), R6 - - // Spill remaining args (a6-a15) onto the stack at 160(R15) - MOVD ARGP_SAVE(R15), R9 // reload args pointer - MOVD syscall15Args_a6(R9), R1 - MOVD R1, (STACK_ARGS+0*8)(R15) - MOVD syscall15Args_a7(R9), R1 - MOVD R1, (STACK_ARGS+1*8)(R15) - MOVD syscall15Args_a8(R9), R1 - MOVD R1, (STACK_ARGS+2*8)(R15) - MOVD syscall15Args_a9(R9), R1 - MOVD R1, (STACK_ARGS+3*8)(R15) - MOVD syscall15Args_a10(R9), R1 - MOVD R1, (STACK_ARGS+4*8)(R15) - MOVD syscall15Args_a11(R9), R1 - MOVD R1, (STACK_ARGS+5*8)(R15) - MOVD syscall15Args_a12(R9), R1 - MOVD R1, (STACK_ARGS+6*8)(R15) - MOVD syscall15Args_a13(R9), R1 - MOVD R1, (STACK_ARGS+7*8)(R15) - MOVD syscall15Args_a14(R9), R1 - MOVD R1, (STACK_ARGS+8*8)(R15) - MOVD syscall15Args_a15(R9), R1 - MOVD R1, (STACK_ARGS+9*8)(R15) - - // Call function - MOVD syscall15Args_fn(R9), R1 - BL (R1) - - // Restore args pointer for storing results - MOVD ARGP_SAVE(R15), R9 - - // Store integer results back (R2, R3) - MOVD R2, syscall15Args_a1(R9) - MOVD R3, syscall15Args_a2(R9) - - // Store float return values (F0, F2, F4, F6) - FMOVD F0, syscall15Args_f1(R9) - FMOVD F2, syscall15Args_f2(R9) - FMOVD F4, syscall15Args_f3(R9) - FMOVD F6, syscall15Args_f4(R9) - - // Deallocate stack frame - ADD $STACK_SIZE, R15 - - // Restore callee-saved registers from caller's save area - LMG 48(R15), R6, R15 - - RET diff --git a/vendor/github.com/ebitengine/purego/sys_unix_386.s b/vendor/github.com/ebitengine/purego/sys_unix_386.s deleted file mode 100644 index 31aecbf3cdf..00000000000 --- a/vendor/github.com/ebitengine/purego/sys_unix_386.s +++ /dev/null @@ -1,226 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -//go:build linux - -#include "textflag.h" -#include "go_asm.h" -#include "funcdata.h" - -// callbackasm1 is the second part of the callback trampoline. -// On entry: -// - CX contains the callback index (set by callbackasm) -// - 0(SP) contains the return address to C caller -// - 4(SP), 8(SP), ... contain C arguments (cdecl convention) -// -// i386 cdecl calling convention: -// - All arguments passed on stack -// - Return value in EAX (and EDX for 64-bit) -// - Caller cleans the stack -// - Callee must preserve: EBX, ESI, EDI, EBP -TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0 - NO_LOCAL_POINTERS - - // Save the return address - MOVL 0(SP), AX - - // Allocate stack frame (must be done carefully to preserve args access) - // Layout: - // 0-15: saved callee-saved registers (BX, SI, DI, BP) - // 16-19: saved callback index - // 20-23: saved return address - // 24-35: callbackArgs struct (12 bytes) - // 36-291: copy of C arguments (256 bytes for 64 args, matching callbackMaxFrame) - // Total: 292 bytes, round up to 304 for alignment - SUBL $304, SP - - // Save callee-saved registers - MOVL BX, 0(SP) - MOVL SI, 4(SP) - MOVL DI, 8(SP) - MOVL BP, 12(SP) - - // Save callback index and return address - MOVL CX, 16(SP) - MOVL AX, 20(SP) - - // Copy C arguments from original stack location to our frame - // Original args start at 304+4(SP) = 308(SP) (past our frame + original return addr) - // Copy to our frame at 36(SP) - // Copy 64 arguments (256 bytes, matching callbackMaxFrame = 64 * ptrSize) - MOVL 308(SP), AX - MOVL AX, 36(SP) - MOVL 312(SP), AX - MOVL AX, 40(SP) - MOVL 316(SP), AX - MOVL AX, 44(SP) - MOVL 320(SP), AX - MOVL AX, 48(SP) - MOVL 324(SP), AX - MOVL AX, 52(SP) - MOVL 328(SP), AX - MOVL AX, 56(SP) - MOVL 332(SP), AX - MOVL AX, 60(SP) - MOVL 336(SP), AX - MOVL AX, 64(SP) - MOVL 340(SP), AX - MOVL AX, 68(SP) - MOVL 344(SP), AX - MOVL AX, 72(SP) - MOVL 348(SP), AX - MOVL AX, 76(SP) - MOVL 352(SP), AX - MOVL AX, 80(SP) - MOVL 356(SP), AX - MOVL AX, 84(SP) - MOVL 360(SP), AX - MOVL AX, 88(SP) - MOVL 364(SP), AX - MOVL AX, 92(SP) - MOVL 368(SP), AX - MOVL AX, 96(SP) - MOVL 372(SP), AX - MOVL AX, 100(SP) - MOVL 376(SP), AX - MOVL AX, 104(SP) - MOVL 380(SP), AX - MOVL AX, 108(SP) - MOVL 384(SP), AX - MOVL AX, 112(SP) - MOVL 388(SP), AX - MOVL AX, 116(SP) - MOVL 392(SP), AX - MOVL AX, 120(SP) - MOVL 396(SP), AX - MOVL AX, 124(SP) - MOVL 400(SP), AX - MOVL AX, 128(SP) - MOVL 404(SP), AX - MOVL AX, 132(SP) - MOVL 408(SP), AX - MOVL AX, 136(SP) - MOVL 412(SP), AX - MOVL AX, 140(SP) - MOVL 416(SP), AX - MOVL AX, 144(SP) - MOVL 420(SP), AX - MOVL AX, 148(SP) - MOVL 424(SP), AX - MOVL AX, 152(SP) - MOVL 428(SP), AX - MOVL AX, 156(SP) - MOVL 432(SP), AX - MOVL AX, 160(SP) - MOVL 436(SP), AX - MOVL AX, 164(SP) - MOVL 440(SP), AX - MOVL AX, 168(SP) - MOVL 444(SP), AX - MOVL AX, 172(SP) - MOVL 448(SP), AX - MOVL AX, 176(SP) - MOVL 452(SP), AX - MOVL AX, 180(SP) - MOVL 456(SP), AX - MOVL AX, 184(SP) - MOVL 460(SP), AX - MOVL AX, 188(SP) - MOVL 464(SP), AX - MOVL AX, 192(SP) - MOVL 468(SP), AX - MOVL AX, 196(SP) - MOVL 472(SP), AX - MOVL AX, 200(SP) - MOVL 476(SP), AX - MOVL AX, 204(SP) - MOVL 480(SP), AX - MOVL AX, 208(SP) - MOVL 484(SP), AX - MOVL AX, 212(SP) - MOVL 488(SP), AX - MOVL AX, 216(SP) - MOVL 492(SP), AX - MOVL AX, 220(SP) - MOVL 496(SP), AX - MOVL AX, 224(SP) - MOVL 500(SP), AX - MOVL AX, 228(SP) - MOVL 504(SP), AX - MOVL AX, 232(SP) - MOVL 508(SP), AX - MOVL AX, 236(SP) - MOVL 512(SP), AX - MOVL AX, 240(SP) - MOVL 516(SP), AX - MOVL AX, 244(SP) - MOVL 520(SP), AX - MOVL AX, 248(SP) - MOVL 524(SP), AX - MOVL AX, 252(SP) - MOVL 528(SP), AX - MOVL AX, 256(SP) - MOVL 532(SP), AX - MOVL AX, 260(SP) - MOVL 536(SP), AX - MOVL AX, 264(SP) - MOVL 540(SP), AX - MOVL AX, 268(SP) - MOVL 544(SP), AX - MOVL AX, 272(SP) - MOVL 548(SP), AX - MOVL AX, 276(SP) - MOVL 552(SP), AX - MOVL AX, 280(SP) - MOVL 556(SP), AX - MOVL AX, 284(SP) - MOVL 560(SP), AX - MOVL AX, 288(SP) - - // Set up callbackArgs struct at 24(SP) - // struct callbackArgs { - // index uintptr // offset 0 - // args *byte // offset 4 - // result uintptr // offset 8 - // } - MOVL 16(SP), AX // callback index - MOVL AX, 24(SP) // callbackArgs.index - LEAL 36(SP), AX // pointer to copied arguments - MOVL AX, 28(SP) // callbackArgs.args - MOVL $0, 32(SP) // callbackArgs.result = 0 - - // Call crosscall2(fn, frame, 0, ctxt) - // crosscall2 expects arguments on stack: - // 0(SP) = fn - // 4(SP) = frame (pointer to callbackArgs) - // 8(SP) = ignored (was n) - // 12(SP) = ctxt - SUBL $16, SP - - MOVL ·callbackWrap_call(SB), AX - MOVL (AX), AX // fn = *callbackWrap_call - MOVL AX, 0(SP) // fn - LEAL (24+16)(SP), AX // &callbackArgs (adjusted for SUB $16) - MOVL AX, 4(SP) // frame - MOVL $0, 8(SP) // 0 - MOVL $0, 12(SP) // ctxt - - CALL crosscall2(SB) - - ADDL $16, SP - - // Get result from callbackArgs.result - MOVL 32(SP), AX - - // Restore callee-saved registers - MOVL 0(SP), BX - MOVL 4(SP), SI - MOVL 8(SP), DI - MOVL 12(SP), BP - - // Restore return address and clean up - MOVL 20(SP), CX // get return address - ADDL $304, SP // remove our frame - MOVL CX, 0(SP) // put return address back - - RET diff --git a/vendor/github.com/ebitengine/purego/sys_unix_arm.s b/vendor/github.com/ebitengine/purego/sys_unix_arm.s deleted file mode 100644 index a97e9437ddb..00000000000 --- a/vendor/github.com/ebitengine/purego/sys_unix_arm.s +++ /dev/null @@ -1,89 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -//go:build linux - -#include "textflag.h" -#include "go_asm.h" -#include "funcdata.h" - -TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0 - NO_LOCAL_POINTERS - - // Allocate stack frame: 48 + 16 + 64 + 16 = 144 bytes - SUB $144, R13 - - // Save callee-saved registers at SP+0 - MOVW R4, 0(R13) - MOVW R5, 4(R13) - MOVW R6, 8(R13) - MOVW R7, 12(R13) - MOVW R8, 16(R13) - MOVW R9, 20(R13) - MOVW g, 24(R13) - MOVW R11, 28(R13) - MOVW R14, 32(R13) - - // Save callback index (passed in R12) at SP+36 - MOVW R12, 36(R13) - - // Save integer arguments R0-R3 at SP+128 (frame[16..19]) - MOVW R0, 128(R13) - MOVW R1, 132(R13) - MOVW R2, 136(R13) - MOVW R3, 140(R13) - - // Save floating point registers F0-F7 at SP+64 (frame[0..15]) - // Note: We always save these since we target hard-float ABI. - MOVD F0, 64(R13) - MOVD F1, 72(R13) - MOVD F2, 80(R13) - MOVD F3, 88(R13) - MOVD F4, 96(R13) - MOVD F5, 104(R13) - MOVD F6, 112(R13) - MOVD F7, 120(R13) - - // Set up callbackArgs at SP+48 - MOVW 36(R13), R4 - MOVW R4, 48(R13) - ADD $64, R13, R4 - MOVW R4, 52(R13) - MOVW $0, R4 - MOVW R4, 56(R13) - - // Call crosscall2(fn, frame, 0, ctxt) - MOVW ·callbackWrap_call(SB), R0 - MOVW (R0), R0 - ADD $48, R13, R1 - MOVW $0, R2 - MOVW $0, R3 - - BL crosscall2(SB) - - // Get result - MOVW 56(R13), R0 - - // Restore float registers - MOVD 64(R13), F0 - MOVD 72(R13), F1 - MOVD 80(R13), F2 - MOVD 88(R13), F3 - MOVD 96(R13), F4 - MOVD 104(R13), F5 - MOVD 112(R13), F6 - MOVD 120(R13), F7 - - // Restore callee-saved registers - MOVW 0(R13), R4 - MOVW 4(R13), R5 - MOVW 8(R13), R6 - MOVW 12(R13), R7 - MOVW 16(R13), R8 - MOVW 20(R13), R9 - MOVW 24(R13), g - MOVW 28(R13), R11 - MOVW 32(R13), R14 - - ADD $144, R13 - RET diff --git a/vendor/github.com/ebitengine/purego/sys_unix_arm64.s b/vendor/github.com/ebitengine/purego/sys_unix_arm64.s deleted file mode 100644 index cea803ef9a1..00000000000 --- a/vendor/github.com/ebitengine/purego/sys_unix_arm64.s +++ /dev/null @@ -1,70 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2023 The Ebitengine Authors - -//go:build darwin || freebsd || linux || netbsd - -#include "textflag.h" -#include "go_asm.h" -#include "funcdata.h" -#include "abi_arm64.h" - -TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0 - NO_LOCAL_POINTERS - - // On entry, the trampoline in zcallback_darwin_arm64.s left - // the callback index in R12 (which is volatile in the C ABI). - - // Save callback register arguments R0-R7 and F0-F7. - // We do this at the top of the frame so they're contiguous with stack arguments. - SUB $(16*8), RSP, R14 - FSTPD (F0, F1), (0*8)(R14) - FSTPD (F2, F3), (2*8)(R14) - FSTPD (F4, F5), (4*8)(R14) - FSTPD (F6, F7), (6*8)(R14) - STP (R0, R1), (8*8)(R14) - STP (R2, R3), (10*8)(R14) - STP (R4, R5), (12*8)(R14) - STP (R6, R7), (14*8)(R14) - - // Adjust SP by frame size. - SUB $(26*8), RSP - - // It is important to save R27 because the go assembler - // uses it for move instructions for a variable. - // This line: - // MOVD ·callbackWrap_call(SB), R0 - // Creates the instructions: - // ADRP 14335(PC), R27 - // MOVD 388(27), R0 - // R27 is a callee saved register so we are responsible - // for ensuring its value doesn't change. So save it and - // restore it at the end of this function. - // R30 is the link register. crosscall2 doesn't save it - // so it's saved here. - STP (R27, R30), 0(RSP) - - // Create a struct callbackArgs on our stack. - MOVD $(callbackArgs__size)(RSP), R13 - MOVD R12, callbackArgs_index(R13) // callback index - MOVD R14, callbackArgs_args(R13) // address of args vector - MOVD ZR, callbackArgs_result(R13) // result - - // Move parameters into registers - // Get the ABIInternal function pointer - // without by using a closure. - MOVD ·callbackWrap_call(SB), R0 - MOVD (R0), R0 // fn unsafe.Pointer - MOVD R13, R1 // frame (&callbackArgs{...}) - MOVD $0, R3 // ctxt uintptr - - BL crosscall2(SB) - - // Get callback result. - MOVD $(callbackArgs__size)(RSP), R13 - MOVD callbackArgs_result(R13), R0 - - // Restore LR and R27 - LDP 0(RSP), (R27, R30) - ADD $(26*8), RSP - - RET diff --git a/vendor/github.com/ebitengine/purego/sys_unix_loong64.s b/vendor/github.com/ebitengine/purego/sys_unix_loong64.s deleted file mode 100644 index cd00f9c1a11..00000000000 --- a/vendor/github.com/ebitengine/purego/sys_unix_loong64.s +++ /dev/null @@ -1,75 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2025 The Ebitengine Authors - -//go:build linux - -#include "textflag.h" -#include "go_asm.h" -#include "funcdata.h" -#include "abi_loong64.h" - -TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0 - NO_LOCAL_POINTERS - - SUBV $(16*8), R3, R14 - MOVD F0, 0(R14) - MOVD F1, 8(R14) - MOVD F2, 16(R14) - MOVD F3, 24(R14) - MOVD F4, 32(R14) - MOVD F5, 40(R14) - MOVD F6, 48(R14) - MOVD F7, 56(R14) - MOVV R4, 64(R14) - MOVV R5, 72(R14) - MOVV R6, 80(R14) - MOVV R7, 88(R14) - MOVV R8, 96(R14) - MOVV R9, 104(R14) - MOVV R10, 112(R14) - MOVV R11, 120(R14) - - // Adjust SP by frame size. - SUBV $(22*8), R3 - - // It is important to save R30 because the go assembler - // uses it for move instructions for a variable. - // This line: - // MOVV ·callbackWrap_call(SB), R4 - // Creates the instructions: - // PCALAU12I off1(PC), R30 - // MOVV off2(R30), R4 - // R30 is a callee saved register so we are responsible - // for ensuring its value doesn't change. So save it and - // restore it at the end of this function. - // R1 is the link register. crosscall2 doesn't save it - // so it's saved here. - MOVV R1, 0(R3) - MOVV R30, 8(R3) - - // Create a struct callbackArgs on our stack. - MOVV $(callbackArgs__size)(R3), R13 - MOVV R12, callbackArgs_index(R13) // callback index - MOVV R14, callbackArgs_args(R13) // address of args vector - MOVV $0, callbackArgs_result(R13) // result - - // Move parameters into registers - // Get the ABIInternal function pointer - // without by using a closure. - MOVV ·callbackWrap_call(SB), R4 - MOVV (R4), R4 // fn unsafe.Pointer - MOVV R13, R5 // frame (&callbackArgs{...}) - MOVV $0, R7 // ctxt uintptr - - JAL crosscall2(SB) - - // Get callback result. - MOVV $(callbackArgs__size)(R3), R13 - MOVV callbackArgs_result(R13), R4 - - // Restore LR and R30 - MOVV 0(R3), R1 - MOVV 8(R3), R30 - ADDV $(22*8), R3 - - RET diff --git a/vendor/github.com/ebitengine/purego/sys_unix_ppc64le.s b/vendor/github.com/ebitengine/purego/sys_unix_ppc64le.s deleted file mode 100644 index 37f0d8d601a..00000000000 --- a/vendor/github.com/ebitengine/purego/sys_unix_ppc64le.s +++ /dev/null @@ -1,114 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -//go:build linux - -#include "textflag.h" -#include "go_asm.h" -#include "funcdata.h" - -// PPC64LE ELFv2 ABI callbackasm1 implementation -// On entry, R11 contains the callback index (set by callbackasm) -// -// ELFv2 stack frame layout requirements: -// 0(R1) - back chain (pointer to caller's frame) -// 8(R1) - CR save area (optional) -// 16(R1) - LR save area (for callee to save caller's LR) -// 24(R1) - TOC save area (if needed) -// 32(R1)+ - parameter save area / local variables -// -// Our frame (total 208 bytes, 16-byte aligned): -// 32(R1) - saved R31 (8 bytes) -// 40(R1) - callbackArgs struct (32 bytes: index, args, result, stackArgs) -// 72(R1) - args array: floats (64) + ints (64) = 128 bytes, ends at 200 -// Total with alignment: 208 bytes -// -// Stack args are NOT copied - we pass a pointer to their location in caller's frame. -// This keeps frame size small enough for NOSPLIT with CGO_ENABLED=1. -// Budget: 208 + 544 (crosscall2) + 56 (cgocallback) = 808 bytes -// This is 8 bytes over the 800 limit, but cgocallback's children (load_g, save_g) -// reuse the same stack space, so in practice it works. - -#define FRAME_SIZE 200 -#define SAVE_R31 32 -#define CB_ARGS 40 -#define ARGS_ARRAY 72 -#define FLOAT_OFF 0 -#define INT_OFF 64 - -TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0 - NO_LOCAL_POINTERS - - // On entry, the trampoline in zcallback_ppc64le.s left - // the callback index in R11. - - // Per ELFv2 ABI, save LR to caller's frame BEFORE allocating our frame - MOVD LR, R0 - MOVD R0, 16(R1) - - // Allocate our stack frame (with back chain via MOVDU) - MOVDU R1, -FRAME_SIZE(R1) - - // Save R31 - Go assembler uses it for MOVD from SB (like arm64's R27) - MOVD R31, SAVE_R31(R1) - - // Save R11 (callback index) immediately - it's volatile and will be clobbered! - // Store it in the callbackArgs struct's index field now. - MOVD R11, (CB_ARGS+0)(R1) - - // Save callback arguments to args array. - // Layout: floats first (F1-F8), then ints (R3-R10), then stack args - FMOVD F1, (ARGS_ARRAY+FLOAT_OFF+0*8)(R1) - FMOVD F2, (ARGS_ARRAY+FLOAT_OFF+1*8)(R1) - FMOVD F3, (ARGS_ARRAY+FLOAT_OFF+2*8)(R1) - FMOVD F4, (ARGS_ARRAY+FLOAT_OFF+3*8)(R1) - FMOVD F5, (ARGS_ARRAY+FLOAT_OFF+4*8)(R1) - FMOVD F6, (ARGS_ARRAY+FLOAT_OFF+5*8)(R1) - FMOVD F7, (ARGS_ARRAY+FLOAT_OFF+6*8)(R1) - FMOVD F8, (ARGS_ARRAY+FLOAT_OFF+7*8)(R1) - - MOVD R3, (ARGS_ARRAY+INT_OFF+0*8)(R1) - MOVD R4, (ARGS_ARRAY+INT_OFF+1*8)(R1) - MOVD R5, (ARGS_ARRAY+INT_OFF+2*8)(R1) - MOVD R6, (ARGS_ARRAY+INT_OFF+3*8)(R1) - MOVD R7, (ARGS_ARRAY+INT_OFF+4*8)(R1) - MOVD R8, (ARGS_ARRAY+INT_OFF+5*8)(R1) - MOVD R9, (ARGS_ARRAY+INT_OFF+6*8)(R1) - MOVD R10, (ARGS_ARRAY+INT_OFF+7*8)(R1) - - // Finish setting up callbackArgs struct at CB_ARGS(R1) - // struct { index uintptr; args unsafe.Pointer; result uintptr; stackArgs unsafe.Pointer } - // Note: index was already saved earlier (R11 is volatile) - ADD $ARGS_ARRAY, R1, R12 - MOVD R12, (CB_ARGS+8)(R1) // args = address of register args - MOVD $0, (CB_ARGS+16)(R1) // result = 0 - - // stackArgs points to caller's stack arguments at old_R1+96 = R1+FRAME_SIZE+96 - ADD $(FRAME_SIZE+96), R1, R12 - MOVD R12, (CB_ARGS+24)(R1) // stackArgs = &caller_stack_args - - // Call crosscall2 with arguments in registers: - // R3 = fn (from callbackWrap_call closure) - // R4 = frame (address of callbackArgs) - // R6 = ctxt (0) - MOVD ·callbackWrap_call(SB), R3 - MOVD (R3), R3 // dereference closure to get fn - ADD $CB_ARGS, R1, R4 // frame = &callbackArgs - MOVD $0, R6 // ctxt = 0 - - BL crosscall2(SB) - - // Get callback result into R3 - MOVD (CB_ARGS+16)(R1), R3 - - // Restore R31 - MOVD SAVE_R31(R1), R31 - - // Deallocate frame - ADD $FRAME_SIZE, R1 - - // Restore LR from caller's frame (per ELFv2, it was saved at 16(old_R1)) - MOVD 16(R1), R0 - MOVD R0, LR - - RET diff --git a/vendor/github.com/ebitengine/purego/sys_unix_riscv64.s b/vendor/github.com/ebitengine/purego/sys_unix_riscv64.s deleted file mode 100644 index 8341d5b08ea..00000000000 --- a/vendor/github.com/ebitengine/purego/sys_unix_riscv64.s +++ /dev/null @@ -1,79 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -//go:build linux - -#include "textflag.h" -#include "go_asm.h" -#include "funcdata.h" - -TEXT callbackasm1(SB), NOFRAME, $0 - NO_LOCAL_POINTERS - - // On entry, the trampoline in zcallback_riscv64.s left - // the callback index in X7. - - // Save callback register arguments X10-X17 and F10-F17. - // Stack args (if any) are at 0(SP), 8(SP), etc. - // We save register args at SP-128, making them contiguous with stack args. - ADD $-(16*8), SP, X6 - - // Save float arg regs fa0-fa7 (F10-F17) - MOVD F10, 0(X6) - MOVD F11, 8(X6) - MOVD F12, 16(X6) - MOVD F13, 24(X6) - MOVD F14, 32(X6) - MOVD F15, 40(X6) - MOVD F16, 48(X6) - MOVD F17, 56(X6) - - // Save integer arg regs a0-a7 (X10-X17) - MOV X10, 64(X6) - MOV X11, 72(X6) - MOV X12, 80(X6) - MOV X13, 88(X6) - MOV X14, 96(X6) - MOV X15, 104(X6) - MOV X16, 112(X6) - MOV X17, 120(X6) - - // Allocate space on stack for RA, saved regs, and callbackArgs. - // We need: 8 (RA) + 8 (X9 callee-saved) + 24 (callbackArgs) = 40, round to 176 (22*8) - // to match loong64 and ensure we don't overlap with saved register args. - // The saved regs end at SP-8 (original), so we need new SP below SP-128. - ADD $-(22*8), SP - - // Save link register (RA/X1) and callee-saved register X9 - // (X9 is used by the assembler for some instructions) - MOV X1, 0(SP) - MOV X9, 8(SP) - - // Create a struct callbackArgs on our stack. - // callbackArgs struct: index(0), args(8), result(16) - // Place it at 16(SP) to avoid overlap - ADD $16, SP, X9 - MOV X7, 0(X9) // callback index - MOV X6, 8(X9) // address of args vector - MOV X0, 16(X9) // result = 0 - - // Call crosscall2 with arguments in registers - MOV ·callbackWrap_call(SB), X10 // Get the ABIInternal function pointer - MOV (X10), X10 // without by using a closure. X10 = fn - MOV X9, X11 // X11 = frame (address of callbackArgs) - MOV X0, X13 // X13 = ctxt = 0 - - CALL crosscall2(SB) - - // Get callback result. - ADD $16, SP, X9 - MOV 16(X9), X10 - - // Restore link register and callee-saved X9 - MOV 8(SP), X9 - MOV 0(SP), X1 - - // Restore stack pointer - ADD $(22*8), SP - - RET diff --git a/vendor/github.com/ebitengine/purego/sys_unix_s390x.s b/vendor/github.com/ebitengine/purego/sys_unix_s390x.s deleted file mode 100644 index 9eed6d29c3a..00000000000 --- a/vendor/github.com/ebitengine/purego/sys_unix_s390x.s +++ /dev/null @@ -1,109 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -//go:build linux - -#include "textflag.h" -#include "go_asm.h" -#include "funcdata.h" - -// S390X ELF ABI callbackasm1 implementation -// On entry, R0 contains the callback index (set by callbackasm) -// NOTE: We use R0 instead of R11 because R11 is callee-saved on S390X. -// -// S390X stack frame layout: -// 0(R15) - back chain -// 48(R15) - register save area (R6-R15) -// 160(R15) - parameter area -// -// S390X uses R2-R6 for integer arguments (5 registers) and F0,F2,F4,F6 for floats (4 registers). -// -// Our frame layout (total 264 bytes, 8-byte aligned): -// 0(R15) - back chain -// 48(R15) - saved R6-R15 (done by STMG) -// 160(R15) - callbackArgs struct (32 bytes: index, args, result, stackArgs) -// 192(R15) - args array start -// -// Args array layout: -// - floats F0,F2,F4,F6 (32 bytes) -// - ints R2-R6 (40 bytes) -// Total args array: 72 bytes, ends at 264 -// -// Stack args in caller's frame start at old_R15+160 - -#define FRAME_SIZE 264 -#define CB_ARGS 160 -#define ARGS_ARRAY 192 -#define FLOAT_OFF 0 -#define INT_OFF 32 - -TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0 - NO_LOCAL_POINTERS - - // On entry, the trampoline in zcallback_s390x.s left - // the callback index in R0 (NOT R11, since R11 is callee-saved). - // R6 contains the 5th integer argument. - - // Save R6-R15 in caller's frame (per S390X ABI) BEFORE allocating our frame - // STMG stores R6's current value (the 5th arg) at 48(R15) - STMG R6, R15, 48(R15) - - // Save current stack pointer (will be back chain) - MOVD R15, R1 - - // Allocate our stack frame - SUB $FRAME_SIZE, R15 - MOVD R1, 0(R15) // back chain - - // Save R0 (callback index) immediately - it's volatile - MOVD R0, (CB_ARGS+0)(R15) - - // Save callback arguments to args array. - // Layout: floats first (F0,F2,F4,F6), then ints (R2-R6) - FMOVD F0, (ARGS_ARRAY+FLOAT_OFF+0*8)(R15) - FMOVD F2, (ARGS_ARRAY+FLOAT_OFF+1*8)(R15) - FMOVD F4, (ARGS_ARRAY+FLOAT_OFF+2*8)(R15) - FMOVD F6, (ARGS_ARRAY+FLOAT_OFF+3*8)(R15) - - MOVD R2, (ARGS_ARRAY+INT_OFF+0*8)(R15) - MOVD R3, (ARGS_ARRAY+INT_OFF+1*8)(R15) - MOVD R4, (ARGS_ARRAY+INT_OFF+2*8)(R15) - MOVD R5, (ARGS_ARRAY+INT_OFF+3*8)(R15) - - // R6 (5th int arg) was saved at 48(old_R15) by STMG - // old_R15 = current R15 + FRAME_SIZE, so R6 is at 48+FRAME_SIZE(R15) = 312(R15) - MOVD (48+FRAME_SIZE)(R15), R1 - MOVD R1, (ARGS_ARRAY+INT_OFF+4*8)(R15) - - // Finish setting up callbackArgs struct at CB_ARGS(R15) - // struct { index uintptr; args unsafe.Pointer; result uintptr; stackArgs unsafe.Pointer } - // Note: index was already saved earlier - ADD $ARGS_ARRAY, R15, R1 - MOVD R1, (CB_ARGS+8)(R15) // args = address of register args - MOVD $0, (CB_ARGS+16)(R15) // result = 0 - - // stackArgs points to caller's stack arguments at old_R15+160 = R15+FRAME_SIZE+160 - ADD $(FRAME_SIZE+160), R15, R1 - MOVD R1, (CB_ARGS+24)(R15) // stackArgs = &caller_stack_args - - // Call crosscall2 with arguments in registers: - // R2 = fn (from callbackWrap_call closure) - // R3 = frame (address of callbackArgs) - // R5 = ctxt (0) - MOVD ·callbackWrap_call(SB), R2 - MOVD (R2), R2 // dereference closure to get fn - ADD $CB_ARGS, R15, R3 // frame = &callbackArgs - MOVD $0, R5 // ctxt = 0 - - BL crosscall2(SB) - - // Get callback result into R2 - MOVD (CB_ARGS+16)(R15), R2 - - // Deallocate frame - ADD $FRAME_SIZE, R15 - - // Restore R6-R15 from caller's frame - LMG 48(R15), R6, R15 - - RET diff --git a/vendor/github.com/ebitengine/purego/syscall.go b/vendor/github.com/ebitengine/purego/syscall.go deleted file mode 100644 index 7b45383d343..00000000000 --- a/vendor/github.com/ebitengine/purego/syscall.go +++ /dev/null @@ -1,83 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build !386 && !arm && (darwin || freebsd || linux || netbsd || windows) - -package purego - -// CDecl marks a function as being called using the __cdecl calling convention as defined in -// the [MSDocs] when passed to NewCallback. It must be the first argument to the function. -// This is only useful on 386 Windows, but it is safe to use on other platforms. -// -// [MSDocs]: https://learn.microsoft.com/en-us/cpp/cpp/cdecl?view=msvc-170 -type CDecl struct{} - -const ( - maxArgs = 15 -) - -type syscall15Args struct { - fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr - f1, f2, f3, f4, f5, f6, f7, f8 uintptr - arm64_r8 uintptr -} - -func (s *syscall15Args) Set(fn uintptr, ints []uintptr, floats []uintptr, r8 uintptr) { - s.fn = fn - s.a1 = ints[0] - s.a2 = ints[1] - s.a3 = ints[2] - s.a4 = ints[3] - s.a5 = ints[4] - s.a6 = ints[5] - s.a7 = ints[6] - s.a8 = ints[7] - s.a9 = ints[8] - s.a10 = ints[9] - s.a11 = ints[10] - s.a12 = ints[11] - s.a13 = ints[12] - s.a14 = ints[13] - s.a15 = ints[14] - s.f1 = floats[0] - s.f2 = floats[1] - s.f3 = floats[2] - s.f4 = floats[3] - s.f5 = floats[4] - s.f6 = floats[5] - s.f7 = floats[6] - s.f8 = floats[7] - s.arm64_r8 = r8 -} - -// SyscallN takes fn, a C function pointer and a list of arguments as uintptr. -// There is an internal maximum number of arguments that SyscallN can take. It panics -// when the maximum is exceeded. It returns the result and the libc error code if there is one. -// -// In order to call this function properly make sure to follow all the rules specified in [unsafe.Pointer] -// especially point 4. -// -// NOTE: SyscallN does not properly call functions that have both integer and float parameters. -// See discussion comment https://github.com/ebiten/purego/pull/1#issuecomment-1128057607 -// for an explanation of why that is. -// -// On amd64, if there are more than 8 floats the 9th and so on will be placed incorrectly on the -// stack. -// -// The pragma go:nosplit is not needed at this function declaration because it uses go:uintptrescapes -// which forces all the objects that the uintptrs point to onto the heap where a stack split won't affect -// their memory location. -// -//go:uintptrescapes -func SyscallN(fn uintptr, args ...uintptr) (r1, r2, err uintptr) { - if fn == 0 { - panic("purego: fn is nil") - } - if len(args) > maxArgs { - panic("purego: too many arguments to SyscallN") - } - // add padding so there is no out-of-bounds slicing - var tmp [maxArgs]uintptr - copy(tmp[:], args) - return syscall_syscall15X(fn, tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5], tmp[6], tmp[7], tmp[8], tmp[9], tmp[10], tmp[11], tmp[12], tmp[13], tmp[14]) -} diff --git a/vendor/github.com/ebitengine/purego/syscall_32bit.go b/vendor/github.com/ebitengine/purego/syscall_32bit.go deleted file mode 100644 index f9f37630305..00000000000 --- a/vendor/github.com/ebitengine/purego/syscall_32bit.go +++ /dev/null @@ -1,109 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build (386 || arm) && (freebsd || linux || netbsd || windows) - -package purego - -// CDecl marks a function as being called using the __cdecl calling convention as defined in -// the [MSDocs] when passed to NewCallback. It must be the first argument to the function. -// This is only useful on 386 Windows, but it is safe to use on other platforms. -// -// [MSDocs]: https://learn.microsoft.com/en-us/cpp/cpp/cdecl?view=msvc-170 -type CDecl struct{} - -const ( - maxArgs = 32 -) - -type syscall15Args struct { - fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr - a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32 uintptr - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16 uintptr - arm64_r8 uintptr -} - -func (s *syscall15Args) Set(fn uintptr, ints []uintptr, floats []uintptr, r8 uintptr) { - s.fn = fn - s.a1 = ints[0] - s.a2 = ints[1] - s.a3 = ints[2] - s.a4 = ints[3] - s.a5 = ints[4] - s.a6 = ints[5] - s.a7 = ints[6] - s.a8 = ints[7] - s.a9 = ints[8] - s.a10 = ints[9] - s.a11 = ints[10] - s.a12 = ints[11] - s.a13 = ints[12] - s.a14 = ints[13] - s.a15 = ints[14] - s.a16 = ints[15] - s.a17 = ints[16] - s.a18 = ints[17] - s.a19 = ints[18] - s.a20 = ints[19] - s.a21 = ints[20] - s.a22 = ints[21] - s.a23 = ints[22] - s.a24 = ints[23] - s.a25 = ints[24] - s.a26 = ints[25] - s.a27 = ints[26] - s.a28 = ints[27] - s.a29 = ints[28] - s.a30 = ints[29] - s.a31 = ints[30] - s.a32 = ints[31] - s.f1 = floats[0] - s.f2 = floats[1] - s.f3 = floats[2] - s.f4 = floats[3] - s.f5 = floats[4] - s.f6 = floats[5] - s.f7 = floats[6] - s.f8 = floats[7] - s.f9 = floats[8] - s.f10 = floats[9] - s.f11 = floats[10] - s.f12 = floats[11] - s.f13 = floats[12] - s.f14 = floats[13] - s.f15 = floats[14] - s.f16 = floats[15] - s.arm64_r8 = r8 -} - -// SyscallN takes fn, a C function pointer and a list of arguments as uintptr. -// There is an internal maximum number of arguments that SyscallN can take. It panics -// when the maximum is exceeded. It returns the result and the libc error code if there is one. -// -// In order to call this function properly make sure to follow all the rules specified in [unsafe.Pointer] -// especially point 4. -// -// NOTE: SyscallN does not properly call functions that have both integer and float parameters. -// See discussion comment https://github.com/ebiten/purego/pull/1#issuecomment-1128057607 -// for an explanation of why that is. -// -// On amd64, if there are more than 8 floats the 9th and so on will be placed incorrectly on the -// stack. -// -// The pragma go:nosplit is not needed at this function declaration because it uses go:uintptrescapes -// which forces all the objects that the uintptrs point to onto the heap where a stack split won't affect -// their memory location. -// -//go:uintptrescapes -func SyscallN(fn uintptr, args ...uintptr) (r1, r2, err uintptr) { - if fn == 0 { - panic("purego: fn is nil") - } - if len(args) > maxArgs { - panic("purego: too many arguments to SyscallN") - } - // add padding so there is no out-of-bounds slicing - var tmp [maxArgs]uintptr - copy(tmp[:], args) - return syscall_syscall15X(fn, tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5], tmp[6], tmp[7], tmp[8], tmp[9], tmp[10], tmp[11], tmp[12], tmp[13], tmp[14]) -} diff --git a/vendor/github.com/ebitengine/purego/syscall_cgo_linux.go b/vendor/github.com/ebitengine/purego/syscall_cgo_linux.go deleted file mode 100644 index 179167f4b45..00000000000 --- a/vendor/github.com/ebitengine/purego/syscall_cgo_linux.go +++ /dev/null @@ -1,21 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -//go:build cgo && !(386 || amd64 || arm || arm64 || loong64 || ppc64le || riscv64 || s390x) - -package purego - -import ( - "github.com/ebitengine/purego/internal/cgo" -) - -var syscall15XABI0 = uintptr(cgo.Syscall15XABI0) - -//go:nosplit -func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) { - return cgo.Syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) -} - -func NewCallback(_ any) uintptr { - panic("purego: NewCallback on Linux is only supported on 386/amd64/arm64/arm/loong64/ppc64le/riscv64/s390x") -} diff --git a/vendor/github.com/ebitengine/purego/syscall_sysv.go b/vendor/github.com/ebitengine/purego/syscall_sysv.go deleted file mode 100644 index e35b32e71d1..00000000000 --- a/vendor/github.com/ebitengine/purego/syscall_sysv.go +++ /dev/null @@ -1,320 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -// TODO: remove s390x cgo dependency once golang/go#77449 is resolved -//go:build darwin || freebsd || (linux && (386 || amd64 || arm || arm64 || loong64 || ppc64le || riscv64 || (cgo && s390x))) || netbsd - -package purego - -import ( - "reflect" - "runtime" - "sync" - "unsafe" -) - -var syscall15XABI0 uintptr - -func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) { - args := thePool.Get().(*syscall15Args) - defer thePool.Put(args) - - *args = syscall15Args{ - fn: fn, - a1: a1, a2: a2, a3: a3, a4: a4, a5: a5, a6: a6, a7: a7, a8: a8, - a9: a9, a10: a10, a11: a11, a12: a12, a13: a13, a14: a14, a15: a15, - f1: a1, f2: a2, f3: a3, f4: a4, f5: a5, f6: a6, f7: a7, f8: a8, - } - - runtime_cgocall(syscall15XABI0, unsafe.Pointer(args)) - return args.a1, args.a2, args.a3 -} - -// NewCallback converts a Go function to a function pointer conforming to the C calling convention. -// This is useful when interoperating with C code requiring callbacks. The argument is expected to be a -// function with zero or one uintptr-sized result. The function must not have arguments with size larger than the size -// of uintptr. Only a limited number of callbacks may be created in a single Go process, and any memory allocated -// for these callbacks is never released. At least 2000 callbacks can always be created. Although this function -// provides similar functionality to windows.NewCallback it is distinct. -func NewCallback(fn any) uintptr { - ty := reflect.TypeOf(fn) - for i := 0; i < ty.NumIn(); i++ { - in := ty.In(i) - if !in.AssignableTo(reflect.TypeOf(CDecl{})) { - continue - } - if i != 0 { - panic("purego: CDecl must be the first argument") - } - } - return compileCallback(fn) -} - -// maxCb is the maximum number of callbacks -// only increase this if you have added more to the callbackasm function -const maxCB = 2000 - -var cbs struct { - lock sync.Mutex - numFn int // the number of functions currently in cbs.funcs - funcs [maxCB]reflect.Value // the saved callbacks -} - -func compileCallback(fn any) uintptr { - val := reflect.ValueOf(fn) - if val.Kind() != reflect.Func { - panic("purego: the type must be a function but was not") - } - if val.IsNil() { - panic("purego: function must not be nil") - } - ty := val.Type() - for i := 0; i < ty.NumIn(); i++ { - in := ty.In(i) - switch in.Kind() { - case reflect.Struct: - if i == 0 && in.AssignableTo(reflect.TypeOf(CDecl{})) { - continue - } - fallthrough - case reflect.Interface, reflect.Func, reflect.Slice, - reflect.Chan, reflect.Complex64, reflect.Complex128, - reflect.String, reflect.Map, reflect.Invalid: - panic("purego: unsupported argument type: " + in.Kind().String()) - } - } -output: - switch { - case ty.NumOut() == 1: - switch ty.Out(0).Kind() { - case reflect.Pointer, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, - reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, - reflect.Bool, reflect.UnsafePointer: - break output - } - panic("purego: unsupported return type: " + ty.String()) - case ty.NumOut() > 1: - panic("purego: callbacks can only have one return") - } - cbs.lock.Lock() - defer cbs.lock.Unlock() - if cbs.numFn >= maxCB { - panic("purego: the maximum number of callbacks has been reached") - } - cbs.funcs[cbs.numFn] = val - cbs.numFn++ - return callbackasmAddr(cbs.numFn - 1) -} - -const ptrSize = unsafe.Sizeof((*int)(nil)) - -const callbackMaxFrame = 64 * ptrSize - -// callbackasm is implemented in zcallback_GOOS_GOARCH.s -// -//go:linkname __callbackasm callbackasm -var __callbackasm byte -var callbackasmABI0 = uintptr(unsafe.Pointer(&__callbackasm)) - -// callbackWrap_call allows the calling of the ABIInternal wrapper -// which is required for runtime.cgocallback without the -// tag which is only allowed in the runtime. -// This closure is used inside sys_darwin_GOARCH.s -var callbackWrap_call = callbackWrap - -// callbackWrap is called by assembly code which determines which Go function to call. -// This function takes the arguments and passes them to the Go function and returns the result. -func callbackWrap(a *callbackArgs) { - cbs.lock.Lock() - fn := cbs.funcs[a.index] - cbs.lock.Unlock() - fnType := fn.Type() - args := make([]reflect.Value, fnType.NumIn()) - frame := (*[callbackMaxFrame]uintptr)(a.args) - // stackFrame points to stack-passed arguments. On most architectures this is - // contiguous with frame (after register args), but on ppc64le it's separate. - var stackFrame *[callbackMaxFrame]uintptr - if sf := a.stackFrame(); sf != nil { - // Only ppc64le uses separate stackArgs pointer due to NOSPLIT constraints - stackFrame = (*[callbackMaxFrame]uintptr)(sf) - } - // floatsN and intsN track the number of register slots used, not argument count. - // This distinction matters on ARM32 where float64 uses 2 slots (32-bit registers). - var floatsN int - var intsN int - // stackSlot points to the index into frame (or stackFrame) of the current stack element. - // When stackFrame is nil, stack begins after float and integer registers in frame. - // When stackFrame is not nil (ppc64le), stackSlot indexes into stackFrame starting at 0. - stackSlot := numOfIntegerRegisters() + numOfFloatRegisters() - if stackFrame != nil { - // ppc64le: stackArgs is a separate pointer, indices start at 0 - stackSlot = 0 - } - // stackByteOffset tracks the byte offset within the stack area for Darwin ARM64 - // tight packing. On Darwin ARM64, C passes small types packed on the stack. - stackByteOffset := uintptr(0) - for i := range args { - // slots is the number of pointer-sized slots the argument takes - var slots int - inType := fnType.In(i) - switch inType.Kind() { - case reflect.Float32, reflect.Float64: - slots = int((fnType.In(i).Size() + ptrSize - 1) / ptrSize) - if floatsN+slots > numOfFloatRegisters() { - if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" { - // Darwin ARM64: read from packed stack with proper alignment - args[i] = callbackArgFromStack(a.args, stackSlot, &stackByteOffset, inType) - } else if stackFrame != nil { - // ppc64le/s390x: stack args are in separate stackFrame - if runtime.GOARCH == "s390x" { - // s390x big-endian: sub-8-byte values are right-justified - args[i] = callbackArgFromSlotBigEndian(unsafe.Pointer(&stackFrame[stackSlot]), inType) - } else { - args[i] = reflect.NewAt(inType, unsafe.Pointer(&stackFrame[stackSlot])).Elem() - } - stackSlot += slots - } else { - args[i] = reflect.NewAt(inType, unsafe.Pointer(&frame[stackSlot])).Elem() - stackSlot += slots - } - } else { - if runtime.GOARCH == "s390x" { - // s390x big-endian: float32 is right-justified in 8-byte FPR slot - args[i] = callbackArgFromSlotBigEndian(unsafe.Pointer(&frame[floatsN]), inType) - } else { - args[i] = reflect.NewAt(inType, unsafe.Pointer(&frame[floatsN])).Elem() - } - } - floatsN += slots - case reflect.Struct: - // This is the CDecl field - args[i] = reflect.Zero(inType) - default: - slots = int((inType.Size() + ptrSize - 1) / ptrSize) - if intsN+slots > numOfIntegerRegisters() { - if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" { - // Darwin ARM64: read from packed stack with proper alignment - args[i] = callbackArgFromStack(a.args, stackSlot, &stackByteOffset, inType) - } else if stackFrame != nil { - // ppc64le/s390x: stack args are in separate stackFrame - if runtime.GOARCH == "s390x" { - // s390x big-endian: sub-8-byte values are right-justified - args[i] = callbackArgFromSlotBigEndian(unsafe.Pointer(&stackFrame[stackSlot]), inType) - } else { - args[i] = reflect.NewAt(inType, unsafe.Pointer(&stackFrame[stackSlot])).Elem() - } - stackSlot += slots - } else { - args[i] = reflect.NewAt(inType, unsafe.Pointer(&frame[stackSlot])).Elem() - stackSlot += slots - } - } else { - // the integers begin after the floats in frame - pos := intsN + numOfFloatRegisters() - if runtime.GOARCH == "s390x" { - // s390x big-endian: sub-8-byte values are right-justified in GPR slot - args[i] = callbackArgFromSlotBigEndian(unsafe.Pointer(&frame[pos]), inType) - } else { - args[i] = reflect.NewAt(inType, unsafe.Pointer(&frame[pos])).Elem() - } - } - intsN += slots - } - } - ret := fn.Call(args) - if len(ret) > 0 { - switch k := ret[0].Kind(); k { - case reflect.Uint, reflect.Uint64, reflect.Uint32, reflect.Uint16, reflect.Uint8, reflect.Uintptr: - a.result = uintptr(ret[0].Uint()) - case reflect.Int, reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8: - a.result = uintptr(ret[0].Int()) - case reflect.Bool: - if ret[0].Bool() { - a.result = 1 - } else { - a.result = 0 - } - case reflect.Pointer: - a.result = ret[0].Pointer() - case reflect.UnsafePointer: - a.result = ret[0].Pointer() - default: - panic("purego: unsupported kind: " + k.String()) - } - } -} - -// callbackArgFromStack reads an argument from the tightly-packed stack area on Darwin ARM64. -// The C ABI on Darwin ARM64 packs small types on the stack without padding to 8 bytes. -// This function handles proper alignment and advances stackByteOffset accordingly. -func callbackArgFromStack(argsBase unsafe.Pointer, stackSlot int, stackByteOffset *uintptr, inType reflect.Type) reflect.Value { - // Calculate base address of stack area (after float and int registers) - stackBase := unsafe.Add(argsBase, stackSlot*int(ptrSize)) - - // Get type's natural alignment - align := uintptr(inType.Align()) - size := inType.Size() - - // Align the offset - if *stackByteOffset%align != 0 { - *stackByteOffset = (*stackByteOffset + align - 1) &^ (align - 1) - } - - // Read value at aligned offset - ptr := unsafe.Add(stackBase, *stackByteOffset) - *stackByteOffset += size - - return reflect.NewAt(inType, ptr).Elem() -} - -// callbackArgFromSlotBigEndian reads an argument from an 8-byte slot on big-endian architectures. -// On s390x: -// - Integer types are right-justified in GPRs: sub-8-byte values are at offset (8 - size) -// - Float32 in FPRs is left-justified: stored in upper 32 bits, so at offset 0 -// - Float64 occupies the full 8-byte slot -func callbackArgFromSlotBigEndian(slotPtr unsafe.Pointer, inType reflect.Type) reflect.Value { - size := inType.Size() - if size >= 8 { - // 8-byte values occupy the entire slot - return reflect.NewAt(inType, slotPtr).Elem() - } - // Float32 is left-justified in FPRs (upper 32 bits), so offset is 0 - if inType.Kind() == reflect.Float32 { - return reflect.NewAt(inType, slotPtr).Elem() - } - // Integer types are right-justified: offset = 8 - size - offset := 8 - size - ptr := unsafe.Add(slotPtr, offset) - return reflect.NewAt(inType, ptr).Elem() -} - -// callbackasmAddr returns address of runtime.callbackasm -// function adjusted by i. -// On x86 and amd64, runtime.callbackasm is a series of CALL instructions, -// and we want callback to arrive at -// correspondent call instruction instead of start of -// runtime.callbackasm. -// On ARM, runtime.callbackasm is a series of mov and branch instructions. -// R12 is loaded with the callback index. Each entry is two instructions, -// hence 8 bytes. -func callbackasmAddr(i int) uintptr { - var entrySize int - switch runtime.GOARCH { - default: - panic("purego: unsupported architecture") - case "amd64": - // On amd64, each callback entry is just a CALL instruction (5 bytes) - entrySize = 5 - case "386": - // On 386, each callback entry is MOVL $imm, CX (5 bytes) + JMP (5 bytes) - entrySize = 10 - case "arm", "arm64", "loong64", "ppc64le", "riscv64": - // On ARM, ARM64, Loong64, PPC64LE and RISCV64, each entry is a MOV instruction - // followed by a branch instruction - entrySize = 8 - case "s390x": - // On S390X, each entry is LGHI (4 bytes) + JG (6 bytes) - entrySize = 10 - } - return callbackasmABI0 + uintptr(i*entrySize) -} diff --git a/vendor/github.com/ebitengine/purego/syscall_sysv_others.go b/vendor/github.com/ebitengine/purego/syscall_sysv_others.go deleted file mode 100644 index d4f6c7b7fb9..00000000000 --- a/vendor/github.com/ebitengine/purego/syscall_sysv_others.go +++ /dev/null @@ -1,28 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -//go:build darwin || freebsd || (linux && (386 || amd64 || arm || arm64 || loong64 || riscv64)) || netbsd - -package purego - -import "unsafe" - -type callbackArgs struct { - index uintptr - // args points to the argument block. - // - // The structure of the arguments goes - // float registers followed by the - // integer registers followed by the stack. - // - // This variable is treated as a continuous - // block of memory containing all of the arguments - // for this callback. - args unsafe.Pointer - // Below are out-args from callbackWrap - result uintptr -} - -func (c *callbackArgs) stackFrame() unsafe.Pointer { - return nil -} diff --git a/vendor/github.com/ebitengine/purego/syscall_sysv_stackargs.go b/vendor/github.com/ebitengine/purego/syscall_sysv_stackargs.go deleted file mode 100644 index 87ed9811191..00000000000 --- a/vendor/github.com/ebitengine/purego/syscall_sysv_stackargs.go +++ /dev/null @@ -1,33 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2026 The Ebitengine Authors - -//go:build linux && (ppc64le || s390x) - -package purego - -import "unsafe" - -type callbackArgs struct { - index uintptr - // args points to the argument block. - // - // The structure of the arguments goes - // float registers followed by the - // integer registers followed by the stack. - // - // This variable is treated as a continuous - // block of memory containing all of the arguments - // for this callback. - args unsafe.Pointer - // Below are out-args from callbackWrap - result uintptr - // stackArgs points to stack-passed arguments for architectures where - // they can't be made contiguous with register args (e.g., ppc64le). - // On other architectures, this is nil and stack args are read from - // the end of the args block. - stackArgs unsafe.Pointer -} - -func (c *callbackArgs) stackFrame() unsafe.Pointer { - return c.stackArgs -} diff --git a/vendor/github.com/ebitengine/purego/syscall_windows.go b/vendor/github.com/ebitengine/purego/syscall_windows.go deleted file mode 100644 index 5afd8d83ca2..00000000000 --- a/vendor/github.com/ebitengine/purego/syscall_windows.go +++ /dev/null @@ -1,46 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2022 The Ebitengine Authors - -package purego - -import ( - "reflect" - "syscall" -) - -var syscall15XABI0 uintptr - -func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) { - r1, r2, errno := syscall.Syscall15(fn, 15, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) - return r1, r2, uintptr(errno) -} - -// NewCallback converts a Go function to a function pointer conforming to the stdcall calling convention. -// This is useful when interoperating with Windows code requiring callbacks. The argument is expected to be a -// function with one uintptr-sized result. The function must not have arguments with size larger than the -// size of uintptr. Only a limited number of callbacks may be created in a single Go process, and any memory -// allocated for these callbacks is never released. Between NewCallback and NewCallbackCDecl, at least 1024 -// callbacks can always be created. Although this function is similiar to the darwin version it may act -// differently. -func NewCallback(fn any) uintptr { - isCDecl := false - ty := reflect.TypeOf(fn) - for i := 0; i < ty.NumIn(); i++ { - in := ty.In(i) - if !in.AssignableTo(reflect.TypeOf(CDecl{})) { - continue - } - if i != 0 { - panic("purego: CDecl must be the first argument") - } - isCDecl = true - } - if isCDecl { - return syscall.NewCallbackCDecl(fn) - } - return syscall.NewCallback(fn) -} - -func loadSymbol(handle uintptr, name string) (uintptr, error) { - return syscall.GetProcAddress(syscall.Handle(handle), name) -} diff --git a/vendor/github.com/ebitengine/purego/zcallback_386.s b/vendor/github.com/ebitengine/purego/zcallback_386.s deleted file mode 100644 index bd2d9c85ac0..00000000000 --- a/vendor/github.com/ebitengine/purego/zcallback_386.s +++ /dev/null @@ -1,4014 +0,0 @@ -// Code generated by wincallback.go using 'go generate'. DO NOT EDIT. - -//go:build linux - -// External code calls into callbackasm at an offset corresponding -// to the callback index. Callbackasm is a table of MOVL and JMP instructions. -// The MOVL instruction loads CX with the callback index, and the -// JMP instruction branches to callbackasm1. -// callbackasm1 takes the callback index from CX and -// indexes into an array that stores information about each callback. -// It then calls the Go implementation for that callback. -#include "textflag.h" - -TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0 - MOVL $0, CX - JMP callbackasm1(SB) - MOVL $1, CX - JMP callbackasm1(SB) - MOVL $2, CX - JMP callbackasm1(SB) - MOVL $3, CX - JMP callbackasm1(SB) - MOVL $4, CX - JMP callbackasm1(SB) - MOVL $5, CX - JMP callbackasm1(SB) - MOVL $6, CX - JMP callbackasm1(SB) - MOVL $7, CX - JMP callbackasm1(SB) - MOVL $8, CX - JMP callbackasm1(SB) - MOVL $9, CX - JMP callbackasm1(SB) - MOVL $10, CX - JMP callbackasm1(SB) - MOVL $11, CX - JMP callbackasm1(SB) - MOVL $12, CX - JMP callbackasm1(SB) - MOVL $13, CX - JMP callbackasm1(SB) - MOVL $14, CX - JMP callbackasm1(SB) - MOVL $15, CX - JMP callbackasm1(SB) - MOVL $16, CX - JMP callbackasm1(SB) - MOVL $17, CX - JMP callbackasm1(SB) - MOVL $18, CX - JMP callbackasm1(SB) - MOVL $19, CX - JMP callbackasm1(SB) - MOVL $20, CX - JMP callbackasm1(SB) - MOVL $21, CX - JMP callbackasm1(SB) - MOVL $22, CX - JMP callbackasm1(SB) - MOVL $23, CX - JMP callbackasm1(SB) - MOVL $24, CX - JMP callbackasm1(SB) - MOVL $25, CX - JMP callbackasm1(SB) - MOVL $26, CX - JMP callbackasm1(SB) - MOVL $27, CX - JMP callbackasm1(SB) - MOVL $28, CX - JMP callbackasm1(SB) - MOVL $29, CX - JMP callbackasm1(SB) - MOVL $30, CX - JMP callbackasm1(SB) - MOVL $31, CX - JMP callbackasm1(SB) - MOVL $32, CX - JMP callbackasm1(SB) - MOVL $33, CX - JMP callbackasm1(SB) - MOVL $34, CX - JMP callbackasm1(SB) - MOVL $35, CX - JMP callbackasm1(SB) - MOVL $36, CX - JMP callbackasm1(SB) - MOVL $37, CX - JMP callbackasm1(SB) - MOVL $38, CX - JMP callbackasm1(SB) - MOVL $39, CX - JMP callbackasm1(SB) - MOVL $40, CX - JMP callbackasm1(SB) - MOVL $41, CX - JMP callbackasm1(SB) - MOVL $42, CX - JMP callbackasm1(SB) - MOVL $43, CX - JMP callbackasm1(SB) - MOVL $44, CX - JMP callbackasm1(SB) - MOVL $45, CX - JMP callbackasm1(SB) - MOVL $46, CX - JMP callbackasm1(SB) - MOVL $47, CX - JMP callbackasm1(SB) - MOVL $48, CX - JMP callbackasm1(SB) - MOVL $49, CX - JMP callbackasm1(SB) - MOVL $50, CX - JMP callbackasm1(SB) - MOVL $51, CX - JMP callbackasm1(SB) - MOVL $52, CX - JMP callbackasm1(SB) - MOVL $53, CX - JMP callbackasm1(SB) - MOVL $54, CX - JMP callbackasm1(SB) - MOVL $55, CX - JMP callbackasm1(SB) - MOVL $56, CX - JMP callbackasm1(SB) - MOVL $57, CX - JMP callbackasm1(SB) - MOVL $58, CX - JMP callbackasm1(SB) - MOVL $59, CX - JMP callbackasm1(SB) - MOVL $60, CX - JMP callbackasm1(SB) - MOVL $61, CX - JMP callbackasm1(SB) - MOVL $62, CX - JMP callbackasm1(SB) - MOVL $63, CX - JMP callbackasm1(SB) - MOVL $64, CX - JMP callbackasm1(SB) - MOVL $65, CX - JMP callbackasm1(SB) - MOVL $66, CX - JMP callbackasm1(SB) - MOVL $67, CX - JMP callbackasm1(SB) - MOVL $68, CX - JMP callbackasm1(SB) - MOVL $69, CX - JMP callbackasm1(SB) - MOVL $70, CX - JMP callbackasm1(SB) - MOVL $71, CX - JMP callbackasm1(SB) - MOVL $72, CX - JMP callbackasm1(SB) - MOVL $73, CX - JMP callbackasm1(SB) - MOVL $74, CX - JMP callbackasm1(SB) - MOVL $75, CX - JMP callbackasm1(SB) - MOVL $76, CX - JMP callbackasm1(SB) - MOVL $77, CX - JMP callbackasm1(SB) - MOVL $78, CX - JMP callbackasm1(SB) - MOVL $79, CX - JMP callbackasm1(SB) - MOVL $80, CX - JMP callbackasm1(SB) - MOVL $81, CX - JMP callbackasm1(SB) - MOVL $82, CX - JMP callbackasm1(SB) - MOVL $83, CX - JMP callbackasm1(SB) - MOVL $84, CX - JMP callbackasm1(SB) - MOVL $85, CX - JMP callbackasm1(SB) - MOVL $86, CX - JMP callbackasm1(SB) - MOVL $87, CX - JMP callbackasm1(SB) - MOVL $88, CX - JMP callbackasm1(SB) - MOVL $89, CX - JMP callbackasm1(SB) - MOVL $90, CX - JMP callbackasm1(SB) - MOVL $91, CX - JMP callbackasm1(SB) - MOVL $92, CX - JMP callbackasm1(SB) - MOVL $93, CX - JMP callbackasm1(SB) - MOVL $94, CX - JMP callbackasm1(SB) - MOVL $95, CX - JMP callbackasm1(SB) - MOVL $96, CX - JMP callbackasm1(SB) - MOVL $97, CX - JMP callbackasm1(SB) - MOVL $98, CX - JMP callbackasm1(SB) - MOVL $99, CX - JMP callbackasm1(SB) - MOVL $100, CX - JMP callbackasm1(SB) - MOVL $101, CX - JMP callbackasm1(SB) - MOVL $102, CX - JMP callbackasm1(SB) - MOVL $103, CX - JMP callbackasm1(SB) - MOVL $104, CX - JMP callbackasm1(SB) - MOVL $105, CX - JMP callbackasm1(SB) - MOVL $106, CX - JMP callbackasm1(SB) - MOVL $107, CX - JMP callbackasm1(SB) - MOVL $108, CX - JMP callbackasm1(SB) - MOVL $109, CX - JMP callbackasm1(SB) - MOVL $110, CX - JMP callbackasm1(SB) - MOVL $111, CX - JMP callbackasm1(SB) - MOVL $112, CX - JMP callbackasm1(SB) - MOVL $113, CX - JMP callbackasm1(SB) - MOVL $114, CX - JMP callbackasm1(SB) - MOVL $115, CX - JMP callbackasm1(SB) - MOVL $116, CX - JMP callbackasm1(SB) - MOVL $117, CX - JMP callbackasm1(SB) - MOVL $118, CX - JMP callbackasm1(SB) - MOVL $119, CX - JMP callbackasm1(SB) - MOVL $120, CX - JMP callbackasm1(SB) - MOVL $121, CX - JMP callbackasm1(SB) - MOVL $122, CX - JMP callbackasm1(SB) - MOVL $123, CX - JMP callbackasm1(SB) - MOVL $124, CX - JMP callbackasm1(SB) - MOVL $125, CX - JMP callbackasm1(SB) - MOVL $126, CX - JMP callbackasm1(SB) - MOVL $127, CX - JMP callbackasm1(SB) - MOVL $128, CX - JMP callbackasm1(SB) - MOVL $129, CX - JMP callbackasm1(SB) - MOVL $130, CX - JMP callbackasm1(SB) - MOVL $131, CX - JMP callbackasm1(SB) - MOVL $132, CX - JMP callbackasm1(SB) - MOVL $133, CX - JMP callbackasm1(SB) - MOVL $134, CX - JMP callbackasm1(SB) - MOVL $135, CX - JMP callbackasm1(SB) - MOVL $136, CX - JMP callbackasm1(SB) - MOVL $137, CX - JMP callbackasm1(SB) - MOVL $138, CX - JMP callbackasm1(SB) - MOVL $139, CX - JMP callbackasm1(SB) - MOVL $140, CX - JMP callbackasm1(SB) - MOVL $141, CX - JMP callbackasm1(SB) - MOVL $142, CX - JMP callbackasm1(SB) - MOVL $143, CX - JMP callbackasm1(SB) - MOVL $144, CX - JMP callbackasm1(SB) - MOVL $145, CX - JMP callbackasm1(SB) - MOVL $146, CX - JMP callbackasm1(SB) - MOVL $147, CX - JMP callbackasm1(SB) - MOVL $148, CX - JMP callbackasm1(SB) - MOVL $149, CX - JMP callbackasm1(SB) - MOVL $150, CX - JMP callbackasm1(SB) - MOVL $151, CX - JMP callbackasm1(SB) - MOVL $152, CX - JMP callbackasm1(SB) - MOVL $153, CX - JMP callbackasm1(SB) - MOVL $154, CX - JMP callbackasm1(SB) - MOVL $155, CX - JMP callbackasm1(SB) - MOVL $156, CX - JMP callbackasm1(SB) - MOVL $157, CX - JMP callbackasm1(SB) - MOVL $158, CX - JMP callbackasm1(SB) - MOVL $159, CX - JMP callbackasm1(SB) - MOVL $160, CX - JMP callbackasm1(SB) - MOVL $161, CX - JMP callbackasm1(SB) - MOVL $162, CX - JMP callbackasm1(SB) - MOVL $163, CX - JMP callbackasm1(SB) - MOVL $164, CX - JMP callbackasm1(SB) - MOVL $165, CX - JMP callbackasm1(SB) - MOVL $166, CX - JMP callbackasm1(SB) - MOVL $167, CX - JMP callbackasm1(SB) - MOVL $168, CX - JMP callbackasm1(SB) - MOVL $169, CX - JMP callbackasm1(SB) - MOVL $170, CX - JMP callbackasm1(SB) - MOVL $171, CX - JMP callbackasm1(SB) - MOVL $172, CX - JMP callbackasm1(SB) - MOVL $173, CX - JMP callbackasm1(SB) - MOVL $174, CX - JMP callbackasm1(SB) - MOVL $175, CX - JMP callbackasm1(SB) - MOVL $176, CX - JMP callbackasm1(SB) - MOVL $177, CX - JMP callbackasm1(SB) - MOVL $178, CX - JMP callbackasm1(SB) - MOVL $179, CX - JMP callbackasm1(SB) - MOVL $180, CX - JMP callbackasm1(SB) - MOVL $181, CX - JMP callbackasm1(SB) - MOVL $182, CX - JMP callbackasm1(SB) - MOVL $183, CX - JMP callbackasm1(SB) - MOVL $184, CX - JMP callbackasm1(SB) - MOVL $185, CX - JMP callbackasm1(SB) - MOVL $186, CX - JMP callbackasm1(SB) - MOVL $187, CX - JMP callbackasm1(SB) - MOVL $188, CX - JMP callbackasm1(SB) - MOVL $189, CX - JMP callbackasm1(SB) - MOVL $190, CX - JMP callbackasm1(SB) - MOVL $191, CX - JMP callbackasm1(SB) - MOVL $192, CX - JMP callbackasm1(SB) - MOVL $193, CX - JMP callbackasm1(SB) - MOVL $194, CX - JMP callbackasm1(SB) - MOVL $195, CX - JMP callbackasm1(SB) - MOVL $196, CX - JMP callbackasm1(SB) - MOVL $197, CX - JMP callbackasm1(SB) - MOVL $198, CX - JMP callbackasm1(SB) - MOVL $199, CX - JMP callbackasm1(SB) - MOVL $200, CX - JMP callbackasm1(SB) - MOVL $201, CX - JMP callbackasm1(SB) - MOVL $202, CX - JMP callbackasm1(SB) - MOVL $203, CX - JMP callbackasm1(SB) - MOVL $204, CX - JMP callbackasm1(SB) - MOVL $205, CX - JMP callbackasm1(SB) - MOVL $206, CX - JMP callbackasm1(SB) - MOVL $207, CX - JMP callbackasm1(SB) - MOVL $208, CX - JMP callbackasm1(SB) - MOVL $209, CX - JMP callbackasm1(SB) - MOVL $210, CX - JMP callbackasm1(SB) - MOVL $211, CX - JMP callbackasm1(SB) - MOVL $212, CX - JMP callbackasm1(SB) - MOVL $213, CX - JMP callbackasm1(SB) - MOVL $214, CX - JMP callbackasm1(SB) - MOVL $215, CX - JMP callbackasm1(SB) - MOVL $216, CX - JMP callbackasm1(SB) - MOVL $217, CX - JMP callbackasm1(SB) - MOVL $218, CX - JMP callbackasm1(SB) - MOVL $219, CX - JMP callbackasm1(SB) - MOVL $220, CX - JMP callbackasm1(SB) - MOVL $221, CX - JMP callbackasm1(SB) - MOVL $222, CX - JMP callbackasm1(SB) - MOVL $223, CX - JMP callbackasm1(SB) - MOVL $224, CX - JMP callbackasm1(SB) - MOVL $225, CX - JMP callbackasm1(SB) - MOVL $226, CX - JMP callbackasm1(SB) - MOVL $227, CX - JMP callbackasm1(SB) - MOVL $228, CX - JMP callbackasm1(SB) - MOVL $229, CX - JMP callbackasm1(SB) - MOVL $230, CX - JMP callbackasm1(SB) - MOVL $231, CX - JMP callbackasm1(SB) - MOVL $232, CX - JMP callbackasm1(SB) - MOVL $233, CX - JMP callbackasm1(SB) - MOVL $234, CX - JMP callbackasm1(SB) - MOVL $235, CX - JMP callbackasm1(SB) - MOVL $236, CX - JMP callbackasm1(SB) - MOVL $237, CX - JMP callbackasm1(SB) - MOVL $238, CX - JMP callbackasm1(SB) - MOVL $239, CX - JMP callbackasm1(SB) - MOVL $240, CX - JMP callbackasm1(SB) - MOVL $241, CX - JMP callbackasm1(SB) - MOVL $242, CX - JMP callbackasm1(SB) - MOVL $243, CX - JMP callbackasm1(SB) - MOVL $244, CX - JMP callbackasm1(SB) - MOVL $245, CX - JMP callbackasm1(SB) - MOVL $246, CX - JMP callbackasm1(SB) - MOVL $247, CX - JMP callbackasm1(SB) - MOVL $248, CX - JMP callbackasm1(SB) - MOVL $249, CX - JMP callbackasm1(SB) - MOVL $250, CX - JMP callbackasm1(SB) - MOVL $251, CX - JMP callbackasm1(SB) - MOVL $252, CX - JMP callbackasm1(SB) - MOVL $253, CX - JMP callbackasm1(SB) - MOVL $254, CX - JMP callbackasm1(SB) - MOVL $255, CX - JMP callbackasm1(SB) - MOVL $256, CX - JMP callbackasm1(SB) - MOVL $257, CX - JMP callbackasm1(SB) - MOVL $258, CX - JMP callbackasm1(SB) - MOVL $259, CX - JMP callbackasm1(SB) - MOVL $260, CX - JMP callbackasm1(SB) - MOVL $261, CX - JMP callbackasm1(SB) - MOVL $262, CX - JMP callbackasm1(SB) - MOVL $263, CX - JMP callbackasm1(SB) - MOVL $264, CX - JMP callbackasm1(SB) - MOVL $265, CX - JMP callbackasm1(SB) - MOVL $266, CX - JMP callbackasm1(SB) - MOVL $267, CX - JMP callbackasm1(SB) - MOVL $268, CX - JMP callbackasm1(SB) - MOVL $269, CX - JMP callbackasm1(SB) - MOVL $270, CX - JMP callbackasm1(SB) - MOVL $271, CX - JMP callbackasm1(SB) - MOVL $272, CX - JMP callbackasm1(SB) - MOVL $273, CX - JMP callbackasm1(SB) - MOVL $274, CX - JMP callbackasm1(SB) - MOVL $275, CX - JMP callbackasm1(SB) - MOVL $276, CX - JMP callbackasm1(SB) - MOVL $277, CX - JMP callbackasm1(SB) - MOVL $278, CX - JMP callbackasm1(SB) - MOVL $279, CX - JMP callbackasm1(SB) - MOVL $280, CX - JMP callbackasm1(SB) - MOVL $281, CX - JMP callbackasm1(SB) - MOVL $282, CX - JMP callbackasm1(SB) - MOVL $283, CX - JMP callbackasm1(SB) - MOVL $284, CX - JMP callbackasm1(SB) - MOVL $285, CX - JMP callbackasm1(SB) - MOVL $286, CX - JMP callbackasm1(SB) - MOVL $287, CX - JMP callbackasm1(SB) - MOVL $288, CX - JMP callbackasm1(SB) - MOVL $289, CX - JMP callbackasm1(SB) - MOVL $290, CX - JMP callbackasm1(SB) - MOVL $291, CX - JMP callbackasm1(SB) - MOVL $292, CX - JMP callbackasm1(SB) - MOVL $293, CX - JMP callbackasm1(SB) - MOVL $294, CX - JMP callbackasm1(SB) - MOVL $295, CX - JMP callbackasm1(SB) - MOVL $296, CX - JMP callbackasm1(SB) - MOVL $297, CX - JMP callbackasm1(SB) - MOVL $298, CX - JMP callbackasm1(SB) - MOVL $299, CX - JMP callbackasm1(SB) - MOVL $300, CX - JMP callbackasm1(SB) - MOVL $301, CX - JMP callbackasm1(SB) - MOVL $302, CX - JMP callbackasm1(SB) - MOVL $303, CX - JMP callbackasm1(SB) - MOVL $304, CX - JMP callbackasm1(SB) - MOVL $305, CX - JMP callbackasm1(SB) - MOVL $306, CX - JMP callbackasm1(SB) - MOVL $307, CX - JMP callbackasm1(SB) - MOVL $308, CX - JMP callbackasm1(SB) - MOVL $309, CX - JMP callbackasm1(SB) - MOVL $310, CX - JMP callbackasm1(SB) - MOVL $311, CX - JMP callbackasm1(SB) - MOVL $312, CX - JMP callbackasm1(SB) - MOVL $313, CX - JMP callbackasm1(SB) - MOVL $314, CX - JMP callbackasm1(SB) - MOVL $315, CX - JMP callbackasm1(SB) - MOVL $316, CX - JMP callbackasm1(SB) - MOVL $317, CX - JMP callbackasm1(SB) - MOVL $318, CX - JMP callbackasm1(SB) - MOVL $319, CX - JMP callbackasm1(SB) - MOVL $320, CX - JMP callbackasm1(SB) - MOVL $321, CX - JMP callbackasm1(SB) - MOVL $322, CX - JMP callbackasm1(SB) - MOVL $323, CX - JMP callbackasm1(SB) - MOVL $324, CX - JMP callbackasm1(SB) - MOVL $325, CX - JMP callbackasm1(SB) - MOVL $326, CX - JMP callbackasm1(SB) - MOVL $327, CX - JMP callbackasm1(SB) - MOVL $328, CX - JMP callbackasm1(SB) - MOVL $329, CX - JMP callbackasm1(SB) - MOVL $330, CX - JMP callbackasm1(SB) - MOVL $331, CX - JMP callbackasm1(SB) - MOVL $332, CX - JMP callbackasm1(SB) - MOVL $333, CX - JMP callbackasm1(SB) - MOVL $334, CX - JMP callbackasm1(SB) - MOVL $335, CX - JMP callbackasm1(SB) - MOVL $336, CX - JMP callbackasm1(SB) - MOVL $337, CX - JMP callbackasm1(SB) - MOVL $338, CX - JMP callbackasm1(SB) - MOVL $339, CX - JMP callbackasm1(SB) - MOVL $340, CX - JMP callbackasm1(SB) - MOVL $341, CX - JMP callbackasm1(SB) - MOVL $342, CX - JMP callbackasm1(SB) - MOVL $343, CX - JMP callbackasm1(SB) - MOVL $344, CX - JMP callbackasm1(SB) - MOVL $345, CX - JMP callbackasm1(SB) - MOVL $346, CX - JMP callbackasm1(SB) - MOVL $347, CX - JMP callbackasm1(SB) - MOVL $348, CX - JMP callbackasm1(SB) - MOVL $349, CX - JMP callbackasm1(SB) - MOVL $350, CX - JMP callbackasm1(SB) - MOVL $351, CX - JMP callbackasm1(SB) - MOVL $352, CX - JMP callbackasm1(SB) - MOVL $353, CX - JMP callbackasm1(SB) - MOVL $354, CX - JMP callbackasm1(SB) - MOVL $355, CX - JMP callbackasm1(SB) - MOVL $356, CX - JMP callbackasm1(SB) - MOVL $357, CX - JMP callbackasm1(SB) - MOVL $358, CX - JMP callbackasm1(SB) - MOVL $359, CX - JMP callbackasm1(SB) - MOVL $360, CX - JMP callbackasm1(SB) - MOVL $361, CX - JMP callbackasm1(SB) - MOVL $362, CX - JMP callbackasm1(SB) - MOVL $363, CX - JMP callbackasm1(SB) - MOVL $364, CX - JMP callbackasm1(SB) - MOVL $365, CX - JMP callbackasm1(SB) - MOVL $366, CX - JMP callbackasm1(SB) - MOVL $367, CX - JMP callbackasm1(SB) - MOVL $368, CX - JMP callbackasm1(SB) - MOVL $369, CX - JMP callbackasm1(SB) - MOVL $370, CX - JMP callbackasm1(SB) - MOVL $371, CX - JMP callbackasm1(SB) - MOVL $372, CX - JMP callbackasm1(SB) - MOVL $373, CX - JMP callbackasm1(SB) - MOVL $374, CX - JMP callbackasm1(SB) - MOVL $375, CX - JMP callbackasm1(SB) - MOVL $376, CX - JMP callbackasm1(SB) - MOVL $377, CX - JMP callbackasm1(SB) - MOVL $378, CX - JMP callbackasm1(SB) - MOVL $379, CX - JMP callbackasm1(SB) - MOVL $380, CX - JMP callbackasm1(SB) - MOVL $381, CX - JMP callbackasm1(SB) - MOVL $382, CX - JMP callbackasm1(SB) - MOVL $383, CX - JMP callbackasm1(SB) - MOVL $384, CX - JMP callbackasm1(SB) - MOVL $385, CX - JMP callbackasm1(SB) - MOVL $386, CX - JMP callbackasm1(SB) - MOVL $387, CX - JMP callbackasm1(SB) - MOVL $388, CX - JMP callbackasm1(SB) - MOVL $389, CX - JMP callbackasm1(SB) - MOVL $390, CX - JMP callbackasm1(SB) - MOVL $391, CX - JMP callbackasm1(SB) - MOVL $392, CX - JMP callbackasm1(SB) - MOVL $393, CX - JMP callbackasm1(SB) - MOVL $394, CX - JMP callbackasm1(SB) - MOVL $395, CX - JMP callbackasm1(SB) - MOVL $396, CX - JMP callbackasm1(SB) - MOVL $397, CX - JMP callbackasm1(SB) - MOVL $398, CX - JMP callbackasm1(SB) - MOVL $399, CX - JMP callbackasm1(SB) - MOVL $400, CX - JMP callbackasm1(SB) - MOVL $401, CX - JMP callbackasm1(SB) - MOVL $402, CX - JMP callbackasm1(SB) - MOVL $403, CX - JMP callbackasm1(SB) - MOVL $404, CX - JMP callbackasm1(SB) - MOVL $405, CX - JMP callbackasm1(SB) - MOVL $406, CX - JMP callbackasm1(SB) - MOVL $407, CX - JMP callbackasm1(SB) - MOVL $408, CX - JMP callbackasm1(SB) - MOVL $409, CX - JMP callbackasm1(SB) - MOVL $410, CX - JMP callbackasm1(SB) - MOVL $411, CX - JMP callbackasm1(SB) - MOVL $412, CX - JMP callbackasm1(SB) - MOVL $413, CX - JMP callbackasm1(SB) - MOVL $414, CX - JMP callbackasm1(SB) - MOVL $415, CX - JMP callbackasm1(SB) - MOVL $416, CX - JMP callbackasm1(SB) - MOVL $417, CX - JMP callbackasm1(SB) - MOVL $418, CX - JMP callbackasm1(SB) - MOVL $419, CX - JMP callbackasm1(SB) - MOVL $420, CX - JMP callbackasm1(SB) - MOVL $421, CX - JMP callbackasm1(SB) - MOVL $422, CX - JMP callbackasm1(SB) - MOVL $423, CX - JMP callbackasm1(SB) - MOVL $424, CX - JMP callbackasm1(SB) - MOVL $425, CX - JMP callbackasm1(SB) - MOVL $426, CX - JMP callbackasm1(SB) - MOVL $427, CX - JMP callbackasm1(SB) - MOVL $428, CX - JMP callbackasm1(SB) - MOVL $429, CX - JMP callbackasm1(SB) - MOVL $430, CX - JMP callbackasm1(SB) - MOVL $431, CX - JMP callbackasm1(SB) - MOVL $432, CX - JMP callbackasm1(SB) - MOVL $433, CX - JMP callbackasm1(SB) - MOVL $434, CX - JMP callbackasm1(SB) - MOVL $435, CX - JMP callbackasm1(SB) - MOVL $436, CX - JMP callbackasm1(SB) - MOVL $437, CX - JMP callbackasm1(SB) - MOVL $438, CX - JMP callbackasm1(SB) - MOVL $439, CX - JMP callbackasm1(SB) - MOVL $440, CX - JMP callbackasm1(SB) - MOVL $441, CX - JMP callbackasm1(SB) - MOVL $442, CX - JMP callbackasm1(SB) - MOVL $443, CX - JMP callbackasm1(SB) - MOVL $444, CX - JMP callbackasm1(SB) - MOVL $445, CX - JMP callbackasm1(SB) - MOVL $446, CX - JMP callbackasm1(SB) - MOVL $447, CX - JMP callbackasm1(SB) - MOVL $448, CX - JMP callbackasm1(SB) - MOVL $449, CX - JMP callbackasm1(SB) - MOVL $450, CX - JMP callbackasm1(SB) - MOVL $451, CX - JMP callbackasm1(SB) - MOVL $452, CX - JMP callbackasm1(SB) - MOVL $453, CX - JMP callbackasm1(SB) - MOVL $454, CX - JMP callbackasm1(SB) - MOVL $455, CX - JMP callbackasm1(SB) - MOVL $456, CX - JMP callbackasm1(SB) - MOVL $457, CX - JMP callbackasm1(SB) - MOVL $458, CX - JMP callbackasm1(SB) - MOVL $459, CX - JMP callbackasm1(SB) - MOVL $460, CX - JMP callbackasm1(SB) - MOVL $461, CX - JMP callbackasm1(SB) - MOVL $462, CX - JMP callbackasm1(SB) - MOVL $463, CX - JMP callbackasm1(SB) - MOVL $464, CX - JMP callbackasm1(SB) - MOVL $465, CX - JMP callbackasm1(SB) - MOVL $466, CX - JMP callbackasm1(SB) - MOVL $467, CX - JMP callbackasm1(SB) - MOVL $468, CX - JMP callbackasm1(SB) - MOVL $469, CX - JMP callbackasm1(SB) - MOVL $470, CX - JMP callbackasm1(SB) - MOVL $471, CX - JMP callbackasm1(SB) - MOVL $472, CX - JMP callbackasm1(SB) - MOVL $473, CX - JMP callbackasm1(SB) - MOVL $474, CX - JMP callbackasm1(SB) - MOVL $475, CX - JMP callbackasm1(SB) - MOVL $476, CX - JMP callbackasm1(SB) - MOVL $477, CX - JMP callbackasm1(SB) - MOVL $478, CX - JMP callbackasm1(SB) - MOVL $479, CX - JMP callbackasm1(SB) - MOVL $480, CX - JMP callbackasm1(SB) - MOVL $481, CX - JMP callbackasm1(SB) - MOVL $482, CX - JMP callbackasm1(SB) - MOVL $483, CX - JMP callbackasm1(SB) - MOVL $484, CX - JMP callbackasm1(SB) - MOVL $485, CX - JMP callbackasm1(SB) - MOVL $486, CX - JMP callbackasm1(SB) - MOVL $487, CX - JMP callbackasm1(SB) - MOVL $488, CX - JMP callbackasm1(SB) - MOVL $489, CX - JMP callbackasm1(SB) - MOVL $490, CX - JMP callbackasm1(SB) - MOVL $491, CX - JMP callbackasm1(SB) - MOVL $492, CX - JMP callbackasm1(SB) - MOVL $493, CX - JMP callbackasm1(SB) - MOVL $494, CX - JMP callbackasm1(SB) - MOVL $495, CX - JMP callbackasm1(SB) - MOVL $496, CX - JMP callbackasm1(SB) - MOVL $497, CX - JMP callbackasm1(SB) - MOVL $498, CX - JMP callbackasm1(SB) - MOVL $499, CX - JMP callbackasm1(SB) - MOVL $500, CX - JMP callbackasm1(SB) - MOVL $501, CX - JMP callbackasm1(SB) - MOVL $502, CX - JMP callbackasm1(SB) - MOVL $503, CX - JMP callbackasm1(SB) - MOVL $504, CX - JMP callbackasm1(SB) - MOVL $505, CX - JMP callbackasm1(SB) - MOVL $506, CX - JMP callbackasm1(SB) - MOVL $507, CX - JMP callbackasm1(SB) - MOVL $508, CX - JMP callbackasm1(SB) - MOVL $509, CX - JMP callbackasm1(SB) - MOVL $510, CX - JMP callbackasm1(SB) - MOVL $511, CX - JMP callbackasm1(SB) - MOVL $512, CX - JMP callbackasm1(SB) - MOVL $513, CX - JMP callbackasm1(SB) - MOVL $514, CX - JMP callbackasm1(SB) - MOVL $515, CX - JMP callbackasm1(SB) - MOVL $516, CX - JMP callbackasm1(SB) - MOVL $517, CX - JMP callbackasm1(SB) - MOVL $518, CX - JMP callbackasm1(SB) - MOVL $519, CX - JMP callbackasm1(SB) - MOVL $520, CX - JMP callbackasm1(SB) - MOVL $521, CX - JMP callbackasm1(SB) - MOVL $522, CX - JMP callbackasm1(SB) - MOVL $523, CX - JMP callbackasm1(SB) - MOVL $524, CX - JMP callbackasm1(SB) - MOVL $525, CX - JMP callbackasm1(SB) - MOVL $526, CX - JMP callbackasm1(SB) - MOVL $527, CX - JMP callbackasm1(SB) - MOVL $528, CX - JMP callbackasm1(SB) - MOVL $529, CX - JMP callbackasm1(SB) - MOVL $530, CX - JMP callbackasm1(SB) - MOVL $531, CX - JMP callbackasm1(SB) - MOVL $532, CX - JMP callbackasm1(SB) - MOVL $533, CX - JMP callbackasm1(SB) - MOVL $534, CX - JMP callbackasm1(SB) - MOVL $535, CX - JMP callbackasm1(SB) - MOVL $536, CX - JMP callbackasm1(SB) - MOVL $537, CX - JMP callbackasm1(SB) - MOVL $538, CX - JMP callbackasm1(SB) - MOVL $539, CX - JMP callbackasm1(SB) - MOVL $540, CX - JMP callbackasm1(SB) - MOVL $541, CX - JMP callbackasm1(SB) - MOVL $542, CX - JMP callbackasm1(SB) - MOVL $543, CX - JMP callbackasm1(SB) - MOVL $544, CX - JMP callbackasm1(SB) - MOVL $545, CX - JMP callbackasm1(SB) - MOVL $546, CX - JMP callbackasm1(SB) - MOVL $547, CX - JMP callbackasm1(SB) - MOVL $548, CX - JMP callbackasm1(SB) - MOVL $549, CX - JMP callbackasm1(SB) - MOVL $550, CX - JMP callbackasm1(SB) - MOVL $551, CX - JMP callbackasm1(SB) - MOVL $552, CX - JMP callbackasm1(SB) - MOVL $553, CX - JMP callbackasm1(SB) - MOVL $554, CX - JMP callbackasm1(SB) - MOVL $555, CX - JMP callbackasm1(SB) - MOVL $556, CX - JMP callbackasm1(SB) - MOVL $557, CX - JMP callbackasm1(SB) - MOVL $558, CX - JMP callbackasm1(SB) - MOVL $559, CX - JMP callbackasm1(SB) - MOVL $560, CX - JMP callbackasm1(SB) - MOVL $561, CX - JMP callbackasm1(SB) - MOVL $562, CX - JMP callbackasm1(SB) - MOVL $563, CX - JMP callbackasm1(SB) - MOVL $564, CX - JMP callbackasm1(SB) - MOVL $565, CX - JMP callbackasm1(SB) - MOVL $566, CX - JMP callbackasm1(SB) - MOVL $567, CX - JMP callbackasm1(SB) - MOVL $568, CX - JMP callbackasm1(SB) - MOVL $569, CX - JMP callbackasm1(SB) - MOVL $570, CX - JMP callbackasm1(SB) - MOVL $571, CX - JMP callbackasm1(SB) - MOVL $572, CX - JMP callbackasm1(SB) - MOVL $573, CX - JMP callbackasm1(SB) - MOVL $574, CX - JMP callbackasm1(SB) - MOVL $575, CX - JMP callbackasm1(SB) - MOVL $576, CX - JMP callbackasm1(SB) - MOVL $577, CX - JMP callbackasm1(SB) - MOVL $578, CX - JMP callbackasm1(SB) - MOVL $579, CX - JMP callbackasm1(SB) - MOVL $580, CX - JMP callbackasm1(SB) - MOVL $581, CX - JMP callbackasm1(SB) - MOVL $582, CX - JMP callbackasm1(SB) - MOVL $583, CX - JMP callbackasm1(SB) - MOVL $584, CX - JMP callbackasm1(SB) - MOVL $585, CX - JMP callbackasm1(SB) - MOVL $586, CX - JMP callbackasm1(SB) - MOVL $587, CX - JMP callbackasm1(SB) - MOVL $588, CX - JMP callbackasm1(SB) - MOVL $589, CX - JMP callbackasm1(SB) - MOVL $590, CX - JMP callbackasm1(SB) - MOVL $591, CX - JMP callbackasm1(SB) - MOVL $592, CX - JMP callbackasm1(SB) - MOVL $593, CX - JMP callbackasm1(SB) - MOVL $594, CX - JMP callbackasm1(SB) - MOVL $595, CX - JMP callbackasm1(SB) - MOVL $596, CX - JMP callbackasm1(SB) - MOVL $597, CX - JMP callbackasm1(SB) - MOVL $598, CX - JMP callbackasm1(SB) - MOVL $599, CX - JMP callbackasm1(SB) - MOVL $600, CX - JMP callbackasm1(SB) - MOVL $601, CX - JMP callbackasm1(SB) - MOVL $602, CX - JMP callbackasm1(SB) - MOVL $603, CX - JMP callbackasm1(SB) - MOVL $604, CX - JMP callbackasm1(SB) - MOVL $605, CX - JMP callbackasm1(SB) - MOVL $606, CX - JMP callbackasm1(SB) - MOVL $607, CX - JMP callbackasm1(SB) - MOVL $608, CX - JMP callbackasm1(SB) - MOVL $609, CX - JMP callbackasm1(SB) - MOVL $610, CX - JMP callbackasm1(SB) - MOVL $611, CX - JMP callbackasm1(SB) - MOVL $612, CX - JMP callbackasm1(SB) - MOVL $613, CX - JMP callbackasm1(SB) - MOVL $614, CX - JMP callbackasm1(SB) - MOVL $615, CX - JMP callbackasm1(SB) - MOVL $616, CX - JMP callbackasm1(SB) - MOVL $617, CX - JMP callbackasm1(SB) - MOVL $618, CX - JMP callbackasm1(SB) - MOVL $619, CX - JMP callbackasm1(SB) - MOVL $620, CX - JMP callbackasm1(SB) - MOVL $621, CX - JMP callbackasm1(SB) - MOVL $622, CX - JMP callbackasm1(SB) - MOVL $623, CX - JMP callbackasm1(SB) - MOVL $624, CX - JMP callbackasm1(SB) - MOVL $625, CX - JMP callbackasm1(SB) - MOVL $626, CX - JMP callbackasm1(SB) - MOVL $627, CX - JMP callbackasm1(SB) - MOVL $628, CX - JMP callbackasm1(SB) - MOVL $629, CX - JMP callbackasm1(SB) - MOVL $630, CX - JMP callbackasm1(SB) - MOVL $631, CX - JMP callbackasm1(SB) - MOVL $632, CX - JMP callbackasm1(SB) - MOVL $633, CX - JMP callbackasm1(SB) - MOVL $634, CX - JMP callbackasm1(SB) - MOVL $635, CX - JMP callbackasm1(SB) - MOVL $636, CX - JMP callbackasm1(SB) - MOVL $637, CX - JMP callbackasm1(SB) - MOVL $638, CX - JMP callbackasm1(SB) - MOVL $639, CX - JMP callbackasm1(SB) - MOVL $640, CX - JMP callbackasm1(SB) - MOVL $641, CX - JMP callbackasm1(SB) - MOVL $642, CX - JMP callbackasm1(SB) - MOVL $643, CX - JMP callbackasm1(SB) - MOVL $644, CX - JMP callbackasm1(SB) - MOVL $645, CX - JMP callbackasm1(SB) - MOVL $646, CX - JMP callbackasm1(SB) - MOVL $647, CX - JMP callbackasm1(SB) - MOVL $648, CX - JMP callbackasm1(SB) - MOVL $649, CX - JMP callbackasm1(SB) - MOVL $650, CX - JMP callbackasm1(SB) - MOVL $651, CX - JMP callbackasm1(SB) - MOVL $652, CX - JMP callbackasm1(SB) - MOVL $653, CX - JMP callbackasm1(SB) - MOVL $654, CX - JMP callbackasm1(SB) - MOVL $655, CX - JMP callbackasm1(SB) - MOVL $656, CX - JMP callbackasm1(SB) - MOVL $657, CX - JMP callbackasm1(SB) - MOVL $658, CX - JMP callbackasm1(SB) - MOVL $659, CX - JMP callbackasm1(SB) - MOVL $660, CX - JMP callbackasm1(SB) - MOVL $661, CX - JMP callbackasm1(SB) - MOVL $662, CX - JMP callbackasm1(SB) - MOVL $663, CX - JMP callbackasm1(SB) - MOVL $664, CX - JMP callbackasm1(SB) - MOVL $665, CX - JMP callbackasm1(SB) - MOVL $666, CX - JMP callbackasm1(SB) - MOVL $667, CX - JMP callbackasm1(SB) - MOVL $668, CX - JMP callbackasm1(SB) - MOVL $669, CX - JMP callbackasm1(SB) - MOVL $670, CX - JMP callbackasm1(SB) - MOVL $671, CX - JMP callbackasm1(SB) - MOVL $672, CX - JMP callbackasm1(SB) - MOVL $673, CX - JMP callbackasm1(SB) - MOVL $674, CX - JMP callbackasm1(SB) - MOVL $675, CX - JMP callbackasm1(SB) - MOVL $676, CX - JMP callbackasm1(SB) - MOVL $677, CX - JMP callbackasm1(SB) - MOVL $678, CX - JMP callbackasm1(SB) - MOVL $679, CX - JMP callbackasm1(SB) - MOVL $680, CX - JMP callbackasm1(SB) - MOVL $681, CX - JMP callbackasm1(SB) - MOVL $682, CX - JMP callbackasm1(SB) - MOVL $683, CX - JMP callbackasm1(SB) - MOVL $684, CX - JMP callbackasm1(SB) - MOVL $685, CX - JMP callbackasm1(SB) - MOVL $686, CX - JMP callbackasm1(SB) - MOVL $687, CX - JMP callbackasm1(SB) - MOVL $688, CX - JMP callbackasm1(SB) - MOVL $689, CX - JMP callbackasm1(SB) - MOVL $690, CX - JMP callbackasm1(SB) - MOVL $691, CX - JMP callbackasm1(SB) - MOVL $692, CX - JMP callbackasm1(SB) - MOVL $693, CX - JMP callbackasm1(SB) - MOVL $694, CX - JMP callbackasm1(SB) - MOVL $695, CX - JMP callbackasm1(SB) - MOVL $696, CX - JMP callbackasm1(SB) - MOVL $697, CX - JMP callbackasm1(SB) - MOVL $698, CX - JMP callbackasm1(SB) - MOVL $699, CX - JMP callbackasm1(SB) - MOVL $700, CX - JMP callbackasm1(SB) - MOVL $701, CX - JMP callbackasm1(SB) - MOVL $702, CX - JMP callbackasm1(SB) - MOVL $703, CX - JMP callbackasm1(SB) - MOVL $704, CX - JMP callbackasm1(SB) - MOVL $705, CX - JMP callbackasm1(SB) - MOVL $706, CX - JMP callbackasm1(SB) - MOVL $707, CX - JMP callbackasm1(SB) - MOVL $708, CX - JMP callbackasm1(SB) - MOVL $709, CX - JMP callbackasm1(SB) - MOVL $710, CX - JMP callbackasm1(SB) - MOVL $711, CX - JMP callbackasm1(SB) - MOVL $712, CX - JMP callbackasm1(SB) - MOVL $713, CX - JMP callbackasm1(SB) - MOVL $714, CX - JMP callbackasm1(SB) - MOVL $715, CX - JMP callbackasm1(SB) - MOVL $716, CX - JMP callbackasm1(SB) - MOVL $717, CX - JMP callbackasm1(SB) - MOVL $718, CX - JMP callbackasm1(SB) - MOVL $719, CX - JMP callbackasm1(SB) - MOVL $720, CX - JMP callbackasm1(SB) - MOVL $721, CX - JMP callbackasm1(SB) - MOVL $722, CX - JMP callbackasm1(SB) - MOVL $723, CX - JMP callbackasm1(SB) - MOVL $724, CX - JMP callbackasm1(SB) - MOVL $725, CX - JMP callbackasm1(SB) - MOVL $726, CX - JMP callbackasm1(SB) - MOVL $727, CX - JMP callbackasm1(SB) - MOVL $728, CX - JMP callbackasm1(SB) - MOVL $729, CX - JMP callbackasm1(SB) - MOVL $730, CX - JMP callbackasm1(SB) - MOVL $731, CX - JMP callbackasm1(SB) - MOVL $732, CX - JMP callbackasm1(SB) - MOVL $733, CX - JMP callbackasm1(SB) - MOVL $734, CX - JMP callbackasm1(SB) - MOVL $735, CX - JMP callbackasm1(SB) - MOVL $736, CX - JMP callbackasm1(SB) - MOVL $737, CX - JMP callbackasm1(SB) - MOVL $738, CX - JMP callbackasm1(SB) - MOVL $739, CX - JMP callbackasm1(SB) - MOVL $740, CX - JMP callbackasm1(SB) - MOVL $741, CX - JMP callbackasm1(SB) - MOVL $742, CX - JMP callbackasm1(SB) - MOVL $743, CX - JMP callbackasm1(SB) - MOVL $744, CX - JMP callbackasm1(SB) - MOVL $745, CX - JMP callbackasm1(SB) - MOVL $746, CX - JMP callbackasm1(SB) - MOVL $747, CX - JMP callbackasm1(SB) - MOVL $748, CX - JMP callbackasm1(SB) - MOVL $749, CX - JMP callbackasm1(SB) - MOVL $750, CX - JMP callbackasm1(SB) - MOVL $751, CX - JMP callbackasm1(SB) - MOVL $752, CX - JMP callbackasm1(SB) - MOVL $753, CX - JMP callbackasm1(SB) - MOVL $754, CX - JMP callbackasm1(SB) - MOVL $755, CX - JMP callbackasm1(SB) - MOVL $756, CX - JMP callbackasm1(SB) - MOVL $757, CX - JMP callbackasm1(SB) - MOVL $758, CX - JMP callbackasm1(SB) - MOVL $759, CX - JMP callbackasm1(SB) - MOVL $760, CX - JMP callbackasm1(SB) - MOVL $761, CX - JMP callbackasm1(SB) - MOVL $762, CX - JMP callbackasm1(SB) - MOVL $763, CX - JMP callbackasm1(SB) - MOVL $764, CX - JMP callbackasm1(SB) - MOVL $765, CX - JMP callbackasm1(SB) - MOVL $766, CX - JMP callbackasm1(SB) - MOVL $767, CX - JMP callbackasm1(SB) - MOVL $768, CX - JMP callbackasm1(SB) - MOVL $769, CX - JMP callbackasm1(SB) - MOVL $770, CX - JMP callbackasm1(SB) - MOVL $771, CX - JMP callbackasm1(SB) - MOVL $772, CX - JMP callbackasm1(SB) - MOVL $773, CX - JMP callbackasm1(SB) - MOVL $774, CX - JMP callbackasm1(SB) - MOVL $775, CX - JMP callbackasm1(SB) - MOVL $776, CX - JMP callbackasm1(SB) - MOVL $777, CX - JMP callbackasm1(SB) - MOVL $778, CX - JMP callbackasm1(SB) - MOVL $779, CX - JMP callbackasm1(SB) - MOVL $780, CX - JMP callbackasm1(SB) - MOVL $781, CX - JMP callbackasm1(SB) - MOVL $782, CX - JMP callbackasm1(SB) - MOVL $783, CX - JMP callbackasm1(SB) - MOVL $784, CX - JMP callbackasm1(SB) - MOVL $785, CX - JMP callbackasm1(SB) - MOVL $786, CX - JMP callbackasm1(SB) - MOVL $787, CX - JMP callbackasm1(SB) - MOVL $788, CX - JMP callbackasm1(SB) - MOVL $789, CX - JMP callbackasm1(SB) - MOVL $790, CX - JMP callbackasm1(SB) - MOVL $791, CX - JMP callbackasm1(SB) - MOVL $792, CX - JMP callbackasm1(SB) - MOVL $793, CX - JMP callbackasm1(SB) - MOVL $794, CX - JMP callbackasm1(SB) - MOVL $795, CX - JMP callbackasm1(SB) - MOVL $796, CX - JMP callbackasm1(SB) - MOVL $797, CX - JMP callbackasm1(SB) - MOVL $798, CX - JMP callbackasm1(SB) - MOVL $799, CX - JMP callbackasm1(SB) - MOVL $800, CX - JMP callbackasm1(SB) - MOVL $801, CX - JMP callbackasm1(SB) - MOVL $802, CX - JMP callbackasm1(SB) - MOVL $803, CX - JMP callbackasm1(SB) - MOVL $804, CX - JMP callbackasm1(SB) - MOVL $805, CX - JMP callbackasm1(SB) - MOVL $806, CX - JMP callbackasm1(SB) - MOVL $807, CX - JMP callbackasm1(SB) - MOVL $808, CX - JMP callbackasm1(SB) - MOVL $809, CX - JMP callbackasm1(SB) - MOVL $810, CX - JMP callbackasm1(SB) - MOVL $811, CX - JMP callbackasm1(SB) - MOVL $812, CX - JMP callbackasm1(SB) - MOVL $813, CX - JMP callbackasm1(SB) - MOVL $814, CX - JMP callbackasm1(SB) - MOVL $815, CX - JMP callbackasm1(SB) - MOVL $816, CX - JMP callbackasm1(SB) - MOVL $817, CX - JMP callbackasm1(SB) - MOVL $818, CX - JMP callbackasm1(SB) - MOVL $819, CX - JMP callbackasm1(SB) - MOVL $820, CX - JMP callbackasm1(SB) - MOVL $821, CX - JMP callbackasm1(SB) - MOVL $822, CX - JMP callbackasm1(SB) - MOVL $823, CX - JMP callbackasm1(SB) - MOVL $824, CX - JMP callbackasm1(SB) - MOVL $825, CX - JMP callbackasm1(SB) - MOVL $826, CX - JMP callbackasm1(SB) - MOVL $827, CX - JMP callbackasm1(SB) - MOVL $828, CX - JMP callbackasm1(SB) - MOVL $829, CX - JMP callbackasm1(SB) - MOVL $830, CX - JMP callbackasm1(SB) - MOVL $831, CX - JMP callbackasm1(SB) - MOVL $832, CX - JMP callbackasm1(SB) - MOVL $833, CX - JMP callbackasm1(SB) - MOVL $834, CX - JMP callbackasm1(SB) - MOVL $835, CX - JMP callbackasm1(SB) - MOVL $836, CX - JMP callbackasm1(SB) - MOVL $837, CX - JMP callbackasm1(SB) - MOVL $838, CX - JMP callbackasm1(SB) - MOVL $839, CX - JMP callbackasm1(SB) - MOVL $840, CX - JMP callbackasm1(SB) - MOVL $841, CX - JMP callbackasm1(SB) - MOVL $842, CX - JMP callbackasm1(SB) - MOVL $843, CX - JMP callbackasm1(SB) - MOVL $844, CX - JMP callbackasm1(SB) - MOVL $845, CX - JMP callbackasm1(SB) - MOVL $846, CX - JMP callbackasm1(SB) - MOVL $847, CX - JMP callbackasm1(SB) - MOVL $848, CX - JMP callbackasm1(SB) - MOVL $849, CX - JMP callbackasm1(SB) - MOVL $850, CX - JMP callbackasm1(SB) - MOVL $851, CX - JMP callbackasm1(SB) - MOVL $852, CX - JMP callbackasm1(SB) - MOVL $853, CX - JMP callbackasm1(SB) - MOVL $854, CX - JMP callbackasm1(SB) - MOVL $855, CX - JMP callbackasm1(SB) - MOVL $856, CX - JMP callbackasm1(SB) - MOVL $857, CX - JMP callbackasm1(SB) - MOVL $858, CX - JMP callbackasm1(SB) - MOVL $859, CX - JMP callbackasm1(SB) - MOVL $860, CX - JMP callbackasm1(SB) - MOVL $861, CX - JMP callbackasm1(SB) - MOVL $862, CX - JMP callbackasm1(SB) - MOVL $863, CX - JMP callbackasm1(SB) - MOVL $864, CX - JMP callbackasm1(SB) - MOVL $865, CX - JMP callbackasm1(SB) - MOVL $866, CX - JMP callbackasm1(SB) - MOVL $867, CX - JMP callbackasm1(SB) - MOVL $868, CX - JMP callbackasm1(SB) - MOVL $869, CX - JMP callbackasm1(SB) - MOVL $870, CX - JMP callbackasm1(SB) - MOVL $871, CX - JMP callbackasm1(SB) - MOVL $872, CX - JMP callbackasm1(SB) - MOVL $873, CX - JMP callbackasm1(SB) - MOVL $874, CX - JMP callbackasm1(SB) - MOVL $875, CX - JMP callbackasm1(SB) - MOVL $876, CX - JMP callbackasm1(SB) - MOVL $877, CX - JMP callbackasm1(SB) - MOVL $878, CX - JMP callbackasm1(SB) - MOVL $879, CX - JMP callbackasm1(SB) - MOVL $880, CX - JMP callbackasm1(SB) - MOVL $881, CX - JMP callbackasm1(SB) - MOVL $882, CX - JMP callbackasm1(SB) - MOVL $883, CX - JMP callbackasm1(SB) - MOVL $884, CX - JMP callbackasm1(SB) - MOVL $885, CX - JMP callbackasm1(SB) - MOVL $886, CX - JMP callbackasm1(SB) - MOVL $887, CX - JMP callbackasm1(SB) - MOVL $888, CX - JMP callbackasm1(SB) - MOVL $889, CX - JMP callbackasm1(SB) - MOVL $890, CX - JMP callbackasm1(SB) - MOVL $891, CX - JMP callbackasm1(SB) - MOVL $892, CX - JMP callbackasm1(SB) - MOVL $893, CX - JMP callbackasm1(SB) - MOVL $894, CX - JMP callbackasm1(SB) - MOVL $895, CX - JMP callbackasm1(SB) - MOVL $896, CX - JMP callbackasm1(SB) - MOVL $897, CX - JMP callbackasm1(SB) - MOVL $898, CX - JMP callbackasm1(SB) - MOVL $899, CX - JMP callbackasm1(SB) - MOVL $900, CX - JMP callbackasm1(SB) - MOVL $901, CX - JMP callbackasm1(SB) - MOVL $902, CX - JMP callbackasm1(SB) - MOVL $903, CX - JMP callbackasm1(SB) - MOVL $904, CX - JMP callbackasm1(SB) - MOVL $905, CX - JMP callbackasm1(SB) - MOVL $906, CX - JMP callbackasm1(SB) - MOVL $907, CX - JMP callbackasm1(SB) - MOVL $908, CX - JMP callbackasm1(SB) - MOVL $909, CX - JMP callbackasm1(SB) - MOVL $910, CX - JMP callbackasm1(SB) - MOVL $911, CX - JMP callbackasm1(SB) - MOVL $912, CX - JMP callbackasm1(SB) - MOVL $913, CX - JMP callbackasm1(SB) - MOVL $914, CX - JMP callbackasm1(SB) - MOVL $915, CX - JMP callbackasm1(SB) - MOVL $916, CX - JMP callbackasm1(SB) - MOVL $917, CX - JMP callbackasm1(SB) - MOVL $918, CX - JMP callbackasm1(SB) - MOVL $919, CX - JMP callbackasm1(SB) - MOVL $920, CX - JMP callbackasm1(SB) - MOVL $921, CX - JMP callbackasm1(SB) - MOVL $922, CX - JMP callbackasm1(SB) - MOVL $923, CX - JMP callbackasm1(SB) - MOVL $924, CX - JMP callbackasm1(SB) - MOVL $925, CX - JMP callbackasm1(SB) - MOVL $926, CX - JMP callbackasm1(SB) - MOVL $927, CX - JMP callbackasm1(SB) - MOVL $928, CX - JMP callbackasm1(SB) - MOVL $929, CX - JMP callbackasm1(SB) - MOVL $930, CX - JMP callbackasm1(SB) - MOVL $931, CX - JMP callbackasm1(SB) - MOVL $932, CX - JMP callbackasm1(SB) - MOVL $933, CX - JMP callbackasm1(SB) - MOVL $934, CX - JMP callbackasm1(SB) - MOVL $935, CX - JMP callbackasm1(SB) - MOVL $936, CX - JMP callbackasm1(SB) - MOVL $937, CX - JMP callbackasm1(SB) - MOVL $938, CX - JMP callbackasm1(SB) - MOVL $939, CX - JMP callbackasm1(SB) - MOVL $940, CX - JMP callbackasm1(SB) - MOVL $941, CX - JMP callbackasm1(SB) - MOVL $942, CX - JMP callbackasm1(SB) - MOVL $943, CX - JMP callbackasm1(SB) - MOVL $944, CX - JMP callbackasm1(SB) - MOVL $945, CX - JMP callbackasm1(SB) - MOVL $946, CX - JMP callbackasm1(SB) - MOVL $947, CX - JMP callbackasm1(SB) - MOVL $948, CX - JMP callbackasm1(SB) - MOVL $949, CX - JMP callbackasm1(SB) - MOVL $950, CX - JMP callbackasm1(SB) - MOVL $951, CX - JMP callbackasm1(SB) - MOVL $952, CX - JMP callbackasm1(SB) - MOVL $953, CX - JMP callbackasm1(SB) - MOVL $954, CX - JMP callbackasm1(SB) - MOVL $955, CX - JMP callbackasm1(SB) - MOVL $956, CX - JMP callbackasm1(SB) - MOVL $957, CX - JMP callbackasm1(SB) - MOVL $958, CX - JMP callbackasm1(SB) - MOVL $959, CX - JMP callbackasm1(SB) - MOVL $960, CX - JMP callbackasm1(SB) - MOVL $961, CX - JMP callbackasm1(SB) - MOVL $962, CX - JMP callbackasm1(SB) - MOVL $963, CX - JMP callbackasm1(SB) - MOVL $964, CX - JMP callbackasm1(SB) - MOVL $965, CX - JMP callbackasm1(SB) - MOVL $966, CX - JMP callbackasm1(SB) - MOVL $967, CX - JMP callbackasm1(SB) - MOVL $968, CX - JMP callbackasm1(SB) - MOVL $969, CX - JMP callbackasm1(SB) - MOVL $970, CX - JMP callbackasm1(SB) - MOVL $971, CX - JMP callbackasm1(SB) - MOVL $972, CX - JMP callbackasm1(SB) - MOVL $973, CX - JMP callbackasm1(SB) - MOVL $974, CX - JMP callbackasm1(SB) - MOVL $975, CX - JMP callbackasm1(SB) - MOVL $976, CX - JMP callbackasm1(SB) - MOVL $977, CX - JMP callbackasm1(SB) - MOVL $978, CX - JMP callbackasm1(SB) - MOVL $979, CX - JMP callbackasm1(SB) - MOVL $980, CX - JMP callbackasm1(SB) - MOVL $981, CX - JMP callbackasm1(SB) - MOVL $982, CX - JMP callbackasm1(SB) - MOVL $983, CX - JMP callbackasm1(SB) - MOVL $984, CX - JMP callbackasm1(SB) - MOVL $985, CX - JMP callbackasm1(SB) - MOVL $986, CX - JMP callbackasm1(SB) - MOVL $987, CX - JMP callbackasm1(SB) - MOVL $988, CX - JMP callbackasm1(SB) - MOVL $989, CX - JMP callbackasm1(SB) - MOVL $990, CX - JMP callbackasm1(SB) - MOVL $991, CX - JMP callbackasm1(SB) - MOVL $992, CX - JMP callbackasm1(SB) - MOVL $993, CX - JMP callbackasm1(SB) - MOVL $994, CX - JMP callbackasm1(SB) - MOVL $995, CX - JMP callbackasm1(SB) - MOVL $996, CX - JMP callbackasm1(SB) - MOVL $997, CX - JMP callbackasm1(SB) - MOVL $998, CX - JMP callbackasm1(SB) - MOVL $999, CX - JMP callbackasm1(SB) - MOVL $1000, CX - JMP callbackasm1(SB) - MOVL $1001, CX - JMP callbackasm1(SB) - MOVL $1002, CX - JMP callbackasm1(SB) - MOVL $1003, CX - JMP callbackasm1(SB) - MOVL $1004, CX - JMP callbackasm1(SB) - MOVL $1005, CX - JMP callbackasm1(SB) - MOVL $1006, CX - JMP callbackasm1(SB) - MOVL $1007, CX - JMP callbackasm1(SB) - MOVL $1008, CX - JMP callbackasm1(SB) - MOVL $1009, CX - JMP callbackasm1(SB) - MOVL $1010, CX - JMP callbackasm1(SB) - MOVL $1011, CX - JMP callbackasm1(SB) - MOVL $1012, CX - JMP callbackasm1(SB) - MOVL $1013, CX - JMP callbackasm1(SB) - MOVL $1014, CX - JMP callbackasm1(SB) - MOVL $1015, CX - JMP callbackasm1(SB) - MOVL $1016, CX - JMP callbackasm1(SB) - MOVL $1017, CX - JMP callbackasm1(SB) - MOVL $1018, CX - JMP callbackasm1(SB) - MOVL $1019, CX - JMP callbackasm1(SB) - MOVL $1020, CX - JMP callbackasm1(SB) - MOVL $1021, CX - JMP callbackasm1(SB) - MOVL $1022, CX - JMP callbackasm1(SB) - MOVL $1023, CX - JMP callbackasm1(SB) - MOVL $1024, CX - JMP callbackasm1(SB) - MOVL $1025, CX - JMP callbackasm1(SB) - MOVL $1026, CX - JMP callbackasm1(SB) - MOVL $1027, CX - JMP callbackasm1(SB) - MOVL $1028, CX - JMP callbackasm1(SB) - MOVL $1029, CX - JMP callbackasm1(SB) - MOVL $1030, CX - JMP callbackasm1(SB) - MOVL $1031, CX - JMP callbackasm1(SB) - MOVL $1032, CX - JMP callbackasm1(SB) - MOVL $1033, CX - JMP callbackasm1(SB) - MOVL $1034, CX - JMP callbackasm1(SB) - MOVL $1035, CX - JMP callbackasm1(SB) - MOVL $1036, CX - JMP callbackasm1(SB) - MOVL $1037, CX - JMP callbackasm1(SB) - MOVL $1038, CX - JMP callbackasm1(SB) - MOVL $1039, CX - JMP callbackasm1(SB) - MOVL $1040, CX - JMP callbackasm1(SB) - MOVL $1041, CX - JMP callbackasm1(SB) - MOVL $1042, CX - JMP callbackasm1(SB) - MOVL $1043, CX - JMP callbackasm1(SB) - MOVL $1044, CX - JMP callbackasm1(SB) - MOVL $1045, CX - JMP callbackasm1(SB) - MOVL $1046, CX - JMP callbackasm1(SB) - MOVL $1047, CX - JMP callbackasm1(SB) - MOVL $1048, CX - JMP callbackasm1(SB) - MOVL $1049, CX - JMP callbackasm1(SB) - MOVL $1050, CX - JMP callbackasm1(SB) - MOVL $1051, CX - JMP callbackasm1(SB) - MOVL $1052, CX - JMP callbackasm1(SB) - MOVL $1053, CX - JMP callbackasm1(SB) - MOVL $1054, CX - JMP callbackasm1(SB) - MOVL $1055, CX - JMP callbackasm1(SB) - MOVL $1056, CX - JMP callbackasm1(SB) - MOVL $1057, CX - JMP callbackasm1(SB) - MOVL $1058, CX - JMP callbackasm1(SB) - MOVL $1059, CX - JMP callbackasm1(SB) - MOVL $1060, CX - JMP callbackasm1(SB) - MOVL $1061, CX - JMP callbackasm1(SB) - MOVL $1062, CX - JMP callbackasm1(SB) - MOVL $1063, CX - JMP callbackasm1(SB) - MOVL $1064, CX - JMP callbackasm1(SB) - MOVL $1065, CX - JMP callbackasm1(SB) - MOVL $1066, CX - JMP callbackasm1(SB) - MOVL $1067, CX - JMP callbackasm1(SB) - MOVL $1068, CX - JMP callbackasm1(SB) - MOVL $1069, CX - JMP callbackasm1(SB) - MOVL $1070, CX - JMP callbackasm1(SB) - MOVL $1071, CX - JMP callbackasm1(SB) - MOVL $1072, CX - JMP callbackasm1(SB) - MOVL $1073, CX - JMP callbackasm1(SB) - MOVL $1074, CX - JMP callbackasm1(SB) - MOVL $1075, CX - JMP callbackasm1(SB) - MOVL $1076, CX - JMP callbackasm1(SB) - MOVL $1077, CX - JMP callbackasm1(SB) - MOVL $1078, CX - JMP callbackasm1(SB) - MOVL $1079, CX - JMP callbackasm1(SB) - MOVL $1080, CX - JMP callbackasm1(SB) - MOVL $1081, CX - JMP callbackasm1(SB) - MOVL $1082, CX - JMP callbackasm1(SB) - MOVL $1083, CX - JMP callbackasm1(SB) - MOVL $1084, CX - JMP callbackasm1(SB) - MOVL $1085, CX - JMP callbackasm1(SB) - MOVL $1086, CX - JMP callbackasm1(SB) - MOVL $1087, CX - JMP callbackasm1(SB) - MOVL $1088, CX - JMP callbackasm1(SB) - MOVL $1089, CX - JMP callbackasm1(SB) - MOVL $1090, CX - JMP callbackasm1(SB) - MOVL $1091, CX - JMP callbackasm1(SB) - MOVL $1092, CX - JMP callbackasm1(SB) - MOVL $1093, CX - JMP callbackasm1(SB) - MOVL $1094, CX - JMP callbackasm1(SB) - MOVL $1095, CX - JMP callbackasm1(SB) - MOVL $1096, CX - JMP callbackasm1(SB) - MOVL $1097, CX - JMP callbackasm1(SB) - MOVL $1098, CX - JMP callbackasm1(SB) - MOVL $1099, CX - JMP callbackasm1(SB) - MOVL $1100, CX - JMP callbackasm1(SB) - MOVL $1101, CX - JMP callbackasm1(SB) - MOVL $1102, CX - JMP callbackasm1(SB) - MOVL $1103, CX - JMP callbackasm1(SB) - MOVL $1104, CX - JMP callbackasm1(SB) - MOVL $1105, CX - JMP callbackasm1(SB) - MOVL $1106, CX - JMP callbackasm1(SB) - MOVL $1107, CX - JMP callbackasm1(SB) - MOVL $1108, CX - JMP callbackasm1(SB) - MOVL $1109, CX - JMP callbackasm1(SB) - MOVL $1110, CX - JMP callbackasm1(SB) - MOVL $1111, CX - JMP callbackasm1(SB) - MOVL $1112, CX - JMP callbackasm1(SB) - MOVL $1113, CX - JMP callbackasm1(SB) - MOVL $1114, CX - JMP callbackasm1(SB) - MOVL $1115, CX - JMP callbackasm1(SB) - MOVL $1116, CX - JMP callbackasm1(SB) - MOVL $1117, CX - JMP callbackasm1(SB) - MOVL $1118, CX - JMP callbackasm1(SB) - MOVL $1119, CX - JMP callbackasm1(SB) - MOVL $1120, CX - JMP callbackasm1(SB) - MOVL $1121, CX - JMP callbackasm1(SB) - MOVL $1122, CX - JMP callbackasm1(SB) - MOVL $1123, CX - JMP callbackasm1(SB) - MOVL $1124, CX - JMP callbackasm1(SB) - MOVL $1125, CX - JMP callbackasm1(SB) - MOVL $1126, CX - JMP callbackasm1(SB) - MOVL $1127, CX - JMP callbackasm1(SB) - MOVL $1128, CX - JMP callbackasm1(SB) - MOVL $1129, CX - JMP callbackasm1(SB) - MOVL $1130, CX - JMP callbackasm1(SB) - MOVL $1131, CX - JMP callbackasm1(SB) - MOVL $1132, CX - JMP callbackasm1(SB) - MOVL $1133, CX - JMP callbackasm1(SB) - MOVL $1134, CX - JMP callbackasm1(SB) - MOVL $1135, CX - JMP callbackasm1(SB) - MOVL $1136, CX - JMP callbackasm1(SB) - MOVL $1137, CX - JMP callbackasm1(SB) - MOVL $1138, CX - JMP callbackasm1(SB) - MOVL $1139, CX - JMP callbackasm1(SB) - MOVL $1140, CX - JMP callbackasm1(SB) - MOVL $1141, CX - JMP callbackasm1(SB) - MOVL $1142, CX - JMP callbackasm1(SB) - MOVL $1143, CX - JMP callbackasm1(SB) - MOVL $1144, CX - JMP callbackasm1(SB) - MOVL $1145, CX - JMP callbackasm1(SB) - MOVL $1146, CX - JMP callbackasm1(SB) - MOVL $1147, CX - JMP callbackasm1(SB) - MOVL $1148, CX - JMP callbackasm1(SB) - MOVL $1149, CX - JMP callbackasm1(SB) - MOVL $1150, CX - JMP callbackasm1(SB) - MOVL $1151, CX - JMP callbackasm1(SB) - MOVL $1152, CX - JMP callbackasm1(SB) - MOVL $1153, CX - JMP callbackasm1(SB) - MOVL $1154, CX - JMP callbackasm1(SB) - MOVL $1155, CX - JMP callbackasm1(SB) - MOVL $1156, CX - JMP callbackasm1(SB) - MOVL $1157, CX - JMP callbackasm1(SB) - MOVL $1158, CX - JMP callbackasm1(SB) - MOVL $1159, CX - JMP callbackasm1(SB) - MOVL $1160, CX - JMP callbackasm1(SB) - MOVL $1161, CX - JMP callbackasm1(SB) - MOVL $1162, CX - JMP callbackasm1(SB) - MOVL $1163, CX - JMP callbackasm1(SB) - MOVL $1164, CX - JMP callbackasm1(SB) - MOVL $1165, CX - JMP callbackasm1(SB) - MOVL $1166, CX - JMP callbackasm1(SB) - MOVL $1167, CX - JMP callbackasm1(SB) - MOVL $1168, CX - JMP callbackasm1(SB) - MOVL $1169, CX - JMP callbackasm1(SB) - MOVL $1170, CX - JMP callbackasm1(SB) - MOVL $1171, CX - JMP callbackasm1(SB) - MOVL $1172, CX - JMP callbackasm1(SB) - MOVL $1173, CX - JMP callbackasm1(SB) - MOVL $1174, CX - JMP callbackasm1(SB) - MOVL $1175, CX - JMP callbackasm1(SB) - MOVL $1176, CX - JMP callbackasm1(SB) - MOVL $1177, CX - JMP callbackasm1(SB) - MOVL $1178, CX - JMP callbackasm1(SB) - MOVL $1179, CX - JMP callbackasm1(SB) - MOVL $1180, CX - JMP callbackasm1(SB) - MOVL $1181, CX - JMP callbackasm1(SB) - MOVL $1182, CX - JMP callbackasm1(SB) - MOVL $1183, CX - JMP callbackasm1(SB) - MOVL $1184, CX - JMP callbackasm1(SB) - MOVL $1185, CX - JMP callbackasm1(SB) - MOVL $1186, CX - JMP callbackasm1(SB) - MOVL $1187, CX - JMP callbackasm1(SB) - MOVL $1188, CX - JMP callbackasm1(SB) - MOVL $1189, CX - JMP callbackasm1(SB) - MOVL $1190, CX - JMP callbackasm1(SB) - MOVL $1191, CX - JMP callbackasm1(SB) - MOVL $1192, CX - JMP callbackasm1(SB) - MOVL $1193, CX - JMP callbackasm1(SB) - MOVL $1194, CX - JMP callbackasm1(SB) - MOVL $1195, CX - JMP callbackasm1(SB) - MOVL $1196, CX - JMP callbackasm1(SB) - MOVL $1197, CX - JMP callbackasm1(SB) - MOVL $1198, CX - JMP callbackasm1(SB) - MOVL $1199, CX - JMP callbackasm1(SB) - MOVL $1200, CX - JMP callbackasm1(SB) - MOVL $1201, CX - JMP callbackasm1(SB) - MOVL $1202, CX - JMP callbackasm1(SB) - MOVL $1203, CX - JMP callbackasm1(SB) - MOVL $1204, CX - JMP callbackasm1(SB) - MOVL $1205, CX - JMP callbackasm1(SB) - MOVL $1206, CX - JMP callbackasm1(SB) - MOVL $1207, CX - JMP callbackasm1(SB) - MOVL $1208, CX - JMP callbackasm1(SB) - MOVL $1209, CX - JMP callbackasm1(SB) - MOVL $1210, CX - JMP callbackasm1(SB) - MOVL $1211, CX - JMP callbackasm1(SB) - MOVL $1212, CX - JMP callbackasm1(SB) - MOVL $1213, CX - JMP callbackasm1(SB) - MOVL $1214, CX - JMP callbackasm1(SB) - MOVL $1215, CX - JMP callbackasm1(SB) - MOVL $1216, CX - JMP callbackasm1(SB) - MOVL $1217, CX - JMP callbackasm1(SB) - MOVL $1218, CX - JMP callbackasm1(SB) - MOVL $1219, CX - JMP callbackasm1(SB) - MOVL $1220, CX - JMP callbackasm1(SB) - MOVL $1221, CX - JMP callbackasm1(SB) - MOVL $1222, CX - JMP callbackasm1(SB) - MOVL $1223, CX - JMP callbackasm1(SB) - MOVL $1224, CX - JMP callbackasm1(SB) - MOVL $1225, CX - JMP callbackasm1(SB) - MOVL $1226, CX - JMP callbackasm1(SB) - MOVL $1227, CX - JMP callbackasm1(SB) - MOVL $1228, CX - JMP callbackasm1(SB) - MOVL $1229, CX - JMP callbackasm1(SB) - MOVL $1230, CX - JMP callbackasm1(SB) - MOVL $1231, CX - JMP callbackasm1(SB) - MOVL $1232, CX - JMP callbackasm1(SB) - MOVL $1233, CX - JMP callbackasm1(SB) - MOVL $1234, CX - JMP callbackasm1(SB) - MOVL $1235, CX - JMP callbackasm1(SB) - MOVL $1236, CX - JMP callbackasm1(SB) - MOVL $1237, CX - JMP callbackasm1(SB) - MOVL $1238, CX - JMP callbackasm1(SB) - MOVL $1239, CX - JMP callbackasm1(SB) - MOVL $1240, CX - JMP callbackasm1(SB) - MOVL $1241, CX - JMP callbackasm1(SB) - MOVL $1242, CX - JMP callbackasm1(SB) - MOVL $1243, CX - JMP callbackasm1(SB) - MOVL $1244, CX - JMP callbackasm1(SB) - MOVL $1245, CX - JMP callbackasm1(SB) - MOVL $1246, CX - JMP callbackasm1(SB) - MOVL $1247, CX - JMP callbackasm1(SB) - MOVL $1248, CX - JMP callbackasm1(SB) - MOVL $1249, CX - JMP callbackasm1(SB) - MOVL $1250, CX - JMP callbackasm1(SB) - MOVL $1251, CX - JMP callbackasm1(SB) - MOVL $1252, CX - JMP callbackasm1(SB) - MOVL $1253, CX - JMP callbackasm1(SB) - MOVL $1254, CX - JMP callbackasm1(SB) - MOVL $1255, CX - JMP callbackasm1(SB) - MOVL $1256, CX - JMP callbackasm1(SB) - MOVL $1257, CX - JMP callbackasm1(SB) - MOVL $1258, CX - JMP callbackasm1(SB) - MOVL $1259, CX - JMP callbackasm1(SB) - MOVL $1260, CX - JMP callbackasm1(SB) - MOVL $1261, CX - JMP callbackasm1(SB) - MOVL $1262, CX - JMP callbackasm1(SB) - MOVL $1263, CX - JMP callbackasm1(SB) - MOVL $1264, CX - JMP callbackasm1(SB) - MOVL $1265, CX - JMP callbackasm1(SB) - MOVL $1266, CX - JMP callbackasm1(SB) - MOVL $1267, CX - JMP callbackasm1(SB) - MOVL $1268, CX - JMP callbackasm1(SB) - MOVL $1269, CX - JMP callbackasm1(SB) - MOVL $1270, CX - JMP callbackasm1(SB) - MOVL $1271, CX - JMP callbackasm1(SB) - MOVL $1272, CX - JMP callbackasm1(SB) - MOVL $1273, CX - JMP callbackasm1(SB) - MOVL $1274, CX - JMP callbackasm1(SB) - MOVL $1275, CX - JMP callbackasm1(SB) - MOVL $1276, CX - JMP callbackasm1(SB) - MOVL $1277, CX - JMP callbackasm1(SB) - MOVL $1278, CX - JMP callbackasm1(SB) - MOVL $1279, CX - JMP callbackasm1(SB) - MOVL $1280, CX - JMP callbackasm1(SB) - MOVL $1281, CX - JMP callbackasm1(SB) - MOVL $1282, CX - JMP callbackasm1(SB) - MOVL $1283, CX - JMP callbackasm1(SB) - MOVL $1284, CX - JMP callbackasm1(SB) - MOVL $1285, CX - JMP callbackasm1(SB) - MOVL $1286, CX - JMP callbackasm1(SB) - MOVL $1287, CX - JMP callbackasm1(SB) - MOVL $1288, CX - JMP callbackasm1(SB) - MOVL $1289, CX - JMP callbackasm1(SB) - MOVL $1290, CX - JMP callbackasm1(SB) - MOVL $1291, CX - JMP callbackasm1(SB) - MOVL $1292, CX - JMP callbackasm1(SB) - MOVL $1293, CX - JMP callbackasm1(SB) - MOVL $1294, CX - JMP callbackasm1(SB) - MOVL $1295, CX - JMP callbackasm1(SB) - MOVL $1296, CX - JMP callbackasm1(SB) - MOVL $1297, CX - JMP callbackasm1(SB) - MOVL $1298, CX - JMP callbackasm1(SB) - MOVL $1299, CX - JMP callbackasm1(SB) - MOVL $1300, CX - JMP callbackasm1(SB) - MOVL $1301, CX - JMP callbackasm1(SB) - MOVL $1302, CX - JMP callbackasm1(SB) - MOVL $1303, CX - JMP callbackasm1(SB) - MOVL $1304, CX - JMP callbackasm1(SB) - MOVL $1305, CX - JMP callbackasm1(SB) - MOVL $1306, CX - JMP callbackasm1(SB) - MOVL $1307, CX - JMP callbackasm1(SB) - MOVL $1308, CX - JMP callbackasm1(SB) - MOVL $1309, CX - JMP callbackasm1(SB) - MOVL $1310, CX - JMP callbackasm1(SB) - MOVL $1311, CX - JMP callbackasm1(SB) - MOVL $1312, CX - JMP callbackasm1(SB) - MOVL $1313, CX - JMP callbackasm1(SB) - MOVL $1314, CX - JMP callbackasm1(SB) - MOVL $1315, CX - JMP callbackasm1(SB) - MOVL $1316, CX - JMP callbackasm1(SB) - MOVL $1317, CX - JMP callbackasm1(SB) - MOVL $1318, CX - JMP callbackasm1(SB) - MOVL $1319, CX - JMP callbackasm1(SB) - MOVL $1320, CX - JMP callbackasm1(SB) - MOVL $1321, CX - JMP callbackasm1(SB) - MOVL $1322, CX - JMP callbackasm1(SB) - MOVL $1323, CX - JMP callbackasm1(SB) - MOVL $1324, CX - JMP callbackasm1(SB) - MOVL $1325, CX - JMP callbackasm1(SB) - MOVL $1326, CX - JMP callbackasm1(SB) - MOVL $1327, CX - JMP callbackasm1(SB) - MOVL $1328, CX - JMP callbackasm1(SB) - MOVL $1329, CX - JMP callbackasm1(SB) - MOVL $1330, CX - JMP callbackasm1(SB) - MOVL $1331, CX - JMP callbackasm1(SB) - MOVL $1332, CX - JMP callbackasm1(SB) - MOVL $1333, CX - JMP callbackasm1(SB) - MOVL $1334, CX - JMP callbackasm1(SB) - MOVL $1335, CX - JMP callbackasm1(SB) - MOVL $1336, CX - JMP callbackasm1(SB) - MOVL $1337, CX - JMP callbackasm1(SB) - MOVL $1338, CX - JMP callbackasm1(SB) - MOVL $1339, CX - JMP callbackasm1(SB) - MOVL $1340, CX - JMP callbackasm1(SB) - MOVL $1341, CX - JMP callbackasm1(SB) - MOVL $1342, CX - JMP callbackasm1(SB) - MOVL $1343, CX - JMP callbackasm1(SB) - MOVL $1344, CX - JMP callbackasm1(SB) - MOVL $1345, CX - JMP callbackasm1(SB) - MOVL $1346, CX - JMP callbackasm1(SB) - MOVL $1347, CX - JMP callbackasm1(SB) - MOVL $1348, CX - JMP callbackasm1(SB) - MOVL $1349, CX - JMP callbackasm1(SB) - MOVL $1350, CX - JMP callbackasm1(SB) - MOVL $1351, CX - JMP callbackasm1(SB) - MOVL $1352, CX - JMP callbackasm1(SB) - MOVL $1353, CX - JMP callbackasm1(SB) - MOVL $1354, CX - JMP callbackasm1(SB) - MOVL $1355, CX - JMP callbackasm1(SB) - MOVL $1356, CX - JMP callbackasm1(SB) - MOVL $1357, CX - JMP callbackasm1(SB) - MOVL $1358, CX - JMP callbackasm1(SB) - MOVL $1359, CX - JMP callbackasm1(SB) - MOVL $1360, CX - JMP callbackasm1(SB) - MOVL $1361, CX - JMP callbackasm1(SB) - MOVL $1362, CX - JMP callbackasm1(SB) - MOVL $1363, CX - JMP callbackasm1(SB) - MOVL $1364, CX - JMP callbackasm1(SB) - MOVL $1365, CX - JMP callbackasm1(SB) - MOVL $1366, CX - JMP callbackasm1(SB) - MOVL $1367, CX - JMP callbackasm1(SB) - MOVL $1368, CX - JMP callbackasm1(SB) - MOVL $1369, CX - JMP callbackasm1(SB) - MOVL $1370, CX - JMP callbackasm1(SB) - MOVL $1371, CX - JMP callbackasm1(SB) - MOVL $1372, CX - JMP callbackasm1(SB) - MOVL $1373, CX - JMP callbackasm1(SB) - MOVL $1374, CX - JMP callbackasm1(SB) - MOVL $1375, CX - JMP callbackasm1(SB) - MOVL $1376, CX - JMP callbackasm1(SB) - MOVL $1377, CX - JMP callbackasm1(SB) - MOVL $1378, CX - JMP callbackasm1(SB) - MOVL $1379, CX - JMP callbackasm1(SB) - MOVL $1380, CX - JMP callbackasm1(SB) - MOVL $1381, CX - JMP callbackasm1(SB) - MOVL $1382, CX - JMP callbackasm1(SB) - MOVL $1383, CX - JMP callbackasm1(SB) - MOVL $1384, CX - JMP callbackasm1(SB) - MOVL $1385, CX - JMP callbackasm1(SB) - MOVL $1386, CX - JMP callbackasm1(SB) - MOVL $1387, CX - JMP callbackasm1(SB) - MOVL $1388, CX - JMP callbackasm1(SB) - MOVL $1389, CX - JMP callbackasm1(SB) - MOVL $1390, CX - JMP callbackasm1(SB) - MOVL $1391, CX - JMP callbackasm1(SB) - MOVL $1392, CX - JMP callbackasm1(SB) - MOVL $1393, CX - JMP callbackasm1(SB) - MOVL $1394, CX - JMP callbackasm1(SB) - MOVL $1395, CX - JMP callbackasm1(SB) - MOVL $1396, CX - JMP callbackasm1(SB) - MOVL $1397, CX - JMP callbackasm1(SB) - MOVL $1398, CX - JMP callbackasm1(SB) - MOVL $1399, CX - JMP callbackasm1(SB) - MOVL $1400, CX - JMP callbackasm1(SB) - MOVL $1401, CX - JMP callbackasm1(SB) - MOVL $1402, CX - JMP callbackasm1(SB) - MOVL $1403, CX - JMP callbackasm1(SB) - MOVL $1404, CX - JMP callbackasm1(SB) - MOVL $1405, CX - JMP callbackasm1(SB) - MOVL $1406, CX - JMP callbackasm1(SB) - MOVL $1407, CX - JMP callbackasm1(SB) - MOVL $1408, CX - JMP callbackasm1(SB) - MOVL $1409, CX - JMP callbackasm1(SB) - MOVL $1410, CX - JMP callbackasm1(SB) - MOVL $1411, CX - JMP callbackasm1(SB) - MOVL $1412, CX - JMP callbackasm1(SB) - MOVL $1413, CX - JMP callbackasm1(SB) - MOVL $1414, CX - JMP callbackasm1(SB) - MOVL $1415, CX - JMP callbackasm1(SB) - MOVL $1416, CX - JMP callbackasm1(SB) - MOVL $1417, CX - JMP callbackasm1(SB) - MOVL $1418, CX - JMP callbackasm1(SB) - MOVL $1419, CX - JMP callbackasm1(SB) - MOVL $1420, CX - JMP callbackasm1(SB) - MOVL $1421, CX - JMP callbackasm1(SB) - MOVL $1422, CX - JMP callbackasm1(SB) - MOVL $1423, CX - JMP callbackasm1(SB) - MOVL $1424, CX - JMP callbackasm1(SB) - MOVL $1425, CX - JMP callbackasm1(SB) - MOVL $1426, CX - JMP callbackasm1(SB) - MOVL $1427, CX - JMP callbackasm1(SB) - MOVL $1428, CX - JMP callbackasm1(SB) - MOVL $1429, CX - JMP callbackasm1(SB) - MOVL $1430, CX - JMP callbackasm1(SB) - MOVL $1431, CX - JMP callbackasm1(SB) - MOVL $1432, CX - JMP callbackasm1(SB) - MOVL $1433, CX - JMP callbackasm1(SB) - MOVL $1434, CX - JMP callbackasm1(SB) - MOVL $1435, CX - JMP callbackasm1(SB) - MOVL $1436, CX - JMP callbackasm1(SB) - MOVL $1437, CX - JMP callbackasm1(SB) - MOVL $1438, CX - JMP callbackasm1(SB) - MOVL $1439, CX - JMP callbackasm1(SB) - MOVL $1440, CX - JMP callbackasm1(SB) - MOVL $1441, CX - JMP callbackasm1(SB) - MOVL $1442, CX - JMP callbackasm1(SB) - MOVL $1443, CX - JMP callbackasm1(SB) - MOVL $1444, CX - JMP callbackasm1(SB) - MOVL $1445, CX - JMP callbackasm1(SB) - MOVL $1446, CX - JMP callbackasm1(SB) - MOVL $1447, CX - JMP callbackasm1(SB) - MOVL $1448, CX - JMP callbackasm1(SB) - MOVL $1449, CX - JMP callbackasm1(SB) - MOVL $1450, CX - JMP callbackasm1(SB) - MOVL $1451, CX - JMP callbackasm1(SB) - MOVL $1452, CX - JMP callbackasm1(SB) - MOVL $1453, CX - JMP callbackasm1(SB) - MOVL $1454, CX - JMP callbackasm1(SB) - MOVL $1455, CX - JMP callbackasm1(SB) - MOVL $1456, CX - JMP callbackasm1(SB) - MOVL $1457, CX - JMP callbackasm1(SB) - MOVL $1458, CX - JMP callbackasm1(SB) - MOVL $1459, CX - JMP callbackasm1(SB) - MOVL $1460, CX - JMP callbackasm1(SB) - MOVL $1461, CX - JMP callbackasm1(SB) - MOVL $1462, CX - JMP callbackasm1(SB) - MOVL $1463, CX - JMP callbackasm1(SB) - MOVL $1464, CX - JMP callbackasm1(SB) - MOVL $1465, CX - JMP callbackasm1(SB) - MOVL $1466, CX - JMP callbackasm1(SB) - MOVL $1467, CX - JMP callbackasm1(SB) - MOVL $1468, CX - JMP callbackasm1(SB) - MOVL $1469, CX - JMP callbackasm1(SB) - MOVL $1470, CX - JMP callbackasm1(SB) - MOVL $1471, CX - JMP callbackasm1(SB) - MOVL $1472, CX - JMP callbackasm1(SB) - MOVL $1473, CX - JMP callbackasm1(SB) - MOVL $1474, CX - JMP callbackasm1(SB) - MOVL $1475, CX - JMP callbackasm1(SB) - MOVL $1476, CX - JMP callbackasm1(SB) - MOVL $1477, CX - JMP callbackasm1(SB) - MOVL $1478, CX - JMP callbackasm1(SB) - MOVL $1479, CX - JMP callbackasm1(SB) - MOVL $1480, CX - JMP callbackasm1(SB) - MOVL $1481, CX - JMP callbackasm1(SB) - MOVL $1482, CX - JMP callbackasm1(SB) - MOVL $1483, CX - JMP callbackasm1(SB) - MOVL $1484, CX - JMP callbackasm1(SB) - MOVL $1485, CX - JMP callbackasm1(SB) - MOVL $1486, CX - JMP callbackasm1(SB) - MOVL $1487, CX - JMP callbackasm1(SB) - MOVL $1488, CX - JMP callbackasm1(SB) - MOVL $1489, CX - JMP callbackasm1(SB) - MOVL $1490, CX - JMP callbackasm1(SB) - MOVL $1491, CX - JMP callbackasm1(SB) - MOVL $1492, CX - JMP callbackasm1(SB) - MOVL $1493, CX - JMP callbackasm1(SB) - MOVL $1494, CX - JMP callbackasm1(SB) - MOVL $1495, CX - JMP callbackasm1(SB) - MOVL $1496, CX - JMP callbackasm1(SB) - MOVL $1497, CX - JMP callbackasm1(SB) - MOVL $1498, CX - JMP callbackasm1(SB) - MOVL $1499, CX - JMP callbackasm1(SB) - MOVL $1500, CX - JMP callbackasm1(SB) - MOVL $1501, CX - JMP callbackasm1(SB) - MOVL $1502, CX - JMP callbackasm1(SB) - MOVL $1503, CX - JMP callbackasm1(SB) - MOVL $1504, CX - JMP callbackasm1(SB) - MOVL $1505, CX - JMP callbackasm1(SB) - MOVL $1506, CX - JMP callbackasm1(SB) - MOVL $1507, CX - JMP callbackasm1(SB) - MOVL $1508, CX - JMP callbackasm1(SB) - MOVL $1509, CX - JMP callbackasm1(SB) - MOVL $1510, CX - JMP callbackasm1(SB) - MOVL $1511, CX - JMP callbackasm1(SB) - MOVL $1512, CX - JMP callbackasm1(SB) - MOVL $1513, CX - JMP callbackasm1(SB) - MOVL $1514, CX - JMP callbackasm1(SB) - MOVL $1515, CX - JMP callbackasm1(SB) - MOVL $1516, CX - JMP callbackasm1(SB) - MOVL $1517, CX - JMP callbackasm1(SB) - MOVL $1518, CX - JMP callbackasm1(SB) - MOVL $1519, CX - JMP callbackasm1(SB) - MOVL $1520, CX - JMP callbackasm1(SB) - MOVL $1521, CX - JMP callbackasm1(SB) - MOVL $1522, CX - JMP callbackasm1(SB) - MOVL $1523, CX - JMP callbackasm1(SB) - MOVL $1524, CX - JMP callbackasm1(SB) - MOVL $1525, CX - JMP callbackasm1(SB) - MOVL $1526, CX - JMP callbackasm1(SB) - MOVL $1527, CX - JMP callbackasm1(SB) - MOVL $1528, CX - JMP callbackasm1(SB) - MOVL $1529, CX - JMP callbackasm1(SB) - MOVL $1530, CX - JMP callbackasm1(SB) - MOVL $1531, CX - JMP callbackasm1(SB) - MOVL $1532, CX - JMP callbackasm1(SB) - MOVL $1533, CX - JMP callbackasm1(SB) - MOVL $1534, CX - JMP callbackasm1(SB) - MOVL $1535, CX - JMP callbackasm1(SB) - MOVL $1536, CX - JMP callbackasm1(SB) - MOVL $1537, CX - JMP callbackasm1(SB) - MOVL $1538, CX - JMP callbackasm1(SB) - MOVL $1539, CX - JMP callbackasm1(SB) - MOVL $1540, CX - JMP callbackasm1(SB) - MOVL $1541, CX - JMP callbackasm1(SB) - MOVL $1542, CX - JMP callbackasm1(SB) - MOVL $1543, CX - JMP callbackasm1(SB) - MOVL $1544, CX - JMP callbackasm1(SB) - MOVL $1545, CX - JMP callbackasm1(SB) - MOVL $1546, CX - JMP callbackasm1(SB) - MOVL $1547, CX - JMP callbackasm1(SB) - MOVL $1548, CX - JMP callbackasm1(SB) - MOVL $1549, CX - JMP callbackasm1(SB) - MOVL $1550, CX - JMP callbackasm1(SB) - MOVL $1551, CX - JMP callbackasm1(SB) - MOVL $1552, CX - JMP callbackasm1(SB) - MOVL $1553, CX - JMP callbackasm1(SB) - MOVL $1554, CX - JMP callbackasm1(SB) - MOVL $1555, CX - JMP callbackasm1(SB) - MOVL $1556, CX - JMP callbackasm1(SB) - MOVL $1557, CX - JMP callbackasm1(SB) - MOVL $1558, CX - JMP callbackasm1(SB) - MOVL $1559, CX - JMP callbackasm1(SB) - MOVL $1560, CX - JMP callbackasm1(SB) - MOVL $1561, CX - JMP callbackasm1(SB) - MOVL $1562, CX - JMP callbackasm1(SB) - MOVL $1563, CX - JMP callbackasm1(SB) - MOVL $1564, CX - JMP callbackasm1(SB) - MOVL $1565, CX - JMP callbackasm1(SB) - MOVL $1566, CX - JMP callbackasm1(SB) - MOVL $1567, CX - JMP callbackasm1(SB) - MOVL $1568, CX - JMP callbackasm1(SB) - MOVL $1569, CX - JMP callbackasm1(SB) - MOVL $1570, CX - JMP callbackasm1(SB) - MOVL $1571, CX - JMP callbackasm1(SB) - MOVL $1572, CX - JMP callbackasm1(SB) - MOVL $1573, CX - JMP callbackasm1(SB) - MOVL $1574, CX - JMP callbackasm1(SB) - MOVL $1575, CX - JMP callbackasm1(SB) - MOVL $1576, CX - JMP callbackasm1(SB) - MOVL $1577, CX - JMP callbackasm1(SB) - MOVL $1578, CX - JMP callbackasm1(SB) - MOVL $1579, CX - JMP callbackasm1(SB) - MOVL $1580, CX - JMP callbackasm1(SB) - MOVL $1581, CX - JMP callbackasm1(SB) - MOVL $1582, CX - JMP callbackasm1(SB) - MOVL $1583, CX - JMP callbackasm1(SB) - MOVL $1584, CX - JMP callbackasm1(SB) - MOVL $1585, CX - JMP callbackasm1(SB) - MOVL $1586, CX - JMP callbackasm1(SB) - MOVL $1587, CX - JMP callbackasm1(SB) - MOVL $1588, CX - JMP callbackasm1(SB) - MOVL $1589, CX - JMP callbackasm1(SB) - MOVL $1590, CX - JMP callbackasm1(SB) - MOVL $1591, CX - JMP callbackasm1(SB) - MOVL $1592, CX - JMP callbackasm1(SB) - MOVL $1593, CX - JMP callbackasm1(SB) - MOVL $1594, CX - JMP callbackasm1(SB) - MOVL $1595, CX - JMP callbackasm1(SB) - MOVL $1596, CX - JMP callbackasm1(SB) - MOVL $1597, CX - JMP callbackasm1(SB) - MOVL $1598, CX - JMP callbackasm1(SB) - MOVL $1599, CX - JMP callbackasm1(SB) - MOVL $1600, CX - JMP callbackasm1(SB) - MOVL $1601, CX - JMP callbackasm1(SB) - MOVL $1602, CX - JMP callbackasm1(SB) - MOVL $1603, CX - JMP callbackasm1(SB) - MOVL $1604, CX - JMP callbackasm1(SB) - MOVL $1605, CX - JMP callbackasm1(SB) - MOVL $1606, CX - JMP callbackasm1(SB) - MOVL $1607, CX - JMP callbackasm1(SB) - MOVL $1608, CX - JMP callbackasm1(SB) - MOVL $1609, CX - JMP callbackasm1(SB) - MOVL $1610, CX - JMP callbackasm1(SB) - MOVL $1611, CX - JMP callbackasm1(SB) - MOVL $1612, CX - JMP callbackasm1(SB) - MOVL $1613, CX - JMP callbackasm1(SB) - MOVL $1614, CX - JMP callbackasm1(SB) - MOVL $1615, CX - JMP callbackasm1(SB) - MOVL $1616, CX - JMP callbackasm1(SB) - MOVL $1617, CX - JMP callbackasm1(SB) - MOVL $1618, CX - JMP callbackasm1(SB) - MOVL $1619, CX - JMP callbackasm1(SB) - MOVL $1620, CX - JMP callbackasm1(SB) - MOVL $1621, CX - JMP callbackasm1(SB) - MOVL $1622, CX - JMP callbackasm1(SB) - MOVL $1623, CX - JMP callbackasm1(SB) - MOVL $1624, CX - JMP callbackasm1(SB) - MOVL $1625, CX - JMP callbackasm1(SB) - MOVL $1626, CX - JMP callbackasm1(SB) - MOVL $1627, CX - JMP callbackasm1(SB) - MOVL $1628, CX - JMP callbackasm1(SB) - MOVL $1629, CX - JMP callbackasm1(SB) - MOVL $1630, CX - JMP callbackasm1(SB) - MOVL $1631, CX - JMP callbackasm1(SB) - MOVL $1632, CX - JMP callbackasm1(SB) - MOVL $1633, CX - JMP callbackasm1(SB) - MOVL $1634, CX - JMP callbackasm1(SB) - MOVL $1635, CX - JMP callbackasm1(SB) - MOVL $1636, CX - JMP callbackasm1(SB) - MOVL $1637, CX - JMP callbackasm1(SB) - MOVL $1638, CX - JMP callbackasm1(SB) - MOVL $1639, CX - JMP callbackasm1(SB) - MOVL $1640, CX - JMP callbackasm1(SB) - MOVL $1641, CX - JMP callbackasm1(SB) - MOVL $1642, CX - JMP callbackasm1(SB) - MOVL $1643, CX - JMP callbackasm1(SB) - MOVL $1644, CX - JMP callbackasm1(SB) - MOVL $1645, CX - JMP callbackasm1(SB) - MOVL $1646, CX - JMP callbackasm1(SB) - MOVL $1647, CX - JMP callbackasm1(SB) - MOVL $1648, CX - JMP callbackasm1(SB) - MOVL $1649, CX - JMP callbackasm1(SB) - MOVL $1650, CX - JMP callbackasm1(SB) - MOVL $1651, CX - JMP callbackasm1(SB) - MOVL $1652, CX - JMP callbackasm1(SB) - MOVL $1653, CX - JMP callbackasm1(SB) - MOVL $1654, CX - JMP callbackasm1(SB) - MOVL $1655, CX - JMP callbackasm1(SB) - MOVL $1656, CX - JMP callbackasm1(SB) - MOVL $1657, CX - JMP callbackasm1(SB) - MOVL $1658, CX - JMP callbackasm1(SB) - MOVL $1659, CX - JMP callbackasm1(SB) - MOVL $1660, CX - JMP callbackasm1(SB) - MOVL $1661, CX - JMP callbackasm1(SB) - MOVL $1662, CX - JMP callbackasm1(SB) - MOVL $1663, CX - JMP callbackasm1(SB) - MOVL $1664, CX - JMP callbackasm1(SB) - MOVL $1665, CX - JMP callbackasm1(SB) - MOVL $1666, CX - JMP callbackasm1(SB) - MOVL $1667, CX - JMP callbackasm1(SB) - MOVL $1668, CX - JMP callbackasm1(SB) - MOVL $1669, CX - JMP callbackasm1(SB) - MOVL $1670, CX - JMP callbackasm1(SB) - MOVL $1671, CX - JMP callbackasm1(SB) - MOVL $1672, CX - JMP callbackasm1(SB) - MOVL $1673, CX - JMP callbackasm1(SB) - MOVL $1674, CX - JMP callbackasm1(SB) - MOVL $1675, CX - JMP callbackasm1(SB) - MOVL $1676, CX - JMP callbackasm1(SB) - MOVL $1677, CX - JMP callbackasm1(SB) - MOVL $1678, CX - JMP callbackasm1(SB) - MOVL $1679, CX - JMP callbackasm1(SB) - MOVL $1680, CX - JMP callbackasm1(SB) - MOVL $1681, CX - JMP callbackasm1(SB) - MOVL $1682, CX - JMP callbackasm1(SB) - MOVL $1683, CX - JMP callbackasm1(SB) - MOVL $1684, CX - JMP callbackasm1(SB) - MOVL $1685, CX - JMP callbackasm1(SB) - MOVL $1686, CX - JMP callbackasm1(SB) - MOVL $1687, CX - JMP callbackasm1(SB) - MOVL $1688, CX - JMP callbackasm1(SB) - MOVL $1689, CX - JMP callbackasm1(SB) - MOVL $1690, CX - JMP callbackasm1(SB) - MOVL $1691, CX - JMP callbackasm1(SB) - MOVL $1692, CX - JMP callbackasm1(SB) - MOVL $1693, CX - JMP callbackasm1(SB) - MOVL $1694, CX - JMP callbackasm1(SB) - MOVL $1695, CX - JMP callbackasm1(SB) - MOVL $1696, CX - JMP callbackasm1(SB) - MOVL $1697, CX - JMP callbackasm1(SB) - MOVL $1698, CX - JMP callbackasm1(SB) - MOVL $1699, CX - JMP callbackasm1(SB) - MOVL $1700, CX - JMP callbackasm1(SB) - MOVL $1701, CX - JMP callbackasm1(SB) - MOVL $1702, CX - JMP callbackasm1(SB) - MOVL $1703, CX - JMP callbackasm1(SB) - MOVL $1704, CX - JMP callbackasm1(SB) - MOVL $1705, CX - JMP callbackasm1(SB) - MOVL $1706, CX - JMP callbackasm1(SB) - MOVL $1707, CX - JMP callbackasm1(SB) - MOVL $1708, CX - JMP callbackasm1(SB) - MOVL $1709, CX - JMP callbackasm1(SB) - MOVL $1710, CX - JMP callbackasm1(SB) - MOVL $1711, CX - JMP callbackasm1(SB) - MOVL $1712, CX - JMP callbackasm1(SB) - MOVL $1713, CX - JMP callbackasm1(SB) - MOVL $1714, CX - JMP callbackasm1(SB) - MOVL $1715, CX - JMP callbackasm1(SB) - MOVL $1716, CX - JMP callbackasm1(SB) - MOVL $1717, CX - JMP callbackasm1(SB) - MOVL $1718, CX - JMP callbackasm1(SB) - MOVL $1719, CX - JMP callbackasm1(SB) - MOVL $1720, CX - JMP callbackasm1(SB) - MOVL $1721, CX - JMP callbackasm1(SB) - MOVL $1722, CX - JMP callbackasm1(SB) - MOVL $1723, CX - JMP callbackasm1(SB) - MOVL $1724, CX - JMP callbackasm1(SB) - MOVL $1725, CX - JMP callbackasm1(SB) - MOVL $1726, CX - JMP callbackasm1(SB) - MOVL $1727, CX - JMP callbackasm1(SB) - MOVL $1728, CX - JMP callbackasm1(SB) - MOVL $1729, CX - JMP callbackasm1(SB) - MOVL $1730, CX - JMP callbackasm1(SB) - MOVL $1731, CX - JMP callbackasm1(SB) - MOVL $1732, CX - JMP callbackasm1(SB) - MOVL $1733, CX - JMP callbackasm1(SB) - MOVL $1734, CX - JMP callbackasm1(SB) - MOVL $1735, CX - JMP callbackasm1(SB) - MOVL $1736, CX - JMP callbackasm1(SB) - MOVL $1737, CX - JMP callbackasm1(SB) - MOVL $1738, CX - JMP callbackasm1(SB) - MOVL $1739, CX - JMP callbackasm1(SB) - MOVL $1740, CX - JMP callbackasm1(SB) - MOVL $1741, CX - JMP callbackasm1(SB) - MOVL $1742, CX - JMP callbackasm1(SB) - MOVL $1743, CX - JMP callbackasm1(SB) - MOVL $1744, CX - JMP callbackasm1(SB) - MOVL $1745, CX - JMP callbackasm1(SB) - MOVL $1746, CX - JMP callbackasm1(SB) - MOVL $1747, CX - JMP callbackasm1(SB) - MOVL $1748, CX - JMP callbackasm1(SB) - MOVL $1749, CX - JMP callbackasm1(SB) - MOVL $1750, CX - JMP callbackasm1(SB) - MOVL $1751, CX - JMP callbackasm1(SB) - MOVL $1752, CX - JMP callbackasm1(SB) - MOVL $1753, CX - JMP callbackasm1(SB) - MOVL $1754, CX - JMP callbackasm1(SB) - MOVL $1755, CX - JMP callbackasm1(SB) - MOVL $1756, CX - JMP callbackasm1(SB) - MOVL $1757, CX - JMP callbackasm1(SB) - MOVL $1758, CX - JMP callbackasm1(SB) - MOVL $1759, CX - JMP callbackasm1(SB) - MOVL $1760, CX - JMP callbackasm1(SB) - MOVL $1761, CX - JMP callbackasm1(SB) - MOVL $1762, CX - JMP callbackasm1(SB) - MOVL $1763, CX - JMP callbackasm1(SB) - MOVL $1764, CX - JMP callbackasm1(SB) - MOVL $1765, CX - JMP callbackasm1(SB) - MOVL $1766, CX - JMP callbackasm1(SB) - MOVL $1767, CX - JMP callbackasm1(SB) - MOVL $1768, CX - JMP callbackasm1(SB) - MOVL $1769, CX - JMP callbackasm1(SB) - MOVL $1770, CX - JMP callbackasm1(SB) - MOVL $1771, CX - JMP callbackasm1(SB) - MOVL $1772, CX - JMP callbackasm1(SB) - MOVL $1773, CX - JMP callbackasm1(SB) - MOVL $1774, CX - JMP callbackasm1(SB) - MOVL $1775, CX - JMP callbackasm1(SB) - MOVL $1776, CX - JMP callbackasm1(SB) - MOVL $1777, CX - JMP callbackasm1(SB) - MOVL $1778, CX - JMP callbackasm1(SB) - MOVL $1779, CX - JMP callbackasm1(SB) - MOVL $1780, CX - JMP callbackasm1(SB) - MOVL $1781, CX - JMP callbackasm1(SB) - MOVL $1782, CX - JMP callbackasm1(SB) - MOVL $1783, CX - JMP callbackasm1(SB) - MOVL $1784, CX - JMP callbackasm1(SB) - MOVL $1785, CX - JMP callbackasm1(SB) - MOVL $1786, CX - JMP callbackasm1(SB) - MOVL $1787, CX - JMP callbackasm1(SB) - MOVL $1788, CX - JMP callbackasm1(SB) - MOVL $1789, CX - JMP callbackasm1(SB) - MOVL $1790, CX - JMP callbackasm1(SB) - MOVL $1791, CX - JMP callbackasm1(SB) - MOVL $1792, CX - JMP callbackasm1(SB) - MOVL $1793, CX - JMP callbackasm1(SB) - MOVL $1794, CX - JMP callbackasm1(SB) - MOVL $1795, CX - JMP callbackasm1(SB) - MOVL $1796, CX - JMP callbackasm1(SB) - MOVL $1797, CX - JMP callbackasm1(SB) - MOVL $1798, CX - JMP callbackasm1(SB) - MOVL $1799, CX - JMP callbackasm1(SB) - MOVL $1800, CX - JMP callbackasm1(SB) - MOVL $1801, CX - JMP callbackasm1(SB) - MOVL $1802, CX - JMP callbackasm1(SB) - MOVL $1803, CX - JMP callbackasm1(SB) - MOVL $1804, CX - JMP callbackasm1(SB) - MOVL $1805, CX - JMP callbackasm1(SB) - MOVL $1806, CX - JMP callbackasm1(SB) - MOVL $1807, CX - JMP callbackasm1(SB) - MOVL $1808, CX - JMP callbackasm1(SB) - MOVL $1809, CX - JMP callbackasm1(SB) - MOVL $1810, CX - JMP callbackasm1(SB) - MOVL $1811, CX - JMP callbackasm1(SB) - MOVL $1812, CX - JMP callbackasm1(SB) - MOVL $1813, CX - JMP callbackasm1(SB) - MOVL $1814, CX - JMP callbackasm1(SB) - MOVL $1815, CX - JMP callbackasm1(SB) - MOVL $1816, CX - JMP callbackasm1(SB) - MOVL $1817, CX - JMP callbackasm1(SB) - MOVL $1818, CX - JMP callbackasm1(SB) - MOVL $1819, CX - JMP callbackasm1(SB) - MOVL $1820, CX - JMP callbackasm1(SB) - MOVL $1821, CX - JMP callbackasm1(SB) - MOVL $1822, CX - JMP callbackasm1(SB) - MOVL $1823, CX - JMP callbackasm1(SB) - MOVL $1824, CX - JMP callbackasm1(SB) - MOVL $1825, CX - JMP callbackasm1(SB) - MOVL $1826, CX - JMP callbackasm1(SB) - MOVL $1827, CX - JMP callbackasm1(SB) - MOVL $1828, CX - JMP callbackasm1(SB) - MOVL $1829, CX - JMP callbackasm1(SB) - MOVL $1830, CX - JMP callbackasm1(SB) - MOVL $1831, CX - JMP callbackasm1(SB) - MOVL $1832, CX - JMP callbackasm1(SB) - MOVL $1833, CX - JMP callbackasm1(SB) - MOVL $1834, CX - JMP callbackasm1(SB) - MOVL $1835, CX - JMP callbackasm1(SB) - MOVL $1836, CX - JMP callbackasm1(SB) - MOVL $1837, CX - JMP callbackasm1(SB) - MOVL $1838, CX - JMP callbackasm1(SB) - MOVL $1839, CX - JMP callbackasm1(SB) - MOVL $1840, CX - JMP callbackasm1(SB) - MOVL $1841, CX - JMP callbackasm1(SB) - MOVL $1842, CX - JMP callbackasm1(SB) - MOVL $1843, CX - JMP callbackasm1(SB) - MOVL $1844, CX - JMP callbackasm1(SB) - MOVL $1845, CX - JMP callbackasm1(SB) - MOVL $1846, CX - JMP callbackasm1(SB) - MOVL $1847, CX - JMP callbackasm1(SB) - MOVL $1848, CX - JMP callbackasm1(SB) - MOVL $1849, CX - JMP callbackasm1(SB) - MOVL $1850, CX - JMP callbackasm1(SB) - MOVL $1851, CX - JMP callbackasm1(SB) - MOVL $1852, CX - JMP callbackasm1(SB) - MOVL $1853, CX - JMP callbackasm1(SB) - MOVL $1854, CX - JMP callbackasm1(SB) - MOVL $1855, CX - JMP callbackasm1(SB) - MOVL $1856, CX - JMP callbackasm1(SB) - MOVL $1857, CX - JMP callbackasm1(SB) - MOVL $1858, CX - JMP callbackasm1(SB) - MOVL $1859, CX - JMP callbackasm1(SB) - MOVL $1860, CX - JMP callbackasm1(SB) - MOVL $1861, CX - JMP callbackasm1(SB) - MOVL $1862, CX - JMP callbackasm1(SB) - MOVL $1863, CX - JMP callbackasm1(SB) - MOVL $1864, CX - JMP callbackasm1(SB) - MOVL $1865, CX - JMP callbackasm1(SB) - MOVL $1866, CX - JMP callbackasm1(SB) - MOVL $1867, CX - JMP callbackasm1(SB) - MOVL $1868, CX - JMP callbackasm1(SB) - MOVL $1869, CX - JMP callbackasm1(SB) - MOVL $1870, CX - JMP callbackasm1(SB) - MOVL $1871, CX - JMP callbackasm1(SB) - MOVL $1872, CX - JMP callbackasm1(SB) - MOVL $1873, CX - JMP callbackasm1(SB) - MOVL $1874, CX - JMP callbackasm1(SB) - MOVL $1875, CX - JMP callbackasm1(SB) - MOVL $1876, CX - JMP callbackasm1(SB) - MOVL $1877, CX - JMP callbackasm1(SB) - MOVL $1878, CX - JMP callbackasm1(SB) - MOVL $1879, CX - JMP callbackasm1(SB) - MOVL $1880, CX - JMP callbackasm1(SB) - MOVL $1881, CX - JMP callbackasm1(SB) - MOVL $1882, CX - JMP callbackasm1(SB) - MOVL $1883, CX - JMP callbackasm1(SB) - MOVL $1884, CX - JMP callbackasm1(SB) - MOVL $1885, CX - JMP callbackasm1(SB) - MOVL $1886, CX - JMP callbackasm1(SB) - MOVL $1887, CX - JMP callbackasm1(SB) - MOVL $1888, CX - JMP callbackasm1(SB) - MOVL $1889, CX - JMP callbackasm1(SB) - MOVL $1890, CX - JMP callbackasm1(SB) - MOVL $1891, CX - JMP callbackasm1(SB) - MOVL $1892, CX - JMP callbackasm1(SB) - MOVL $1893, CX - JMP callbackasm1(SB) - MOVL $1894, CX - JMP callbackasm1(SB) - MOVL $1895, CX - JMP callbackasm1(SB) - MOVL $1896, CX - JMP callbackasm1(SB) - MOVL $1897, CX - JMP callbackasm1(SB) - MOVL $1898, CX - JMP callbackasm1(SB) - MOVL $1899, CX - JMP callbackasm1(SB) - MOVL $1900, CX - JMP callbackasm1(SB) - MOVL $1901, CX - JMP callbackasm1(SB) - MOVL $1902, CX - JMP callbackasm1(SB) - MOVL $1903, CX - JMP callbackasm1(SB) - MOVL $1904, CX - JMP callbackasm1(SB) - MOVL $1905, CX - JMP callbackasm1(SB) - MOVL $1906, CX - JMP callbackasm1(SB) - MOVL $1907, CX - JMP callbackasm1(SB) - MOVL $1908, CX - JMP callbackasm1(SB) - MOVL $1909, CX - JMP callbackasm1(SB) - MOVL $1910, CX - JMP callbackasm1(SB) - MOVL $1911, CX - JMP callbackasm1(SB) - MOVL $1912, CX - JMP callbackasm1(SB) - MOVL $1913, CX - JMP callbackasm1(SB) - MOVL $1914, CX - JMP callbackasm1(SB) - MOVL $1915, CX - JMP callbackasm1(SB) - MOVL $1916, CX - JMP callbackasm1(SB) - MOVL $1917, CX - JMP callbackasm1(SB) - MOVL $1918, CX - JMP callbackasm1(SB) - MOVL $1919, CX - JMP callbackasm1(SB) - MOVL $1920, CX - JMP callbackasm1(SB) - MOVL $1921, CX - JMP callbackasm1(SB) - MOVL $1922, CX - JMP callbackasm1(SB) - MOVL $1923, CX - JMP callbackasm1(SB) - MOVL $1924, CX - JMP callbackasm1(SB) - MOVL $1925, CX - JMP callbackasm1(SB) - MOVL $1926, CX - JMP callbackasm1(SB) - MOVL $1927, CX - JMP callbackasm1(SB) - MOVL $1928, CX - JMP callbackasm1(SB) - MOVL $1929, CX - JMP callbackasm1(SB) - MOVL $1930, CX - JMP callbackasm1(SB) - MOVL $1931, CX - JMP callbackasm1(SB) - MOVL $1932, CX - JMP callbackasm1(SB) - MOVL $1933, CX - JMP callbackasm1(SB) - MOVL $1934, CX - JMP callbackasm1(SB) - MOVL $1935, CX - JMP callbackasm1(SB) - MOVL $1936, CX - JMP callbackasm1(SB) - MOVL $1937, CX - JMP callbackasm1(SB) - MOVL $1938, CX - JMP callbackasm1(SB) - MOVL $1939, CX - JMP callbackasm1(SB) - MOVL $1940, CX - JMP callbackasm1(SB) - MOVL $1941, CX - JMP callbackasm1(SB) - MOVL $1942, CX - JMP callbackasm1(SB) - MOVL $1943, CX - JMP callbackasm1(SB) - MOVL $1944, CX - JMP callbackasm1(SB) - MOVL $1945, CX - JMP callbackasm1(SB) - MOVL $1946, CX - JMP callbackasm1(SB) - MOVL $1947, CX - JMP callbackasm1(SB) - MOVL $1948, CX - JMP callbackasm1(SB) - MOVL $1949, CX - JMP callbackasm1(SB) - MOVL $1950, CX - JMP callbackasm1(SB) - MOVL $1951, CX - JMP callbackasm1(SB) - MOVL $1952, CX - JMP callbackasm1(SB) - MOVL $1953, CX - JMP callbackasm1(SB) - MOVL $1954, CX - JMP callbackasm1(SB) - MOVL $1955, CX - JMP callbackasm1(SB) - MOVL $1956, CX - JMP callbackasm1(SB) - MOVL $1957, CX - JMP callbackasm1(SB) - MOVL $1958, CX - JMP callbackasm1(SB) - MOVL $1959, CX - JMP callbackasm1(SB) - MOVL $1960, CX - JMP callbackasm1(SB) - MOVL $1961, CX - JMP callbackasm1(SB) - MOVL $1962, CX - JMP callbackasm1(SB) - MOVL $1963, CX - JMP callbackasm1(SB) - MOVL $1964, CX - JMP callbackasm1(SB) - MOVL $1965, CX - JMP callbackasm1(SB) - MOVL $1966, CX - JMP callbackasm1(SB) - MOVL $1967, CX - JMP callbackasm1(SB) - MOVL $1968, CX - JMP callbackasm1(SB) - MOVL $1969, CX - JMP callbackasm1(SB) - MOVL $1970, CX - JMP callbackasm1(SB) - MOVL $1971, CX - JMP callbackasm1(SB) - MOVL $1972, CX - JMP callbackasm1(SB) - MOVL $1973, CX - JMP callbackasm1(SB) - MOVL $1974, CX - JMP callbackasm1(SB) - MOVL $1975, CX - JMP callbackasm1(SB) - MOVL $1976, CX - JMP callbackasm1(SB) - MOVL $1977, CX - JMP callbackasm1(SB) - MOVL $1978, CX - JMP callbackasm1(SB) - MOVL $1979, CX - JMP callbackasm1(SB) - MOVL $1980, CX - JMP callbackasm1(SB) - MOVL $1981, CX - JMP callbackasm1(SB) - MOVL $1982, CX - JMP callbackasm1(SB) - MOVL $1983, CX - JMP callbackasm1(SB) - MOVL $1984, CX - JMP callbackasm1(SB) - MOVL $1985, CX - JMP callbackasm1(SB) - MOVL $1986, CX - JMP callbackasm1(SB) - MOVL $1987, CX - JMP callbackasm1(SB) - MOVL $1988, CX - JMP callbackasm1(SB) - MOVL $1989, CX - JMP callbackasm1(SB) - MOVL $1990, CX - JMP callbackasm1(SB) - MOVL $1991, CX - JMP callbackasm1(SB) - MOVL $1992, CX - JMP callbackasm1(SB) - MOVL $1993, CX - JMP callbackasm1(SB) - MOVL $1994, CX - JMP callbackasm1(SB) - MOVL $1995, CX - JMP callbackasm1(SB) - MOVL $1996, CX - JMP callbackasm1(SB) - MOVL $1997, CX - JMP callbackasm1(SB) - MOVL $1998, CX - JMP callbackasm1(SB) - MOVL $1999, CX - JMP callbackasm1(SB) diff --git a/vendor/github.com/ebitengine/purego/zcallback_amd64.s b/vendor/github.com/ebitengine/purego/zcallback_amd64.s deleted file mode 100644 index b2da0225566..00000000000 --- a/vendor/github.com/ebitengine/purego/zcallback_amd64.s +++ /dev/null @@ -1,2014 +0,0 @@ -// Code generated by wincallback.go using 'go generate'. DO NOT EDIT. - -//go:build darwin || freebsd || linux || netbsd - -// runtime·callbackasm is called by external code to -// execute Go implemented callback function. It is not -// called from the start, instead runtime·compilecallback -// always returns address into runtime·callbackasm offset -// appropriately so different callbacks start with different -// CALL instruction in runtime·callbackasm. This determines -// which Go callback function is executed later on. -#include "textflag.h" - -TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0 - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) - CALL callbackasm1(SB) diff --git a/vendor/github.com/ebitengine/purego/zcallback_arm.s b/vendor/github.com/ebitengine/purego/zcallback_arm.s deleted file mode 100644 index d969d81d013..00000000000 --- a/vendor/github.com/ebitengine/purego/zcallback_arm.s +++ /dev/null @@ -1,4014 +0,0 @@ -// Code generated by wincallback.go using 'go generate'. DO NOT EDIT. - -//go:build linux - -// External code calls into callbackasm at an offset corresponding -// to the callback index. Callbackasm is a table of MOVW and B instructions. -// The MOVW instruction loads R12 with the callback index, and the -// B instruction branches to callbackasm1. -// callbackasm1 takes the callback index from R12 and -// indexes into an array that stores information about each callback. -// It then calls the Go implementation for that callback. -#include "textflag.h" - -TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0 - MOVW $0, R12 - B callbackasm1(SB) - MOVW $1, R12 - B callbackasm1(SB) - MOVW $2, R12 - B callbackasm1(SB) - MOVW $3, R12 - B callbackasm1(SB) - MOVW $4, R12 - B callbackasm1(SB) - MOVW $5, R12 - B callbackasm1(SB) - MOVW $6, R12 - B callbackasm1(SB) - MOVW $7, R12 - B callbackasm1(SB) - MOVW $8, R12 - B callbackasm1(SB) - MOVW $9, R12 - B callbackasm1(SB) - MOVW $10, R12 - B callbackasm1(SB) - MOVW $11, R12 - B callbackasm1(SB) - MOVW $12, R12 - B callbackasm1(SB) - MOVW $13, R12 - B callbackasm1(SB) - MOVW $14, R12 - B callbackasm1(SB) - MOVW $15, R12 - B callbackasm1(SB) - MOVW $16, R12 - B callbackasm1(SB) - MOVW $17, R12 - B callbackasm1(SB) - MOVW $18, R12 - B callbackasm1(SB) - MOVW $19, R12 - B callbackasm1(SB) - MOVW $20, R12 - B callbackasm1(SB) - MOVW $21, R12 - B callbackasm1(SB) - MOVW $22, R12 - B callbackasm1(SB) - MOVW $23, R12 - B callbackasm1(SB) - MOVW $24, R12 - B callbackasm1(SB) - MOVW $25, R12 - B callbackasm1(SB) - MOVW $26, R12 - B callbackasm1(SB) - MOVW $27, R12 - B callbackasm1(SB) - MOVW $28, R12 - B callbackasm1(SB) - MOVW $29, R12 - B callbackasm1(SB) - MOVW $30, R12 - B callbackasm1(SB) - MOVW $31, R12 - B callbackasm1(SB) - MOVW $32, R12 - B callbackasm1(SB) - MOVW $33, R12 - B callbackasm1(SB) - MOVW $34, R12 - B callbackasm1(SB) - MOVW $35, R12 - B callbackasm1(SB) - MOVW $36, R12 - B callbackasm1(SB) - MOVW $37, R12 - B callbackasm1(SB) - MOVW $38, R12 - B callbackasm1(SB) - MOVW $39, R12 - B callbackasm1(SB) - MOVW $40, R12 - B callbackasm1(SB) - MOVW $41, R12 - B callbackasm1(SB) - MOVW $42, R12 - B callbackasm1(SB) - MOVW $43, R12 - B callbackasm1(SB) - MOVW $44, R12 - B callbackasm1(SB) - MOVW $45, R12 - B callbackasm1(SB) - MOVW $46, R12 - B callbackasm1(SB) - MOVW $47, R12 - B callbackasm1(SB) - MOVW $48, R12 - B callbackasm1(SB) - MOVW $49, R12 - B callbackasm1(SB) - MOVW $50, R12 - B callbackasm1(SB) - MOVW $51, R12 - B callbackasm1(SB) - MOVW $52, R12 - B callbackasm1(SB) - MOVW $53, R12 - B callbackasm1(SB) - MOVW $54, R12 - B callbackasm1(SB) - MOVW $55, R12 - B callbackasm1(SB) - MOVW $56, R12 - B callbackasm1(SB) - MOVW $57, R12 - B callbackasm1(SB) - MOVW $58, R12 - B callbackasm1(SB) - MOVW $59, R12 - B callbackasm1(SB) - MOVW $60, R12 - B callbackasm1(SB) - MOVW $61, R12 - B callbackasm1(SB) - MOVW $62, R12 - B callbackasm1(SB) - MOVW $63, R12 - B callbackasm1(SB) - MOVW $64, R12 - B callbackasm1(SB) - MOVW $65, R12 - B callbackasm1(SB) - MOVW $66, R12 - B callbackasm1(SB) - MOVW $67, R12 - B callbackasm1(SB) - MOVW $68, R12 - B callbackasm1(SB) - MOVW $69, R12 - B callbackasm1(SB) - MOVW $70, R12 - B callbackasm1(SB) - MOVW $71, R12 - B callbackasm1(SB) - MOVW $72, R12 - B callbackasm1(SB) - MOVW $73, R12 - B callbackasm1(SB) - MOVW $74, R12 - B callbackasm1(SB) - MOVW $75, R12 - B callbackasm1(SB) - MOVW $76, R12 - B callbackasm1(SB) - MOVW $77, R12 - B callbackasm1(SB) - MOVW $78, R12 - B callbackasm1(SB) - MOVW $79, R12 - B callbackasm1(SB) - MOVW $80, R12 - B callbackasm1(SB) - MOVW $81, R12 - B callbackasm1(SB) - MOVW $82, R12 - B callbackasm1(SB) - MOVW $83, R12 - B callbackasm1(SB) - MOVW $84, R12 - B callbackasm1(SB) - MOVW $85, R12 - B callbackasm1(SB) - MOVW $86, R12 - B callbackasm1(SB) - MOVW $87, R12 - B callbackasm1(SB) - MOVW $88, R12 - B callbackasm1(SB) - MOVW $89, R12 - B callbackasm1(SB) - MOVW $90, R12 - B callbackasm1(SB) - MOVW $91, R12 - B callbackasm1(SB) - MOVW $92, R12 - B callbackasm1(SB) - MOVW $93, R12 - B callbackasm1(SB) - MOVW $94, R12 - B callbackasm1(SB) - MOVW $95, R12 - B callbackasm1(SB) - MOVW $96, R12 - B callbackasm1(SB) - MOVW $97, R12 - B callbackasm1(SB) - MOVW $98, R12 - B callbackasm1(SB) - MOVW $99, R12 - B callbackasm1(SB) - MOVW $100, R12 - B callbackasm1(SB) - MOVW $101, R12 - B callbackasm1(SB) - MOVW $102, R12 - B callbackasm1(SB) - MOVW $103, R12 - B callbackasm1(SB) - MOVW $104, R12 - B callbackasm1(SB) - MOVW $105, R12 - B callbackasm1(SB) - MOVW $106, R12 - B callbackasm1(SB) - MOVW $107, R12 - B callbackasm1(SB) - MOVW $108, R12 - B callbackasm1(SB) - MOVW $109, R12 - B callbackasm1(SB) - MOVW $110, R12 - B callbackasm1(SB) - MOVW $111, R12 - B callbackasm1(SB) - MOVW $112, R12 - B callbackasm1(SB) - MOVW $113, R12 - B callbackasm1(SB) - MOVW $114, R12 - B callbackasm1(SB) - MOVW $115, R12 - B callbackasm1(SB) - MOVW $116, R12 - B callbackasm1(SB) - MOVW $117, R12 - B callbackasm1(SB) - MOVW $118, R12 - B callbackasm1(SB) - MOVW $119, R12 - B callbackasm1(SB) - MOVW $120, R12 - B callbackasm1(SB) - MOVW $121, R12 - B callbackasm1(SB) - MOVW $122, R12 - B callbackasm1(SB) - MOVW $123, R12 - B callbackasm1(SB) - MOVW $124, R12 - B callbackasm1(SB) - MOVW $125, R12 - B callbackasm1(SB) - MOVW $126, R12 - B callbackasm1(SB) - MOVW $127, R12 - B callbackasm1(SB) - MOVW $128, R12 - B callbackasm1(SB) - MOVW $129, R12 - B callbackasm1(SB) - MOVW $130, R12 - B callbackasm1(SB) - MOVW $131, R12 - B callbackasm1(SB) - MOVW $132, R12 - B callbackasm1(SB) - MOVW $133, R12 - B callbackasm1(SB) - MOVW $134, R12 - B callbackasm1(SB) - MOVW $135, R12 - B callbackasm1(SB) - MOVW $136, R12 - B callbackasm1(SB) - MOVW $137, R12 - B callbackasm1(SB) - MOVW $138, R12 - B callbackasm1(SB) - MOVW $139, R12 - B callbackasm1(SB) - MOVW $140, R12 - B callbackasm1(SB) - MOVW $141, R12 - B callbackasm1(SB) - MOVW $142, R12 - B callbackasm1(SB) - MOVW $143, R12 - B callbackasm1(SB) - MOVW $144, R12 - B callbackasm1(SB) - MOVW $145, R12 - B callbackasm1(SB) - MOVW $146, R12 - B callbackasm1(SB) - MOVW $147, R12 - B callbackasm1(SB) - MOVW $148, R12 - B callbackasm1(SB) - MOVW $149, R12 - B callbackasm1(SB) - MOVW $150, R12 - B callbackasm1(SB) - MOVW $151, R12 - B callbackasm1(SB) - MOVW $152, R12 - B callbackasm1(SB) - MOVW $153, R12 - B callbackasm1(SB) - MOVW $154, R12 - B callbackasm1(SB) - MOVW $155, R12 - B callbackasm1(SB) - MOVW $156, R12 - B callbackasm1(SB) - MOVW $157, R12 - B callbackasm1(SB) - MOVW $158, R12 - B callbackasm1(SB) - MOVW $159, R12 - B callbackasm1(SB) - MOVW $160, R12 - B callbackasm1(SB) - MOVW $161, R12 - B callbackasm1(SB) - MOVW $162, R12 - B callbackasm1(SB) - MOVW $163, R12 - B callbackasm1(SB) - MOVW $164, R12 - B callbackasm1(SB) - MOVW $165, R12 - B callbackasm1(SB) - MOVW $166, R12 - B callbackasm1(SB) - MOVW $167, R12 - B callbackasm1(SB) - MOVW $168, R12 - B callbackasm1(SB) - MOVW $169, R12 - B callbackasm1(SB) - MOVW $170, R12 - B callbackasm1(SB) - MOVW $171, R12 - B callbackasm1(SB) - MOVW $172, R12 - B callbackasm1(SB) - MOVW $173, R12 - B callbackasm1(SB) - MOVW $174, R12 - B callbackasm1(SB) - MOVW $175, R12 - B callbackasm1(SB) - MOVW $176, R12 - B callbackasm1(SB) - MOVW $177, R12 - B callbackasm1(SB) - MOVW $178, R12 - B callbackasm1(SB) - MOVW $179, R12 - B callbackasm1(SB) - MOVW $180, R12 - B callbackasm1(SB) - MOVW $181, R12 - B callbackasm1(SB) - MOVW $182, R12 - B callbackasm1(SB) - MOVW $183, R12 - B callbackasm1(SB) - MOVW $184, R12 - B callbackasm1(SB) - MOVW $185, R12 - B callbackasm1(SB) - MOVW $186, R12 - B callbackasm1(SB) - MOVW $187, R12 - B callbackasm1(SB) - MOVW $188, R12 - B callbackasm1(SB) - MOVW $189, R12 - B callbackasm1(SB) - MOVW $190, R12 - B callbackasm1(SB) - MOVW $191, R12 - B callbackasm1(SB) - MOVW $192, R12 - B callbackasm1(SB) - MOVW $193, R12 - B callbackasm1(SB) - MOVW $194, R12 - B callbackasm1(SB) - MOVW $195, R12 - B callbackasm1(SB) - MOVW $196, R12 - B callbackasm1(SB) - MOVW $197, R12 - B callbackasm1(SB) - MOVW $198, R12 - B callbackasm1(SB) - MOVW $199, R12 - B callbackasm1(SB) - MOVW $200, R12 - B callbackasm1(SB) - MOVW $201, R12 - B callbackasm1(SB) - MOVW $202, R12 - B callbackasm1(SB) - MOVW $203, R12 - B callbackasm1(SB) - MOVW $204, R12 - B callbackasm1(SB) - MOVW $205, R12 - B callbackasm1(SB) - MOVW $206, R12 - B callbackasm1(SB) - MOVW $207, R12 - B callbackasm1(SB) - MOVW $208, R12 - B callbackasm1(SB) - MOVW $209, R12 - B callbackasm1(SB) - MOVW $210, R12 - B callbackasm1(SB) - MOVW $211, R12 - B callbackasm1(SB) - MOVW $212, R12 - B callbackasm1(SB) - MOVW $213, R12 - B callbackasm1(SB) - MOVW $214, R12 - B callbackasm1(SB) - MOVW $215, R12 - B callbackasm1(SB) - MOVW $216, R12 - B callbackasm1(SB) - MOVW $217, R12 - B callbackasm1(SB) - MOVW $218, R12 - B callbackasm1(SB) - MOVW $219, R12 - B callbackasm1(SB) - MOVW $220, R12 - B callbackasm1(SB) - MOVW $221, R12 - B callbackasm1(SB) - MOVW $222, R12 - B callbackasm1(SB) - MOVW $223, R12 - B callbackasm1(SB) - MOVW $224, R12 - B callbackasm1(SB) - MOVW $225, R12 - B callbackasm1(SB) - MOVW $226, R12 - B callbackasm1(SB) - MOVW $227, R12 - B callbackasm1(SB) - MOVW $228, R12 - B callbackasm1(SB) - MOVW $229, R12 - B callbackasm1(SB) - MOVW $230, R12 - B callbackasm1(SB) - MOVW $231, R12 - B callbackasm1(SB) - MOVW $232, R12 - B callbackasm1(SB) - MOVW $233, R12 - B callbackasm1(SB) - MOVW $234, R12 - B callbackasm1(SB) - MOVW $235, R12 - B callbackasm1(SB) - MOVW $236, R12 - B callbackasm1(SB) - MOVW $237, R12 - B callbackasm1(SB) - MOVW $238, R12 - B callbackasm1(SB) - MOVW $239, R12 - B callbackasm1(SB) - MOVW $240, R12 - B callbackasm1(SB) - MOVW $241, R12 - B callbackasm1(SB) - MOVW $242, R12 - B callbackasm1(SB) - MOVW $243, R12 - B callbackasm1(SB) - MOVW $244, R12 - B callbackasm1(SB) - MOVW $245, R12 - B callbackasm1(SB) - MOVW $246, R12 - B callbackasm1(SB) - MOVW $247, R12 - B callbackasm1(SB) - MOVW $248, R12 - B callbackasm1(SB) - MOVW $249, R12 - B callbackasm1(SB) - MOVW $250, R12 - B callbackasm1(SB) - MOVW $251, R12 - B callbackasm1(SB) - MOVW $252, R12 - B callbackasm1(SB) - MOVW $253, R12 - B callbackasm1(SB) - MOVW $254, R12 - B callbackasm1(SB) - MOVW $255, R12 - B callbackasm1(SB) - MOVW $256, R12 - B callbackasm1(SB) - MOVW $257, R12 - B callbackasm1(SB) - MOVW $258, R12 - B callbackasm1(SB) - MOVW $259, R12 - B callbackasm1(SB) - MOVW $260, R12 - B callbackasm1(SB) - MOVW $261, R12 - B callbackasm1(SB) - MOVW $262, R12 - B callbackasm1(SB) - MOVW $263, R12 - B callbackasm1(SB) - MOVW $264, R12 - B callbackasm1(SB) - MOVW $265, R12 - B callbackasm1(SB) - MOVW $266, R12 - B callbackasm1(SB) - MOVW $267, R12 - B callbackasm1(SB) - MOVW $268, R12 - B callbackasm1(SB) - MOVW $269, R12 - B callbackasm1(SB) - MOVW $270, R12 - B callbackasm1(SB) - MOVW $271, R12 - B callbackasm1(SB) - MOVW $272, R12 - B callbackasm1(SB) - MOVW $273, R12 - B callbackasm1(SB) - MOVW $274, R12 - B callbackasm1(SB) - MOVW $275, R12 - B callbackasm1(SB) - MOVW $276, R12 - B callbackasm1(SB) - MOVW $277, R12 - B callbackasm1(SB) - MOVW $278, R12 - B callbackasm1(SB) - MOVW $279, R12 - B callbackasm1(SB) - MOVW $280, R12 - B callbackasm1(SB) - MOVW $281, R12 - B callbackasm1(SB) - MOVW $282, R12 - B callbackasm1(SB) - MOVW $283, R12 - B callbackasm1(SB) - MOVW $284, R12 - B callbackasm1(SB) - MOVW $285, R12 - B callbackasm1(SB) - MOVW $286, R12 - B callbackasm1(SB) - MOVW $287, R12 - B callbackasm1(SB) - MOVW $288, R12 - B callbackasm1(SB) - MOVW $289, R12 - B callbackasm1(SB) - MOVW $290, R12 - B callbackasm1(SB) - MOVW $291, R12 - B callbackasm1(SB) - MOVW $292, R12 - B callbackasm1(SB) - MOVW $293, R12 - B callbackasm1(SB) - MOVW $294, R12 - B callbackasm1(SB) - MOVW $295, R12 - B callbackasm1(SB) - MOVW $296, R12 - B callbackasm1(SB) - MOVW $297, R12 - B callbackasm1(SB) - MOVW $298, R12 - B callbackasm1(SB) - MOVW $299, R12 - B callbackasm1(SB) - MOVW $300, R12 - B callbackasm1(SB) - MOVW $301, R12 - B callbackasm1(SB) - MOVW $302, R12 - B callbackasm1(SB) - MOVW $303, R12 - B callbackasm1(SB) - MOVW $304, R12 - B callbackasm1(SB) - MOVW $305, R12 - B callbackasm1(SB) - MOVW $306, R12 - B callbackasm1(SB) - MOVW $307, R12 - B callbackasm1(SB) - MOVW $308, R12 - B callbackasm1(SB) - MOVW $309, R12 - B callbackasm1(SB) - MOVW $310, R12 - B callbackasm1(SB) - MOVW $311, R12 - B callbackasm1(SB) - MOVW $312, R12 - B callbackasm1(SB) - MOVW $313, R12 - B callbackasm1(SB) - MOVW $314, R12 - B callbackasm1(SB) - MOVW $315, R12 - B callbackasm1(SB) - MOVW $316, R12 - B callbackasm1(SB) - MOVW $317, R12 - B callbackasm1(SB) - MOVW $318, R12 - B callbackasm1(SB) - MOVW $319, R12 - B callbackasm1(SB) - MOVW $320, R12 - B callbackasm1(SB) - MOVW $321, R12 - B callbackasm1(SB) - MOVW $322, R12 - B callbackasm1(SB) - MOVW $323, R12 - B callbackasm1(SB) - MOVW $324, R12 - B callbackasm1(SB) - MOVW $325, R12 - B callbackasm1(SB) - MOVW $326, R12 - B callbackasm1(SB) - MOVW $327, R12 - B callbackasm1(SB) - MOVW $328, R12 - B callbackasm1(SB) - MOVW $329, R12 - B callbackasm1(SB) - MOVW $330, R12 - B callbackasm1(SB) - MOVW $331, R12 - B callbackasm1(SB) - MOVW $332, R12 - B callbackasm1(SB) - MOVW $333, R12 - B callbackasm1(SB) - MOVW $334, R12 - B callbackasm1(SB) - MOVW $335, R12 - B callbackasm1(SB) - MOVW $336, R12 - B callbackasm1(SB) - MOVW $337, R12 - B callbackasm1(SB) - MOVW $338, R12 - B callbackasm1(SB) - MOVW $339, R12 - B callbackasm1(SB) - MOVW $340, R12 - B callbackasm1(SB) - MOVW $341, R12 - B callbackasm1(SB) - MOVW $342, R12 - B callbackasm1(SB) - MOVW $343, R12 - B callbackasm1(SB) - MOVW $344, R12 - B callbackasm1(SB) - MOVW $345, R12 - B callbackasm1(SB) - MOVW $346, R12 - B callbackasm1(SB) - MOVW $347, R12 - B callbackasm1(SB) - MOVW $348, R12 - B callbackasm1(SB) - MOVW $349, R12 - B callbackasm1(SB) - MOVW $350, R12 - B callbackasm1(SB) - MOVW $351, R12 - B callbackasm1(SB) - MOVW $352, R12 - B callbackasm1(SB) - MOVW $353, R12 - B callbackasm1(SB) - MOVW $354, R12 - B callbackasm1(SB) - MOVW $355, R12 - B callbackasm1(SB) - MOVW $356, R12 - B callbackasm1(SB) - MOVW $357, R12 - B callbackasm1(SB) - MOVW $358, R12 - B callbackasm1(SB) - MOVW $359, R12 - B callbackasm1(SB) - MOVW $360, R12 - B callbackasm1(SB) - MOVW $361, R12 - B callbackasm1(SB) - MOVW $362, R12 - B callbackasm1(SB) - MOVW $363, R12 - B callbackasm1(SB) - MOVW $364, R12 - B callbackasm1(SB) - MOVW $365, R12 - B callbackasm1(SB) - MOVW $366, R12 - B callbackasm1(SB) - MOVW $367, R12 - B callbackasm1(SB) - MOVW $368, R12 - B callbackasm1(SB) - MOVW $369, R12 - B callbackasm1(SB) - MOVW $370, R12 - B callbackasm1(SB) - MOVW $371, R12 - B callbackasm1(SB) - MOVW $372, R12 - B callbackasm1(SB) - MOVW $373, R12 - B callbackasm1(SB) - MOVW $374, R12 - B callbackasm1(SB) - MOVW $375, R12 - B callbackasm1(SB) - MOVW $376, R12 - B callbackasm1(SB) - MOVW $377, R12 - B callbackasm1(SB) - MOVW $378, R12 - B callbackasm1(SB) - MOVW $379, R12 - B callbackasm1(SB) - MOVW $380, R12 - B callbackasm1(SB) - MOVW $381, R12 - B callbackasm1(SB) - MOVW $382, R12 - B callbackasm1(SB) - MOVW $383, R12 - B callbackasm1(SB) - MOVW $384, R12 - B callbackasm1(SB) - MOVW $385, R12 - B callbackasm1(SB) - MOVW $386, R12 - B callbackasm1(SB) - MOVW $387, R12 - B callbackasm1(SB) - MOVW $388, R12 - B callbackasm1(SB) - MOVW $389, R12 - B callbackasm1(SB) - MOVW $390, R12 - B callbackasm1(SB) - MOVW $391, R12 - B callbackasm1(SB) - MOVW $392, R12 - B callbackasm1(SB) - MOVW $393, R12 - B callbackasm1(SB) - MOVW $394, R12 - B callbackasm1(SB) - MOVW $395, R12 - B callbackasm1(SB) - MOVW $396, R12 - B callbackasm1(SB) - MOVW $397, R12 - B callbackasm1(SB) - MOVW $398, R12 - B callbackasm1(SB) - MOVW $399, R12 - B callbackasm1(SB) - MOVW $400, R12 - B callbackasm1(SB) - MOVW $401, R12 - B callbackasm1(SB) - MOVW $402, R12 - B callbackasm1(SB) - MOVW $403, R12 - B callbackasm1(SB) - MOVW $404, R12 - B callbackasm1(SB) - MOVW $405, R12 - B callbackasm1(SB) - MOVW $406, R12 - B callbackasm1(SB) - MOVW $407, R12 - B callbackasm1(SB) - MOVW $408, R12 - B callbackasm1(SB) - MOVW $409, R12 - B callbackasm1(SB) - MOVW $410, R12 - B callbackasm1(SB) - MOVW $411, R12 - B callbackasm1(SB) - MOVW $412, R12 - B callbackasm1(SB) - MOVW $413, R12 - B callbackasm1(SB) - MOVW $414, R12 - B callbackasm1(SB) - MOVW $415, R12 - B callbackasm1(SB) - MOVW $416, R12 - B callbackasm1(SB) - MOVW $417, R12 - B callbackasm1(SB) - MOVW $418, R12 - B callbackasm1(SB) - MOVW $419, R12 - B callbackasm1(SB) - MOVW $420, R12 - B callbackasm1(SB) - MOVW $421, R12 - B callbackasm1(SB) - MOVW $422, R12 - B callbackasm1(SB) - MOVW $423, R12 - B callbackasm1(SB) - MOVW $424, R12 - B callbackasm1(SB) - MOVW $425, R12 - B callbackasm1(SB) - MOVW $426, R12 - B callbackasm1(SB) - MOVW $427, R12 - B callbackasm1(SB) - MOVW $428, R12 - B callbackasm1(SB) - MOVW $429, R12 - B callbackasm1(SB) - MOVW $430, R12 - B callbackasm1(SB) - MOVW $431, R12 - B callbackasm1(SB) - MOVW $432, R12 - B callbackasm1(SB) - MOVW $433, R12 - B callbackasm1(SB) - MOVW $434, R12 - B callbackasm1(SB) - MOVW $435, R12 - B callbackasm1(SB) - MOVW $436, R12 - B callbackasm1(SB) - MOVW $437, R12 - B callbackasm1(SB) - MOVW $438, R12 - B callbackasm1(SB) - MOVW $439, R12 - B callbackasm1(SB) - MOVW $440, R12 - B callbackasm1(SB) - MOVW $441, R12 - B callbackasm1(SB) - MOVW $442, R12 - B callbackasm1(SB) - MOVW $443, R12 - B callbackasm1(SB) - MOVW $444, R12 - B callbackasm1(SB) - MOVW $445, R12 - B callbackasm1(SB) - MOVW $446, R12 - B callbackasm1(SB) - MOVW $447, R12 - B callbackasm1(SB) - MOVW $448, R12 - B callbackasm1(SB) - MOVW $449, R12 - B callbackasm1(SB) - MOVW $450, R12 - B callbackasm1(SB) - MOVW $451, R12 - B callbackasm1(SB) - MOVW $452, R12 - B callbackasm1(SB) - MOVW $453, R12 - B callbackasm1(SB) - MOVW $454, R12 - B callbackasm1(SB) - MOVW $455, R12 - B callbackasm1(SB) - MOVW $456, R12 - B callbackasm1(SB) - MOVW $457, R12 - B callbackasm1(SB) - MOVW $458, R12 - B callbackasm1(SB) - MOVW $459, R12 - B callbackasm1(SB) - MOVW $460, R12 - B callbackasm1(SB) - MOVW $461, R12 - B callbackasm1(SB) - MOVW $462, R12 - B callbackasm1(SB) - MOVW $463, R12 - B callbackasm1(SB) - MOVW $464, R12 - B callbackasm1(SB) - MOVW $465, R12 - B callbackasm1(SB) - MOVW $466, R12 - B callbackasm1(SB) - MOVW $467, R12 - B callbackasm1(SB) - MOVW $468, R12 - B callbackasm1(SB) - MOVW $469, R12 - B callbackasm1(SB) - MOVW $470, R12 - B callbackasm1(SB) - MOVW $471, R12 - B callbackasm1(SB) - MOVW $472, R12 - B callbackasm1(SB) - MOVW $473, R12 - B callbackasm1(SB) - MOVW $474, R12 - B callbackasm1(SB) - MOVW $475, R12 - B callbackasm1(SB) - MOVW $476, R12 - B callbackasm1(SB) - MOVW $477, R12 - B callbackasm1(SB) - MOVW $478, R12 - B callbackasm1(SB) - MOVW $479, R12 - B callbackasm1(SB) - MOVW $480, R12 - B callbackasm1(SB) - MOVW $481, R12 - B callbackasm1(SB) - MOVW $482, R12 - B callbackasm1(SB) - MOVW $483, R12 - B callbackasm1(SB) - MOVW $484, R12 - B callbackasm1(SB) - MOVW $485, R12 - B callbackasm1(SB) - MOVW $486, R12 - B callbackasm1(SB) - MOVW $487, R12 - B callbackasm1(SB) - MOVW $488, R12 - B callbackasm1(SB) - MOVW $489, R12 - B callbackasm1(SB) - MOVW $490, R12 - B callbackasm1(SB) - MOVW $491, R12 - B callbackasm1(SB) - MOVW $492, R12 - B callbackasm1(SB) - MOVW $493, R12 - B callbackasm1(SB) - MOVW $494, R12 - B callbackasm1(SB) - MOVW $495, R12 - B callbackasm1(SB) - MOVW $496, R12 - B callbackasm1(SB) - MOVW $497, R12 - B callbackasm1(SB) - MOVW $498, R12 - B callbackasm1(SB) - MOVW $499, R12 - B callbackasm1(SB) - MOVW $500, R12 - B callbackasm1(SB) - MOVW $501, R12 - B callbackasm1(SB) - MOVW $502, R12 - B callbackasm1(SB) - MOVW $503, R12 - B callbackasm1(SB) - MOVW $504, R12 - B callbackasm1(SB) - MOVW $505, R12 - B callbackasm1(SB) - MOVW $506, R12 - B callbackasm1(SB) - MOVW $507, R12 - B callbackasm1(SB) - MOVW $508, R12 - B callbackasm1(SB) - MOVW $509, R12 - B callbackasm1(SB) - MOVW $510, R12 - B callbackasm1(SB) - MOVW $511, R12 - B callbackasm1(SB) - MOVW $512, R12 - B callbackasm1(SB) - MOVW $513, R12 - B callbackasm1(SB) - MOVW $514, R12 - B callbackasm1(SB) - MOVW $515, R12 - B callbackasm1(SB) - MOVW $516, R12 - B callbackasm1(SB) - MOVW $517, R12 - B callbackasm1(SB) - MOVW $518, R12 - B callbackasm1(SB) - MOVW $519, R12 - B callbackasm1(SB) - MOVW $520, R12 - B callbackasm1(SB) - MOVW $521, R12 - B callbackasm1(SB) - MOVW $522, R12 - B callbackasm1(SB) - MOVW $523, R12 - B callbackasm1(SB) - MOVW $524, R12 - B callbackasm1(SB) - MOVW $525, R12 - B callbackasm1(SB) - MOVW $526, R12 - B callbackasm1(SB) - MOVW $527, R12 - B callbackasm1(SB) - MOVW $528, R12 - B callbackasm1(SB) - MOVW $529, R12 - B callbackasm1(SB) - MOVW $530, R12 - B callbackasm1(SB) - MOVW $531, R12 - B callbackasm1(SB) - MOVW $532, R12 - B callbackasm1(SB) - MOVW $533, R12 - B callbackasm1(SB) - MOVW $534, R12 - B callbackasm1(SB) - MOVW $535, R12 - B callbackasm1(SB) - MOVW $536, R12 - B callbackasm1(SB) - MOVW $537, R12 - B callbackasm1(SB) - MOVW $538, R12 - B callbackasm1(SB) - MOVW $539, R12 - B callbackasm1(SB) - MOVW $540, R12 - B callbackasm1(SB) - MOVW $541, R12 - B callbackasm1(SB) - MOVW $542, R12 - B callbackasm1(SB) - MOVW $543, R12 - B callbackasm1(SB) - MOVW $544, R12 - B callbackasm1(SB) - MOVW $545, R12 - B callbackasm1(SB) - MOVW $546, R12 - B callbackasm1(SB) - MOVW $547, R12 - B callbackasm1(SB) - MOVW $548, R12 - B callbackasm1(SB) - MOVW $549, R12 - B callbackasm1(SB) - MOVW $550, R12 - B callbackasm1(SB) - MOVW $551, R12 - B callbackasm1(SB) - MOVW $552, R12 - B callbackasm1(SB) - MOVW $553, R12 - B callbackasm1(SB) - MOVW $554, R12 - B callbackasm1(SB) - MOVW $555, R12 - B callbackasm1(SB) - MOVW $556, R12 - B callbackasm1(SB) - MOVW $557, R12 - B callbackasm1(SB) - MOVW $558, R12 - B callbackasm1(SB) - MOVW $559, R12 - B callbackasm1(SB) - MOVW $560, R12 - B callbackasm1(SB) - MOVW $561, R12 - B callbackasm1(SB) - MOVW $562, R12 - B callbackasm1(SB) - MOVW $563, R12 - B callbackasm1(SB) - MOVW $564, R12 - B callbackasm1(SB) - MOVW $565, R12 - B callbackasm1(SB) - MOVW $566, R12 - B callbackasm1(SB) - MOVW $567, R12 - B callbackasm1(SB) - MOVW $568, R12 - B callbackasm1(SB) - MOVW $569, R12 - B callbackasm1(SB) - MOVW $570, R12 - B callbackasm1(SB) - MOVW $571, R12 - B callbackasm1(SB) - MOVW $572, R12 - B callbackasm1(SB) - MOVW $573, R12 - B callbackasm1(SB) - MOVW $574, R12 - B callbackasm1(SB) - MOVW $575, R12 - B callbackasm1(SB) - MOVW $576, R12 - B callbackasm1(SB) - MOVW $577, R12 - B callbackasm1(SB) - MOVW $578, R12 - B callbackasm1(SB) - MOVW $579, R12 - B callbackasm1(SB) - MOVW $580, R12 - B callbackasm1(SB) - MOVW $581, R12 - B callbackasm1(SB) - MOVW $582, R12 - B callbackasm1(SB) - MOVW $583, R12 - B callbackasm1(SB) - MOVW $584, R12 - B callbackasm1(SB) - MOVW $585, R12 - B callbackasm1(SB) - MOVW $586, R12 - B callbackasm1(SB) - MOVW $587, R12 - B callbackasm1(SB) - MOVW $588, R12 - B callbackasm1(SB) - MOVW $589, R12 - B callbackasm1(SB) - MOVW $590, R12 - B callbackasm1(SB) - MOVW $591, R12 - B callbackasm1(SB) - MOVW $592, R12 - B callbackasm1(SB) - MOVW $593, R12 - B callbackasm1(SB) - MOVW $594, R12 - B callbackasm1(SB) - MOVW $595, R12 - B callbackasm1(SB) - MOVW $596, R12 - B callbackasm1(SB) - MOVW $597, R12 - B callbackasm1(SB) - MOVW $598, R12 - B callbackasm1(SB) - MOVW $599, R12 - B callbackasm1(SB) - MOVW $600, R12 - B callbackasm1(SB) - MOVW $601, R12 - B callbackasm1(SB) - MOVW $602, R12 - B callbackasm1(SB) - MOVW $603, R12 - B callbackasm1(SB) - MOVW $604, R12 - B callbackasm1(SB) - MOVW $605, R12 - B callbackasm1(SB) - MOVW $606, R12 - B callbackasm1(SB) - MOVW $607, R12 - B callbackasm1(SB) - MOVW $608, R12 - B callbackasm1(SB) - MOVW $609, R12 - B callbackasm1(SB) - MOVW $610, R12 - B callbackasm1(SB) - MOVW $611, R12 - B callbackasm1(SB) - MOVW $612, R12 - B callbackasm1(SB) - MOVW $613, R12 - B callbackasm1(SB) - MOVW $614, R12 - B callbackasm1(SB) - MOVW $615, R12 - B callbackasm1(SB) - MOVW $616, R12 - B callbackasm1(SB) - MOVW $617, R12 - B callbackasm1(SB) - MOVW $618, R12 - B callbackasm1(SB) - MOVW $619, R12 - B callbackasm1(SB) - MOVW $620, R12 - B callbackasm1(SB) - MOVW $621, R12 - B callbackasm1(SB) - MOVW $622, R12 - B callbackasm1(SB) - MOVW $623, R12 - B callbackasm1(SB) - MOVW $624, R12 - B callbackasm1(SB) - MOVW $625, R12 - B callbackasm1(SB) - MOVW $626, R12 - B callbackasm1(SB) - MOVW $627, R12 - B callbackasm1(SB) - MOVW $628, R12 - B callbackasm1(SB) - MOVW $629, R12 - B callbackasm1(SB) - MOVW $630, R12 - B callbackasm1(SB) - MOVW $631, R12 - B callbackasm1(SB) - MOVW $632, R12 - B callbackasm1(SB) - MOVW $633, R12 - B callbackasm1(SB) - MOVW $634, R12 - B callbackasm1(SB) - MOVW $635, R12 - B callbackasm1(SB) - MOVW $636, R12 - B callbackasm1(SB) - MOVW $637, R12 - B callbackasm1(SB) - MOVW $638, R12 - B callbackasm1(SB) - MOVW $639, R12 - B callbackasm1(SB) - MOVW $640, R12 - B callbackasm1(SB) - MOVW $641, R12 - B callbackasm1(SB) - MOVW $642, R12 - B callbackasm1(SB) - MOVW $643, R12 - B callbackasm1(SB) - MOVW $644, R12 - B callbackasm1(SB) - MOVW $645, R12 - B callbackasm1(SB) - MOVW $646, R12 - B callbackasm1(SB) - MOVW $647, R12 - B callbackasm1(SB) - MOVW $648, R12 - B callbackasm1(SB) - MOVW $649, R12 - B callbackasm1(SB) - MOVW $650, R12 - B callbackasm1(SB) - MOVW $651, R12 - B callbackasm1(SB) - MOVW $652, R12 - B callbackasm1(SB) - MOVW $653, R12 - B callbackasm1(SB) - MOVW $654, R12 - B callbackasm1(SB) - MOVW $655, R12 - B callbackasm1(SB) - MOVW $656, R12 - B callbackasm1(SB) - MOVW $657, R12 - B callbackasm1(SB) - MOVW $658, R12 - B callbackasm1(SB) - MOVW $659, R12 - B callbackasm1(SB) - MOVW $660, R12 - B callbackasm1(SB) - MOVW $661, R12 - B callbackasm1(SB) - MOVW $662, R12 - B callbackasm1(SB) - MOVW $663, R12 - B callbackasm1(SB) - MOVW $664, R12 - B callbackasm1(SB) - MOVW $665, R12 - B callbackasm1(SB) - MOVW $666, R12 - B callbackasm1(SB) - MOVW $667, R12 - B callbackasm1(SB) - MOVW $668, R12 - B callbackasm1(SB) - MOVW $669, R12 - B callbackasm1(SB) - MOVW $670, R12 - B callbackasm1(SB) - MOVW $671, R12 - B callbackasm1(SB) - MOVW $672, R12 - B callbackasm1(SB) - MOVW $673, R12 - B callbackasm1(SB) - MOVW $674, R12 - B callbackasm1(SB) - MOVW $675, R12 - B callbackasm1(SB) - MOVW $676, R12 - B callbackasm1(SB) - MOVW $677, R12 - B callbackasm1(SB) - MOVW $678, R12 - B callbackasm1(SB) - MOVW $679, R12 - B callbackasm1(SB) - MOVW $680, R12 - B callbackasm1(SB) - MOVW $681, R12 - B callbackasm1(SB) - MOVW $682, R12 - B callbackasm1(SB) - MOVW $683, R12 - B callbackasm1(SB) - MOVW $684, R12 - B callbackasm1(SB) - MOVW $685, R12 - B callbackasm1(SB) - MOVW $686, R12 - B callbackasm1(SB) - MOVW $687, R12 - B callbackasm1(SB) - MOVW $688, R12 - B callbackasm1(SB) - MOVW $689, R12 - B callbackasm1(SB) - MOVW $690, R12 - B callbackasm1(SB) - MOVW $691, R12 - B callbackasm1(SB) - MOVW $692, R12 - B callbackasm1(SB) - MOVW $693, R12 - B callbackasm1(SB) - MOVW $694, R12 - B callbackasm1(SB) - MOVW $695, R12 - B callbackasm1(SB) - MOVW $696, R12 - B callbackasm1(SB) - MOVW $697, R12 - B callbackasm1(SB) - MOVW $698, R12 - B callbackasm1(SB) - MOVW $699, R12 - B callbackasm1(SB) - MOVW $700, R12 - B callbackasm1(SB) - MOVW $701, R12 - B callbackasm1(SB) - MOVW $702, R12 - B callbackasm1(SB) - MOVW $703, R12 - B callbackasm1(SB) - MOVW $704, R12 - B callbackasm1(SB) - MOVW $705, R12 - B callbackasm1(SB) - MOVW $706, R12 - B callbackasm1(SB) - MOVW $707, R12 - B callbackasm1(SB) - MOVW $708, R12 - B callbackasm1(SB) - MOVW $709, R12 - B callbackasm1(SB) - MOVW $710, R12 - B callbackasm1(SB) - MOVW $711, R12 - B callbackasm1(SB) - MOVW $712, R12 - B callbackasm1(SB) - MOVW $713, R12 - B callbackasm1(SB) - MOVW $714, R12 - B callbackasm1(SB) - MOVW $715, R12 - B callbackasm1(SB) - MOVW $716, R12 - B callbackasm1(SB) - MOVW $717, R12 - B callbackasm1(SB) - MOVW $718, R12 - B callbackasm1(SB) - MOVW $719, R12 - B callbackasm1(SB) - MOVW $720, R12 - B callbackasm1(SB) - MOVW $721, R12 - B callbackasm1(SB) - MOVW $722, R12 - B callbackasm1(SB) - MOVW $723, R12 - B callbackasm1(SB) - MOVW $724, R12 - B callbackasm1(SB) - MOVW $725, R12 - B callbackasm1(SB) - MOVW $726, R12 - B callbackasm1(SB) - MOVW $727, R12 - B callbackasm1(SB) - MOVW $728, R12 - B callbackasm1(SB) - MOVW $729, R12 - B callbackasm1(SB) - MOVW $730, R12 - B callbackasm1(SB) - MOVW $731, R12 - B callbackasm1(SB) - MOVW $732, R12 - B callbackasm1(SB) - MOVW $733, R12 - B callbackasm1(SB) - MOVW $734, R12 - B callbackasm1(SB) - MOVW $735, R12 - B callbackasm1(SB) - MOVW $736, R12 - B callbackasm1(SB) - MOVW $737, R12 - B callbackasm1(SB) - MOVW $738, R12 - B callbackasm1(SB) - MOVW $739, R12 - B callbackasm1(SB) - MOVW $740, R12 - B callbackasm1(SB) - MOVW $741, R12 - B callbackasm1(SB) - MOVW $742, R12 - B callbackasm1(SB) - MOVW $743, R12 - B callbackasm1(SB) - MOVW $744, R12 - B callbackasm1(SB) - MOVW $745, R12 - B callbackasm1(SB) - MOVW $746, R12 - B callbackasm1(SB) - MOVW $747, R12 - B callbackasm1(SB) - MOVW $748, R12 - B callbackasm1(SB) - MOVW $749, R12 - B callbackasm1(SB) - MOVW $750, R12 - B callbackasm1(SB) - MOVW $751, R12 - B callbackasm1(SB) - MOVW $752, R12 - B callbackasm1(SB) - MOVW $753, R12 - B callbackasm1(SB) - MOVW $754, R12 - B callbackasm1(SB) - MOVW $755, R12 - B callbackasm1(SB) - MOVW $756, R12 - B callbackasm1(SB) - MOVW $757, R12 - B callbackasm1(SB) - MOVW $758, R12 - B callbackasm1(SB) - MOVW $759, R12 - B callbackasm1(SB) - MOVW $760, R12 - B callbackasm1(SB) - MOVW $761, R12 - B callbackasm1(SB) - MOVW $762, R12 - B callbackasm1(SB) - MOVW $763, R12 - B callbackasm1(SB) - MOVW $764, R12 - B callbackasm1(SB) - MOVW $765, R12 - B callbackasm1(SB) - MOVW $766, R12 - B callbackasm1(SB) - MOVW $767, R12 - B callbackasm1(SB) - MOVW $768, R12 - B callbackasm1(SB) - MOVW $769, R12 - B callbackasm1(SB) - MOVW $770, R12 - B callbackasm1(SB) - MOVW $771, R12 - B callbackasm1(SB) - MOVW $772, R12 - B callbackasm1(SB) - MOVW $773, R12 - B callbackasm1(SB) - MOVW $774, R12 - B callbackasm1(SB) - MOVW $775, R12 - B callbackasm1(SB) - MOVW $776, R12 - B callbackasm1(SB) - MOVW $777, R12 - B callbackasm1(SB) - MOVW $778, R12 - B callbackasm1(SB) - MOVW $779, R12 - B callbackasm1(SB) - MOVW $780, R12 - B callbackasm1(SB) - MOVW $781, R12 - B callbackasm1(SB) - MOVW $782, R12 - B callbackasm1(SB) - MOVW $783, R12 - B callbackasm1(SB) - MOVW $784, R12 - B callbackasm1(SB) - MOVW $785, R12 - B callbackasm1(SB) - MOVW $786, R12 - B callbackasm1(SB) - MOVW $787, R12 - B callbackasm1(SB) - MOVW $788, R12 - B callbackasm1(SB) - MOVW $789, R12 - B callbackasm1(SB) - MOVW $790, R12 - B callbackasm1(SB) - MOVW $791, R12 - B callbackasm1(SB) - MOVW $792, R12 - B callbackasm1(SB) - MOVW $793, R12 - B callbackasm1(SB) - MOVW $794, R12 - B callbackasm1(SB) - MOVW $795, R12 - B callbackasm1(SB) - MOVW $796, R12 - B callbackasm1(SB) - MOVW $797, R12 - B callbackasm1(SB) - MOVW $798, R12 - B callbackasm1(SB) - MOVW $799, R12 - B callbackasm1(SB) - MOVW $800, R12 - B callbackasm1(SB) - MOVW $801, R12 - B callbackasm1(SB) - MOVW $802, R12 - B callbackasm1(SB) - MOVW $803, R12 - B callbackasm1(SB) - MOVW $804, R12 - B callbackasm1(SB) - MOVW $805, R12 - B callbackasm1(SB) - MOVW $806, R12 - B callbackasm1(SB) - MOVW $807, R12 - B callbackasm1(SB) - MOVW $808, R12 - B callbackasm1(SB) - MOVW $809, R12 - B callbackasm1(SB) - MOVW $810, R12 - B callbackasm1(SB) - MOVW $811, R12 - B callbackasm1(SB) - MOVW $812, R12 - B callbackasm1(SB) - MOVW $813, R12 - B callbackasm1(SB) - MOVW $814, R12 - B callbackasm1(SB) - MOVW $815, R12 - B callbackasm1(SB) - MOVW $816, R12 - B callbackasm1(SB) - MOVW $817, R12 - B callbackasm1(SB) - MOVW $818, R12 - B callbackasm1(SB) - MOVW $819, R12 - B callbackasm1(SB) - MOVW $820, R12 - B callbackasm1(SB) - MOVW $821, R12 - B callbackasm1(SB) - MOVW $822, R12 - B callbackasm1(SB) - MOVW $823, R12 - B callbackasm1(SB) - MOVW $824, R12 - B callbackasm1(SB) - MOVW $825, R12 - B callbackasm1(SB) - MOVW $826, R12 - B callbackasm1(SB) - MOVW $827, R12 - B callbackasm1(SB) - MOVW $828, R12 - B callbackasm1(SB) - MOVW $829, R12 - B callbackasm1(SB) - MOVW $830, R12 - B callbackasm1(SB) - MOVW $831, R12 - B callbackasm1(SB) - MOVW $832, R12 - B callbackasm1(SB) - MOVW $833, R12 - B callbackasm1(SB) - MOVW $834, R12 - B callbackasm1(SB) - MOVW $835, R12 - B callbackasm1(SB) - MOVW $836, R12 - B callbackasm1(SB) - MOVW $837, R12 - B callbackasm1(SB) - MOVW $838, R12 - B callbackasm1(SB) - MOVW $839, R12 - B callbackasm1(SB) - MOVW $840, R12 - B callbackasm1(SB) - MOVW $841, R12 - B callbackasm1(SB) - MOVW $842, R12 - B callbackasm1(SB) - MOVW $843, R12 - B callbackasm1(SB) - MOVW $844, R12 - B callbackasm1(SB) - MOVW $845, R12 - B callbackasm1(SB) - MOVW $846, R12 - B callbackasm1(SB) - MOVW $847, R12 - B callbackasm1(SB) - MOVW $848, R12 - B callbackasm1(SB) - MOVW $849, R12 - B callbackasm1(SB) - MOVW $850, R12 - B callbackasm1(SB) - MOVW $851, R12 - B callbackasm1(SB) - MOVW $852, R12 - B callbackasm1(SB) - MOVW $853, R12 - B callbackasm1(SB) - MOVW $854, R12 - B callbackasm1(SB) - MOVW $855, R12 - B callbackasm1(SB) - MOVW $856, R12 - B callbackasm1(SB) - MOVW $857, R12 - B callbackasm1(SB) - MOVW $858, R12 - B callbackasm1(SB) - MOVW $859, R12 - B callbackasm1(SB) - MOVW $860, R12 - B callbackasm1(SB) - MOVW $861, R12 - B callbackasm1(SB) - MOVW $862, R12 - B callbackasm1(SB) - MOVW $863, R12 - B callbackasm1(SB) - MOVW $864, R12 - B callbackasm1(SB) - MOVW $865, R12 - B callbackasm1(SB) - MOVW $866, R12 - B callbackasm1(SB) - MOVW $867, R12 - B callbackasm1(SB) - MOVW $868, R12 - B callbackasm1(SB) - MOVW $869, R12 - B callbackasm1(SB) - MOVW $870, R12 - B callbackasm1(SB) - MOVW $871, R12 - B callbackasm1(SB) - MOVW $872, R12 - B callbackasm1(SB) - MOVW $873, R12 - B callbackasm1(SB) - MOVW $874, R12 - B callbackasm1(SB) - MOVW $875, R12 - B callbackasm1(SB) - MOVW $876, R12 - B callbackasm1(SB) - MOVW $877, R12 - B callbackasm1(SB) - MOVW $878, R12 - B callbackasm1(SB) - MOVW $879, R12 - B callbackasm1(SB) - MOVW $880, R12 - B callbackasm1(SB) - MOVW $881, R12 - B callbackasm1(SB) - MOVW $882, R12 - B callbackasm1(SB) - MOVW $883, R12 - B callbackasm1(SB) - MOVW $884, R12 - B callbackasm1(SB) - MOVW $885, R12 - B callbackasm1(SB) - MOVW $886, R12 - B callbackasm1(SB) - MOVW $887, R12 - B callbackasm1(SB) - MOVW $888, R12 - B callbackasm1(SB) - MOVW $889, R12 - B callbackasm1(SB) - MOVW $890, R12 - B callbackasm1(SB) - MOVW $891, R12 - B callbackasm1(SB) - MOVW $892, R12 - B callbackasm1(SB) - MOVW $893, R12 - B callbackasm1(SB) - MOVW $894, R12 - B callbackasm1(SB) - MOVW $895, R12 - B callbackasm1(SB) - MOVW $896, R12 - B callbackasm1(SB) - MOVW $897, R12 - B callbackasm1(SB) - MOVW $898, R12 - B callbackasm1(SB) - MOVW $899, R12 - B callbackasm1(SB) - MOVW $900, R12 - B callbackasm1(SB) - MOVW $901, R12 - B callbackasm1(SB) - MOVW $902, R12 - B callbackasm1(SB) - MOVW $903, R12 - B callbackasm1(SB) - MOVW $904, R12 - B callbackasm1(SB) - MOVW $905, R12 - B callbackasm1(SB) - MOVW $906, R12 - B callbackasm1(SB) - MOVW $907, R12 - B callbackasm1(SB) - MOVW $908, R12 - B callbackasm1(SB) - MOVW $909, R12 - B callbackasm1(SB) - MOVW $910, R12 - B callbackasm1(SB) - MOVW $911, R12 - B callbackasm1(SB) - MOVW $912, R12 - B callbackasm1(SB) - MOVW $913, R12 - B callbackasm1(SB) - MOVW $914, R12 - B callbackasm1(SB) - MOVW $915, R12 - B callbackasm1(SB) - MOVW $916, R12 - B callbackasm1(SB) - MOVW $917, R12 - B callbackasm1(SB) - MOVW $918, R12 - B callbackasm1(SB) - MOVW $919, R12 - B callbackasm1(SB) - MOVW $920, R12 - B callbackasm1(SB) - MOVW $921, R12 - B callbackasm1(SB) - MOVW $922, R12 - B callbackasm1(SB) - MOVW $923, R12 - B callbackasm1(SB) - MOVW $924, R12 - B callbackasm1(SB) - MOVW $925, R12 - B callbackasm1(SB) - MOVW $926, R12 - B callbackasm1(SB) - MOVW $927, R12 - B callbackasm1(SB) - MOVW $928, R12 - B callbackasm1(SB) - MOVW $929, R12 - B callbackasm1(SB) - MOVW $930, R12 - B callbackasm1(SB) - MOVW $931, R12 - B callbackasm1(SB) - MOVW $932, R12 - B callbackasm1(SB) - MOVW $933, R12 - B callbackasm1(SB) - MOVW $934, R12 - B callbackasm1(SB) - MOVW $935, R12 - B callbackasm1(SB) - MOVW $936, R12 - B callbackasm1(SB) - MOVW $937, R12 - B callbackasm1(SB) - MOVW $938, R12 - B callbackasm1(SB) - MOVW $939, R12 - B callbackasm1(SB) - MOVW $940, R12 - B callbackasm1(SB) - MOVW $941, R12 - B callbackasm1(SB) - MOVW $942, R12 - B callbackasm1(SB) - MOVW $943, R12 - B callbackasm1(SB) - MOVW $944, R12 - B callbackasm1(SB) - MOVW $945, R12 - B callbackasm1(SB) - MOVW $946, R12 - B callbackasm1(SB) - MOVW $947, R12 - B callbackasm1(SB) - MOVW $948, R12 - B callbackasm1(SB) - MOVW $949, R12 - B callbackasm1(SB) - MOVW $950, R12 - B callbackasm1(SB) - MOVW $951, R12 - B callbackasm1(SB) - MOVW $952, R12 - B callbackasm1(SB) - MOVW $953, R12 - B callbackasm1(SB) - MOVW $954, R12 - B callbackasm1(SB) - MOVW $955, R12 - B callbackasm1(SB) - MOVW $956, R12 - B callbackasm1(SB) - MOVW $957, R12 - B callbackasm1(SB) - MOVW $958, R12 - B callbackasm1(SB) - MOVW $959, R12 - B callbackasm1(SB) - MOVW $960, R12 - B callbackasm1(SB) - MOVW $961, R12 - B callbackasm1(SB) - MOVW $962, R12 - B callbackasm1(SB) - MOVW $963, R12 - B callbackasm1(SB) - MOVW $964, R12 - B callbackasm1(SB) - MOVW $965, R12 - B callbackasm1(SB) - MOVW $966, R12 - B callbackasm1(SB) - MOVW $967, R12 - B callbackasm1(SB) - MOVW $968, R12 - B callbackasm1(SB) - MOVW $969, R12 - B callbackasm1(SB) - MOVW $970, R12 - B callbackasm1(SB) - MOVW $971, R12 - B callbackasm1(SB) - MOVW $972, R12 - B callbackasm1(SB) - MOVW $973, R12 - B callbackasm1(SB) - MOVW $974, R12 - B callbackasm1(SB) - MOVW $975, R12 - B callbackasm1(SB) - MOVW $976, R12 - B callbackasm1(SB) - MOVW $977, R12 - B callbackasm1(SB) - MOVW $978, R12 - B callbackasm1(SB) - MOVW $979, R12 - B callbackasm1(SB) - MOVW $980, R12 - B callbackasm1(SB) - MOVW $981, R12 - B callbackasm1(SB) - MOVW $982, R12 - B callbackasm1(SB) - MOVW $983, R12 - B callbackasm1(SB) - MOVW $984, R12 - B callbackasm1(SB) - MOVW $985, R12 - B callbackasm1(SB) - MOVW $986, R12 - B callbackasm1(SB) - MOVW $987, R12 - B callbackasm1(SB) - MOVW $988, R12 - B callbackasm1(SB) - MOVW $989, R12 - B callbackasm1(SB) - MOVW $990, R12 - B callbackasm1(SB) - MOVW $991, R12 - B callbackasm1(SB) - MOVW $992, R12 - B callbackasm1(SB) - MOVW $993, R12 - B callbackasm1(SB) - MOVW $994, R12 - B callbackasm1(SB) - MOVW $995, R12 - B callbackasm1(SB) - MOVW $996, R12 - B callbackasm1(SB) - MOVW $997, R12 - B callbackasm1(SB) - MOVW $998, R12 - B callbackasm1(SB) - MOVW $999, R12 - B callbackasm1(SB) - MOVW $1000, R12 - B callbackasm1(SB) - MOVW $1001, R12 - B callbackasm1(SB) - MOVW $1002, R12 - B callbackasm1(SB) - MOVW $1003, R12 - B callbackasm1(SB) - MOVW $1004, R12 - B callbackasm1(SB) - MOVW $1005, R12 - B callbackasm1(SB) - MOVW $1006, R12 - B callbackasm1(SB) - MOVW $1007, R12 - B callbackasm1(SB) - MOVW $1008, R12 - B callbackasm1(SB) - MOVW $1009, R12 - B callbackasm1(SB) - MOVW $1010, R12 - B callbackasm1(SB) - MOVW $1011, R12 - B callbackasm1(SB) - MOVW $1012, R12 - B callbackasm1(SB) - MOVW $1013, R12 - B callbackasm1(SB) - MOVW $1014, R12 - B callbackasm1(SB) - MOVW $1015, R12 - B callbackasm1(SB) - MOVW $1016, R12 - B callbackasm1(SB) - MOVW $1017, R12 - B callbackasm1(SB) - MOVW $1018, R12 - B callbackasm1(SB) - MOVW $1019, R12 - B callbackasm1(SB) - MOVW $1020, R12 - B callbackasm1(SB) - MOVW $1021, R12 - B callbackasm1(SB) - MOVW $1022, R12 - B callbackasm1(SB) - MOVW $1023, R12 - B callbackasm1(SB) - MOVW $1024, R12 - B callbackasm1(SB) - MOVW $1025, R12 - B callbackasm1(SB) - MOVW $1026, R12 - B callbackasm1(SB) - MOVW $1027, R12 - B callbackasm1(SB) - MOVW $1028, R12 - B callbackasm1(SB) - MOVW $1029, R12 - B callbackasm1(SB) - MOVW $1030, R12 - B callbackasm1(SB) - MOVW $1031, R12 - B callbackasm1(SB) - MOVW $1032, R12 - B callbackasm1(SB) - MOVW $1033, R12 - B callbackasm1(SB) - MOVW $1034, R12 - B callbackasm1(SB) - MOVW $1035, R12 - B callbackasm1(SB) - MOVW $1036, R12 - B callbackasm1(SB) - MOVW $1037, R12 - B callbackasm1(SB) - MOVW $1038, R12 - B callbackasm1(SB) - MOVW $1039, R12 - B callbackasm1(SB) - MOVW $1040, R12 - B callbackasm1(SB) - MOVW $1041, R12 - B callbackasm1(SB) - MOVW $1042, R12 - B callbackasm1(SB) - MOVW $1043, R12 - B callbackasm1(SB) - MOVW $1044, R12 - B callbackasm1(SB) - MOVW $1045, R12 - B callbackasm1(SB) - MOVW $1046, R12 - B callbackasm1(SB) - MOVW $1047, R12 - B callbackasm1(SB) - MOVW $1048, R12 - B callbackasm1(SB) - MOVW $1049, R12 - B callbackasm1(SB) - MOVW $1050, R12 - B callbackasm1(SB) - MOVW $1051, R12 - B callbackasm1(SB) - MOVW $1052, R12 - B callbackasm1(SB) - MOVW $1053, R12 - B callbackasm1(SB) - MOVW $1054, R12 - B callbackasm1(SB) - MOVW $1055, R12 - B callbackasm1(SB) - MOVW $1056, R12 - B callbackasm1(SB) - MOVW $1057, R12 - B callbackasm1(SB) - MOVW $1058, R12 - B callbackasm1(SB) - MOVW $1059, R12 - B callbackasm1(SB) - MOVW $1060, R12 - B callbackasm1(SB) - MOVW $1061, R12 - B callbackasm1(SB) - MOVW $1062, R12 - B callbackasm1(SB) - MOVW $1063, R12 - B callbackasm1(SB) - MOVW $1064, R12 - B callbackasm1(SB) - MOVW $1065, R12 - B callbackasm1(SB) - MOVW $1066, R12 - B callbackasm1(SB) - MOVW $1067, R12 - B callbackasm1(SB) - MOVW $1068, R12 - B callbackasm1(SB) - MOVW $1069, R12 - B callbackasm1(SB) - MOVW $1070, R12 - B callbackasm1(SB) - MOVW $1071, R12 - B callbackasm1(SB) - MOVW $1072, R12 - B callbackasm1(SB) - MOVW $1073, R12 - B callbackasm1(SB) - MOVW $1074, R12 - B callbackasm1(SB) - MOVW $1075, R12 - B callbackasm1(SB) - MOVW $1076, R12 - B callbackasm1(SB) - MOVW $1077, R12 - B callbackasm1(SB) - MOVW $1078, R12 - B callbackasm1(SB) - MOVW $1079, R12 - B callbackasm1(SB) - MOVW $1080, R12 - B callbackasm1(SB) - MOVW $1081, R12 - B callbackasm1(SB) - MOVW $1082, R12 - B callbackasm1(SB) - MOVW $1083, R12 - B callbackasm1(SB) - MOVW $1084, R12 - B callbackasm1(SB) - MOVW $1085, R12 - B callbackasm1(SB) - MOVW $1086, R12 - B callbackasm1(SB) - MOVW $1087, R12 - B callbackasm1(SB) - MOVW $1088, R12 - B callbackasm1(SB) - MOVW $1089, R12 - B callbackasm1(SB) - MOVW $1090, R12 - B callbackasm1(SB) - MOVW $1091, R12 - B callbackasm1(SB) - MOVW $1092, R12 - B callbackasm1(SB) - MOVW $1093, R12 - B callbackasm1(SB) - MOVW $1094, R12 - B callbackasm1(SB) - MOVW $1095, R12 - B callbackasm1(SB) - MOVW $1096, R12 - B callbackasm1(SB) - MOVW $1097, R12 - B callbackasm1(SB) - MOVW $1098, R12 - B callbackasm1(SB) - MOVW $1099, R12 - B callbackasm1(SB) - MOVW $1100, R12 - B callbackasm1(SB) - MOVW $1101, R12 - B callbackasm1(SB) - MOVW $1102, R12 - B callbackasm1(SB) - MOVW $1103, R12 - B callbackasm1(SB) - MOVW $1104, R12 - B callbackasm1(SB) - MOVW $1105, R12 - B callbackasm1(SB) - MOVW $1106, R12 - B callbackasm1(SB) - MOVW $1107, R12 - B callbackasm1(SB) - MOVW $1108, R12 - B callbackasm1(SB) - MOVW $1109, R12 - B callbackasm1(SB) - MOVW $1110, R12 - B callbackasm1(SB) - MOVW $1111, R12 - B callbackasm1(SB) - MOVW $1112, R12 - B callbackasm1(SB) - MOVW $1113, R12 - B callbackasm1(SB) - MOVW $1114, R12 - B callbackasm1(SB) - MOVW $1115, R12 - B callbackasm1(SB) - MOVW $1116, R12 - B callbackasm1(SB) - MOVW $1117, R12 - B callbackasm1(SB) - MOVW $1118, R12 - B callbackasm1(SB) - MOVW $1119, R12 - B callbackasm1(SB) - MOVW $1120, R12 - B callbackasm1(SB) - MOVW $1121, R12 - B callbackasm1(SB) - MOVW $1122, R12 - B callbackasm1(SB) - MOVW $1123, R12 - B callbackasm1(SB) - MOVW $1124, R12 - B callbackasm1(SB) - MOVW $1125, R12 - B callbackasm1(SB) - MOVW $1126, R12 - B callbackasm1(SB) - MOVW $1127, R12 - B callbackasm1(SB) - MOVW $1128, R12 - B callbackasm1(SB) - MOVW $1129, R12 - B callbackasm1(SB) - MOVW $1130, R12 - B callbackasm1(SB) - MOVW $1131, R12 - B callbackasm1(SB) - MOVW $1132, R12 - B callbackasm1(SB) - MOVW $1133, R12 - B callbackasm1(SB) - MOVW $1134, R12 - B callbackasm1(SB) - MOVW $1135, R12 - B callbackasm1(SB) - MOVW $1136, R12 - B callbackasm1(SB) - MOVW $1137, R12 - B callbackasm1(SB) - MOVW $1138, R12 - B callbackasm1(SB) - MOVW $1139, R12 - B callbackasm1(SB) - MOVW $1140, R12 - B callbackasm1(SB) - MOVW $1141, R12 - B callbackasm1(SB) - MOVW $1142, R12 - B callbackasm1(SB) - MOVW $1143, R12 - B callbackasm1(SB) - MOVW $1144, R12 - B callbackasm1(SB) - MOVW $1145, R12 - B callbackasm1(SB) - MOVW $1146, R12 - B callbackasm1(SB) - MOVW $1147, R12 - B callbackasm1(SB) - MOVW $1148, R12 - B callbackasm1(SB) - MOVW $1149, R12 - B callbackasm1(SB) - MOVW $1150, R12 - B callbackasm1(SB) - MOVW $1151, R12 - B callbackasm1(SB) - MOVW $1152, R12 - B callbackasm1(SB) - MOVW $1153, R12 - B callbackasm1(SB) - MOVW $1154, R12 - B callbackasm1(SB) - MOVW $1155, R12 - B callbackasm1(SB) - MOVW $1156, R12 - B callbackasm1(SB) - MOVW $1157, R12 - B callbackasm1(SB) - MOVW $1158, R12 - B callbackasm1(SB) - MOVW $1159, R12 - B callbackasm1(SB) - MOVW $1160, R12 - B callbackasm1(SB) - MOVW $1161, R12 - B callbackasm1(SB) - MOVW $1162, R12 - B callbackasm1(SB) - MOVW $1163, R12 - B callbackasm1(SB) - MOVW $1164, R12 - B callbackasm1(SB) - MOVW $1165, R12 - B callbackasm1(SB) - MOVW $1166, R12 - B callbackasm1(SB) - MOVW $1167, R12 - B callbackasm1(SB) - MOVW $1168, R12 - B callbackasm1(SB) - MOVW $1169, R12 - B callbackasm1(SB) - MOVW $1170, R12 - B callbackasm1(SB) - MOVW $1171, R12 - B callbackasm1(SB) - MOVW $1172, R12 - B callbackasm1(SB) - MOVW $1173, R12 - B callbackasm1(SB) - MOVW $1174, R12 - B callbackasm1(SB) - MOVW $1175, R12 - B callbackasm1(SB) - MOVW $1176, R12 - B callbackasm1(SB) - MOVW $1177, R12 - B callbackasm1(SB) - MOVW $1178, R12 - B callbackasm1(SB) - MOVW $1179, R12 - B callbackasm1(SB) - MOVW $1180, R12 - B callbackasm1(SB) - MOVW $1181, R12 - B callbackasm1(SB) - MOVW $1182, R12 - B callbackasm1(SB) - MOVW $1183, R12 - B callbackasm1(SB) - MOVW $1184, R12 - B callbackasm1(SB) - MOVW $1185, R12 - B callbackasm1(SB) - MOVW $1186, R12 - B callbackasm1(SB) - MOVW $1187, R12 - B callbackasm1(SB) - MOVW $1188, R12 - B callbackasm1(SB) - MOVW $1189, R12 - B callbackasm1(SB) - MOVW $1190, R12 - B callbackasm1(SB) - MOVW $1191, R12 - B callbackasm1(SB) - MOVW $1192, R12 - B callbackasm1(SB) - MOVW $1193, R12 - B callbackasm1(SB) - MOVW $1194, R12 - B callbackasm1(SB) - MOVW $1195, R12 - B callbackasm1(SB) - MOVW $1196, R12 - B callbackasm1(SB) - MOVW $1197, R12 - B callbackasm1(SB) - MOVW $1198, R12 - B callbackasm1(SB) - MOVW $1199, R12 - B callbackasm1(SB) - MOVW $1200, R12 - B callbackasm1(SB) - MOVW $1201, R12 - B callbackasm1(SB) - MOVW $1202, R12 - B callbackasm1(SB) - MOVW $1203, R12 - B callbackasm1(SB) - MOVW $1204, R12 - B callbackasm1(SB) - MOVW $1205, R12 - B callbackasm1(SB) - MOVW $1206, R12 - B callbackasm1(SB) - MOVW $1207, R12 - B callbackasm1(SB) - MOVW $1208, R12 - B callbackasm1(SB) - MOVW $1209, R12 - B callbackasm1(SB) - MOVW $1210, R12 - B callbackasm1(SB) - MOVW $1211, R12 - B callbackasm1(SB) - MOVW $1212, R12 - B callbackasm1(SB) - MOVW $1213, R12 - B callbackasm1(SB) - MOVW $1214, R12 - B callbackasm1(SB) - MOVW $1215, R12 - B callbackasm1(SB) - MOVW $1216, R12 - B callbackasm1(SB) - MOVW $1217, R12 - B callbackasm1(SB) - MOVW $1218, R12 - B callbackasm1(SB) - MOVW $1219, R12 - B callbackasm1(SB) - MOVW $1220, R12 - B callbackasm1(SB) - MOVW $1221, R12 - B callbackasm1(SB) - MOVW $1222, R12 - B callbackasm1(SB) - MOVW $1223, R12 - B callbackasm1(SB) - MOVW $1224, R12 - B callbackasm1(SB) - MOVW $1225, R12 - B callbackasm1(SB) - MOVW $1226, R12 - B callbackasm1(SB) - MOVW $1227, R12 - B callbackasm1(SB) - MOVW $1228, R12 - B callbackasm1(SB) - MOVW $1229, R12 - B callbackasm1(SB) - MOVW $1230, R12 - B callbackasm1(SB) - MOVW $1231, R12 - B callbackasm1(SB) - MOVW $1232, R12 - B callbackasm1(SB) - MOVW $1233, R12 - B callbackasm1(SB) - MOVW $1234, R12 - B callbackasm1(SB) - MOVW $1235, R12 - B callbackasm1(SB) - MOVW $1236, R12 - B callbackasm1(SB) - MOVW $1237, R12 - B callbackasm1(SB) - MOVW $1238, R12 - B callbackasm1(SB) - MOVW $1239, R12 - B callbackasm1(SB) - MOVW $1240, R12 - B callbackasm1(SB) - MOVW $1241, R12 - B callbackasm1(SB) - MOVW $1242, R12 - B callbackasm1(SB) - MOVW $1243, R12 - B callbackasm1(SB) - MOVW $1244, R12 - B callbackasm1(SB) - MOVW $1245, R12 - B callbackasm1(SB) - MOVW $1246, R12 - B callbackasm1(SB) - MOVW $1247, R12 - B callbackasm1(SB) - MOVW $1248, R12 - B callbackasm1(SB) - MOVW $1249, R12 - B callbackasm1(SB) - MOVW $1250, R12 - B callbackasm1(SB) - MOVW $1251, R12 - B callbackasm1(SB) - MOVW $1252, R12 - B callbackasm1(SB) - MOVW $1253, R12 - B callbackasm1(SB) - MOVW $1254, R12 - B callbackasm1(SB) - MOVW $1255, R12 - B callbackasm1(SB) - MOVW $1256, R12 - B callbackasm1(SB) - MOVW $1257, R12 - B callbackasm1(SB) - MOVW $1258, R12 - B callbackasm1(SB) - MOVW $1259, R12 - B callbackasm1(SB) - MOVW $1260, R12 - B callbackasm1(SB) - MOVW $1261, R12 - B callbackasm1(SB) - MOVW $1262, R12 - B callbackasm1(SB) - MOVW $1263, R12 - B callbackasm1(SB) - MOVW $1264, R12 - B callbackasm1(SB) - MOVW $1265, R12 - B callbackasm1(SB) - MOVW $1266, R12 - B callbackasm1(SB) - MOVW $1267, R12 - B callbackasm1(SB) - MOVW $1268, R12 - B callbackasm1(SB) - MOVW $1269, R12 - B callbackasm1(SB) - MOVW $1270, R12 - B callbackasm1(SB) - MOVW $1271, R12 - B callbackasm1(SB) - MOVW $1272, R12 - B callbackasm1(SB) - MOVW $1273, R12 - B callbackasm1(SB) - MOVW $1274, R12 - B callbackasm1(SB) - MOVW $1275, R12 - B callbackasm1(SB) - MOVW $1276, R12 - B callbackasm1(SB) - MOVW $1277, R12 - B callbackasm1(SB) - MOVW $1278, R12 - B callbackasm1(SB) - MOVW $1279, R12 - B callbackasm1(SB) - MOVW $1280, R12 - B callbackasm1(SB) - MOVW $1281, R12 - B callbackasm1(SB) - MOVW $1282, R12 - B callbackasm1(SB) - MOVW $1283, R12 - B callbackasm1(SB) - MOVW $1284, R12 - B callbackasm1(SB) - MOVW $1285, R12 - B callbackasm1(SB) - MOVW $1286, R12 - B callbackasm1(SB) - MOVW $1287, R12 - B callbackasm1(SB) - MOVW $1288, R12 - B callbackasm1(SB) - MOVW $1289, R12 - B callbackasm1(SB) - MOVW $1290, R12 - B callbackasm1(SB) - MOVW $1291, R12 - B callbackasm1(SB) - MOVW $1292, R12 - B callbackasm1(SB) - MOVW $1293, R12 - B callbackasm1(SB) - MOVW $1294, R12 - B callbackasm1(SB) - MOVW $1295, R12 - B callbackasm1(SB) - MOVW $1296, R12 - B callbackasm1(SB) - MOVW $1297, R12 - B callbackasm1(SB) - MOVW $1298, R12 - B callbackasm1(SB) - MOVW $1299, R12 - B callbackasm1(SB) - MOVW $1300, R12 - B callbackasm1(SB) - MOVW $1301, R12 - B callbackasm1(SB) - MOVW $1302, R12 - B callbackasm1(SB) - MOVW $1303, R12 - B callbackasm1(SB) - MOVW $1304, R12 - B callbackasm1(SB) - MOVW $1305, R12 - B callbackasm1(SB) - MOVW $1306, R12 - B callbackasm1(SB) - MOVW $1307, R12 - B callbackasm1(SB) - MOVW $1308, R12 - B callbackasm1(SB) - MOVW $1309, R12 - B callbackasm1(SB) - MOVW $1310, R12 - B callbackasm1(SB) - MOVW $1311, R12 - B callbackasm1(SB) - MOVW $1312, R12 - B callbackasm1(SB) - MOVW $1313, R12 - B callbackasm1(SB) - MOVW $1314, R12 - B callbackasm1(SB) - MOVW $1315, R12 - B callbackasm1(SB) - MOVW $1316, R12 - B callbackasm1(SB) - MOVW $1317, R12 - B callbackasm1(SB) - MOVW $1318, R12 - B callbackasm1(SB) - MOVW $1319, R12 - B callbackasm1(SB) - MOVW $1320, R12 - B callbackasm1(SB) - MOVW $1321, R12 - B callbackasm1(SB) - MOVW $1322, R12 - B callbackasm1(SB) - MOVW $1323, R12 - B callbackasm1(SB) - MOVW $1324, R12 - B callbackasm1(SB) - MOVW $1325, R12 - B callbackasm1(SB) - MOVW $1326, R12 - B callbackasm1(SB) - MOVW $1327, R12 - B callbackasm1(SB) - MOVW $1328, R12 - B callbackasm1(SB) - MOVW $1329, R12 - B callbackasm1(SB) - MOVW $1330, R12 - B callbackasm1(SB) - MOVW $1331, R12 - B callbackasm1(SB) - MOVW $1332, R12 - B callbackasm1(SB) - MOVW $1333, R12 - B callbackasm1(SB) - MOVW $1334, R12 - B callbackasm1(SB) - MOVW $1335, R12 - B callbackasm1(SB) - MOVW $1336, R12 - B callbackasm1(SB) - MOVW $1337, R12 - B callbackasm1(SB) - MOVW $1338, R12 - B callbackasm1(SB) - MOVW $1339, R12 - B callbackasm1(SB) - MOVW $1340, R12 - B callbackasm1(SB) - MOVW $1341, R12 - B callbackasm1(SB) - MOVW $1342, R12 - B callbackasm1(SB) - MOVW $1343, R12 - B callbackasm1(SB) - MOVW $1344, R12 - B callbackasm1(SB) - MOVW $1345, R12 - B callbackasm1(SB) - MOVW $1346, R12 - B callbackasm1(SB) - MOVW $1347, R12 - B callbackasm1(SB) - MOVW $1348, R12 - B callbackasm1(SB) - MOVW $1349, R12 - B callbackasm1(SB) - MOVW $1350, R12 - B callbackasm1(SB) - MOVW $1351, R12 - B callbackasm1(SB) - MOVW $1352, R12 - B callbackasm1(SB) - MOVW $1353, R12 - B callbackasm1(SB) - MOVW $1354, R12 - B callbackasm1(SB) - MOVW $1355, R12 - B callbackasm1(SB) - MOVW $1356, R12 - B callbackasm1(SB) - MOVW $1357, R12 - B callbackasm1(SB) - MOVW $1358, R12 - B callbackasm1(SB) - MOVW $1359, R12 - B callbackasm1(SB) - MOVW $1360, R12 - B callbackasm1(SB) - MOVW $1361, R12 - B callbackasm1(SB) - MOVW $1362, R12 - B callbackasm1(SB) - MOVW $1363, R12 - B callbackasm1(SB) - MOVW $1364, R12 - B callbackasm1(SB) - MOVW $1365, R12 - B callbackasm1(SB) - MOVW $1366, R12 - B callbackasm1(SB) - MOVW $1367, R12 - B callbackasm1(SB) - MOVW $1368, R12 - B callbackasm1(SB) - MOVW $1369, R12 - B callbackasm1(SB) - MOVW $1370, R12 - B callbackasm1(SB) - MOVW $1371, R12 - B callbackasm1(SB) - MOVW $1372, R12 - B callbackasm1(SB) - MOVW $1373, R12 - B callbackasm1(SB) - MOVW $1374, R12 - B callbackasm1(SB) - MOVW $1375, R12 - B callbackasm1(SB) - MOVW $1376, R12 - B callbackasm1(SB) - MOVW $1377, R12 - B callbackasm1(SB) - MOVW $1378, R12 - B callbackasm1(SB) - MOVW $1379, R12 - B callbackasm1(SB) - MOVW $1380, R12 - B callbackasm1(SB) - MOVW $1381, R12 - B callbackasm1(SB) - MOVW $1382, R12 - B callbackasm1(SB) - MOVW $1383, R12 - B callbackasm1(SB) - MOVW $1384, R12 - B callbackasm1(SB) - MOVW $1385, R12 - B callbackasm1(SB) - MOVW $1386, R12 - B callbackasm1(SB) - MOVW $1387, R12 - B callbackasm1(SB) - MOVW $1388, R12 - B callbackasm1(SB) - MOVW $1389, R12 - B callbackasm1(SB) - MOVW $1390, R12 - B callbackasm1(SB) - MOVW $1391, R12 - B callbackasm1(SB) - MOVW $1392, R12 - B callbackasm1(SB) - MOVW $1393, R12 - B callbackasm1(SB) - MOVW $1394, R12 - B callbackasm1(SB) - MOVW $1395, R12 - B callbackasm1(SB) - MOVW $1396, R12 - B callbackasm1(SB) - MOVW $1397, R12 - B callbackasm1(SB) - MOVW $1398, R12 - B callbackasm1(SB) - MOVW $1399, R12 - B callbackasm1(SB) - MOVW $1400, R12 - B callbackasm1(SB) - MOVW $1401, R12 - B callbackasm1(SB) - MOVW $1402, R12 - B callbackasm1(SB) - MOVW $1403, R12 - B callbackasm1(SB) - MOVW $1404, R12 - B callbackasm1(SB) - MOVW $1405, R12 - B callbackasm1(SB) - MOVW $1406, R12 - B callbackasm1(SB) - MOVW $1407, R12 - B callbackasm1(SB) - MOVW $1408, R12 - B callbackasm1(SB) - MOVW $1409, R12 - B callbackasm1(SB) - MOVW $1410, R12 - B callbackasm1(SB) - MOVW $1411, R12 - B callbackasm1(SB) - MOVW $1412, R12 - B callbackasm1(SB) - MOVW $1413, R12 - B callbackasm1(SB) - MOVW $1414, R12 - B callbackasm1(SB) - MOVW $1415, R12 - B callbackasm1(SB) - MOVW $1416, R12 - B callbackasm1(SB) - MOVW $1417, R12 - B callbackasm1(SB) - MOVW $1418, R12 - B callbackasm1(SB) - MOVW $1419, R12 - B callbackasm1(SB) - MOVW $1420, R12 - B callbackasm1(SB) - MOVW $1421, R12 - B callbackasm1(SB) - MOVW $1422, R12 - B callbackasm1(SB) - MOVW $1423, R12 - B callbackasm1(SB) - MOVW $1424, R12 - B callbackasm1(SB) - MOVW $1425, R12 - B callbackasm1(SB) - MOVW $1426, R12 - B callbackasm1(SB) - MOVW $1427, R12 - B callbackasm1(SB) - MOVW $1428, R12 - B callbackasm1(SB) - MOVW $1429, R12 - B callbackasm1(SB) - MOVW $1430, R12 - B callbackasm1(SB) - MOVW $1431, R12 - B callbackasm1(SB) - MOVW $1432, R12 - B callbackasm1(SB) - MOVW $1433, R12 - B callbackasm1(SB) - MOVW $1434, R12 - B callbackasm1(SB) - MOVW $1435, R12 - B callbackasm1(SB) - MOVW $1436, R12 - B callbackasm1(SB) - MOVW $1437, R12 - B callbackasm1(SB) - MOVW $1438, R12 - B callbackasm1(SB) - MOVW $1439, R12 - B callbackasm1(SB) - MOVW $1440, R12 - B callbackasm1(SB) - MOVW $1441, R12 - B callbackasm1(SB) - MOVW $1442, R12 - B callbackasm1(SB) - MOVW $1443, R12 - B callbackasm1(SB) - MOVW $1444, R12 - B callbackasm1(SB) - MOVW $1445, R12 - B callbackasm1(SB) - MOVW $1446, R12 - B callbackasm1(SB) - MOVW $1447, R12 - B callbackasm1(SB) - MOVW $1448, R12 - B callbackasm1(SB) - MOVW $1449, R12 - B callbackasm1(SB) - MOVW $1450, R12 - B callbackasm1(SB) - MOVW $1451, R12 - B callbackasm1(SB) - MOVW $1452, R12 - B callbackasm1(SB) - MOVW $1453, R12 - B callbackasm1(SB) - MOVW $1454, R12 - B callbackasm1(SB) - MOVW $1455, R12 - B callbackasm1(SB) - MOVW $1456, R12 - B callbackasm1(SB) - MOVW $1457, R12 - B callbackasm1(SB) - MOVW $1458, R12 - B callbackasm1(SB) - MOVW $1459, R12 - B callbackasm1(SB) - MOVW $1460, R12 - B callbackasm1(SB) - MOVW $1461, R12 - B callbackasm1(SB) - MOVW $1462, R12 - B callbackasm1(SB) - MOVW $1463, R12 - B callbackasm1(SB) - MOVW $1464, R12 - B callbackasm1(SB) - MOVW $1465, R12 - B callbackasm1(SB) - MOVW $1466, R12 - B callbackasm1(SB) - MOVW $1467, R12 - B callbackasm1(SB) - MOVW $1468, R12 - B callbackasm1(SB) - MOVW $1469, R12 - B callbackasm1(SB) - MOVW $1470, R12 - B callbackasm1(SB) - MOVW $1471, R12 - B callbackasm1(SB) - MOVW $1472, R12 - B callbackasm1(SB) - MOVW $1473, R12 - B callbackasm1(SB) - MOVW $1474, R12 - B callbackasm1(SB) - MOVW $1475, R12 - B callbackasm1(SB) - MOVW $1476, R12 - B callbackasm1(SB) - MOVW $1477, R12 - B callbackasm1(SB) - MOVW $1478, R12 - B callbackasm1(SB) - MOVW $1479, R12 - B callbackasm1(SB) - MOVW $1480, R12 - B callbackasm1(SB) - MOVW $1481, R12 - B callbackasm1(SB) - MOVW $1482, R12 - B callbackasm1(SB) - MOVW $1483, R12 - B callbackasm1(SB) - MOVW $1484, R12 - B callbackasm1(SB) - MOVW $1485, R12 - B callbackasm1(SB) - MOVW $1486, R12 - B callbackasm1(SB) - MOVW $1487, R12 - B callbackasm1(SB) - MOVW $1488, R12 - B callbackasm1(SB) - MOVW $1489, R12 - B callbackasm1(SB) - MOVW $1490, R12 - B callbackasm1(SB) - MOVW $1491, R12 - B callbackasm1(SB) - MOVW $1492, R12 - B callbackasm1(SB) - MOVW $1493, R12 - B callbackasm1(SB) - MOVW $1494, R12 - B callbackasm1(SB) - MOVW $1495, R12 - B callbackasm1(SB) - MOVW $1496, R12 - B callbackasm1(SB) - MOVW $1497, R12 - B callbackasm1(SB) - MOVW $1498, R12 - B callbackasm1(SB) - MOVW $1499, R12 - B callbackasm1(SB) - MOVW $1500, R12 - B callbackasm1(SB) - MOVW $1501, R12 - B callbackasm1(SB) - MOVW $1502, R12 - B callbackasm1(SB) - MOVW $1503, R12 - B callbackasm1(SB) - MOVW $1504, R12 - B callbackasm1(SB) - MOVW $1505, R12 - B callbackasm1(SB) - MOVW $1506, R12 - B callbackasm1(SB) - MOVW $1507, R12 - B callbackasm1(SB) - MOVW $1508, R12 - B callbackasm1(SB) - MOVW $1509, R12 - B callbackasm1(SB) - MOVW $1510, R12 - B callbackasm1(SB) - MOVW $1511, R12 - B callbackasm1(SB) - MOVW $1512, R12 - B callbackasm1(SB) - MOVW $1513, R12 - B callbackasm1(SB) - MOVW $1514, R12 - B callbackasm1(SB) - MOVW $1515, R12 - B callbackasm1(SB) - MOVW $1516, R12 - B callbackasm1(SB) - MOVW $1517, R12 - B callbackasm1(SB) - MOVW $1518, R12 - B callbackasm1(SB) - MOVW $1519, R12 - B callbackasm1(SB) - MOVW $1520, R12 - B callbackasm1(SB) - MOVW $1521, R12 - B callbackasm1(SB) - MOVW $1522, R12 - B callbackasm1(SB) - MOVW $1523, R12 - B callbackasm1(SB) - MOVW $1524, R12 - B callbackasm1(SB) - MOVW $1525, R12 - B callbackasm1(SB) - MOVW $1526, R12 - B callbackasm1(SB) - MOVW $1527, R12 - B callbackasm1(SB) - MOVW $1528, R12 - B callbackasm1(SB) - MOVW $1529, R12 - B callbackasm1(SB) - MOVW $1530, R12 - B callbackasm1(SB) - MOVW $1531, R12 - B callbackasm1(SB) - MOVW $1532, R12 - B callbackasm1(SB) - MOVW $1533, R12 - B callbackasm1(SB) - MOVW $1534, R12 - B callbackasm1(SB) - MOVW $1535, R12 - B callbackasm1(SB) - MOVW $1536, R12 - B callbackasm1(SB) - MOVW $1537, R12 - B callbackasm1(SB) - MOVW $1538, R12 - B callbackasm1(SB) - MOVW $1539, R12 - B callbackasm1(SB) - MOVW $1540, R12 - B callbackasm1(SB) - MOVW $1541, R12 - B callbackasm1(SB) - MOVW $1542, R12 - B callbackasm1(SB) - MOVW $1543, R12 - B callbackasm1(SB) - MOVW $1544, R12 - B callbackasm1(SB) - MOVW $1545, R12 - B callbackasm1(SB) - MOVW $1546, R12 - B callbackasm1(SB) - MOVW $1547, R12 - B callbackasm1(SB) - MOVW $1548, R12 - B callbackasm1(SB) - MOVW $1549, R12 - B callbackasm1(SB) - MOVW $1550, R12 - B callbackasm1(SB) - MOVW $1551, R12 - B callbackasm1(SB) - MOVW $1552, R12 - B callbackasm1(SB) - MOVW $1553, R12 - B callbackasm1(SB) - MOVW $1554, R12 - B callbackasm1(SB) - MOVW $1555, R12 - B callbackasm1(SB) - MOVW $1556, R12 - B callbackasm1(SB) - MOVW $1557, R12 - B callbackasm1(SB) - MOVW $1558, R12 - B callbackasm1(SB) - MOVW $1559, R12 - B callbackasm1(SB) - MOVW $1560, R12 - B callbackasm1(SB) - MOVW $1561, R12 - B callbackasm1(SB) - MOVW $1562, R12 - B callbackasm1(SB) - MOVW $1563, R12 - B callbackasm1(SB) - MOVW $1564, R12 - B callbackasm1(SB) - MOVW $1565, R12 - B callbackasm1(SB) - MOVW $1566, R12 - B callbackasm1(SB) - MOVW $1567, R12 - B callbackasm1(SB) - MOVW $1568, R12 - B callbackasm1(SB) - MOVW $1569, R12 - B callbackasm1(SB) - MOVW $1570, R12 - B callbackasm1(SB) - MOVW $1571, R12 - B callbackasm1(SB) - MOVW $1572, R12 - B callbackasm1(SB) - MOVW $1573, R12 - B callbackasm1(SB) - MOVW $1574, R12 - B callbackasm1(SB) - MOVW $1575, R12 - B callbackasm1(SB) - MOVW $1576, R12 - B callbackasm1(SB) - MOVW $1577, R12 - B callbackasm1(SB) - MOVW $1578, R12 - B callbackasm1(SB) - MOVW $1579, R12 - B callbackasm1(SB) - MOVW $1580, R12 - B callbackasm1(SB) - MOVW $1581, R12 - B callbackasm1(SB) - MOVW $1582, R12 - B callbackasm1(SB) - MOVW $1583, R12 - B callbackasm1(SB) - MOVW $1584, R12 - B callbackasm1(SB) - MOVW $1585, R12 - B callbackasm1(SB) - MOVW $1586, R12 - B callbackasm1(SB) - MOVW $1587, R12 - B callbackasm1(SB) - MOVW $1588, R12 - B callbackasm1(SB) - MOVW $1589, R12 - B callbackasm1(SB) - MOVW $1590, R12 - B callbackasm1(SB) - MOVW $1591, R12 - B callbackasm1(SB) - MOVW $1592, R12 - B callbackasm1(SB) - MOVW $1593, R12 - B callbackasm1(SB) - MOVW $1594, R12 - B callbackasm1(SB) - MOVW $1595, R12 - B callbackasm1(SB) - MOVW $1596, R12 - B callbackasm1(SB) - MOVW $1597, R12 - B callbackasm1(SB) - MOVW $1598, R12 - B callbackasm1(SB) - MOVW $1599, R12 - B callbackasm1(SB) - MOVW $1600, R12 - B callbackasm1(SB) - MOVW $1601, R12 - B callbackasm1(SB) - MOVW $1602, R12 - B callbackasm1(SB) - MOVW $1603, R12 - B callbackasm1(SB) - MOVW $1604, R12 - B callbackasm1(SB) - MOVW $1605, R12 - B callbackasm1(SB) - MOVW $1606, R12 - B callbackasm1(SB) - MOVW $1607, R12 - B callbackasm1(SB) - MOVW $1608, R12 - B callbackasm1(SB) - MOVW $1609, R12 - B callbackasm1(SB) - MOVW $1610, R12 - B callbackasm1(SB) - MOVW $1611, R12 - B callbackasm1(SB) - MOVW $1612, R12 - B callbackasm1(SB) - MOVW $1613, R12 - B callbackasm1(SB) - MOVW $1614, R12 - B callbackasm1(SB) - MOVW $1615, R12 - B callbackasm1(SB) - MOVW $1616, R12 - B callbackasm1(SB) - MOVW $1617, R12 - B callbackasm1(SB) - MOVW $1618, R12 - B callbackasm1(SB) - MOVW $1619, R12 - B callbackasm1(SB) - MOVW $1620, R12 - B callbackasm1(SB) - MOVW $1621, R12 - B callbackasm1(SB) - MOVW $1622, R12 - B callbackasm1(SB) - MOVW $1623, R12 - B callbackasm1(SB) - MOVW $1624, R12 - B callbackasm1(SB) - MOVW $1625, R12 - B callbackasm1(SB) - MOVW $1626, R12 - B callbackasm1(SB) - MOVW $1627, R12 - B callbackasm1(SB) - MOVW $1628, R12 - B callbackasm1(SB) - MOVW $1629, R12 - B callbackasm1(SB) - MOVW $1630, R12 - B callbackasm1(SB) - MOVW $1631, R12 - B callbackasm1(SB) - MOVW $1632, R12 - B callbackasm1(SB) - MOVW $1633, R12 - B callbackasm1(SB) - MOVW $1634, R12 - B callbackasm1(SB) - MOVW $1635, R12 - B callbackasm1(SB) - MOVW $1636, R12 - B callbackasm1(SB) - MOVW $1637, R12 - B callbackasm1(SB) - MOVW $1638, R12 - B callbackasm1(SB) - MOVW $1639, R12 - B callbackasm1(SB) - MOVW $1640, R12 - B callbackasm1(SB) - MOVW $1641, R12 - B callbackasm1(SB) - MOVW $1642, R12 - B callbackasm1(SB) - MOVW $1643, R12 - B callbackasm1(SB) - MOVW $1644, R12 - B callbackasm1(SB) - MOVW $1645, R12 - B callbackasm1(SB) - MOVW $1646, R12 - B callbackasm1(SB) - MOVW $1647, R12 - B callbackasm1(SB) - MOVW $1648, R12 - B callbackasm1(SB) - MOVW $1649, R12 - B callbackasm1(SB) - MOVW $1650, R12 - B callbackasm1(SB) - MOVW $1651, R12 - B callbackasm1(SB) - MOVW $1652, R12 - B callbackasm1(SB) - MOVW $1653, R12 - B callbackasm1(SB) - MOVW $1654, R12 - B callbackasm1(SB) - MOVW $1655, R12 - B callbackasm1(SB) - MOVW $1656, R12 - B callbackasm1(SB) - MOVW $1657, R12 - B callbackasm1(SB) - MOVW $1658, R12 - B callbackasm1(SB) - MOVW $1659, R12 - B callbackasm1(SB) - MOVW $1660, R12 - B callbackasm1(SB) - MOVW $1661, R12 - B callbackasm1(SB) - MOVW $1662, R12 - B callbackasm1(SB) - MOVW $1663, R12 - B callbackasm1(SB) - MOVW $1664, R12 - B callbackasm1(SB) - MOVW $1665, R12 - B callbackasm1(SB) - MOVW $1666, R12 - B callbackasm1(SB) - MOVW $1667, R12 - B callbackasm1(SB) - MOVW $1668, R12 - B callbackasm1(SB) - MOVW $1669, R12 - B callbackasm1(SB) - MOVW $1670, R12 - B callbackasm1(SB) - MOVW $1671, R12 - B callbackasm1(SB) - MOVW $1672, R12 - B callbackasm1(SB) - MOVW $1673, R12 - B callbackasm1(SB) - MOVW $1674, R12 - B callbackasm1(SB) - MOVW $1675, R12 - B callbackasm1(SB) - MOVW $1676, R12 - B callbackasm1(SB) - MOVW $1677, R12 - B callbackasm1(SB) - MOVW $1678, R12 - B callbackasm1(SB) - MOVW $1679, R12 - B callbackasm1(SB) - MOVW $1680, R12 - B callbackasm1(SB) - MOVW $1681, R12 - B callbackasm1(SB) - MOVW $1682, R12 - B callbackasm1(SB) - MOVW $1683, R12 - B callbackasm1(SB) - MOVW $1684, R12 - B callbackasm1(SB) - MOVW $1685, R12 - B callbackasm1(SB) - MOVW $1686, R12 - B callbackasm1(SB) - MOVW $1687, R12 - B callbackasm1(SB) - MOVW $1688, R12 - B callbackasm1(SB) - MOVW $1689, R12 - B callbackasm1(SB) - MOVW $1690, R12 - B callbackasm1(SB) - MOVW $1691, R12 - B callbackasm1(SB) - MOVW $1692, R12 - B callbackasm1(SB) - MOVW $1693, R12 - B callbackasm1(SB) - MOVW $1694, R12 - B callbackasm1(SB) - MOVW $1695, R12 - B callbackasm1(SB) - MOVW $1696, R12 - B callbackasm1(SB) - MOVW $1697, R12 - B callbackasm1(SB) - MOVW $1698, R12 - B callbackasm1(SB) - MOVW $1699, R12 - B callbackasm1(SB) - MOVW $1700, R12 - B callbackasm1(SB) - MOVW $1701, R12 - B callbackasm1(SB) - MOVW $1702, R12 - B callbackasm1(SB) - MOVW $1703, R12 - B callbackasm1(SB) - MOVW $1704, R12 - B callbackasm1(SB) - MOVW $1705, R12 - B callbackasm1(SB) - MOVW $1706, R12 - B callbackasm1(SB) - MOVW $1707, R12 - B callbackasm1(SB) - MOVW $1708, R12 - B callbackasm1(SB) - MOVW $1709, R12 - B callbackasm1(SB) - MOVW $1710, R12 - B callbackasm1(SB) - MOVW $1711, R12 - B callbackasm1(SB) - MOVW $1712, R12 - B callbackasm1(SB) - MOVW $1713, R12 - B callbackasm1(SB) - MOVW $1714, R12 - B callbackasm1(SB) - MOVW $1715, R12 - B callbackasm1(SB) - MOVW $1716, R12 - B callbackasm1(SB) - MOVW $1717, R12 - B callbackasm1(SB) - MOVW $1718, R12 - B callbackasm1(SB) - MOVW $1719, R12 - B callbackasm1(SB) - MOVW $1720, R12 - B callbackasm1(SB) - MOVW $1721, R12 - B callbackasm1(SB) - MOVW $1722, R12 - B callbackasm1(SB) - MOVW $1723, R12 - B callbackasm1(SB) - MOVW $1724, R12 - B callbackasm1(SB) - MOVW $1725, R12 - B callbackasm1(SB) - MOVW $1726, R12 - B callbackasm1(SB) - MOVW $1727, R12 - B callbackasm1(SB) - MOVW $1728, R12 - B callbackasm1(SB) - MOVW $1729, R12 - B callbackasm1(SB) - MOVW $1730, R12 - B callbackasm1(SB) - MOVW $1731, R12 - B callbackasm1(SB) - MOVW $1732, R12 - B callbackasm1(SB) - MOVW $1733, R12 - B callbackasm1(SB) - MOVW $1734, R12 - B callbackasm1(SB) - MOVW $1735, R12 - B callbackasm1(SB) - MOVW $1736, R12 - B callbackasm1(SB) - MOVW $1737, R12 - B callbackasm1(SB) - MOVW $1738, R12 - B callbackasm1(SB) - MOVW $1739, R12 - B callbackasm1(SB) - MOVW $1740, R12 - B callbackasm1(SB) - MOVW $1741, R12 - B callbackasm1(SB) - MOVW $1742, R12 - B callbackasm1(SB) - MOVW $1743, R12 - B callbackasm1(SB) - MOVW $1744, R12 - B callbackasm1(SB) - MOVW $1745, R12 - B callbackasm1(SB) - MOVW $1746, R12 - B callbackasm1(SB) - MOVW $1747, R12 - B callbackasm1(SB) - MOVW $1748, R12 - B callbackasm1(SB) - MOVW $1749, R12 - B callbackasm1(SB) - MOVW $1750, R12 - B callbackasm1(SB) - MOVW $1751, R12 - B callbackasm1(SB) - MOVW $1752, R12 - B callbackasm1(SB) - MOVW $1753, R12 - B callbackasm1(SB) - MOVW $1754, R12 - B callbackasm1(SB) - MOVW $1755, R12 - B callbackasm1(SB) - MOVW $1756, R12 - B callbackasm1(SB) - MOVW $1757, R12 - B callbackasm1(SB) - MOVW $1758, R12 - B callbackasm1(SB) - MOVW $1759, R12 - B callbackasm1(SB) - MOVW $1760, R12 - B callbackasm1(SB) - MOVW $1761, R12 - B callbackasm1(SB) - MOVW $1762, R12 - B callbackasm1(SB) - MOVW $1763, R12 - B callbackasm1(SB) - MOVW $1764, R12 - B callbackasm1(SB) - MOVW $1765, R12 - B callbackasm1(SB) - MOVW $1766, R12 - B callbackasm1(SB) - MOVW $1767, R12 - B callbackasm1(SB) - MOVW $1768, R12 - B callbackasm1(SB) - MOVW $1769, R12 - B callbackasm1(SB) - MOVW $1770, R12 - B callbackasm1(SB) - MOVW $1771, R12 - B callbackasm1(SB) - MOVW $1772, R12 - B callbackasm1(SB) - MOVW $1773, R12 - B callbackasm1(SB) - MOVW $1774, R12 - B callbackasm1(SB) - MOVW $1775, R12 - B callbackasm1(SB) - MOVW $1776, R12 - B callbackasm1(SB) - MOVW $1777, R12 - B callbackasm1(SB) - MOVW $1778, R12 - B callbackasm1(SB) - MOVW $1779, R12 - B callbackasm1(SB) - MOVW $1780, R12 - B callbackasm1(SB) - MOVW $1781, R12 - B callbackasm1(SB) - MOVW $1782, R12 - B callbackasm1(SB) - MOVW $1783, R12 - B callbackasm1(SB) - MOVW $1784, R12 - B callbackasm1(SB) - MOVW $1785, R12 - B callbackasm1(SB) - MOVW $1786, R12 - B callbackasm1(SB) - MOVW $1787, R12 - B callbackasm1(SB) - MOVW $1788, R12 - B callbackasm1(SB) - MOVW $1789, R12 - B callbackasm1(SB) - MOVW $1790, R12 - B callbackasm1(SB) - MOVW $1791, R12 - B callbackasm1(SB) - MOVW $1792, R12 - B callbackasm1(SB) - MOVW $1793, R12 - B callbackasm1(SB) - MOVW $1794, R12 - B callbackasm1(SB) - MOVW $1795, R12 - B callbackasm1(SB) - MOVW $1796, R12 - B callbackasm1(SB) - MOVW $1797, R12 - B callbackasm1(SB) - MOVW $1798, R12 - B callbackasm1(SB) - MOVW $1799, R12 - B callbackasm1(SB) - MOVW $1800, R12 - B callbackasm1(SB) - MOVW $1801, R12 - B callbackasm1(SB) - MOVW $1802, R12 - B callbackasm1(SB) - MOVW $1803, R12 - B callbackasm1(SB) - MOVW $1804, R12 - B callbackasm1(SB) - MOVW $1805, R12 - B callbackasm1(SB) - MOVW $1806, R12 - B callbackasm1(SB) - MOVW $1807, R12 - B callbackasm1(SB) - MOVW $1808, R12 - B callbackasm1(SB) - MOVW $1809, R12 - B callbackasm1(SB) - MOVW $1810, R12 - B callbackasm1(SB) - MOVW $1811, R12 - B callbackasm1(SB) - MOVW $1812, R12 - B callbackasm1(SB) - MOVW $1813, R12 - B callbackasm1(SB) - MOVW $1814, R12 - B callbackasm1(SB) - MOVW $1815, R12 - B callbackasm1(SB) - MOVW $1816, R12 - B callbackasm1(SB) - MOVW $1817, R12 - B callbackasm1(SB) - MOVW $1818, R12 - B callbackasm1(SB) - MOVW $1819, R12 - B callbackasm1(SB) - MOVW $1820, R12 - B callbackasm1(SB) - MOVW $1821, R12 - B callbackasm1(SB) - MOVW $1822, R12 - B callbackasm1(SB) - MOVW $1823, R12 - B callbackasm1(SB) - MOVW $1824, R12 - B callbackasm1(SB) - MOVW $1825, R12 - B callbackasm1(SB) - MOVW $1826, R12 - B callbackasm1(SB) - MOVW $1827, R12 - B callbackasm1(SB) - MOVW $1828, R12 - B callbackasm1(SB) - MOVW $1829, R12 - B callbackasm1(SB) - MOVW $1830, R12 - B callbackasm1(SB) - MOVW $1831, R12 - B callbackasm1(SB) - MOVW $1832, R12 - B callbackasm1(SB) - MOVW $1833, R12 - B callbackasm1(SB) - MOVW $1834, R12 - B callbackasm1(SB) - MOVW $1835, R12 - B callbackasm1(SB) - MOVW $1836, R12 - B callbackasm1(SB) - MOVW $1837, R12 - B callbackasm1(SB) - MOVW $1838, R12 - B callbackasm1(SB) - MOVW $1839, R12 - B callbackasm1(SB) - MOVW $1840, R12 - B callbackasm1(SB) - MOVW $1841, R12 - B callbackasm1(SB) - MOVW $1842, R12 - B callbackasm1(SB) - MOVW $1843, R12 - B callbackasm1(SB) - MOVW $1844, R12 - B callbackasm1(SB) - MOVW $1845, R12 - B callbackasm1(SB) - MOVW $1846, R12 - B callbackasm1(SB) - MOVW $1847, R12 - B callbackasm1(SB) - MOVW $1848, R12 - B callbackasm1(SB) - MOVW $1849, R12 - B callbackasm1(SB) - MOVW $1850, R12 - B callbackasm1(SB) - MOVW $1851, R12 - B callbackasm1(SB) - MOVW $1852, R12 - B callbackasm1(SB) - MOVW $1853, R12 - B callbackasm1(SB) - MOVW $1854, R12 - B callbackasm1(SB) - MOVW $1855, R12 - B callbackasm1(SB) - MOVW $1856, R12 - B callbackasm1(SB) - MOVW $1857, R12 - B callbackasm1(SB) - MOVW $1858, R12 - B callbackasm1(SB) - MOVW $1859, R12 - B callbackasm1(SB) - MOVW $1860, R12 - B callbackasm1(SB) - MOVW $1861, R12 - B callbackasm1(SB) - MOVW $1862, R12 - B callbackasm1(SB) - MOVW $1863, R12 - B callbackasm1(SB) - MOVW $1864, R12 - B callbackasm1(SB) - MOVW $1865, R12 - B callbackasm1(SB) - MOVW $1866, R12 - B callbackasm1(SB) - MOVW $1867, R12 - B callbackasm1(SB) - MOVW $1868, R12 - B callbackasm1(SB) - MOVW $1869, R12 - B callbackasm1(SB) - MOVW $1870, R12 - B callbackasm1(SB) - MOVW $1871, R12 - B callbackasm1(SB) - MOVW $1872, R12 - B callbackasm1(SB) - MOVW $1873, R12 - B callbackasm1(SB) - MOVW $1874, R12 - B callbackasm1(SB) - MOVW $1875, R12 - B callbackasm1(SB) - MOVW $1876, R12 - B callbackasm1(SB) - MOVW $1877, R12 - B callbackasm1(SB) - MOVW $1878, R12 - B callbackasm1(SB) - MOVW $1879, R12 - B callbackasm1(SB) - MOVW $1880, R12 - B callbackasm1(SB) - MOVW $1881, R12 - B callbackasm1(SB) - MOVW $1882, R12 - B callbackasm1(SB) - MOVW $1883, R12 - B callbackasm1(SB) - MOVW $1884, R12 - B callbackasm1(SB) - MOVW $1885, R12 - B callbackasm1(SB) - MOVW $1886, R12 - B callbackasm1(SB) - MOVW $1887, R12 - B callbackasm1(SB) - MOVW $1888, R12 - B callbackasm1(SB) - MOVW $1889, R12 - B callbackasm1(SB) - MOVW $1890, R12 - B callbackasm1(SB) - MOVW $1891, R12 - B callbackasm1(SB) - MOVW $1892, R12 - B callbackasm1(SB) - MOVW $1893, R12 - B callbackasm1(SB) - MOVW $1894, R12 - B callbackasm1(SB) - MOVW $1895, R12 - B callbackasm1(SB) - MOVW $1896, R12 - B callbackasm1(SB) - MOVW $1897, R12 - B callbackasm1(SB) - MOVW $1898, R12 - B callbackasm1(SB) - MOVW $1899, R12 - B callbackasm1(SB) - MOVW $1900, R12 - B callbackasm1(SB) - MOVW $1901, R12 - B callbackasm1(SB) - MOVW $1902, R12 - B callbackasm1(SB) - MOVW $1903, R12 - B callbackasm1(SB) - MOVW $1904, R12 - B callbackasm1(SB) - MOVW $1905, R12 - B callbackasm1(SB) - MOVW $1906, R12 - B callbackasm1(SB) - MOVW $1907, R12 - B callbackasm1(SB) - MOVW $1908, R12 - B callbackasm1(SB) - MOVW $1909, R12 - B callbackasm1(SB) - MOVW $1910, R12 - B callbackasm1(SB) - MOVW $1911, R12 - B callbackasm1(SB) - MOVW $1912, R12 - B callbackasm1(SB) - MOVW $1913, R12 - B callbackasm1(SB) - MOVW $1914, R12 - B callbackasm1(SB) - MOVW $1915, R12 - B callbackasm1(SB) - MOVW $1916, R12 - B callbackasm1(SB) - MOVW $1917, R12 - B callbackasm1(SB) - MOVW $1918, R12 - B callbackasm1(SB) - MOVW $1919, R12 - B callbackasm1(SB) - MOVW $1920, R12 - B callbackasm1(SB) - MOVW $1921, R12 - B callbackasm1(SB) - MOVW $1922, R12 - B callbackasm1(SB) - MOVW $1923, R12 - B callbackasm1(SB) - MOVW $1924, R12 - B callbackasm1(SB) - MOVW $1925, R12 - B callbackasm1(SB) - MOVW $1926, R12 - B callbackasm1(SB) - MOVW $1927, R12 - B callbackasm1(SB) - MOVW $1928, R12 - B callbackasm1(SB) - MOVW $1929, R12 - B callbackasm1(SB) - MOVW $1930, R12 - B callbackasm1(SB) - MOVW $1931, R12 - B callbackasm1(SB) - MOVW $1932, R12 - B callbackasm1(SB) - MOVW $1933, R12 - B callbackasm1(SB) - MOVW $1934, R12 - B callbackasm1(SB) - MOVW $1935, R12 - B callbackasm1(SB) - MOVW $1936, R12 - B callbackasm1(SB) - MOVW $1937, R12 - B callbackasm1(SB) - MOVW $1938, R12 - B callbackasm1(SB) - MOVW $1939, R12 - B callbackasm1(SB) - MOVW $1940, R12 - B callbackasm1(SB) - MOVW $1941, R12 - B callbackasm1(SB) - MOVW $1942, R12 - B callbackasm1(SB) - MOVW $1943, R12 - B callbackasm1(SB) - MOVW $1944, R12 - B callbackasm1(SB) - MOVW $1945, R12 - B callbackasm1(SB) - MOVW $1946, R12 - B callbackasm1(SB) - MOVW $1947, R12 - B callbackasm1(SB) - MOVW $1948, R12 - B callbackasm1(SB) - MOVW $1949, R12 - B callbackasm1(SB) - MOVW $1950, R12 - B callbackasm1(SB) - MOVW $1951, R12 - B callbackasm1(SB) - MOVW $1952, R12 - B callbackasm1(SB) - MOVW $1953, R12 - B callbackasm1(SB) - MOVW $1954, R12 - B callbackasm1(SB) - MOVW $1955, R12 - B callbackasm1(SB) - MOVW $1956, R12 - B callbackasm1(SB) - MOVW $1957, R12 - B callbackasm1(SB) - MOVW $1958, R12 - B callbackasm1(SB) - MOVW $1959, R12 - B callbackasm1(SB) - MOVW $1960, R12 - B callbackasm1(SB) - MOVW $1961, R12 - B callbackasm1(SB) - MOVW $1962, R12 - B callbackasm1(SB) - MOVW $1963, R12 - B callbackasm1(SB) - MOVW $1964, R12 - B callbackasm1(SB) - MOVW $1965, R12 - B callbackasm1(SB) - MOVW $1966, R12 - B callbackasm1(SB) - MOVW $1967, R12 - B callbackasm1(SB) - MOVW $1968, R12 - B callbackasm1(SB) - MOVW $1969, R12 - B callbackasm1(SB) - MOVW $1970, R12 - B callbackasm1(SB) - MOVW $1971, R12 - B callbackasm1(SB) - MOVW $1972, R12 - B callbackasm1(SB) - MOVW $1973, R12 - B callbackasm1(SB) - MOVW $1974, R12 - B callbackasm1(SB) - MOVW $1975, R12 - B callbackasm1(SB) - MOVW $1976, R12 - B callbackasm1(SB) - MOVW $1977, R12 - B callbackasm1(SB) - MOVW $1978, R12 - B callbackasm1(SB) - MOVW $1979, R12 - B callbackasm1(SB) - MOVW $1980, R12 - B callbackasm1(SB) - MOVW $1981, R12 - B callbackasm1(SB) - MOVW $1982, R12 - B callbackasm1(SB) - MOVW $1983, R12 - B callbackasm1(SB) - MOVW $1984, R12 - B callbackasm1(SB) - MOVW $1985, R12 - B callbackasm1(SB) - MOVW $1986, R12 - B callbackasm1(SB) - MOVW $1987, R12 - B callbackasm1(SB) - MOVW $1988, R12 - B callbackasm1(SB) - MOVW $1989, R12 - B callbackasm1(SB) - MOVW $1990, R12 - B callbackasm1(SB) - MOVW $1991, R12 - B callbackasm1(SB) - MOVW $1992, R12 - B callbackasm1(SB) - MOVW $1993, R12 - B callbackasm1(SB) - MOVW $1994, R12 - B callbackasm1(SB) - MOVW $1995, R12 - B callbackasm1(SB) - MOVW $1996, R12 - B callbackasm1(SB) - MOVW $1997, R12 - B callbackasm1(SB) - MOVW $1998, R12 - B callbackasm1(SB) - MOVW $1999, R12 - B callbackasm1(SB) diff --git a/vendor/github.com/ebitengine/purego/zcallback_arm64.s b/vendor/github.com/ebitengine/purego/zcallback_arm64.s deleted file mode 100644 index 3fea4af8b3f..00000000000 --- a/vendor/github.com/ebitengine/purego/zcallback_arm64.s +++ /dev/null @@ -1,4014 +0,0 @@ -// Code generated by wincallback.go using 'go generate'. DO NOT EDIT. - -//go:build darwin || freebsd || linux || netbsd - -// External code calls into callbackasm at an offset corresponding -// to the callback index. Callbackasm is a table of MOV and B instructions. -// The MOV instruction loads R12 with the callback index, and the -// B instruction branches to callbackasm1. -// callbackasm1 takes the callback index from R12 and -// indexes into an array that stores information about each callback. -// It then calls the Go implementation for that callback. -#include "textflag.h" - -TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0 - MOVD $0, R12 - B callbackasm1(SB) - MOVD $1, R12 - B callbackasm1(SB) - MOVD $2, R12 - B callbackasm1(SB) - MOVD $3, R12 - B callbackasm1(SB) - MOVD $4, R12 - B callbackasm1(SB) - MOVD $5, R12 - B callbackasm1(SB) - MOVD $6, R12 - B callbackasm1(SB) - MOVD $7, R12 - B callbackasm1(SB) - MOVD $8, R12 - B callbackasm1(SB) - MOVD $9, R12 - B callbackasm1(SB) - MOVD $10, R12 - B callbackasm1(SB) - MOVD $11, R12 - B callbackasm1(SB) - MOVD $12, R12 - B callbackasm1(SB) - MOVD $13, R12 - B callbackasm1(SB) - MOVD $14, R12 - B callbackasm1(SB) - MOVD $15, R12 - B callbackasm1(SB) - MOVD $16, R12 - B callbackasm1(SB) - MOVD $17, R12 - B callbackasm1(SB) - MOVD $18, R12 - B callbackasm1(SB) - MOVD $19, R12 - B callbackasm1(SB) - MOVD $20, R12 - B callbackasm1(SB) - MOVD $21, R12 - B callbackasm1(SB) - MOVD $22, R12 - B callbackasm1(SB) - MOVD $23, R12 - B callbackasm1(SB) - MOVD $24, R12 - B callbackasm1(SB) - MOVD $25, R12 - B callbackasm1(SB) - MOVD $26, R12 - B callbackasm1(SB) - MOVD $27, R12 - B callbackasm1(SB) - MOVD $28, R12 - B callbackasm1(SB) - MOVD $29, R12 - B callbackasm1(SB) - MOVD $30, R12 - B callbackasm1(SB) - MOVD $31, R12 - B callbackasm1(SB) - MOVD $32, R12 - B callbackasm1(SB) - MOVD $33, R12 - B callbackasm1(SB) - MOVD $34, R12 - B callbackasm1(SB) - MOVD $35, R12 - B callbackasm1(SB) - MOVD $36, R12 - B callbackasm1(SB) - MOVD $37, R12 - B callbackasm1(SB) - MOVD $38, R12 - B callbackasm1(SB) - MOVD $39, R12 - B callbackasm1(SB) - MOVD $40, R12 - B callbackasm1(SB) - MOVD $41, R12 - B callbackasm1(SB) - MOVD $42, R12 - B callbackasm1(SB) - MOVD $43, R12 - B callbackasm1(SB) - MOVD $44, R12 - B callbackasm1(SB) - MOVD $45, R12 - B callbackasm1(SB) - MOVD $46, R12 - B callbackasm1(SB) - MOVD $47, R12 - B callbackasm1(SB) - MOVD $48, R12 - B callbackasm1(SB) - MOVD $49, R12 - B callbackasm1(SB) - MOVD $50, R12 - B callbackasm1(SB) - MOVD $51, R12 - B callbackasm1(SB) - MOVD $52, R12 - B callbackasm1(SB) - MOVD $53, R12 - B callbackasm1(SB) - MOVD $54, R12 - B callbackasm1(SB) - MOVD $55, R12 - B callbackasm1(SB) - MOVD $56, R12 - B callbackasm1(SB) - MOVD $57, R12 - B callbackasm1(SB) - MOVD $58, R12 - B callbackasm1(SB) - MOVD $59, R12 - B callbackasm1(SB) - MOVD $60, R12 - B callbackasm1(SB) - MOVD $61, R12 - B callbackasm1(SB) - MOVD $62, R12 - B callbackasm1(SB) - MOVD $63, R12 - B callbackasm1(SB) - MOVD $64, R12 - B callbackasm1(SB) - MOVD $65, R12 - B callbackasm1(SB) - MOVD $66, R12 - B callbackasm1(SB) - MOVD $67, R12 - B callbackasm1(SB) - MOVD $68, R12 - B callbackasm1(SB) - MOVD $69, R12 - B callbackasm1(SB) - MOVD $70, R12 - B callbackasm1(SB) - MOVD $71, R12 - B callbackasm1(SB) - MOVD $72, R12 - B callbackasm1(SB) - MOVD $73, R12 - B callbackasm1(SB) - MOVD $74, R12 - B callbackasm1(SB) - MOVD $75, R12 - B callbackasm1(SB) - MOVD $76, R12 - B callbackasm1(SB) - MOVD $77, R12 - B callbackasm1(SB) - MOVD $78, R12 - B callbackasm1(SB) - MOVD $79, R12 - B callbackasm1(SB) - MOVD $80, R12 - B callbackasm1(SB) - MOVD $81, R12 - B callbackasm1(SB) - MOVD $82, R12 - B callbackasm1(SB) - MOVD $83, R12 - B callbackasm1(SB) - MOVD $84, R12 - B callbackasm1(SB) - MOVD $85, R12 - B callbackasm1(SB) - MOVD $86, R12 - B callbackasm1(SB) - MOVD $87, R12 - B callbackasm1(SB) - MOVD $88, R12 - B callbackasm1(SB) - MOVD $89, R12 - B callbackasm1(SB) - MOVD $90, R12 - B callbackasm1(SB) - MOVD $91, R12 - B callbackasm1(SB) - MOVD $92, R12 - B callbackasm1(SB) - MOVD $93, R12 - B callbackasm1(SB) - MOVD $94, R12 - B callbackasm1(SB) - MOVD $95, R12 - B callbackasm1(SB) - MOVD $96, R12 - B callbackasm1(SB) - MOVD $97, R12 - B callbackasm1(SB) - MOVD $98, R12 - B callbackasm1(SB) - MOVD $99, R12 - B callbackasm1(SB) - MOVD $100, R12 - B callbackasm1(SB) - MOVD $101, R12 - B callbackasm1(SB) - MOVD $102, R12 - B callbackasm1(SB) - MOVD $103, R12 - B callbackasm1(SB) - MOVD $104, R12 - B callbackasm1(SB) - MOVD $105, R12 - B callbackasm1(SB) - MOVD $106, R12 - B callbackasm1(SB) - MOVD $107, R12 - B callbackasm1(SB) - MOVD $108, R12 - B callbackasm1(SB) - MOVD $109, R12 - B callbackasm1(SB) - MOVD $110, R12 - B callbackasm1(SB) - MOVD $111, R12 - B callbackasm1(SB) - MOVD $112, R12 - B callbackasm1(SB) - MOVD $113, R12 - B callbackasm1(SB) - MOVD $114, R12 - B callbackasm1(SB) - MOVD $115, R12 - B callbackasm1(SB) - MOVD $116, R12 - B callbackasm1(SB) - MOVD $117, R12 - B callbackasm1(SB) - MOVD $118, R12 - B callbackasm1(SB) - MOVD $119, R12 - B callbackasm1(SB) - MOVD $120, R12 - B callbackasm1(SB) - MOVD $121, R12 - B callbackasm1(SB) - MOVD $122, R12 - B callbackasm1(SB) - MOVD $123, R12 - B callbackasm1(SB) - MOVD $124, R12 - B callbackasm1(SB) - MOVD $125, R12 - B callbackasm1(SB) - MOVD $126, R12 - B callbackasm1(SB) - MOVD $127, R12 - B callbackasm1(SB) - MOVD $128, R12 - B callbackasm1(SB) - MOVD $129, R12 - B callbackasm1(SB) - MOVD $130, R12 - B callbackasm1(SB) - MOVD $131, R12 - B callbackasm1(SB) - MOVD $132, R12 - B callbackasm1(SB) - MOVD $133, R12 - B callbackasm1(SB) - MOVD $134, R12 - B callbackasm1(SB) - MOVD $135, R12 - B callbackasm1(SB) - MOVD $136, R12 - B callbackasm1(SB) - MOVD $137, R12 - B callbackasm1(SB) - MOVD $138, R12 - B callbackasm1(SB) - MOVD $139, R12 - B callbackasm1(SB) - MOVD $140, R12 - B callbackasm1(SB) - MOVD $141, R12 - B callbackasm1(SB) - MOVD $142, R12 - B callbackasm1(SB) - MOVD $143, R12 - B callbackasm1(SB) - MOVD $144, R12 - B callbackasm1(SB) - MOVD $145, R12 - B callbackasm1(SB) - MOVD $146, R12 - B callbackasm1(SB) - MOVD $147, R12 - B callbackasm1(SB) - MOVD $148, R12 - B callbackasm1(SB) - MOVD $149, R12 - B callbackasm1(SB) - MOVD $150, R12 - B callbackasm1(SB) - MOVD $151, R12 - B callbackasm1(SB) - MOVD $152, R12 - B callbackasm1(SB) - MOVD $153, R12 - B callbackasm1(SB) - MOVD $154, R12 - B callbackasm1(SB) - MOVD $155, R12 - B callbackasm1(SB) - MOVD $156, R12 - B callbackasm1(SB) - MOVD $157, R12 - B callbackasm1(SB) - MOVD $158, R12 - B callbackasm1(SB) - MOVD $159, R12 - B callbackasm1(SB) - MOVD $160, R12 - B callbackasm1(SB) - MOVD $161, R12 - B callbackasm1(SB) - MOVD $162, R12 - B callbackasm1(SB) - MOVD $163, R12 - B callbackasm1(SB) - MOVD $164, R12 - B callbackasm1(SB) - MOVD $165, R12 - B callbackasm1(SB) - MOVD $166, R12 - B callbackasm1(SB) - MOVD $167, R12 - B callbackasm1(SB) - MOVD $168, R12 - B callbackasm1(SB) - MOVD $169, R12 - B callbackasm1(SB) - MOVD $170, R12 - B callbackasm1(SB) - MOVD $171, R12 - B callbackasm1(SB) - MOVD $172, R12 - B callbackasm1(SB) - MOVD $173, R12 - B callbackasm1(SB) - MOVD $174, R12 - B callbackasm1(SB) - MOVD $175, R12 - B callbackasm1(SB) - MOVD $176, R12 - B callbackasm1(SB) - MOVD $177, R12 - B callbackasm1(SB) - MOVD $178, R12 - B callbackasm1(SB) - MOVD $179, R12 - B callbackasm1(SB) - MOVD $180, R12 - B callbackasm1(SB) - MOVD $181, R12 - B callbackasm1(SB) - MOVD $182, R12 - B callbackasm1(SB) - MOVD $183, R12 - B callbackasm1(SB) - MOVD $184, R12 - B callbackasm1(SB) - MOVD $185, R12 - B callbackasm1(SB) - MOVD $186, R12 - B callbackasm1(SB) - MOVD $187, R12 - B callbackasm1(SB) - MOVD $188, R12 - B callbackasm1(SB) - MOVD $189, R12 - B callbackasm1(SB) - MOVD $190, R12 - B callbackasm1(SB) - MOVD $191, R12 - B callbackasm1(SB) - MOVD $192, R12 - B callbackasm1(SB) - MOVD $193, R12 - B callbackasm1(SB) - MOVD $194, R12 - B callbackasm1(SB) - MOVD $195, R12 - B callbackasm1(SB) - MOVD $196, R12 - B callbackasm1(SB) - MOVD $197, R12 - B callbackasm1(SB) - MOVD $198, R12 - B callbackasm1(SB) - MOVD $199, R12 - B callbackasm1(SB) - MOVD $200, R12 - B callbackasm1(SB) - MOVD $201, R12 - B callbackasm1(SB) - MOVD $202, R12 - B callbackasm1(SB) - MOVD $203, R12 - B callbackasm1(SB) - MOVD $204, R12 - B callbackasm1(SB) - MOVD $205, R12 - B callbackasm1(SB) - MOVD $206, R12 - B callbackasm1(SB) - MOVD $207, R12 - B callbackasm1(SB) - MOVD $208, R12 - B callbackasm1(SB) - MOVD $209, R12 - B callbackasm1(SB) - MOVD $210, R12 - B callbackasm1(SB) - MOVD $211, R12 - B callbackasm1(SB) - MOVD $212, R12 - B callbackasm1(SB) - MOVD $213, R12 - B callbackasm1(SB) - MOVD $214, R12 - B callbackasm1(SB) - MOVD $215, R12 - B callbackasm1(SB) - MOVD $216, R12 - B callbackasm1(SB) - MOVD $217, R12 - B callbackasm1(SB) - MOVD $218, R12 - B callbackasm1(SB) - MOVD $219, R12 - B callbackasm1(SB) - MOVD $220, R12 - B callbackasm1(SB) - MOVD $221, R12 - B callbackasm1(SB) - MOVD $222, R12 - B callbackasm1(SB) - MOVD $223, R12 - B callbackasm1(SB) - MOVD $224, R12 - B callbackasm1(SB) - MOVD $225, R12 - B callbackasm1(SB) - MOVD $226, R12 - B callbackasm1(SB) - MOVD $227, R12 - B callbackasm1(SB) - MOVD $228, R12 - B callbackasm1(SB) - MOVD $229, R12 - B callbackasm1(SB) - MOVD $230, R12 - B callbackasm1(SB) - MOVD $231, R12 - B callbackasm1(SB) - MOVD $232, R12 - B callbackasm1(SB) - MOVD $233, R12 - B callbackasm1(SB) - MOVD $234, R12 - B callbackasm1(SB) - MOVD $235, R12 - B callbackasm1(SB) - MOVD $236, R12 - B callbackasm1(SB) - MOVD $237, R12 - B callbackasm1(SB) - MOVD $238, R12 - B callbackasm1(SB) - MOVD $239, R12 - B callbackasm1(SB) - MOVD $240, R12 - B callbackasm1(SB) - MOVD $241, R12 - B callbackasm1(SB) - MOVD $242, R12 - B callbackasm1(SB) - MOVD $243, R12 - B callbackasm1(SB) - MOVD $244, R12 - B callbackasm1(SB) - MOVD $245, R12 - B callbackasm1(SB) - MOVD $246, R12 - B callbackasm1(SB) - MOVD $247, R12 - B callbackasm1(SB) - MOVD $248, R12 - B callbackasm1(SB) - MOVD $249, R12 - B callbackasm1(SB) - MOVD $250, R12 - B callbackasm1(SB) - MOVD $251, R12 - B callbackasm1(SB) - MOVD $252, R12 - B callbackasm1(SB) - MOVD $253, R12 - B callbackasm1(SB) - MOVD $254, R12 - B callbackasm1(SB) - MOVD $255, R12 - B callbackasm1(SB) - MOVD $256, R12 - B callbackasm1(SB) - MOVD $257, R12 - B callbackasm1(SB) - MOVD $258, R12 - B callbackasm1(SB) - MOVD $259, R12 - B callbackasm1(SB) - MOVD $260, R12 - B callbackasm1(SB) - MOVD $261, R12 - B callbackasm1(SB) - MOVD $262, R12 - B callbackasm1(SB) - MOVD $263, R12 - B callbackasm1(SB) - MOVD $264, R12 - B callbackasm1(SB) - MOVD $265, R12 - B callbackasm1(SB) - MOVD $266, R12 - B callbackasm1(SB) - MOVD $267, R12 - B callbackasm1(SB) - MOVD $268, R12 - B callbackasm1(SB) - MOVD $269, R12 - B callbackasm1(SB) - MOVD $270, R12 - B callbackasm1(SB) - MOVD $271, R12 - B callbackasm1(SB) - MOVD $272, R12 - B callbackasm1(SB) - MOVD $273, R12 - B callbackasm1(SB) - MOVD $274, R12 - B callbackasm1(SB) - MOVD $275, R12 - B callbackasm1(SB) - MOVD $276, R12 - B callbackasm1(SB) - MOVD $277, R12 - B callbackasm1(SB) - MOVD $278, R12 - B callbackasm1(SB) - MOVD $279, R12 - B callbackasm1(SB) - MOVD $280, R12 - B callbackasm1(SB) - MOVD $281, R12 - B callbackasm1(SB) - MOVD $282, R12 - B callbackasm1(SB) - MOVD $283, R12 - B callbackasm1(SB) - MOVD $284, R12 - B callbackasm1(SB) - MOVD $285, R12 - B callbackasm1(SB) - MOVD $286, R12 - B callbackasm1(SB) - MOVD $287, R12 - B callbackasm1(SB) - MOVD $288, R12 - B callbackasm1(SB) - MOVD $289, R12 - B callbackasm1(SB) - MOVD $290, R12 - B callbackasm1(SB) - MOVD $291, R12 - B callbackasm1(SB) - MOVD $292, R12 - B callbackasm1(SB) - MOVD $293, R12 - B callbackasm1(SB) - MOVD $294, R12 - B callbackasm1(SB) - MOVD $295, R12 - B callbackasm1(SB) - MOVD $296, R12 - B callbackasm1(SB) - MOVD $297, R12 - B callbackasm1(SB) - MOVD $298, R12 - B callbackasm1(SB) - MOVD $299, R12 - B callbackasm1(SB) - MOVD $300, R12 - B callbackasm1(SB) - MOVD $301, R12 - B callbackasm1(SB) - MOVD $302, R12 - B callbackasm1(SB) - MOVD $303, R12 - B callbackasm1(SB) - MOVD $304, R12 - B callbackasm1(SB) - MOVD $305, R12 - B callbackasm1(SB) - MOVD $306, R12 - B callbackasm1(SB) - MOVD $307, R12 - B callbackasm1(SB) - MOVD $308, R12 - B callbackasm1(SB) - MOVD $309, R12 - B callbackasm1(SB) - MOVD $310, R12 - B callbackasm1(SB) - MOVD $311, R12 - B callbackasm1(SB) - MOVD $312, R12 - B callbackasm1(SB) - MOVD $313, R12 - B callbackasm1(SB) - MOVD $314, R12 - B callbackasm1(SB) - MOVD $315, R12 - B callbackasm1(SB) - MOVD $316, R12 - B callbackasm1(SB) - MOVD $317, R12 - B callbackasm1(SB) - MOVD $318, R12 - B callbackasm1(SB) - MOVD $319, R12 - B callbackasm1(SB) - MOVD $320, R12 - B callbackasm1(SB) - MOVD $321, R12 - B callbackasm1(SB) - MOVD $322, R12 - B callbackasm1(SB) - MOVD $323, R12 - B callbackasm1(SB) - MOVD $324, R12 - B callbackasm1(SB) - MOVD $325, R12 - B callbackasm1(SB) - MOVD $326, R12 - B callbackasm1(SB) - MOVD $327, R12 - B callbackasm1(SB) - MOVD $328, R12 - B callbackasm1(SB) - MOVD $329, R12 - B callbackasm1(SB) - MOVD $330, R12 - B callbackasm1(SB) - MOVD $331, R12 - B callbackasm1(SB) - MOVD $332, R12 - B callbackasm1(SB) - MOVD $333, R12 - B callbackasm1(SB) - MOVD $334, R12 - B callbackasm1(SB) - MOVD $335, R12 - B callbackasm1(SB) - MOVD $336, R12 - B callbackasm1(SB) - MOVD $337, R12 - B callbackasm1(SB) - MOVD $338, R12 - B callbackasm1(SB) - MOVD $339, R12 - B callbackasm1(SB) - MOVD $340, R12 - B callbackasm1(SB) - MOVD $341, R12 - B callbackasm1(SB) - MOVD $342, R12 - B callbackasm1(SB) - MOVD $343, R12 - B callbackasm1(SB) - MOVD $344, R12 - B callbackasm1(SB) - MOVD $345, R12 - B callbackasm1(SB) - MOVD $346, R12 - B callbackasm1(SB) - MOVD $347, R12 - B callbackasm1(SB) - MOVD $348, R12 - B callbackasm1(SB) - MOVD $349, R12 - B callbackasm1(SB) - MOVD $350, R12 - B callbackasm1(SB) - MOVD $351, R12 - B callbackasm1(SB) - MOVD $352, R12 - B callbackasm1(SB) - MOVD $353, R12 - B callbackasm1(SB) - MOVD $354, R12 - B callbackasm1(SB) - MOVD $355, R12 - B callbackasm1(SB) - MOVD $356, R12 - B callbackasm1(SB) - MOVD $357, R12 - B callbackasm1(SB) - MOVD $358, R12 - B callbackasm1(SB) - MOVD $359, R12 - B callbackasm1(SB) - MOVD $360, R12 - B callbackasm1(SB) - MOVD $361, R12 - B callbackasm1(SB) - MOVD $362, R12 - B callbackasm1(SB) - MOVD $363, R12 - B callbackasm1(SB) - MOVD $364, R12 - B callbackasm1(SB) - MOVD $365, R12 - B callbackasm1(SB) - MOVD $366, R12 - B callbackasm1(SB) - MOVD $367, R12 - B callbackasm1(SB) - MOVD $368, R12 - B callbackasm1(SB) - MOVD $369, R12 - B callbackasm1(SB) - MOVD $370, R12 - B callbackasm1(SB) - MOVD $371, R12 - B callbackasm1(SB) - MOVD $372, R12 - B callbackasm1(SB) - MOVD $373, R12 - B callbackasm1(SB) - MOVD $374, R12 - B callbackasm1(SB) - MOVD $375, R12 - B callbackasm1(SB) - MOVD $376, R12 - B callbackasm1(SB) - MOVD $377, R12 - B callbackasm1(SB) - MOVD $378, R12 - B callbackasm1(SB) - MOVD $379, R12 - B callbackasm1(SB) - MOVD $380, R12 - B callbackasm1(SB) - MOVD $381, R12 - B callbackasm1(SB) - MOVD $382, R12 - B callbackasm1(SB) - MOVD $383, R12 - B callbackasm1(SB) - MOVD $384, R12 - B callbackasm1(SB) - MOVD $385, R12 - B callbackasm1(SB) - MOVD $386, R12 - B callbackasm1(SB) - MOVD $387, R12 - B callbackasm1(SB) - MOVD $388, R12 - B callbackasm1(SB) - MOVD $389, R12 - B callbackasm1(SB) - MOVD $390, R12 - B callbackasm1(SB) - MOVD $391, R12 - B callbackasm1(SB) - MOVD $392, R12 - B callbackasm1(SB) - MOVD $393, R12 - B callbackasm1(SB) - MOVD $394, R12 - B callbackasm1(SB) - MOVD $395, R12 - B callbackasm1(SB) - MOVD $396, R12 - B callbackasm1(SB) - MOVD $397, R12 - B callbackasm1(SB) - MOVD $398, R12 - B callbackasm1(SB) - MOVD $399, R12 - B callbackasm1(SB) - MOVD $400, R12 - B callbackasm1(SB) - MOVD $401, R12 - B callbackasm1(SB) - MOVD $402, R12 - B callbackasm1(SB) - MOVD $403, R12 - B callbackasm1(SB) - MOVD $404, R12 - B callbackasm1(SB) - MOVD $405, R12 - B callbackasm1(SB) - MOVD $406, R12 - B callbackasm1(SB) - MOVD $407, R12 - B callbackasm1(SB) - MOVD $408, R12 - B callbackasm1(SB) - MOVD $409, R12 - B callbackasm1(SB) - MOVD $410, R12 - B callbackasm1(SB) - MOVD $411, R12 - B callbackasm1(SB) - MOVD $412, R12 - B callbackasm1(SB) - MOVD $413, R12 - B callbackasm1(SB) - MOVD $414, R12 - B callbackasm1(SB) - MOVD $415, R12 - B callbackasm1(SB) - MOVD $416, R12 - B callbackasm1(SB) - MOVD $417, R12 - B callbackasm1(SB) - MOVD $418, R12 - B callbackasm1(SB) - MOVD $419, R12 - B callbackasm1(SB) - MOVD $420, R12 - B callbackasm1(SB) - MOVD $421, R12 - B callbackasm1(SB) - MOVD $422, R12 - B callbackasm1(SB) - MOVD $423, R12 - B callbackasm1(SB) - MOVD $424, R12 - B callbackasm1(SB) - MOVD $425, R12 - B callbackasm1(SB) - MOVD $426, R12 - B callbackasm1(SB) - MOVD $427, R12 - B callbackasm1(SB) - MOVD $428, R12 - B callbackasm1(SB) - MOVD $429, R12 - B callbackasm1(SB) - MOVD $430, R12 - B callbackasm1(SB) - MOVD $431, R12 - B callbackasm1(SB) - MOVD $432, R12 - B callbackasm1(SB) - MOVD $433, R12 - B callbackasm1(SB) - MOVD $434, R12 - B callbackasm1(SB) - MOVD $435, R12 - B callbackasm1(SB) - MOVD $436, R12 - B callbackasm1(SB) - MOVD $437, R12 - B callbackasm1(SB) - MOVD $438, R12 - B callbackasm1(SB) - MOVD $439, R12 - B callbackasm1(SB) - MOVD $440, R12 - B callbackasm1(SB) - MOVD $441, R12 - B callbackasm1(SB) - MOVD $442, R12 - B callbackasm1(SB) - MOVD $443, R12 - B callbackasm1(SB) - MOVD $444, R12 - B callbackasm1(SB) - MOVD $445, R12 - B callbackasm1(SB) - MOVD $446, R12 - B callbackasm1(SB) - MOVD $447, R12 - B callbackasm1(SB) - MOVD $448, R12 - B callbackasm1(SB) - MOVD $449, R12 - B callbackasm1(SB) - MOVD $450, R12 - B callbackasm1(SB) - MOVD $451, R12 - B callbackasm1(SB) - MOVD $452, R12 - B callbackasm1(SB) - MOVD $453, R12 - B callbackasm1(SB) - MOVD $454, R12 - B callbackasm1(SB) - MOVD $455, R12 - B callbackasm1(SB) - MOVD $456, R12 - B callbackasm1(SB) - MOVD $457, R12 - B callbackasm1(SB) - MOVD $458, R12 - B callbackasm1(SB) - MOVD $459, R12 - B callbackasm1(SB) - MOVD $460, R12 - B callbackasm1(SB) - MOVD $461, R12 - B callbackasm1(SB) - MOVD $462, R12 - B callbackasm1(SB) - MOVD $463, R12 - B callbackasm1(SB) - MOVD $464, R12 - B callbackasm1(SB) - MOVD $465, R12 - B callbackasm1(SB) - MOVD $466, R12 - B callbackasm1(SB) - MOVD $467, R12 - B callbackasm1(SB) - MOVD $468, R12 - B callbackasm1(SB) - MOVD $469, R12 - B callbackasm1(SB) - MOVD $470, R12 - B callbackasm1(SB) - MOVD $471, R12 - B callbackasm1(SB) - MOVD $472, R12 - B callbackasm1(SB) - MOVD $473, R12 - B callbackasm1(SB) - MOVD $474, R12 - B callbackasm1(SB) - MOVD $475, R12 - B callbackasm1(SB) - MOVD $476, R12 - B callbackasm1(SB) - MOVD $477, R12 - B callbackasm1(SB) - MOVD $478, R12 - B callbackasm1(SB) - MOVD $479, R12 - B callbackasm1(SB) - MOVD $480, R12 - B callbackasm1(SB) - MOVD $481, R12 - B callbackasm1(SB) - MOVD $482, R12 - B callbackasm1(SB) - MOVD $483, R12 - B callbackasm1(SB) - MOVD $484, R12 - B callbackasm1(SB) - MOVD $485, R12 - B callbackasm1(SB) - MOVD $486, R12 - B callbackasm1(SB) - MOVD $487, R12 - B callbackasm1(SB) - MOVD $488, R12 - B callbackasm1(SB) - MOVD $489, R12 - B callbackasm1(SB) - MOVD $490, R12 - B callbackasm1(SB) - MOVD $491, R12 - B callbackasm1(SB) - MOVD $492, R12 - B callbackasm1(SB) - MOVD $493, R12 - B callbackasm1(SB) - MOVD $494, R12 - B callbackasm1(SB) - MOVD $495, R12 - B callbackasm1(SB) - MOVD $496, R12 - B callbackasm1(SB) - MOVD $497, R12 - B callbackasm1(SB) - MOVD $498, R12 - B callbackasm1(SB) - MOVD $499, R12 - B callbackasm1(SB) - MOVD $500, R12 - B callbackasm1(SB) - MOVD $501, R12 - B callbackasm1(SB) - MOVD $502, R12 - B callbackasm1(SB) - MOVD $503, R12 - B callbackasm1(SB) - MOVD $504, R12 - B callbackasm1(SB) - MOVD $505, R12 - B callbackasm1(SB) - MOVD $506, R12 - B callbackasm1(SB) - MOVD $507, R12 - B callbackasm1(SB) - MOVD $508, R12 - B callbackasm1(SB) - MOVD $509, R12 - B callbackasm1(SB) - MOVD $510, R12 - B callbackasm1(SB) - MOVD $511, R12 - B callbackasm1(SB) - MOVD $512, R12 - B callbackasm1(SB) - MOVD $513, R12 - B callbackasm1(SB) - MOVD $514, R12 - B callbackasm1(SB) - MOVD $515, R12 - B callbackasm1(SB) - MOVD $516, R12 - B callbackasm1(SB) - MOVD $517, R12 - B callbackasm1(SB) - MOVD $518, R12 - B callbackasm1(SB) - MOVD $519, R12 - B callbackasm1(SB) - MOVD $520, R12 - B callbackasm1(SB) - MOVD $521, R12 - B callbackasm1(SB) - MOVD $522, R12 - B callbackasm1(SB) - MOVD $523, R12 - B callbackasm1(SB) - MOVD $524, R12 - B callbackasm1(SB) - MOVD $525, R12 - B callbackasm1(SB) - MOVD $526, R12 - B callbackasm1(SB) - MOVD $527, R12 - B callbackasm1(SB) - MOVD $528, R12 - B callbackasm1(SB) - MOVD $529, R12 - B callbackasm1(SB) - MOVD $530, R12 - B callbackasm1(SB) - MOVD $531, R12 - B callbackasm1(SB) - MOVD $532, R12 - B callbackasm1(SB) - MOVD $533, R12 - B callbackasm1(SB) - MOVD $534, R12 - B callbackasm1(SB) - MOVD $535, R12 - B callbackasm1(SB) - MOVD $536, R12 - B callbackasm1(SB) - MOVD $537, R12 - B callbackasm1(SB) - MOVD $538, R12 - B callbackasm1(SB) - MOVD $539, R12 - B callbackasm1(SB) - MOVD $540, R12 - B callbackasm1(SB) - MOVD $541, R12 - B callbackasm1(SB) - MOVD $542, R12 - B callbackasm1(SB) - MOVD $543, R12 - B callbackasm1(SB) - MOVD $544, R12 - B callbackasm1(SB) - MOVD $545, R12 - B callbackasm1(SB) - MOVD $546, R12 - B callbackasm1(SB) - MOVD $547, R12 - B callbackasm1(SB) - MOVD $548, R12 - B callbackasm1(SB) - MOVD $549, R12 - B callbackasm1(SB) - MOVD $550, R12 - B callbackasm1(SB) - MOVD $551, R12 - B callbackasm1(SB) - MOVD $552, R12 - B callbackasm1(SB) - MOVD $553, R12 - B callbackasm1(SB) - MOVD $554, R12 - B callbackasm1(SB) - MOVD $555, R12 - B callbackasm1(SB) - MOVD $556, R12 - B callbackasm1(SB) - MOVD $557, R12 - B callbackasm1(SB) - MOVD $558, R12 - B callbackasm1(SB) - MOVD $559, R12 - B callbackasm1(SB) - MOVD $560, R12 - B callbackasm1(SB) - MOVD $561, R12 - B callbackasm1(SB) - MOVD $562, R12 - B callbackasm1(SB) - MOVD $563, R12 - B callbackasm1(SB) - MOVD $564, R12 - B callbackasm1(SB) - MOVD $565, R12 - B callbackasm1(SB) - MOVD $566, R12 - B callbackasm1(SB) - MOVD $567, R12 - B callbackasm1(SB) - MOVD $568, R12 - B callbackasm1(SB) - MOVD $569, R12 - B callbackasm1(SB) - MOVD $570, R12 - B callbackasm1(SB) - MOVD $571, R12 - B callbackasm1(SB) - MOVD $572, R12 - B callbackasm1(SB) - MOVD $573, R12 - B callbackasm1(SB) - MOVD $574, R12 - B callbackasm1(SB) - MOVD $575, R12 - B callbackasm1(SB) - MOVD $576, R12 - B callbackasm1(SB) - MOVD $577, R12 - B callbackasm1(SB) - MOVD $578, R12 - B callbackasm1(SB) - MOVD $579, R12 - B callbackasm1(SB) - MOVD $580, R12 - B callbackasm1(SB) - MOVD $581, R12 - B callbackasm1(SB) - MOVD $582, R12 - B callbackasm1(SB) - MOVD $583, R12 - B callbackasm1(SB) - MOVD $584, R12 - B callbackasm1(SB) - MOVD $585, R12 - B callbackasm1(SB) - MOVD $586, R12 - B callbackasm1(SB) - MOVD $587, R12 - B callbackasm1(SB) - MOVD $588, R12 - B callbackasm1(SB) - MOVD $589, R12 - B callbackasm1(SB) - MOVD $590, R12 - B callbackasm1(SB) - MOVD $591, R12 - B callbackasm1(SB) - MOVD $592, R12 - B callbackasm1(SB) - MOVD $593, R12 - B callbackasm1(SB) - MOVD $594, R12 - B callbackasm1(SB) - MOVD $595, R12 - B callbackasm1(SB) - MOVD $596, R12 - B callbackasm1(SB) - MOVD $597, R12 - B callbackasm1(SB) - MOVD $598, R12 - B callbackasm1(SB) - MOVD $599, R12 - B callbackasm1(SB) - MOVD $600, R12 - B callbackasm1(SB) - MOVD $601, R12 - B callbackasm1(SB) - MOVD $602, R12 - B callbackasm1(SB) - MOVD $603, R12 - B callbackasm1(SB) - MOVD $604, R12 - B callbackasm1(SB) - MOVD $605, R12 - B callbackasm1(SB) - MOVD $606, R12 - B callbackasm1(SB) - MOVD $607, R12 - B callbackasm1(SB) - MOVD $608, R12 - B callbackasm1(SB) - MOVD $609, R12 - B callbackasm1(SB) - MOVD $610, R12 - B callbackasm1(SB) - MOVD $611, R12 - B callbackasm1(SB) - MOVD $612, R12 - B callbackasm1(SB) - MOVD $613, R12 - B callbackasm1(SB) - MOVD $614, R12 - B callbackasm1(SB) - MOVD $615, R12 - B callbackasm1(SB) - MOVD $616, R12 - B callbackasm1(SB) - MOVD $617, R12 - B callbackasm1(SB) - MOVD $618, R12 - B callbackasm1(SB) - MOVD $619, R12 - B callbackasm1(SB) - MOVD $620, R12 - B callbackasm1(SB) - MOVD $621, R12 - B callbackasm1(SB) - MOVD $622, R12 - B callbackasm1(SB) - MOVD $623, R12 - B callbackasm1(SB) - MOVD $624, R12 - B callbackasm1(SB) - MOVD $625, R12 - B callbackasm1(SB) - MOVD $626, R12 - B callbackasm1(SB) - MOVD $627, R12 - B callbackasm1(SB) - MOVD $628, R12 - B callbackasm1(SB) - MOVD $629, R12 - B callbackasm1(SB) - MOVD $630, R12 - B callbackasm1(SB) - MOVD $631, R12 - B callbackasm1(SB) - MOVD $632, R12 - B callbackasm1(SB) - MOVD $633, R12 - B callbackasm1(SB) - MOVD $634, R12 - B callbackasm1(SB) - MOVD $635, R12 - B callbackasm1(SB) - MOVD $636, R12 - B callbackasm1(SB) - MOVD $637, R12 - B callbackasm1(SB) - MOVD $638, R12 - B callbackasm1(SB) - MOVD $639, R12 - B callbackasm1(SB) - MOVD $640, R12 - B callbackasm1(SB) - MOVD $641, R12 - B callbackasm1(SB) - MOVD $642, R12 - B callbackasm1(SB) - MOVD $643, R12 - B callbackasm1(SB) - MOVD $644, R12 - B callbackasm1(SB) - MOVD $645, R12 - B callbackasm1(SB) - MOVD $646, R12 - B callbackasm1(SB) - MOVD $647, R12 - B callbackasm1(SB) - MOVD $648, R12 - B callbackasm1(SB) - MOVD $649, R12 - B callbackasm1(SB) - MOVD $650, R12 - B callbackasm1(SB) - MOVD $651, R12 - B callbackasm1(SB) - MOVD $652, R12 - B callbackasm1(SB) - MOVD $653, R12 - B callbackasm1(SB) - MOVD $654, R12 - B callbackasm1(SB) - MOVD $655, R12 - B callbackasm1(SB) - MOVD $656, R12 - B callbackasm1(SB) - MOVD $657, R12 - B callbackasm1(SB) - MOVD $658, R12 - B callbackasm1(SB) - MOVD $659, R12 - B callbackasm1(SB) - MOVD $660, R12 - B callbackasm1(SB) - MOVD $661, R12 - B callbackasm1(SB) - MOVD $662, R12 - B callbackasm1(SB) - MOVD $663, R12 - B callbackasm1(SB) - MOVD $664, R12 - B callbackasm1(SB) - MOVD $665, R12 - B callbackasm1(SB) - MOVD $666, R12 - B callbackasm1(SB) - MOVD $667, R12 - B callbackasm1(SB) - MOVD $668, R12 - B callbackasm1(SB) - MOVD $669, R12 - B callbackasm1(SB) - MOVD $670, R12 - B callbackasm1(SB) - MOVD $671, R12 - B callbackasm1(SB) - MOVD $672, R12 - B callbackasm1(SB) - MOVD $673, R12 - B callbackasm1(SB) - MOVD $674, R12 - B callbackasm1(SB) - MOVD $675, R12 - B callbackasm1(SB) - MOVD $676, R12 - B callbackasm1(SB) - MOVD $677, R12 - B callbackasm1(SB) - MOVD $678, R12 - B callbackasm1(SB) - MOVD $679, R12 - B callbackasm1(SB) - MOVD $680, R12 - B callbackasm1(SB) - MOVD $681, R12 - B callbackasm1(SB) - MOVD $682, R12 - B callbackasm1(SB) - MOVD $683, R12 - B callbackasm1(SB) - MOVD $684, R12 - B callbackasm1(SB) - MOVD $685, R12 - B callbackasm1(SB) - MOVD $686, R12 - B callbackasm1(SB) - MOVD $687, R12 - B callbackasm1(SB) - MOVD $688, R12 - B callbackasm1(SB) - MOVD $689, R12 - B callbackasm1(SB) - MOVD $690, R12 - B callbackasm1(SB) - MOVD $691, R12 - B callbackasm1(SB) - MOVD $692, R12 - B callbackasm1(SB) - MOVD $693, R12 - B callbackasm1(SB) - MOVD $694, R12 - B callbackasm1(SB) - MOVD $695, R12 - B callbackasm1(SB) - MOVD $696, R12 - B callbackasm1(SB) - MOVD $697, R12 - B callbackasm1(SB) - MOVD $698, R12 - B callbackasm1(SB) - MOVD $699, R12 - B callbackasm1(SB) - MOVD $700, R12 - B callbackasm1(SB) - MOVD $701, R12 - B callbackasm1(SB) - MOVD $702, R12 - B callbackasm1(SB) - MOVD $703, R12 - B callbackasm1(SB) - MOVD $704, R12 - B callbackasm1(SB) - MOVD $705, R12 - B callbackasm1(SB) - MOVD $706, R12 - B callbackasm1(SB) - MOVD $707, R12 - B callbackasm1(SB) - MOVD $708, R12 - B callbackasm1(SB) - MOVD $709, R12 - B callbackasm1(SB) - MOVD $710, R12 - B callbackasm1(SB) - MOVD $711, R12 - B callbackasm1(SB) - MOVD $712, R12 - B callbackasm1(SB) - MOVD $713, R12 - B callbackasm1(SB) - MOVD $714, R12 - B callbackasm1(SB) - MOVD $715, R12 - B callbackasm1(SB) - MOVD $716, R12 - B callbackasm1(SB) - MOVD $717, R12 - B callbackasm1(SB) - MOVD $718, R12 - B callbackasm1(SB) - MOVD $719, R12 - B callbackasm1(SB) - MOVD $720, R12 - B callbackasm1(SB) - MOVD $721, R12 - B callbackasm1(SB) - MOVD $722, R12 - B callbackasm1(SB) - MOVD $723, R12 - B callbackasm1(SB) - MOVD $724, R12 - B callbackasm1(SB) - MOVD $725, R12 - B callbackasm1(SB) - MOVD $726, R12 - B callbackasm1(SB) - MOVD $727, R12 - B callbackasm1(SB) - MOVD $728, R12 - B callbackasm1(SB) - MOVD $729, R12 - B callbackasm1(SB) - MOVD $730, R12 - B callbackasm1(SB) - MOVD $731, R12 - B callbackasm1(SB) - MOVD $732, R12 - B callbackasm1(SB) - MOVD $733, R12 - B callbackasm1(SB) - MOVD $734, R12 - B callbackasm1(SB) - MOVD $735, R12 - B callbackasm1(SB) - MOVD $736, R12 - B callbackasm1(SB) - MOVD $737, R12 - B callbackasm1(SB) - MOVD $738, R12 - B callbackasm1(SB) - MOVD $739, R12 - B callbackasm1(SB) - MOVD $740, R12 - B callbackasm1(SB) - MOVD $741, R12 - B callbackasm1(SB) - MOVD $742, R12 - B callbackasm1(SB) - MOVD $743, R12 - B callbackasm1(SB) - MOVD $744, R12 - B callbackasm1(SB) - MOVD $745, R12 - B callbackasm1(SB) - MOVD $746, R12 - B callbackasm1(SB) - MOVD $747, R12 - B callbackasm1(SB) - MOVD $748, R12 - B callbackasm1(SB) - MOVD $749, R12 - B callbackasm1(SB) - MOVD $750, R12 - B callbackasm1(SB) - MOVD $751, R12 - B callbackasm1(SB) - MOVD $752, R12 - B callbackasm1(SB) - MOVD $753, R12 - B callbackasm1(SB) - MOVD $754, R12 - B callbackasm1(SB) - MOVD $755, R12 - B callbackasm1(SB) - MOVD $756, R12 - B callbackasm1(SB) - MOVD $757, R12 - B callbackasm1(SB) - MOVD $758, R12 - B callbackasm1(SB) - MOVD $759, R12 - B callbackasm1(SB) - MOVD $760, R12 - B callbackasm1(SB) - MOVD $761, R12 - B callbackasm1(SB) - MOVD $762, R12 - B callbackasm1(SB) - MOVD $763, R12 - B callbackasm1(SB) - MOVD $764, R12 - B callbackasm1(SB) - MOVD $765, R12 - B callbackasm1(SB) - MOVD $766, R12 - B callbackasm1(SB) - MOVD $767, R12 - B callbackasm1(SB) - MOVD $768, R12 - B callbackasm1(SB) - MOVD $769, R12 - B callbackasm1(SB) - MOVD $770, R12 - B callbackasm1(SB) - MOVD $771, R12 - B callbackasm1(SB) - MOVD $772, R12 - B callbackasm1(SB) - MOVD $773, R12 - B callbackasm1(SB) - MOVD $774, R12 - B callbackasm1(SB) - MOVD $775, R12 - B callbackasm1(SB) - MOVD $776, R12 - B callbackasm1(SB) - MOVD $777, R12 - B callbackasm1(SB) - MOVD $778, R12 - B callbackasm1(SB) - MOVD $779, R12 - B callbackasm1(SB) - MOVD $780, R12 - B callbackasm1(SB) - MOVD $781, R12 - B callbackasm1(SB) - MOVD $782, R12 - B callbackasm1(SB) - MOVD $783, R12 - B callbackasm1(SB) - MOVD $784, R12 - B callbackasm1(SB) - MOVD $785, R12 - B callbackasm1(SB) - MOVD $786, R12 - B callbackasm1(SB) - MOVD $787, R12 - B callbackasm1(SB) - MOVD $788, R12 - B callbackasm1(SB) - MOVD $789, R12 - B callbackasm1(SB) - MOVD $790, R12 - B callbackasm1(SB) - MOVD $791, R12 - B callbackasm1(SB) - MOVD $792, R12 - B callbackasm1(SB) - MOVD $793, R12 - B callbackasm1(SB) - MOVD $794, R12 - B callbackasm1(SB) - MOVD $795, R12 - B callbackasm1(SB) - MOVD $796, R12 - B callbackasm1(SB) - MOVD $797, R12 - B callbackasm1(SB) - MOVD $798, R12 - B callbackasm1(SB) - MOVD $799, R12 - B callbackasm1(SB) - MOVD $800, R12 - B callbackasm1(SB) - MOVD $801, R12 - B callbackasm1(SB) - MOVD $802, R12 - B callbackasm1(SB) - MOVD $803, R12 - B callbackasm1(SB) - MOVD $804, R12 - B callbackasm1(SB) - MOVD $805, R12 - B callbackasm1(SB) - MOVD $806, R12 - B callbackasm1(SB) - MOVD $807, R12 - B callbackasm1(SB) - MOVD $808, R12 - B callbackasm1(SB) - MOVD $809, R12 - B callbackasm1(SB) - MOVD $810, R12 - B callbackasm1(SB) - MOVD $811, R12 - B callbackasm1(SB) - MOVD $812, R12 - B callbackasm1(SB) - MOVD $813, R12 - B callbackasm1(SB) - MOVD $814, R12 - B callbackasm1(SB) - MOVD $815, R12 - B callbackasm1(SB) - MOVD $816, R12 - B callbackasm1(SB) - MOVD $817, R12 - B callbackasm1(SB) - MOVD $818, R12 - B callbackasm1(SB) - MOVD $819, R12 - B callbackasm1(SB) - MOVD $820, R12 - B callbackasm1(SB) - MOVD $821, R12 - B callbackasm1(SB) - MOVD $822, R12 - B callbackasm1(SB) - MOVD $823, R12 - B callbackasm1(SB) - MOVD $824, R12 - B callbackasm1(SB) - MOVD $825, R12 - B callbackasm1(SB) - MOVD $826, R12 - B callbackasm1(SB) - MOVD $827, R12 - B callbackasm1(SB) - MOVD $828, R12 - B callbackasm1(SB) - MOVD $829, R12 - B callbackasm1(SB) - MOVD $830, R12 - B callbackasm1(SB) - MOVD $831, R12 - B callbackasm1(SB) - MOVD $832, R12 - B callbackasm1(SB) - MOVD $833, R12 - B callbackasm1(SB) - MOVD $834, R12 - B callbackasm1(SB) - MOVD $835, R12 - B callbackasm1(SB) - MOVD $836, R12 - B callbackasm1(SB) - MOVD $837, R12 - B callbackasm1(SB) - MOVD $838, R12 - B callbackasm1(SB) - MOVD $839, R12 - B callbackasm1(SB) - MOVD $840, R12 - B callbackasm1(SB) - MOVD $841, R12 - B callbackasm1(SB) - MOVD $842, R12 - B callbackasm1(SB) - MOVD $843, R12 - B callbackasm1(SB) - MOVD $844, R12 - B callbackasm1(SB) - MOVD $845, R12 - B callbackasm1(SB) - MOVD $846, R12 - B callbackasm1(SB) - MOVD $847, R12 - B callbackasm1(SB) - MOVD $848, R12 - B callbackasm1(SB) - MOVD $849, R12 - B callbackasm1(SB) - MOVD $850, R12 - B callbackasm1(SB) - MOVD $851, R12 - B callbackasm1(SB) - MOVD $852, R12 - B callbackasm1(SB) - MOVD $853, R12 - B callbackasm1(SB) - MOVD $854, R12 - B callbackasm1(SB) - MOVD $855, R12 - B callbackasm1(SB) - MOVD $856, R12 - B callbackasm1(SB) - MOVD $857, R12 - B callbackasm1(SB) - MOVD $858, R12 - B callbackasm1(SB) - MOVD $859, R12 - B callbackasm1(SB) - MOVD $860, R12 - B callbackasm1(SB) - MOVD $861, R12 - B callbackasm1(SB) - MOVD $862, R12 - B callbackasm1(SB) - MOVD $863, R12 - B callbackasm1(SB) - MOVD $864, R12 - B callbackasm1(SB) - MOVD $865, R12 - B callbackasm1(SB) - MOVD $866, R12 - B callbackasm1(SB) - MOVD $867, R12 - B callbackasm1(SB) - MOVD $868, R12 - B callbackasm1(SB) - MOVD $869, R12 - B callbackasm1(SB) - MOVD $870, R12 - B callbackasm1(SB) - MOVD $871, R12 - B callbackasm1(SB) - MOVD $872, R12 - B callbackasm1(SB) - MOVD $873, R12 - B callbackasm1(SB) - MOVD $874, R12 - B callbackasm1(SB) - MOVD $875, R12 - B callbackasm1(SB) - MOVD $876, R12 - B callbackasm1(SB) - MOVD $877, R12 - B callbackasm1(SB) - MOVD $878, R12 - B callbackasm1(SB) - MOVD $879, R12 - B callbackasm1(SB) - MOVD $880, R12 - B callbackasm1(SB) - MOVD $881, R12 - B callbackasm1(SB) - MOVD $882, R12 - B callbackasm1(SB) - MOVD $883, R12 - B callbackasm1(SB) - MOVD $884, R12 - B callbackasm1(SB) - MOVD $885, R12 - B callbackasm1(SB) - MOVD $886, R12 - B callbackasm1(SB) - MOVD $887, R12 - B callbackasm1(SB) - MOVD $888, R12 - B callbackasm1(SB) - MOVD $889, R12 - B callbackasm1(SB) - MOVD $890, R12 - B callbackasm1(SB) - MOVD $891, R12 - B callbackasm1(SB) - MOVD $892, R12 - B callbackasm1(SB) - MOVD $893, R12 - B callbackasm1(SB) - MOVD $894, R12 - B callbackasm1(SB) - MOVD $895, R12 - B callbackasm1(SB) - MOVD $896, R12 - B callbackasm1(SB) - MOVD $897, R12 - B callbackasm1(SB) - MOVD $898, R12 - B callbackasm1(SB) - MOVD $899, R12 - B callbackasm1(SB) - MOVD $900, R12 - B callbackasm1(SB) - MOVD $901, R12 - B callbackasm1(SB) - MOVD $902, R12 - B callbackasm1(SB) - MOVD $903, R12 - B callbackasm1(SB) - MOVD $904, R12 - B callbackasm1(SB) - MOVD $905, R12 - B callbackasm1(SB) - MOVD $906, R12 - B callbackasm1(SB) - MOVD $907, R12 - B callbackasm1(SB) - MOVD $908, R12 - B callbackasm1(SB) - MOVD $909, R12 - B callbackasm1(SB) - MOVD $910, R12 - B callbackasm1(SB) - MOVD $911, R12 - B callbackasm1(SB) - MOVD $912, R12 - B callbackasm1(SB) - MOVD $913, R12 - B callbackasm1(SB) - MOVD $914, R12 - B callbackasm1(SB) - MOVD $915, R12 - B callbackasm1(SB) - MOVD $916, R12 - B callbackasm1(SB) - MOVD $917, R12 - B callbackasm1(SB) - MOVD $918, R12 - B callbackasm1(SB) - MOVD $919, R12 - B callbackasm1(SB) - MOVD $920, R12 - B callbackasm1(SB) - MOVD $921, R12 - B callbackasm1(SB) - MOVD $922, R12 - B callbackasm1(SB) - MOVD $923, R12 - B callbackasm1(SB) - MOVD $924, R12 - B callbackasm1(SB) - MOVD $925, R12 - B callbackasm1(SB) - MOVD $926, R12 - B callbackasm1(SB) - MOVD $927, R12 - B callbackasm1(SB) - MOVD $928, R12 - B callbackasm1(SB) - MOVD $929, R12 - B callbackasm1(SB) - MOVD $930, R12 - B callbackasm1(SB) - MOVD $931, R12 - B callbackasm1(SB) - MOVD $932, R12 - B callbackasm1(SB) - MOVD $933, R12 - B callbackasm1(SB) - MOVD $934, R12 - B callbackasm1(SB) - MOVD $935, R12 - B callbackasm1(SB) - MOVD $936, R12 - B callbackasm1(SB) - MOVD $937, R12 - B callbackasm1(SB) - MOVD $938, R12 - B callbackasm1(SB) - MOVD $939, R12 - B callbackasm1(SB) - MOVD $940, R12 - B callbackasm1(SB) - MOVD $941, R12 - B callbackasm1(SB) - MOVD $942, R12 - B callbackasm1(SB) - MOVD $943, R12 - B callbackasm1(SB) - MOVD $944, R12 - B callbackasm1(SB) - MOVD $945, R12 - B callbackasm1(SB) - MOVD $946, R12 - B callbackasm1(SB) - MOVD $947, R12 - B callbackasm1(SB) - MOVD $948, R12 - B callbackasm1(SB) - MOVD $949, R12 - B callbackasm1(SB) - MOVD $950, R12 - B callbackasm1(SB) - MOVD $951, R12 - B callbackasm1(SB) - MOVD $952, R12 - B callbackasm1(SB) - MOVD $953, R12 - B callbackasm1(SB) - MOVD $954, R12 - B callbackasm1(SB) - MOVD $955, R12 - B callbackasm1(SB) - MOVD $956, R12 - B callbackasm1(SB) - MOVD $957, R12 - B callbackasm1(SB) - MOVD $958, R12 - B callbackasm1(SB) - MOVD $959, R12 - B callbackasm1(SB) - MOVD $960, R12 - B callbackasm1(SB) - MOVD $961, R12 - B callbackasm1(SB) - MOVD $962, R12 - B callbackasm1(SB) - MOVD $963, R12 - B callbackasm1(SB) - MOVD $964, R12 - B callbackasm1(SB) - MOVD $965, R12 - B callbackasm1(SB) - MOVD $966, R12 - B callbackasm1(SB) - MOVD $967, R12 - B callbackasm1(SB) - MOVD $968, R12 - B callbackasm1(SB) - MOVD $969, R12 - B callbackasm1(SB) - MOVD $970, R12 - B callbackasm1(SB) - MOVD $971, R12 - B callbackasm1(SB) - MOVD $972, R12 - B callbackasm1(SB) - MOVD $973, R12 - B callbackasm1(SB) - MOVD $974, R12 - B callbackasm1(SB) - MOVD $975, R12 - B callbackasm1(SB) - MOVD $976, R12 - B callbackasm1(SB) - MOVD $977, R12 - B callbackasm1(SB) - MOVD $978, R12 - B callbackasm1(SB) - MOVD $979, R12 - B callbackasm1(SB) - MOVD $980, R12 - B callbackasm1(SB) - MOVD $981, R12 - B callbackasm1(SB) - MOVD $982, R12 - B callbackasm1(SB) - MOVD $983, R12 - B callbackasm1(SB) - MOVD $984, R12 - B callbackasm1(SB) - MOVD $985, R12 - B callbackasm1(SB) - MOVD $986, R12 - B callbackasm1(SB) - MOVD $987, R12 - B callbackasm1(SB) - MOVD $988, R12 - B callbackasm1(SB) - MOVD $989, R12 - B callbackasm1(SB) - MOVD $990, R12 - B callbackasm1(SB) - MOVD $991, R12 - B callbackasm1(SB) - MOVD $992, R12 - B callbackasm1(SB) - MOVD $993, R12 - B callbackasm1(SB) - MOVD $994, R12 - B callbackasm1(SB) - MOVD $995, R12 - B callbackasm1(SB) - MOVD $996, R12 - B callbackasm1(SB) - MOVD $997, R12 - B callbackasm1(SB) - MOVD $998, R12 - B callbackasm1(SB) - MOVD $999, R12 - B callbackasm1(SB) - MOVD $1000, R12 - B callbackasm1(SB) - MOVD $1001, R12 - B callbackasm1(SB) - MOVD $1002, R12 - B callbackasm1(SB) - MOVD $1003, R12 - B callbackasm1(SB) - MOVD $1004, R12 - B callbackasm1(SB) - MOVD $1005, R12 - B callbackasm1(SB) - MOVD $1006, R12 - B callbackasm1(SB) - MOVD $1007, R12 - B callbackasm1(SB) - MOVD $1008, R12 - B callbackasm1(SB) - MOVD $1009, R12 - B callbackasm1(SB) - MOVD $1010, R12 - B callbackasm1(SB) - MOVD $1011, R12 - B callbackasm1(SB) - MOVD $1012, R12 - B callbackasm1(SB) - MOVD $1013, R12 - B callbackasm1(SB) - MOVD $1014, R12 - B callbackasm1(SB) - MOVD $1015, R12 - B callbackasm1(SB) - MOVD $1016, R12 - B callbackasm1(SB) - MOVD $1017, R12 - B callbackasm1(SB) - MOVD $1018, R12 - B callbackasm1(SB) - MOVD $1019, R12 - B callbackasm1(SB) - MOVD $1020, R12 - B callbackasm1(SB) - MOVD $1021, R12 - B callbackasm1(SB) - MOVD $1022, R12 - B callbackasm1(SB) - MOVD $1023, R12 - B callbackasm1(SB) - MOVD $1024, R12 - B callbackasm1(SB) - MOVD $1025, R12 - B callbackasm1(SB) - MOVD $1026, R12 - B callbackasm1(SB) - MOVD $1027, R12 - B callbackasm1(SB) - MOVD $1028, R12 - B callbackasm1(SB) - MOVD $1029, R12 - B callbackasm1(SB) - MOVD $1030, R12 - B callbackasm1(SB) - MOVD $1031, R12 - B callbackasm1(SB) - MOVD $1032, R12 - B callbackasm1(SB) - MOVD $1033, R12 - B callbackasm1(SB) - MOVD $1034, R12 - B callbackasm1(SB) - MOVD $1035, R12 - B callbackasm1(SB) - MOVD $1036, R12 - B callbackasm1(SB) - MOVD $1037, R12 - B callbackasm1(SB) - MOVD $1038, R12 - B callbackasm1(SB) - MOVD $1039, R12 - B callbackasm1(SB) - MOVD $1040, R12 - B callbackasm1(SB) - MOVD $1041, R12 - B callbackasm1(SB) - MOVD $1042, R12 - B callbackasm1(SB) - MOVD $1043, R12 - B callbackasm1(SB) - MOVD $1044, R12 - B callbackasm1(SB) - MOVD $1045, R12 - B callbackasm1(SB) - MOVD $1046, R12 - B callbackasm1(SB) - MOVD $1047, R12 - B callbackasm1(SB) - MOVD $1048, R12 - B callbackasm1(SB) - MOVD $1049, R12 - B callbackasm1(SB) - MOVD $1050, R12 - B callbackasm1(SB) - MOVD $1051, R12 - B callbackasm1(SB) - MOVD $1052, R12 - B callbackasm1(SB) - MOVD $1053, R12 - B callbackasm1(SB) - MOVD $1054, R12 - B callbackasm1(SB) - MOVD $1055, R12 - B callbackasm1(SB) - MOVD $1056, R12 - B callbackasm1(SB) - MOVD $1057, R12 - B callbackasm1(SB) - MOVD $1058, R12 - B callbackasm1(SB) - MOVD $1059, R12 - B callbackasm1(SB) - MOVD $1060, R12 - B callbackasm1(SB) - MOVD $1061, R12 - B callbackasm1(SB) - MOVD $1062, R12 - B callbackasm1(SB) - MOVD $1063, R12 - B callbackasm1(SB) - MOVD $1064, R12 - B callbackasm1(SB) - MOVD $1065, R12 - B callbackasm1(SB) - MOVD $1066, R12 - B callbackasm1(SB) - MOVD $1067, R12 - B callbackasm1(SB) - MOVD $1068, R12 - B callbackasm1(SB) - MOVD $1069, R12 - B callbackasm1(SB) - MOVD $1070, R12 - B callbackasm1(SB) - MOVD $1071, R12 - B callbackasm1(SB) - MOVD $1072, R12 - B callbackasm1(SB) - MOVD $1073, R12 - B callbackasm1(SB) - MOVD $1074, R12 - B callbackasm1(SB) - MOVD $1075, R12 - B callbackasm1(SB) - MOVD $1076, R12 - B callbackasm1(SB) - MOVD $1077, R12 - B callbackasm1(SB) - MOVD $1078, R12 - B callbackasm1(SB) - MOVD $1079, R12 - B callbackasm1(SB) - MOVD $1080, R12 - B callbackasm1(SB) - MOVD $1081, R12 - B callbackasm1(SB) - MOVD $1082, R12 - B callbackasm1(SB) - MOVD $1083, R12 - B callbackasm1(SB) - MOVD $1084, R12 - B callbackasm1(SB) - MOVD $1085, R12 - B callbackasm1(SB) - MOVD $1086, R12 - B callbackasm1(SB) - MOVD $1087, R12 - B callbackasm1(SB) - MOVD $1088, R12 - B callbackasm1(SB) - MOVD $1089, R12 - B callbackasm1(SB) - MOVD $1090, R12 - B callbackasm1(SB) - MOVD $1091, R12 - B callbackasm1(SB) - MOVD $1092, R12 - B callbackasm1(SB) - MOVD $1093, R12 - B callbackasm1(SB) - MOVD $1094, R12 - B callbackasm1(SB) - MOVD $1095, R12 - B callbackasm1(SB) - MOVD $1096, R12 - B callbackasm1(SB) - MOVD $1097, R12 - B callbackasm1(SB) - MOVD $1098, R12 - B callbackasm1(SB) - MOVD $1099, R12 - B callbackasm1(SB) - MOVD $1100, R12 - B callbackasm1(SB) - MOVD $1101, R12 - B callbackasm1(SB) - MOVD $1102, R12 - B callbackasm1(SB) - MOVD $1103, R12 - B callbackasm1(SB) - MOVD $1104, R12 - B callbackasm1(SB) - MOVD $1105, R12 - B callbackasm1(SB) - MOVD $1106, R12 - B callbackasm1(SB) - MOVD $1107, R12 - B callbackasm1(SB) - MOVD $1108, R12 - B callbackasm1(SB) - MOVD $1109, R12 - B callbackasm1(SB) - MOVD $1110, R12 - B callbackasm1(SB) - MOVD $1111, R12 - B callbackasm1(SB) - MOVD $1112, R12 - B callbackasm1(SB) - MOVD $1113, R12 - B callbackasm1(SB) - MOVD $1114, R12 - B callbackasm1(SB) - MOVD $1115, R12 - B callbackasm1(SB) - MOVD $1116, R12 - B callbackasm1(SB) - MOVD $1117, R12 - B callbackasm1(SB) - MOVD $1118, R12 - B callbackasm1(SB) - MOVD $1119, R12 - B callbackasm1(SB) - MOVD $1120, R12 - B callbackasm1(SB) - MOVD $1121, R12 - B callbackasm1(SB) - MOVD $1122, R12 - B callbackasm1(SB) - MOVD $1123, R12 - B callbackasm1(SB) - MOVD $1124, R12 - B callbackasm1(SB) - MOVD $1125, R12 - B callbackasm1(SB) - MOVD $1126, R12 - B callbackasm1(SB) - MOVD $1127, R12 - B callbackasm1(SB) - MOVD $1128, R12 - B callbackasm1(SB) - MOVD $1129, R12 - B callbackasm1(SB) - MOVD $1130, R12 - B callbackasm1(SB) - MOVD $1131, R12 - B callbackasm1(SB) - MOVD $1132, R12 - B callbackasm1(SB) - MOVD $1133, R12 - B callbackasm1(SB) - MOVD $1134, R12 - B callbackasm1(SB) - MOVD $1135, R12 - B callbackasm1(SB) - MOVD $1136, R12 - B callbackasm1(SB) - MOVD $1137, R12 - B callbackasm1(SB) - MOVD $1138, R12 - B callbackasm1(SB) - MOVD $1139, R12 - B callbackasm1(SB) - MOVD $1140, R12 - B callbackasm1(SB) - MOVD $1141, R12 - B callbackasm1(SB) - MOVD $1142, R12 - B callbackasm1(SB) - MOVD $1143, R12 - B callbackasm1(SB) - MOVD $1144, R12 - B callbackasm1(SB) - MOVD $1145, R12 - B callbackasm1(SB) - MOVD $1146, R12 - B callbackasm1(SB) - MOVD $1147, R12 - B callbackasm1(SB) - MOVD $1148, R12 - B callbackasm1(SB) - MOVD $1149, R12 - B callbackasm1(SB) - MOVD $1150, R12 - B callbackasm1(SB) - MOVD $1151, R12 - B callbackasm1(SB) - MOVD $1152, R12 - B callbackasm1(SB) - MOVD $1153, R12 - B callbackasm1(SB) - MOVD $1154, R12 - B callbackasm1(SB) - MOVD $1155, R12 - B callbackasm1(SB) - MOVD $1156, R12 - B callbackasm1(SB) - MOVD $1157, R12 - B callbackasm1(SB) - MOVD $1158, R12 - B callbackasm1(SB) - MOVD $1159, R12 - B callbackasm1(SB) - MOVD $1160, R12 - B callbackasm1(SB) - MOVD $1161, R12 - B callbackasm1(SB) - MOVD $1162, R12 - B callbackasm1(SB) - MOVD $1163, R12 - B callbackasm1(SB) - MOVD $1164, R12 - B callbackasm1(SB) - MOVD $1165, R12 - B callbackasm1(SB) - MOVD $1166, R12 - B callbackasm1(SB) - MOVD $1167, R12 - B callbackasm1(SB) - MOVD $1168, R12 - B callbackasm1(SB) - MOVD $1169, R12 - B callbackasm1(SB) - MOVD $1170, R12 - B callbackasm1(SB) - MOVD $1171, R12 - B callbackasm1(SB) - MOVD $1172, R12 - B callbackasm1(SB) - MOVD $1173, R12 - B callbackasm1(SB) - MOVD $1174, R12 - B callbackasm1(SB) - MOVD $1175, R12 - B callbackasm1(SB) - MOVD $1176, R12 - B callbackasm1(SB) - MOVD $1177, R12 - B callbackasm1(SB) - MOVD $1178, R12 - B callbackasm1(SB) - MOVD $1179, R12 - B callbackasm1(SB) - MOVD $1180, R12 - B callbackasm1(SB) - MOVD $1181, R12 - B callbackasm1(SB) - MOVD $1182, R12 - B callbackasm1(SB) - MOVD $1183, R12 - B callbackasm1(SB) - MOVD $1184, R12 - B callbackasm1(SB) - MOVD $1185, R12 - B callbackasm1(SB) - MOVD $1186, R12 - B callbackasm1(SB) - MOVD $1187, R12 - B callbackasm1(SB) - MOVD $1188, R12 - B callbackasm1(SB) - MOVD $1189, R12 - B callbackasm1(SB) - MOVD $1190, R12 - B callbackasm1(SB) - MOVD $1191, R12 - B callbackasm1(SB) - MOVD $1192, R12 - B callbackasm1(SB) - MOVD $1193, R12 - B callbackasm1(SB) - MOVD $1194, R12 - B callbackasm1(SB) - MOVD $1195, R12 - B callbackasm1(SB) - MOVD $1196, R12 - B callbackasm1(SB) - MOVD $1197, R12 - B callbackasm1(SB) - MOVD $1198, R12 - B callbackasm1(SB) - MOVD $1199, R12 - B callbackasm1(SB) - MOVD $1200, R12 - B callbackasm1(SB) - MOVD $1201, R12 - B callbackasm1(SB) - MOVD $1202, R12 - B callbackasm1(SB) - MOVD $1203, R12 - B callbackasm1(SB) - MOVD $1204, R12 - B callbackasm1(SB) - MOVD $1205, R12 - B callbackasm1(SB) - MOVD $1206, R12 - B callbackasm1(SB) - MOVD $1207, R12 - B callbackasm1(SB) - MOVD $1208, R12 - B callbackasm1(SB) - MOVD $1209, R12 - B callbackasm1(SB) - MOVD $1210, R12 - B callbackasm1(SB) - MOVD $1211, R12 - B callbackasm1(SB) - MOVD $1212, R12 - B callbackasm1(SB) - MOVD $1213, R12 - B callbackasm1(SB) - MOVD $1214, R12 - B callbackasm1(SB) - MOVD $1215, R12 - B callbackasm1(SB) - MOVD $1216, R12 - B callbackasm1(SB) - MOVD $1217, R12 - B callbackasm1(SB) - MOVD $1218, R12 - B callbackasm1(SB) - MOVD $1219, R12 - B callbackasm1(SB) - MOVD $1220, R12 - B callbackasm1(SB) - MOVD $1221, R12 - B callbackasm1(SB) - MOVD $1222, R12 - B callbackasm1(SB) - MOVD $1223, R12 - B callbackasm1(SB) - MOVD $1224, R12 - B callbackasm1(SB) - MOVD $1225, R12 - B callbackasm1(SB) - MOVD $1226, R12 - B callbackasm1(SB) - MOVD $1227, R12 - B callbackasm1(SB) - MOVD $1228, R12 - B callbackasm1(SB) - MOVD $1229, R12 - B callbackasm1(SB) - MOVD $1230, R12 - B callbackasm1(SB) - MOVD $1231, R12 - B callbackasm1(SB) - MOVD $1232, R12 - B callbackasm1(SB) - MOVD $1233, R12 - B callbackasm1(SB) - MOVD $1234, R12 - B callbackasm1(SB) - MOVD $1235, R12 - B callbackasm1(SB) - MOVD $1236, R12 - B callbackasm1(SB) - MOVD $1237, R12 - B callbackasm1(SB) - MOVD $1238, R12 - B callbackasm1(SB) - MOVD $1239, R12 - B callbackasm1(SB) - MOVD $1240, R12 - B callbackasm1(SB) - MOVD $1241, R12 - B callbackasm1(SB) - MOVD $1242, R12 - B callbackasm1(SB) - MOVD $1243, R12 - B callbackasm1(SB) - MOVD $1244, R12 - B callbackasm1(SB) - MOVD $1245, R12 - B callbackasm1(SB) - MOVD $1246, R12 - B callbackasm1(SB) - MOVD $1247, R12 - B callbackasm1(SB) - MOVD $1248, R12 - B callbackasm1(SB) - MOVD $1249, R12 - B callbackasm1(SB) - MOVD $1250, R12 - B callbackasm1(SB) - MOVD $1251, R12 - B callbackasm1(SB) - MOVD $1252, R12 - B callbackasm1(SB) - MOVD $1253, R12 - B callbackasm1(SB) - MOVD $1254, R12 - B callbackasm1(SB) - MOVD $1255, R12 - B callbackasm1(SB) - MOVD $1256, R12 - B callbackasm1(SB) - MOVD $1257, R12 - B callbackasm1(SB) - MOVD $1258, R12 - B callbackasm1(SB) - MOVD $1259, R12 - B callbackasm1(SB) - MOVD $1260, R12 - B callbackasm1(SB) - MOVD $1261, R12 - B callbackasm1(SB) - MOVD $1262, R12 - B callbackasm1(SB) - MOVD $1263, R12 - B callbackasm1(SB) - MOVD $1264, R12 - B callbackasm1(SB) - MOVD $1265, R12 - B callbackasm1(SB) - MOVD $1266, R12 - B callbackasm1(SB) - MOVD $1267, R12 - B callbackasm1(SB) - MOVD $1268, R12 - B callbackasm1(SB) - MOVD $1269, R12 - B callbackasm1(SB) - MOVD $1270, R12 - B callbackasm1(SB) - MOVD $1271, R12 - B callbackasm1(SB) - MOVD $1272, R12 - B callbackasm1(SB) - MOVD $1273, R12 - B callbackasm1(SB) - MOVD $1274, R12 - B callbackasm1(SB) - MOVD $1275, R12 - B callbackasm1(SB) - MOVD $1276, R12 - B callbackasm1(SB) - MOVD $1277, R12 - B callbackasm1(SB) - MOVD $1278, R12 - B callbackasm1(SB) - MOVD $1279, R12 - B callbackasm1(SB) - MOVD $1280, R12 - B callbackasm1(SB) - MOVD $1281, R12 - B callbackasm1(SB) - MOVD $1282, R12 - B callbackasm1(SB) - MOVD $1283, R12 - B callbackasm1(SB) - MOVD $1284, R12 - B callbackasm1(SB) - MOVD $1285, R12 - B callbackasm1(SB) - MOVD $1286, R12 - B callbackasm1(SB) - MOVD $1287, R12 - B callbackasm1(SB) - MOVD $1288, R12 - B callbackasm1(SB) - MOVD $1289, R12 - B callbackasm1(SB) - MOVD $1290, R12 - B callbackasm1(SB) - MOVD $1291, R12 - B callbackasm1(SB) - MOVD $1292, R12 - B callbackasm1(SB) - MOVD $1293, R12 - B callbackasm1(SB) - MOVD $1294, R12 - B callbackasm1(SB) - MOVD $1295, R12 - B callbackasm1(SB) - MOVD $1296, R12 - B callbackasm1(SB) - MOVD $1297, R12 - B callbackasm1(SB) - MOVD $1298, R12 - B callbackasm1(SB) - MOVD $1299, R12 - B callbackasm1(SB) - MOVD $1300, R12 - B callbackasm1(SB) - MOVD $1301, R12 - B callbackasm1(SB) - MOVD $1302, R12 - B callbackasm1(SB) - MOVD $1303, R12 - B callbackasm1(SB) - MOVD $1304, R12 - B callbackasm1(SB) - MOVD $1305, R12 - B callbackasm1(SB) - MOVD $1306, R12 - B callbackasm1(SB) - MOVD $1307, R12 - B callbackasm1(SB) - MOVD $1308, R12 - B callbackasm1(SB) - MOVD $1309, R12 - B callbackasm1(SB) - MOVD $1310, R12 - B callbackasm1(SB) - MOVD $1311, R12 - B callbackasm1(SB) - MOVD $1312, R12 - B callbackasm1(SB) - MOVD $1313, R12 - B callbackasm1(SB) - MOVD $1314, R12 - B callbackasm1(SB) - MOVD $1315, R12 - B callbackasm1(SB) - MOVD $1316, R12 - B callbackasm1(SB) - MOVD $1317, R12 - B callbackasm1(SB) - MOVD $1318, R12 - B callbackasm1(SB) - MOVD $1319, R12 - B callbackasm1(SB) - MOVD $1320, R12 - B callbackasm1(SB) - MOVD $1321, R12 - B callbackasm1(SB) - MOVD $1322, R12 - B callbackasm1(SB) - MOVD $1323, R12 - B callbackasm1(SB) - MOVD $1324, R12 - B callbackasm1(SB) - MOVD $1325, R12 - B callbackasm1(SB) - MOVD $1326, R12 - B callbackasm1(SB) - MOVD $1327, R12 - B callbackasm1(SB) - MOVD $1328, R12 - B callbackasm1(SB) - MOVD $1329, R12 - B callbackasm1(SB) - MOVD $1330, R12 - B callbackasm1(SB) - MOVD $1331, R12 - B callbackasm1(SB) - MOVD $1332, R12 - B callbackasm1(SB) - MOVD $1333, R12 - B callbackasm1(SB) - MOVD $1334, R12 - B callbackasm1(SB) - MOVD $1335, R12 - B callbackasm1(SB) - MOVD $1336, R12 - B callbackasm1(SB) - MOVD $1337, R12 - B callbackasm1(SB) - MOVD $1338, R12 - B callbackasm1(SB) - MOVD $1339, R12 - B callbackasm1(SB) - MOVD $1340, R12 - B callbackasm1(SB) - MOVD $1341, R12 - B callbackasm1(SB) - MOVD $1342, R12 - B callbackasm1(SB) - MOVD $1343, R12 - B callbackasm1(SB) - MOVD $1344, R12 - B callbackasm1(SB) - MOVD $1345, R12 - B callbackasm1(SB) - MOVD $1346, R12 - B callbackasm1(SB) - MOVD $1347, R12 - B callbackasm1(SB) - MOVD $1348, R12 - B callbackasm1(SB) - MOVD $1349, R12 - B callbackasm1(SB) - MOVD $1350, R12 - B callbackasm1(SB) - MOVD $1351, R12 - B callbackasm1(SB) - MOVD $1352, R12 - B callbackasm1(SB) - MOVD $1353, R12 - B callbackasm1(SB) - MOVD $1354, R12 - B callbackasm1(SB) - MOVD $1355, R12 - B callbackasm1(SB) - MOVD $1356, R12 - B callbackasm1(SB) - MOVD $1357, R12 - B callbackasm1(SB) - MOVD $1358, R12 - B callbackasm1(SB) - MOVD $1359, R12 - B callbackasm1(SB) - MOVD $1360, R12 - B callbackasm1(SB) - MOVD $1361, R12 - B callbackasm1(SB) - MOVD $1362, R12 - B callbackasm1(SB) - MOVD $1363, R12 - B callbackasm1(SB) - MOVD $1364, R12 - B callbackasm1(SB) - MOVD $1365, R12 - B callbackasm1(SB) - MOVD $1366, R12 - B callbackasm1(SB) - MOVD $1367, R12 - B callbackasm1(SB) - MOVD $1368, R12 - B callbackasm1(SB) - MOVD $1369, R12 - B callbackasm1(SB) - MOVD $1370, R12 - B callbackasm1(SB) - MOVD $1371, R12 - B callbackasm1(SB) - MOVD $1372, R12 - B callbackasm1(SB) - MOVD $1373, R12 - B callbackasm1(SB) - MOVD $1374, R12 - B callbackasm1(SB) - MOVD $1375, R12 - B callbackasm1(SB) - MOVD $1376, R12 - B callbackasm1(SB) - MOVD $1377, R12 - B callbackasm1(SB) - MOVD $1378, R12 - B callbackasm1(SB) - MOVD $1379, R12 - B callbackasm1(SB) - MOVD $1380, R12 - B callbackasm1(SB) - MOVD $1381, R12 - B callbackasm1(SB) - MOVD $1382, R12 - B callbackasm1(SB) - MOVD $1383, R12 - B callbackasm1(SB) - MOVD $1384, R12 - B callbackasm1(SB) - MOVD $1385, R12 - B callbackasm1(SB) - MOVD $1386, R12 - B callbackasm1(SB) - MOVD $1387, R12 - B callbackasm1(SB) - MOVD $1388, R12 - B callbackasm1(SB) - MOVD $1389, R12 - B callbackasm1(SB) - MOVD $1390, R12 - B callbackasm1(SB) - MOVD $1391, R12 - B callbackasm1(SB) - MOVD $1392, R12 - B callbackasm1(SB) - MOVD $1393, R12 - B callbackasm1(SB) - MOVD $1394, R12 - B callbackasm1(SB) - MOVD $1395, R12 - B callbackasm1(SB) - MOVD $1396, R12 - B callbackasm1(SB) - MOVD $1397, R12 - B callbackasm1(SB) - MOVD $1398, R12 - B callbackasm1(SB) - MOVD $1399, R12 - B callbackasm1(SB) - MOVD $1400, R12 - B callbackasm1(SB) - MOVD $1401, R12 - B callbackasm1(SB) - MOVD $1402, R12 - B callbackasm1(SB) - MOVD $1403, R12 - B callbackasm1(SB) - MOVD $1404, R12 - B callbackasm1(SB) - MOVD $1405, R12 - B callbackasm1(SB) - MOVD $1406, R12 - B callbackasm1(SB) - MOVD $1407, R12 - B callbackasm1(SB) - MOVD $1408, R12 - B callbackasm1(SB) - MOVD $1409, R12 - B callbackasm1(SB) - MOVD $1410, R12 - B callbackasm1(SB) - MOVD $1411, R12 - B callbackasm1(SB) - MOVD $1412, R12 - B callbackasm1(SB) - MOVD $1413, R12 - B callbackasm1(SB) - MOVD $1414, R12 - B callbackasm1(SB) - MOVD $1415, R12 - B callbackasm1(SB) - MOVD $1416, R12 - B callbackasm1(SB) - MOVD $1417, R12 - B callbackasm1(SB) - MOVD $1418, R12 - B callbackasm1(SB) - MOVD $1419, R12 - B callbackasm1(SB) - MOVD $1420, R12 - B callbackasm1(SB) - MOVD $1421, R12 - B callbackasm1(SB) - MOVD $1422, R12 - B callbackasm1(SB) - MOVD $1423, R12 - B callbackasm1(SB) - MOVD $1424, R12 - B callbackasm1(SB) - MOVD $1425, R12 - B callbackasm1(SB) - MOVD $1426, R12 - B callbackasm1(SB) - MOVD $1427, R12 - B callbackasm1(SB) - MOVD $1428, R12 - B callbackasm1(SB) - MOVD $1429, R12 - B callbackasm1(SB) - MOVD $1430, R12 - B callbackasm1(SB) - MOVD $1431, R12 - B callbackasm1(SB) - MOVD $1432, R12 - B callbackasm1(SB) - MOVD $1433, R12 - B callbackasm1(SB) - MOVD $1434, R12 - B callbackasm1(SB) - MOVD $1435, R12 - B callbackasm1(SB) - MOVD $1436, R12 - B callbackasm1(SB) - MOVD $1437, R12 - B callbackasm1(SB) - MOVD $1438, R12 - B callbackasm1(SB) - MOVD $1439, R12 - B callbackasm1(SB) - MOVD $1440, R12 - B callbackasm1(SB) - MOVD $1441, R12 - B callbackasm1(SB) - MOVD $1442, R12 - B callbackasm1(SB) - MOVD $1443, R12 - B callbackasm1(SB) - MOVD $1444, R12 - B callbackasm1(SB) - MOVD $1445, R12 - B callbackasm1(SB) - MOVD $1446, R12 - B callbackasm1(SB) - MOVD $1447, R12 - B callbackasm1(SB) - MOVD $1448, R12 - B callbackasm1(SB) - MOVD $1449, R12 - B callbackasm1(SB) - MOVD $1450, R12 - B callbackasm1(SB) - MOVD $1451, R12 - B callbackasm1(SB) - MOVD $1452, R12 - B callbackasm1(SB) - MOVD $1453, R12 - B callbackasm1(SB) - MOVD $1454, R12 - B callbackasm1(SB) - MOVD $1455, R12 - B callbackasm1(SB) - MOVD $1456, R12 - B callbackasm1(SB) - MOVD $1457, R12 - B callbackasm1(SB) - MOVD $1458, R12 - B callbackasm1(SB) - MOVD $1459, R12 - B callbackasm1(SB) - MOVD $1460, R12 - B callbackasm1(SB) - MOVD $1461, R12 - B callbackasm1(SB) - MOVD $1462, R12 - B callbackasm1(SB) - MOVD $1463, R12 - B callbackasm1(SB) - MOVD $1464, R12 - B callbackasm1(SB) - MOVD $1465, R12 - B callbackasm1(SB) - MOVD $1466, R12 - B callbackasm1(SB) - MOVD $1467, R12 - B callbackasm1(SB) - MOVD $1468, R12 - B callbackasm1(SB) - MOVD $1469, R12 - B callbackasm1(SB) - MOVD $1470, R12 - B callbackasm1(SB) - MOVD $1471, R12 - B callbackasm1(SB) - MOVD $1472, R12 - B callbackasm1(SB) - MOVD $1473, R12 - B callbackasm1(SB) - MOVD $1474, R12 - B callbackasm1(SB) - MOVD $1475, R12 - B callbackasm1(SB) - MOVD $1476, R12 - B callbackasm1(SB) - MOVD $1477, R12 - B callbackasm1(SB) - MOVD $1478, R12 - B callbackasm1(SB) - MOVD $1479, R12 - B callbackasm1(SB) - MOVD $1480, R12 - B callbackasm1(SB) - MOVD $1481, R12 - B callbackasm1(SB) - MOVD $1482, R12 - B callbackasm1(SB) - MOVD $1483, R12 - B callbackasm1(SB) - MOVD $1484, R12 - B callbackasm1(SB) - MOVD $1485, R12 - B callbackasm1(SB) - MOVD $1486, R12 - B callbackasm1(SB) - MOVD $1487, R12 - B callbackasm1(SB) - MOVD $1488, R12 - B callbackasm1(SB) - MOVD $1489, R12 - B callbackasm1(SB) - MOVD $1490, R12 - B callbackasm1(SB) - MOVD $1491, R12 - B callbackasm1(SB) - MOVD $1492, R12 - B callbackasm1(SB) - MOVD $1493, R12 - B callbackasm1(SB) - MOVD $1494, R12 - B callbackasm1(SB) - MOVD $1495, R12 - B callbackasm1(SB) - MOVD $1496, R12 - B callbackasm1(SB) - MOVD $1497, R12 - B callbackasm1(SB) - MOVD $1498, R12 - B callbackasm1(SB) - MOVD $1499, R12 - B callbackasm1(SB) - MOVD $1500, R12 - B callbackasm1(SB) - MOVD $1501, R12 - B callbackasm1(SB) - MOVD $1502, R12 - B callbackasm1(SB) - MOVD $1503, R12 - B callbackasm1(SB) - MOVD $1504, R12 - B callbackasm1(SB) - MOVD $1505, R12 - B callbackasm1(SB) - MOVD $1506, R12 - B callbackasm1(SB) - MOVD $1507, R12 - B callbackasm1(SB) - MOVD $1508, R12 - B callbackasm1(SB) - MOVD $1509, R12 - B callbackasm1(SB) - MOVD $1510, R12 - B callbackasm1(SB) - MOVD $1511, R12 - B callbackasm1(SB) - MOVD $1512, R12 - B callbackasm1(SB) - MOVD $1513, R12 - B callbackasm1(SB) - MOVD $1514, R12 - B callbackasm1(SB) - MOVD $1515, R12 - B callbackasm1(SB) - MOVD $1516, R12 - B callbackasm1(SB) - MOVD $1517, R12 - B callbackasm1(SB) - MOVD $1518, R12 - B callbackasm1(SB) - MOVD $1519, R12 - B callbackasm1(SB) - MOVD $1520, R12 - B callbackasm1(SB) - MOVD $1521, R12 - B callbackasm1(SB) - MOVD $1522, R12 - B callbackasm1(SB) - MOVD $1523, R12 - B callbackasm1(SB) - MOVD $1524, R12 - B callbackasm1(SB) - MOVD $1525, R12 - B callbackasm1(SB) - MOVD $1526, R12 - B callbackasm1(SB) - MOVD $1527, R12 - B callbackasm1(SB) - MOVD $1528, R12 - B callbackasm1(SB) - MOVD $1529, R12 - B callbackasm1(SB) - MOVD $1530, R12 - B callbackasm1(SB) - MOVD $1531, R12 - B callbackasm1(SB) - MOVD $1532, R12 - B callbackasm1(SB) - MOVD $1533, R12 - B callbackasm1(SB) - MOVD $1534, R12 - B callbackasm1(SB) - MOVD $1535, R12 - B callbackasm1(SB) - MOVD $1536, R12 - B callbackasm1(SB) - MOVD $1537, R12 - B callbackasm1(SB) - MOVD $1538, R12 - B callbackasm1(SB) - MOVD $1539, R12 - B callbackasm1(SB) - MOVD $1540, R12 - B callbackasm1(SB) - MOVD $1541, R12 - B callbackasm1(SB) - MOVD $1542, R12 - B callbackasm1(SB) - MOVD $1543, R12 - B callbackasm1(SB) - MOVD $1544, R12 - B callbackasm1(SB) - MOVD $1545, R12 - B callbackasm1(SB) - MOVD $1546, R12 - B callbackasm1(SB) - MOVD $1547, R12 - B callbackasm1(SB) - MOVD $1548, R12 - B callbackasm1(SB) - MOVD $1549, R12 - B callbackasm1(SB) - MOVD $1550, R12 - B callbackasm1(SB) - MOVD $1551, R12 - B callbackasm1(SB) - MOVD $1552, R12 - B callbackasm1(SB) - MOVD $1553, R12 - B callbackasm1(SB) - MOVD $1554, R12 - B callbackasm1(SB) - MOVD $1555, R12 - B callbackasm1(SB) - MOVD $1556, R12 - B callbackasm1(SB) - MOVD $1557, R12 - B callbackasm1(SB) - MOVD $1558, R12 - B callbackasm1(SB) - MOVD $1559, R12 - B callbackasm1(SB) - MOVD $1560, R12 - B callbackasm1(SB) - MOVD $1561, R12 - B callbackasm1(SB) - MOVD $1562, R12 - B callbackasm1(SB) - MOVD $1563, R12 - B callbackasm1(SB) - MOVD $1564, R12 - B callbackasm1(SB) - MOVD $1565, R12 - B callbackasm1(SB) - MOVD $1566, R12 - B callbackasm1(SB) - MOVD $1567, R12 - B callbackasm1(SB) - MOVD $1568, R12 - B callbackasm1(SB) - MOVD $1569, R12 - B callbackasm1(SB) - MOVD $1570, R12 - B callbackasm1(SB) - MOVD $1571, R12 - B callbackasm1(SB) - MOVD $1572, R12 - B callbackasm1(SB) - MOVD $1573, R12 - B callbackasm1(SB) - MOVD $1574, R12 - B callbackasm1(SB) - MOVD $1575, R12 - B callbackasm1(SB) - MOVD $1576, R12 - B callbackasm1(SB) - MOVD $1577, R12 - B callbackasm1(SB) - MOVD $1578, R12 - B callbackasm1(SB) - MOVD $1579, R12 - B callbackasm1(SB) - MOVD $1580, R12 - B callbackasm1(SB) - MOVD $1581, R12 - B callbackasm1(SB) - MOVD $1582, R12 - B callbackasm1(SB) - MOVD $1583, R12 - B callbackasm1(SB) - MOVD $1584, R12 - B callbackasm1(SB) - MOVD $1585, R12 - B callbackasm1(SB) - MOVD $1586, R12 - B callbackasm1(SB) - MOVD $1587, R12 - B callbackasm1(SB) - MOVD $1588, R12 - B callbackasm1(SB) - MOVD $1589, R12 - B callbackasm1(SB) - MOVD $1590, R12 - B callbackasm1(SB) - MOVD $1591, R12 - B callbackasm1(SB) - MOVD $1592, R12 - B callbackasm1(SB) - MOVD $1593, R12 - B callbackasm1(SB) - MOVD $1594, R12 - B callbackasm1(SB) - MOVD $1595, R12 - B callbackasm1(SB) - MOVD $1596, R12 - B callbackasm1(SB) - MOVD $1597, R12 - B callbackasm1(SB) - MOVD $1598, R12 - B callbackasm1(SB) - MOVD $1599, R12 - B callbackasm1(SB) - MOVD $1600, R12 - B callbackasm1(SB) - MOVD $1601, R12 - B callbackasm1(SB) - MOVD $1602, R12 - B callbackasm1(SB) - MOVD $1603, R12 - B callbackasm1(SB) - MOVD $1604, R12 - B callbackasm1(SB) - MOVD $1605, R12 - B callbackasm1(SB) - MOVD $1606, R12 - B callbackasm1(SB) - MOVD $1607, R12 - B callbackasm1(SB) - MOVD $1608, R12 - B callbackasm1(SB) - MOVD $1609, R12 - B callbackasm1(SB) - MOVD $1610, R12 - B callbackasm1(SB) - MOVD $1611, R12 - B callbackasm1(SB) - MOVD $1612, R12 - B callbackasm1(SB) - MOVD $1613, R12 - B callbackasm1(SB) - MOVD $1614, R12 - B callbackasm1(SB) - MOVD $1615, R12 - B callbackasm1(SB) - MOVD $1616, R12 - B callbackasm1(SB) - MOVD $1617, R12 - B callbackasm1(SB) - MOVD $1618, R12 - B callbackasm1(SB) - MOVD $1619, R12 - B callbackasm1(SB) - MOVD $1620, R12 - B callbackasm1(SB) - MOVD $1621, R12 - B callbackasm1(SB) - MOVD $1622, R12 - B callbackasm1(SB) - MOVD $1623, R12 - B callbackasm1(SB) - MOVD $1624, R12 - B callbackasm1(SB) - MOVD $1625, R12 - B callbackasm1(SB) - MOVD $1626, R12 - B callbackasm1(SB) - MOVD $1627, R12 - B callbackasm1(SB) - MOVD $1628, R12 - B callbackasm1(SB) - MOVD $1629, R12 - B callbackasm1(SB) - MOVD $1630, R12 - B callbackasm1(SB) - MOVD $1631, R12 - B callbackasm1(SB) - MOVD $1632, R12 - B callbackasm1(SB) - MOVD $1633, R12 - B callbackasm1(SB) - MOVD $1634, R12 - B callbackasm1(SB) - MOVD $1635, R12 - B callbackasm1(SB) - MOVD $1636, R12 - B callbackasm1(SB) - MOVD $1637, R12 - B callbackasm1(SB) - MOVD $1638, R12 - B callbackasm1(SB) - MOVD $1639, R12 - B callbackasm1(SB) - MOVD $1640, R12 - B callbackasm1(SB) - MOVD $1641, R12 - B callbackasm1(SB) - MOVD $1642, R12 - B callbackasm1(SB) - MOVD $1643, R12 - B callbackasm1(SB) - MOVD $1644, R12 - B callbackasm1(SB) - MOVD $1645, R12 - B callbackasm1(SB) - MOVD $1646, R12 - B callbackasm1(SB) - MOVD $1647, R12 - B callbackasm1(SB) - MOVD $1648, R12 - B callbackasm1(SB) - MOVD $1649, R12 - B callbackasm1(SB) - MOVD $1650, R12 - B callbackasm1(SB) - MOVD $1651, R12 - B callbackasm1(SB) - MOVD $1652, R12 - B callbackasm1(SB) - MOVD $1653, R12 - B callbackasm1(SB) - MOVD $1654, R12 - B callbackasm1(SB) - MOVD $1655, R12 - B callbackasm1(SB) - MOVD $1656, R12 - B callbackasm1(SB) - MOVD $1657, R12 - B callbackasm1(SB) - MOVD $1658, R12 - B callbackasm1(SB) - MOVD $1659, R12 - B callbackasm1(SB) - MOVD $1660, R12 - B callbackasm1(SB) - MOVD $1661, R12 - B callbackasm1(SB) - MOVD $1662, R12 - B callbackasm1(SB) - MOVD $1663, R12 - B callbackasm1(SB) - MOVD $1664, R12 - B callbackasm1(SB) - MOVD $1665, R12 - B callbackasm1(SB) - MOVD $1666, R12 - B callbackasm1(SB) - MOVD $1667, R12 - B callbackasm1(SB) - MOVD $1668, R12 - B callbackasm1(SB) - MOVD $1669, R12 - B callbackasm1(SB) - MOVD $1670, R12 - B callbackasm1(SB) - MOVD $1671, R12 - B callbackasm1(SB) - MOVD $1672, R12 - B callbackasm1(SB) - MOVD $1673, R12 - B callbackasm1(SB) - MOVD $1674, R12 - B callbackasm1(SB) - MOVD $1675, R12 - B callbackasm1(SB) - MOVD $1676, R12 - B callbackasm1(SB) - MOVD $1677, R12 - B callbackasm1(SB) - MOVD $1678, R12 - B callbackasm1(SB) - MOVD $1679, R12 - B callbackasm1(SB) - MOVD $1680, R12 - B callbackasm1(SB) - MOVD $1681, R12 - B callbackasm1(SB) - MOVD $1682, R12 - B callbackasm1(SB) - MOVD $1683, R12 - B callbackasm1(SB) - MOVD $1684, R12 - B callbackasm1(SB) - MOVD $1685, R12 - B callbackasm1(SB) - MOVD $1686, R12 - B callbackasm1(SB) - MOVD $1687, R12 - B callbackasm1(SB) - MOVD $1688, R12 - B callbackasm1(SB) - MOVD $1689, R12 - B callbackasm1(SB) - MOVD $1690, R12 - B callbackasm1(SB) - MOVD $1691, R12 - B callbackasm1(SB) - MOVD $1692, R12 - B callbackasm1(SB) - MOVD $1693, R12 - B callbackasm1(SB) - MOVD $1694, R12 - B callbackasm1(SB) - MOVD $1695, R12 - B callbackasm1(SB) - MOVD $1696, R12 - B callbackasm1(SB) - MOVD $1697, R12 - B callbackasm1(SB) - MOVD $1698, R12 - B callbackasm1(SB) - MOVD $1699, R12 - B callbackasm1(SB) - MOVD $1700, R12 - B callbackasm1(SB) - MOVD $1701, R12 - B callbackasm1(SB) - MOVD $1702, R12 - B callbackasm1(SB) - MOVD $1703, R12 - B callbackasm1(SB) - MOVD $1704, R12 - B callbackasm1(SB) - MOVD $1705, R12 - B callbackasm1(SB) - MOVD $1706, R12 - B callbackasm1(SB) - MOVD $1707, R12 - B callbackasm1(SB) - MOVD $1708, R12 - B callbackasm1(SB) - MOVD $1709, R12 - B callbackasm1(SB) - MOVD $1710, R12 - B callbackasm1(SB) - MOVD $1711, R12 - B callbackasm1(SB) - MOVD $1712, R12 - B callbackasm1(SB) - MOVD $1713, R12 - B callbackasm1(SB) - MOVD $1714, R12 - B callbackasm1(SB) - MOVD $1715, R12 - B callbackasm1(SB) - MOVD $1716, R12 - B callbackasm1(SB) - MOVD $1717, R12 - B callbackasm1(SB) - MOVD $1718, R12 - B callbackasm1(SB) - MOVD $1719, R12 - B callbackasm1(SB) - MOVD $1720, R12 - B callbackasm1(SB) - MOVD $1721, R12 - B callbackasm1(SB) - MOVD $1722, R12 - B callbackasm1(SB) - MOVD $1723, R12 - B callbackasm1(SB) - MOVD $1724, R12 - B callbackasm1(SB) - MOVD $1725, R12 - B callbackasm1(SB) - MOVD $1726, R12 - B callbackasm1(SB) - MOVD $1727, R12 - B callbackasm1(SB) - MOVD $1728, R12 - B callbackasm1(SB) - MOVD $1729, R12 - B callbackasm1(SB) - MOVD $1730, R12 - B callbackasm1(SB) - MOVD $1731, R12 - B callbackasm1(SB) - MOVD $1732, R12 - B callbackasm1(SB) - MOVD $1733, R12 - B callbackasm1(SB) - MOVD $1734, R12 - B callbackasm1(SB) - MOVD $1735, R12 - B callbackasm1(SB) - MOVD $1736, R12 - B callbackasm1(SB) - MOVD $1737, R12 - B callbackasm1(SB) - MOVD $1738, R12 - B callbackasm1(SB) - MOVD $1739, R12 - B callbackasm1(SB) - MOVD $1740, R12 - B callbackasm1(SB) - MOVD $1741, R12 - B callbackasm1(SB) - MOVD $1742, R12 - B callbackasm1(SB) - MOVD $1743, R12 - B callbackasm1(SB) - MOVD $1744, R12 - B callbackasm1(SB) - MOVD $1745, R12 - B callbackasm1(SB) - MOVD $1746, R12 - B callbackasm1(SB) - MOVD $1747, R12 - B callbackasm1(SB) - MOVD $1748, R12 - B callbackasm1(SB) - MOVD $1749, R12 - B callbackasm1(SB) - MOVD $1750, R12 - B callbackasm1(SB) - MOVD $1751, R12 - B callbackasm1(SB) - MOVD $1752, R12 - B callbackasm1(SB) - MOVD $1753, R12 - B callbackasm1(SB) - MOVD $1754, R12 - B callbackasm1(SB) - MOVD $1755, R12 - B callbackasm1(SB) - MOVD $1756, R12 - B callbackasm1(SB) - MOVD $1757, R12 - B callbackasm1(SB) - MOVD $1758, R12 - B callbackasm1(SB) - MOVD $1759, R12 - B callbackasm1(SB) - MOVD $1760, R12 - B callbackasm1(SB) - MOVD $1761, R12 - B callbackasm1(SB) - MOVD $1762, R12 - B callbackasm1(SB) - MOVD $1763, R12 - B callbackasm1(SB) - MOVD $1764, R12 - B callbackasm1(SB) - MOVD $1765, R12 - B callbackasm1(SB) - MOVD $1766, R12 - B callbackasm1(SB) - MOVD $1767, R12 - B callbackasm1(SB) - MOVD $1768, R12 - B callbackasm1(SB) - MOVD $1769, R12 - B callbackasm1(SB) - MOVD $1770, R12 - B callbackasm1(SB) - MOVD $1771, R12 - B callbackasm1(SB) - MOVD $1772, R12 - B callbackasm1(SB) - MOVD $1773, R12 - B callbackasm1(SB) - MOVD $1774, R12 - B callbackasm1(SB) - MOVD $1775, R12 - B callbackasm1(SB) - MOVD $1776, R12 - B callbackasm1(SB) - MOVD $1777, R12 - B callbackasm1(SB) - MOVD $1778, R12 - B callbackasm1(SB) - MOVD $1779, R12 - B callbackasm1(SB) - MOVD $1780, R12 - B callbackasm1(SB) - MOVD $1781, R12 - B callbackasm1(SB) - MOVD $1782, R12 - B callbackasm1(SB) - MOVD $1783, R12 - B callbackasm1(SB) - MOVD $1784, R12 - B callbackasm1(SB) - MOVD $1785, R12 - B callbackasm1(SB) - MOVD $1786, R12 - B callbackasm1(SB) - MOVD $1787, R12 - B callbackasm1(SB) - MOVD $1788, R12 - B callbackasm1(SB) - MOVD $1789, R12 - B callbackasm1(SB) - MOVD $1790, R12 - B callbackasm1(SB) - MOVD $1791, R12 - B callbackasm1(SB) - MOVD $1792, R12 - B callbackasm1(SB) - MOVD $1793, R12 - B callbackasm1(SB) - MOVD $1794, R12 - B callbackasm1(SB) - MOVD $1795, R12 - B callbackasm1(SB) - MOVD $1796, R12 - B callbackasm1(SB) - MOVD $1797, R12 - B callbackasm1(SB) - MOVD $1798, R12 - B callbackasm1(SB) - MOVD $1799, R12 - B callbackasm1(SB) - MOVD $1800, R12 - B callbackasm1(SB) - MOVD $1801, R12 - B callbackasm1(SB) - MOVD $1802, R12 - B callbackasm1(SB) - MOVD $1803, R12 - B callbackasm1(SB) - MOVD $1804, R12 - B callbackasm1(SB) - MOVD $1805, R12 - B callbackasm1(SB) - MOVD $1806, R12 - B callbackasm1(SB) - MOVD $1807, R12 - B callbackasm1(SB) - MOVD $1808, R12 - B callbackasm1(SB) - MOVD $1809, R12 - B callbackasm1(SB) - MOVD $1810, R12 - B callbackasm1(SB) - MOVD $1811, R12 - B callbackasm1(SB) - MOVD $1812, R12 - B callbackasm1(SB) - MOVD $1813, R12 - B callbackasm1(SB) - MOVD $1814, R12 - B callbackasm1(SB) - MOVD $1815, R12 - B callbackasm1(SB) - MOVD $1816, R12 - B callbackasm1(SB) - MOVD $1817, R12 - B callbackasm1(SB) - MOVD $1818, R12 - B callbackasm1(SB) - MOVD $1819, R12 - B callbackasm1(SB) - MOVD $1820, R12 - B callbackasm1(SB) - MOVD $1821, R12 - B callbackasm1(SB) - MOVD $1822, R12 - B callbackasm1(SB) - MOVD $1823, R12 - B callbackasm1(SB) - MOVD $1824, R12 - B callbackasm1(SB) - MOVD $1825, R12 - B callbackasm1(SB) - MOVD $1826, R12 - B callbackasm1(SB) - MOVD $1827, R12 - B callbackasm1(SB) - MOVD $1828, R12 - B callbackasm1(SB) - MOVD $1829, R12 - B callbackasm1(SB) - MOVD $1830, R12 - B callbackasm1(SB) - MOVD $1831, R12 - B callbackasm1(SB) - MOVD $1832, R12 - B callbackasm1(SB) - MOVD $1833, R12 - B callbackasm1(SB) - MOVD $1834, R12 - B callbackasm1(SB) - MOVD $1835, R12 - B callbackasm1(SB) - MOVD $1836, R12 - B callbackasm1(SB) - MOVD $1837, R12 - B callbackasm1(SB) - MOVD $1838, R12 - B callbackasm1(SB) - MOVD $1839, R12 - B callbackasm1(SB) - MOVD $1840, R12 - B callbackasm1(SB) - MOVD $1841, R12 - B callbackasm1(SB) - MOVD $1842, R12 - B callbackasm1(SB) - MOVD $1843, R12 - B callbackasm1(SB) - MOVD $1844, R12 - B callbackasm1(SB) - MOVD $1845, R12 - B callbackasm1(SB) - MOVD $1846, R12 - B callbackasm1(SB) - MOVD $1847, R12 - B callbackasm1(SB) - MOVD $1848, R12 - B callbackasm1(SB) - MOVD $1849, R12 - B callbackasm1(SB) - MOVD $1850, R12 - B callbackasm1(SB) - MOVD $1851, R12 - B callbackasm1(SB) - MOVD $1852, R12 - B callbackasm1(SB) - MOVD $1853, R12 - B callbackasm1(SB) - MOVD $1854, R12 - B callbackasm1(SB) - MOVD $1855, R12 - B callbackasm1(SB) - MOVD $1856, R12 - B callbackasm1(SB) - MOVD $1857, R12 - B callbackasm1(SB) - MOVD $1858, R12 - B callbackasm1(SB) - MOVD $1859, R12 - B callbackasm1(SB) - MOVD $1860, R12 - B callbackasm1(SB) - MOVD $1861, R12 - B callbackasm1(SB) - MOVD $1862, R12 - B callbackasm1(SB) - MOVD $1863, R12 - B callbackasm1(SB) - MOVD $1864, R12 - B callbackasm1(SB) - MOVD $1865, R12 - B callbackasm1(SB) - MOVD $1866, R12 - B callbackasm1(SB) - MOVD $1867, R12 - B callbackasm1(SB) - MOVD $1868, R12 - B callbackasm1(SB) - MOVD $1869, R12 - B callbackasm1(SB) - MOVD $1870, R12 - B callbackasm1(SB) - MOVD $1871, R12 - B callbackasm1(SB) - MOVD $1872, R12 - B callbackasm1(SB) - MOVD $1873, R12 - B callbackasm1(SB) - MOVD $1874, R12 - B callbackasm1(SB) - MOVD $1875, R12 - B callbackasm1(SB) - MOVD $1876, R12 - B callbackasm1(SB) - MOVD $1877, R12 - B callbackasm1(SB) - MOVD $1878, R12 - B callbackasm1(SB) - MOVD $1879, R12 - B callbackasm1(SB) - MOVD $1880, R12 - B callbackasm1(SB) - MOVD $1881, R12 - B callbackasm1(SB) - MOVD $1882, R12 - B callbackasm1(SB) - MOVD $1883, R12 - B callbackasm1(SB) - MOVD $1884, R12 - B callbackasm1(SB) - MOVD $1885, R12 - B callbackasm1(SB) - MOVD $1886, R12 - B callbackasm1(SB) - MOVD $1887, R12 - B callbackasm1(SB) - MOVD $1888, R12 - B callbackasm1(SB) - MOVD $1889, R12 - B callbackasm1(SB) - MOVD $1890, R12 - B callbackasm1(SB) - MOVD $1891, R12 - B callbackasm1(SB) - MOVD $1892, R12 - B callbackasm1(SB) - MOVD $1893, R12 - B callbackasm1(SB) - MOVD $1894, R12 - B callbackasm1(SB) - MOVD $1895, R12 - B callbackasm1(SB) - MOVD $1896, R12 - B callbackasm1(SB) - MOVD $1897, R12 - B callbackasm1(SB) - MOVD $1898, R12 - B callbackasm1(SB) - MOVD $1899, R12 - B callbackasm1(SB) - MOVD $1900, R12 - B callbackasm1(SB) - MOVD $1901, R12 - B callbackasm1(SB) - MOVD $1902, R12 - B callbackasm1(SB) - MOVD $1903, R12 - B callbackasm1(SB) - MOVD $1904, R12 - B callbackasm1(SB) - MOVD $1905, R12 - B callbackasm1(SB) - MOVD $1906, R12 - B callbackasm1(SB) - MOVD $1907, R12 - B callbackasm1(SB) - MOVD $1908, R12 - B callbackasm1(SB) - MOVD $1909, R12 - B callbackasm1(SB) - MOVD $1910, R12 - B callbackasm1(SB) - MOVD $1911, R12 - B callbackasm1(SB) - MOVD $1912, R12 - B callbackasm1(SB) - MOVD $1913, R12 - B callbackasm1(SB) - MOVD $1914, R12 - B callbackasm1(SB) - MOVD $1915, R12 - B callbackasm1(SB) - MOVD $1916, R12 - B callbackasm1(SB) - MOVD $1917, R12 - B callbackasm1(SB) - MOVD $1918, R12 - B callbackasm1(SB) - MOVD $1919, R12 - B callbackasm1(SB) - MOVD $1920, R12 - B callbackasm1(SB) - MOVD $1921, R12 - B callbackasm1(SB) - MOVD $1922, R12 - B callbackasm1(SB) - MOVD $1923, R12 - B callbackasm1(SB) - MOVD $1924, R12 - B callbackasm1(SB) - MOVD $1925, R12 - B callbackasm1(SB) - MOVD $1926, R12 - B callbackasm1(SB) - MOVD $1927, R12 - B callbackasm1(SB) - MOVD $1928, R12 - B callbackasm1(SB) - MOVD $1929, R12 - B callbackasm1(SB) - MOVD $1930, R12 - B callbackasm1(SB) - MOVD $1931, R12 - B callbackasm1(SB) - MOVD $1932, R12 - B callbackasm1(SB) - MOVD $1933, R12 - B callbackasm1(SB) - MOVD $1934, R12 - B callbackasm1(SB) - MOVD $1935, R12 - B callbackasm1(SB) - MOVD $1936, R12 - B callbackasm1(SB) - MOVD $1937, R12 - B callbackasm1(SB) - MOVD $1938, R12 - B callbackasm1(SB) - MOVD $1939, R12 - B callbackasm1(SB) - MOVD $1940, R12 - B callbackasm1(SB) - MOVD $1941, R12 - B callbackasm1(SB) - MOVD $1942, R12 - B callbackasm1(SB) - MOVD $1943, R12 - B callbackasm1(SB) - MOVD $1944, R12 - B callbackasm1(SB) - MOVD $1945, R12 - B callbackasm1(SB) - MOVD $1946, R12 - B callbackasm1(SB) - MOVD $1947, R12 - B callbackasm1(SB) - MOVD $1948, R12 - B callbackasm1(SB) - MOVD $1949, R12 - B callbackasm1(SB) - MOVD $1950, R12 - B callbackasm1(SB) - MOVD $1951, R12 - B callbackasm1(SB) - MOVD $1952, R12 - B callbackasm1(SB) - MOVD $1953, R12 - B callbackasm1(SB) - MOVD $1954, R12 - B callbackasm1(SB) - MOVD $1955, R12 - B callbackasm1(SB) - MOVD $1956, R12 - B callbackasm1(SB) - MOVD $1957, R12 - B callbackasm1(SB) - MOVD $1958, R12 - B callbackasm1(SB) - MOVD $1959, R12 - B callbackasm1(SB) - MOVD $1960, R12 - B callbackasm1(SB) - MOVD $1961, R12 - B callbackasm1(SB) - MOVD $1962, R12 - B callbackasm1(SB) - MOVD $1963, R12 - B callbackasm1(SB) - MOVD $1964, R12 - B callbackasm1(SB) - MOVD $1965, R12 - B callbackasm1(SB) - MOVD $1966, R12 - B callbackasm1(SB) - MOVD $1967, R12 - B callbackasm1(SB) - MOVD $1968, R12 - B callbackasm1(SB) - MOVD $1969, R12 - B callbackasm1(SB) - MOVD $1970, R12 - B callbackasm1(SB) - MOVD $1971, R12 - B callbackasm1(SB) - MOVD $1972, R12 - B callbackasm1(SB) - MOVD $1973, R12 - B callbackasm1(SB) - MOVD $1974, R12 - B callbackasm1(SB) - MOVD $1975, R12 - B callbackasm1(SB) - MOVD $1976, R12 - B callbackasm1(SB) - MOVD $1977, R12 - B callbackasm1(SB) - MOVD $1978, R12 - B callbackasm1(SB) - MOVD $1979, R12 - B callbackasm1(SB) - MOVD $1980, R12 - B callbackasm1(SB) - MOVD $1981, R12 - B callbackasm1(SB) - MOVD $1982, R12 - B callbackasm1(SB) - MOVD $1983, R12 - B callbackasm1(SB) - MOVD $1984, R12 - B callbackasm1(SB) - MOVD $1985, R12 - B callbackasm1(SB) - MOVD $1986, R12 - B callbackasm1(SB) - MOVD $1987, R12 - B callbackasm1(SB) - MOVD $1988, R12 - B callbackasm1(SB) - MOVD $1989, R12 - B callbackasm1(SB) - MOVD $1990, R12 - B callbackasm1(SB) - MOVD $1991, R12 - B callbackasm1(SB) - MOVD $1992, R12 - B callbackasm1(SB) - MOVD $1993, R12 - B callbackasm1(SB) - MOVD $1994, R12 - B callbackasm1(SB) - MOVD $1995, R12 - B callbackasm1(SB) - MOVD $1996, R12 - B callbackasm1(SB) - MOVD $1997, R12 - B callbackasm1(SB) - MOVD $1998, R12 - B callbackasm1(SB) - MOVD $1999, R12 - B callbackasm1(SB) diff --git a/vendor/github.com/ebitengine/purego/zcallback_loong64.s b/vendor/github.com/ebitengine/purego/zcallback_loong64.s deleted file mode 100644 index c5dcd48e52a..00000000000 --- a/vendor/github.com/ebitengine/purego/zcallback_loong64.s +++ /dev/null @@ -1,4014 +0,0 @@ -// Code generated by wincallback.go using 'go generate'. DO NOT EDIT. - -//go:build darwin || freebsd || linux || netbsd - -// External code calls into callbackasm at an offset corresponding -// to the callback index. Callbackasm is a table of MOVV and JMP instructions. -// The MOVV instruction loads R12 with the callback index, and the -// JMP instruction branches to callbackasm1. -// callbackasm1 takes the callback index from R12 and -// indexes into an array that stores information about each callback. -// It then calls the Go implementation for that callback. -#include "textflag.h" - -TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0 - MOVV $0, R12 - JMP callbackasm1(SB) - MOVV $1, R12 - JMP callbackasm1(SB) - MOVV $2, R12 - JMP callbackasm1(SB) - MOVV $3, R12 - JMP callbackasm1(SB) - MOVV $4, R12 - JMP callbackasm1(SB) - MOVV $5, R12 - JMP callbackasm1(SB) - MOVV $6, R12 - JMP callbackasm1(SB) - MOVV $7, R12 - JMP callbackasm1(SB) - MOVV $8, R12 - JMP callbackasm1(SB) - MOVV $9, R12 - JMP callbackasm1(SB) - MOVV $10, R12 - JMP callbackasm1(SB) - MOVV $11, R12 - JMP callbackasm1(SB) - MOVV $12, R12 - JMP callbackasm1(SB) - MOVV $13, R12 - JMP callbackasm1(SB) - MOVV $14, R12 - JMP callbackasm1(SB) - MOVV $15, R12 - JMP callbackasm1(SB) - MOVV $16, R12 - JMP callbackasm1(SB) - MOVV $17, R12 - JMP callbackasm1(SB) - MOVV $18, R12 - JMP callbackasm1(SB) - MOVV $19, R12 - JMP callbackasm1(SB) - MOVV $20, R12 - JMP callbackasm1(SB) - MOVV $21, R12 - JMP callbackasm1(SB) - MOVV $22, R12 - JMP callbackasm1(SB) - MOVV $23, R12 - JMP callbackasm1(SB) - MOVV $24, R12 - JMP callbackasm1(SB) - MOVV $25, R12 - JMP callbackasm1(SB) - MOVV $26, R12 - JMP callbackasm1(SB) - MOVV $27, R12 - JMP callbackasm1(SB) - MOVV $28, R12 - JMP callbackasm1(SB) - MOVV $29, R12 - JMP callbackasm1(SB) - MOVV $30, R12 - JMP callbackasm1(SB) - MOVV $31, R12 - JMP callbackasm1(SB) - MOVV $32, R12 - JMP callbackasm1(SB) - MOVV $33, R12 - JMP callbackasm1(SB) - MOVV $34, R12 - JMP callbackasm1(SB) - MOVV $35, R12 - JMP callbackasm1(SB) - MOVV $36, R12 - JMP callbackasm1(SB) - MOVV $37, R12 - JMP callbackasm1(SB) - MOVV $38, R12 - JMP callbackasm1(SB) - MOVV $39, R12 - JMP callbackasm1(SB) - MOVV $40, R12 - JMP callbackasm1(SB) - MOVV $41, R12 - JMP callbackasm1(SB) - MOVV $42, R12 - JMP callbackasm1(SB) - MOVV $43, R12 - JMP callbackasm1(SB) - MOVV $44, R12 - JMP callbackasm1(SB) - MOVV $45, R12 - JMP callbackasm1(SB) - MOVV $46, R12 - JMP callbackasm1(SB) - MOVV $47, R12 - JMP callbackasm1(SB) - MOVV $48, R12 - JMP callbackasm1(SB) - MOVV $49, R12 - JMP callbackasm1(SB) - MOVV $50, R12 - JMP callbackasm1(SB) - MOVV $51, R12 - JMP callbackasm1(SB) - MOVV $52, R12 - JMP callbackasm1(SB) - MOVV $53, R12 - JMP callbackasm1(SB) - MOVV $54, R12 - JMP callbackasm1(SB) - MOVV $55, R12 - JMP callbackasm1(SB) - MOVV $56, R12 - JMP callbackasm1(SB) - MOVV $57, R12 - JMP callbackasm1(SB) - MOVV $58, R12 - JMP callbackasm1(SB) - MOVV $59, R12 - JMP callbackasm1(SB) - MOVV $60, R12 - JMP callbackasm1(SB) - MOVV $61, R12 - JMP callbackasm1(SB) - MOVV $62, R12 - JMP callbackasm1(SB) - MOVV $63, R12 - JMP callbackasm1(SB) - MOVV $64, R12 - JMP callbackasm1(SB) - MOVV $65, R12 - JMP callbackasm1(SB) - MOVV $66, R12 - JMP callbackasm1(SB) - MOVV $67, R12 - JMP callbackasm1(SB) - MOVV $68, R12 - JMP callbackasm1(SB) - MOVV $69, R12 - JMP callbackasm1(SB) - MOVV $70, R12 - JMP callbackasm1(SB) - MOVV $71, R12 - JMP callbackasm1(SB) - MOVV $72, R12 - JMP callbackasm1(SB) - MOVV $73, R12 - JMP callbackasm1(SB) - MOVV $74, R12 - JMP callbackasm1(SB) - MOVV $75, R12 - JMP callbackasm1(SB) - MOVV $76, R12 - JMP callbackasm1(SB) - MOVV $77, R12 - JMP callbackasm1(SB) - MOVV $78, R12 - JMP callbackasm1(SB) - MOVV $79, R12 - JMP callbackasm1(SB) - MOVV $80, R12 - JMP callbackasm1(SB) - MOVV $81, R12 - JMP callbackasm1(SB) - MOVV $82, R12 - JMP callbackasm1(SB) - MOVV $83, R12 - JMP callbackasm1(SB) - MOVV $84, R12 - JMP callbackasm1(SB) - MOVV $85, R12 - JMP callbackasm1(SB) - MOVV $86, R12 - JMP callbackasm1(SB) - MOVV $87, R12 - JMP callbackasm1(SB) - MOVV $88, R12 - JMP callbackasm1(SB) - MOVV $89, R12 - JMP callbackasm1(SB) - MOVV $90, R12 - JMP callbackasm1(SB) - MOVV $91, R12 - JMP callbackasm1(SB) - MOVV $92, R12 - JMP callbackasm1(SB) - MOVV $93, R12 - JMP callbackasm1(SB) - MOVV $94, R12 - JMP callbackasm1(SB) - MOVV $95, R12 - JMP callbackasm1(SB) - MOVV $96, R12 - JMP callbackasm1(SB) - MOVV $97, R12 - JMP callbackasm1(SB) - MOVV $98, R12 - JMP callbackasm1(SB) - MOVV $99, R12 - JMP callbackasm1(SB) - MOVV $100, R12 - JMP callbackasm1(SB) - MOVV $101, R12 - JMP callbackasm1(SB) - MOVV $102, R12 - JMP callbackasm1(SB) - MOVV $103, R12 - JMP callbackasm1(SB) - MOVV $104, R12 - JMP callbackasm1(SB) - MOVV $105, R12 - JMP callbackasm1(SB) - MOVV $106, R12 - JMP callbackasm1(SB) - MOVV $107, R12 - JMP callbackasm1(SB) - MOVV $108, R12 - JMP callbackasm1(SB) - MOVV $109, R12 - JMP callbackasm1(SB) - MOVV $110, R12 - JMP callbackasm1(SB) - MOVV $111, R12 - JMP callbackasm1(SB) - MOVV $112, R12 - JMP callbackasm1(SB) - MOVV $113, R12 - JMP callbackasm1(SB) - MOVV $114, R12 - JMP callbackasm1(SB) - MOVV $115, R12 - JMP callbackasm1(SB) - MOVV $116, R12 - JMP callbackasm1(SB) - MOVV $117, R12 - JMP callbackasm1(SB) - MOVV $118, R12 - JMP callbackasm1(SB) - MOVV $119, R12 - JMP callbackasm1(SB) - MOVV $120, R12 - JMP callbackasm1(SB) - MOVV $121, R12 - JMP callbackasm1(SB) - MOVV $122, R12 - JMP callbackasm1(SB) - MOVV $123, R12 - JMP callbackasm1(SB) - MOVV $124, R12 - JMP callbackasm1(SB) - MOVV $125, R12 - JMP callbackasm1(SB) - MOVV $126, R12 - JMP callbackasm1(SB) - MOVV $127, R12 - JMP callbackasm1(SB) - MOVV $128, R12 - JMP callbackasm1(SB) - MOVV $129, R12 - JMP callbackasm1(SB) - MOVV $130, R12 - JMP callbackasm1(SB) - MOVV $131, R12 - JMP callbackasm1(SB) - MOVV $132, R12 - JMP callbackasm1(SB) - MOVV $133, R12 - JMP callbackasm1(SB) - MOVV $134, R12 - JMP callbackasm1(SB) - MOVV $135, R12 - JMP callbackasm1(SB) - MOVV $136, R12 - JMP callbackasm1(SB) - MOVV $137, R12 - JMP callbackasm1(SB) - MOVV $138, R12 - JMP callbackasm1(SB) - MOVV $139, R12 - JMP callbackasm1(SB) - MOVV $140, R12 - JMP callbackasm1(SB) - MOVV $141, R12 - JMP callbackasm1(SB) - MOVV $142, R12 - JMP callbackasm1(SB) - MOVV $143, R12 - JMP callbackasm1(SB) - MOVV $144, R12 - JMP callbackasm1(SB) - MOVV $145, R12 - JMP callbackasm1(SB) - MOVV $146, R12 - JMP callbackasm1(SB) - MOVV $147, R12 - JMP callbackasm1(SB) - MOVV $148, R12 - JMP callbackasm1(SB) - MOVV $149, R12 - JMP callbackasm1(SB) - MOVV $150, R12 - JMP callbackasm1(SB) - MOVV $151, R12 - JMP callbackasm1(SB) - MOVV $152, R12 - JMP callbackasm1(SB) - MOVV $153, R12 - JMP callbackasm1(SB) - MOVV $154, R12 - JMP callbackasm1(SB) - MOVV $155, R12 - JMP callbackasm1(SB) - MOVV $156, R12 - JMP callbackasm1(SB) - MOVV $157, R12 - JMP callbackasm1(SB) - MOVV $158, R12 - JMP callbackasm1(SB) - MOVV $159, R12 - JMP callbackasm1(SB) - MOVV $160, R12 - JMP callbackasm1(SB) - MOVV $161, R12 - JMP callbackasm1(SB) - MOVV $162, R12 - JMP callbackasm1(SB) - MOVV $163, R12 - JMP callbackasm1(SB) - MOVV $164, R12 - JMP callbackasm1(SB) - MOVV $165, R12 - JMP callbackasm1(SB) - MOVV $166, R12 - JMP callbackasm1(SB) - MOVV $167, R12 - JMP callbackasm1(SB) - MOVV $168, R12 - JMP callbackasm1(SB) - MOVV $169, R12 - JMP callbackasm1(SB) - MOVV $170, R12 - JMP callbackasm1(SB) - MOVV $171, R12 - JMP callbackasm1(SB) - MOVV $172, R12 - JMP callbackasm1(SB) - MOVV $173, R12 - JMP callbackasm1(SB) - MOVV $174, R12 - JMP callbackasm1(SB) - MOVV $175, R12 - JMP callbackasm1(SB) - MOVV $176, R12 - JMP callbackasm1(SB) - MOVV $177, R12 - JMP callbackasm1(SB) - MOVV $178, R12 - JMP callbackasm1(SB) - MOVV $179, R12 - JMP callbackasm1(SB) - MOVV $180, R12 - JMP callbackasm1(SB) - MOVV $181, R12 - JMP callbackasm1(SB) - MOVV $182, R12 - JMP callbackasm1(SB) - MOVV $183, R12 - JMP callbackasm1(SB) - MOVV $184, R12 - JMP callbackasm1(SB) - MOVV $185, R12 - JMP callbackasm1(SB) - MOVV $186, R12 - JMP callbackasm1(SB) - MOVV $187, R12 - JMP callbackasm1(SB) - MOVV $188, R12 - JMP callbackasm1(SB) - MOVV $189, R12 - JMP callbackasm1(SB) - MOVV $190, R12 - JMP callbackasm1(SB) - MOVV $191, R12 - JMP callbackasm1(SB) - MOVV $192, R12 - JMP callbackasm1(SB) - MOVV $193, R12 - JMP callbackasm1(SB) - MOVV $194, R12 - JMP callbackasm1(SB) - MOVV $195, R12 - JMP callbackasm1(SB) - MOVV $196, R12 - JMP callbackasm1(SB) - MOVV $197, R12 - JMP callbackasm1(SB) - MOVV $198, R12 - JMP callbackasm1(SB) - MOVV $199, R12 - JMP callbackasm1(SB) - MOVV $200, R12 - JMP callbackasm1(SB) - MOVV $201, R12 - JMP callbackasm1(SB) - MOVV $202, R12 - JMP callbackasm1(SB) - MOVV $203, R12 - JMP callbackasm1(SB) - MOVV $204, R12 - JMP callbackasm1(SB) - MOVV $205, R12 - JMP callbackasm1(SB) - MOVV $206, R12 - JMP callbackasm1(SB) - MOVV $207, R12 - JMP callbackasm1(SB) - MOVV $208, R12 - JMP callbackasm1(SB) - MOVV $209, R12 - JMP callbackasm1(SB) - MOVV $210, R12 - JMP callbackasm1(SB) - MOVV $211, R12 - JMP callbackasm1(SB) - MOVV $212, R12 - JMP callbackasm1(SB) - MOVV $213, R12 - JMP callbackasm1(SB) - MOVV $214, R12 - JMP callbackasm1(SB) - MOVV $215, R12 - JMP callbackasm1(SB) - MOVV $216, R12 - JMP callbackasm1(SB) - MOVV $217, R12 - JMP callbackasm1(SB) - MOVV $218, R12 - JMP callbackasm1(SB) - MOVV $219, R12 - JMP callbackasm1(SB) - MOVV $220, R12 - JMP callbackasm1(SB) - MOVV $221, R12 - JMP callbackasm1(SB) - MOVV $222, R12 - JMP callbackasm1(SB) - MOVV $223, R12 - JMP callbackasm1(SB) - MOVV $224, R12 - JMP callbackasm1(SB) - MOVV $225, R12 - JMP callbackasm1(SB) - MOVV $226, R12 - JMP callbackasm1(SB) - MOVV $227, R12 - JMP callbackasm1(SB) - MOVV $228, R12 - JMP callbackasm1(SB) - MOVV $229, R12 - JMP callbackasm1(SB) - MOVV $230, R12 - JMP callbackasm1(SB) - MOVV $231, R12 - JMP callbackasm1(SB) - MOVV $232, R12 - JMP callbackasm1(SB) - MOVV $233, R12 - JMP callbackasm1(SB) - MOVV $234, R12 - JMP callbackasm1(SB) - MOVV $235, R12 - JMP callbackasm1(SB) - MOVV $236, R12 - JMP callbackasm1(SB) - MOVV $237, R12 - JMP callbackasm1(SB) - MOVV $238, R12 - JMP callbackasm1(SB) - MOVV $239, R12 - JMP callbackasm1(SB) - MOVV $240, R12 - JMP callbackasm1(SB) - MOVV $241, R12 - JMP callbackasm1(SB) - MOVV $242, R12 - JMP callbackasm1(SB) - MOVV $243, R12 - JMP callbackasm1(SB) - MOVV $244, R12 - JMP callbackasm1(SB) - MOVV $245, R12 - JMP callbackasm1(SB) - MOVV $246, R12 - JMP callbackasm1(SB) - MOVV $247, R12 - JMP callbackasm1(SB) - MOVV $248, R12 - JMP callbackasm1(SB) - MOVV $249, R12 - JMP callbackasm1(SB) - MOVV $250, R12 - JMP callbackasm1(SB) - MOVV $251, R12 - JMP callbackasm1(SB) - MOVV $252, R12 - JMP callbackasm1(SB) - MOVV $253, R12 - JMP callbackasm1(SB) - MOVV $254, R12 - JMP callbackasm1(SB) - MOVV $255, R12 - JMP callbackasm1(SB) - MOVV $256, R12 - JMP callbackasm1(SB) - MOVV $257, R12 - JMP callbackasm1(SB) - MOVV $258, R12 - JMP callbackasm1(SB) - MOVV $259, R12 - JMP callbackasm1(SB) - MOVV $260, R12 - JMP callbackasm1(SB) - MOVV $261, R12 - JMP callbackasm1(SB) - MOVV $262, R12 - JMP callbackasm1(SB) - MOVV $263, R12 - JMP callbackasm1(SB) - MOVV $264, R12 - JMP callbackasm1(SB) - MOVV $265, R12 - JMP callbackasm1(SB) - MOVV $266, R12 - JMP callbackasm1(SB) - MOVV $267, R12 - JMP callbackasm1(SB) - MOVV $268, R12 - JMP callbackasm1(SB) - MOVV $269, R12 - JMP callbackasm1(SB) - MOVV $270, R12 - JMP callbackasm1(SB) - MOVV $271, R12 - JMP callbackasm1(SB) - MOVV $272, R12 - JMP callbackasm1(SB) - MOVV $273, R12 - JMP callbackasm1(SB) - MOVV $274, R12 - JMP callbackasm1(SB) - MOVV $275, R12 - JMP callbackasm1(SB) - MOVV $276, R12 - JMP callbackasm1(SB) - MOVV $277, R12 - JMP callbackasm1(SB) - MOVV $278, R12 - JMP callbackasm1(SB) - MOVV $279, R12 - JMP callbackasm1(SB) - MOVV $280, R12 - JMP callbackasm1(SB) - MOVV $281, R12 - JMP callbackasm1(SB) - MOVV $282, R12 - JMP callbackasm1(SB) - MOVV $283, R12 - JMP callbackasm1(SB) - MOVV $284, R12 - JMP callbackasm1(SB) - MOVV $285, R12 - JMP callbackasm1(SB) - MOVV $286, R12 - JMP callbackasm1(SB) - MOVV $287, R12 - JMP callbackasm1(SB) - MOVV $288, R12 - JMP callbackasm1(SB) - MOVV $289, R12 - JMP callbackasm1(SB) - MOVV $290, R12 - JMP callbackasm1(SB) - MOVV $291, R12 - JMP callbackasm1(SB) - MOVV $292, R12 - JMP callbackasm1(SB) - MOVV $293, R12 - JMP callbackasm1(SB) - MOVV $294, R12 - JMP callbackasm1(SB) - MOVV $295, R12 - JMP callbackasm1(SB) - MOVV $296, R12 - JMP callbackasm1(SB) - MOVV $297, R12 - JMP callbackasm1(SB) - MOVV $298, R12 - JMP callbackasm1(SB) - MOVV $299, R12 - JMP callbackasm1(SB) - MOVV $300, R12 - JMP callbackasm1(SB) - MOVV $301, R12 - JMP callbackasm1(SB) - MOVV $302, R12 - JMP callbackasm1(SB) - MOVV $303, R12 - JMP callbackasm1(SB) - MOVV $304, R12 - JMP callbackasm1(SB) - MOVV $305, R12 - JMP callbackasm1(SB) - MOVV $306, R12 - JMP callbackasm1(SB) - MOVV $307, R12 - JMP callbackasm1(SB) - MOVV $308, R12 - JMP callbackasm1(SB) - MOVV $309, R12 - JMP callbackasm1(SB) - MOVV $310, R12 - JMP callbackasm1(SB) - MOVV $311, R12 - JMP callbackasm1(SB) - MOVV $312, R12 - JMP callbackasm1(SB) - MOVV $313, R12 - JMP callbackasm1(SB) - MOVV $314, R12 - JMP callbackasm1(SB) - MOVV $315, R12 - JMP callbackasm1(SB) - MOVV $316, R12 - JMP callbackasm1(SB) - MOVV $317, R12 - JMP callbackasm1(SB) - MOVV $318, R12 - JMP callbackasm1(SB) - MOVV $319, R12 - JMP callbackasm1(SB) - MOVV $320, R12 - JMP callbackasm1(SB) - MOVV $321, R12 - JMP callbackasm1(SB) - MOVV $322, R12 - JMP callbackasm1(SB) - MOVV $323, R12 - JMP callbackasm1(SB) - MOVV $324, R12 - JMP callbackasm1(SB) - MOVV $325, R12 - JMP callbackasm1(SB) - MOVV $326, R12 - JMP callbackasm1(SB) - MOVV $327, R12 - JMP callbackasm1(SB) - MOVV $328, R12 - JMP callbackasm1(SB) - MOVV $329, R12 - JMP callbackasm1(SB) - MOVV $330, R12 - JMP callbackasm1(SB) - MOVV $331, R12 - JMP callbackasm1(SB) - MOVV $332, R12 - JMP callbackasm1(SB) - MOVV $333, R12 - JMP callbackasm1(SB) - MOVV $334, R12 - JMP callbackasm1(SB) - MOVV $335, R12 - JMP callbackasm1(SB) - MOVV $336, R12 - JMP callbackasm1(SB) - MOVV $337, R12 - JMP callbackasm1(SB) - MOVV $338, R12 - JMP callbackasm1(SB) - MOVV $339, R12 - JMP callbackasm1(SB) - MOVV $340, R12 - JMP callbackasm1(SB) - MOVV $341, R12 - JMP callbackasm1(SB) - MOVV $342, R12 - JMP callbackasm1(SB) - MOVV $343, R12 - JMP callbackasm1(SB) - MOVV $344, R12 - JMP callbackasm1(SB) - MOVV $345, R12 - JMP callbackasm1(SB) - MOVV $346, R12 - JMP callbackasm1(SB) - MOVV $347, R12 - JMP callbackasm1(SB) - MOVV $348, R12 - JMP callbackasm1(SB) - MOVV $349, R12 - JMP callbackasm1(SB) - MOVV $350, R12 - JMP callbackasm1(SB) - MOVV $351, R12 - JMP callbackasm1(SB) - MOVV $352, R12 - JMP callbackasm1(SB) - MOVV $353, R12 - JMP callbackasm1(SB) - MOVV $354, R12 - JMP callbackasm1(SB) - MOVV $355, R12 - JMP callbackasm1(SB) - MOVV $356, R12 - JMP callbackasm1(SB) - MOVV $357, R12 - JMP callbackasm1(SB) - MOVV $358, R12 - JMP callbackasm1(SB) - MOVV $359, R12 - JMP callbackasm1(SB) - MOVV $360, R12 - JMP callbackasm1(SB) - MOVV $361, R12 - JMP callbackasm1(SB) - MOVV $362, R12 - JMP callbackasm1(SB) - MOVV $363, R12 - JMP callbackasm1(SB) - MOVV $364, R12 - JMP callbackasm1(SB) - MOVV $365, R12 - JMP callbackasm1(SB) - MOVV $366, R12 - JMP callbackasm1(SB) - MOVV $367, R12 - JMP callbackasm1(SB) - MOVV $368, R12 - JMP callbackasm1(SB) - MOVV $369, R12 - JMP callbackasm1(SB) - MOVV $370, R12 - JMP callbackasm1(SB) - MOVV $371, R12 - JMP callbackasm1(SB) - MOVV $372, R12 - JMP callbackasm1(SB) - MOVV $373, R12 - JMP callbackasm1(SB) - MOVV $374, R12 - JMP callbackasm1(SB) - MOVV $375, R12 - JMP callbackasm1(SB) - MOVV $376, R12 - JMP callbackasm1(SB) - MOVV $377, R12 - JMP callbackasm1(SB) - MOVV $378, R12 - JMP callbackasm1(SB) - MOVV $379, R12 - JMP callbackasm1(SB) - MOVV $380, R12 - JMP callbackasm1(SB) - MOVV $381, R12 - JMP callbackasm1(SB) - MOVV $382, R12 - JMP callbackasm1(SB) - MOVV $383, R12 - JMP callbackasm1(SB) - MOVV $384, R12 - JMP callbackasm1(SB) - MOVV $385, R12 - JMP callbackasm1(SB) - MOVV $386, R12 - JMP callbackasm1(SB) - MOVV $387, R12 - JMP callbackasm1(SB) - MOVV $388, R12 - JMP callbackasm1(SB) - MOVV $389, R12 - JMP callbackasm1(SB) - MOVV $390, R12 - JMP callbackasm1(SB) - MOVV $391, R12 - JMP callbackasm1(SB) - MOVV $392, R12 - JMP callbackasm1(SB) - MOVV $393, R12 - JMP callbackasm1(SB) - MOVV $394, R12 - JMP callbackasm1(SB) - MOVV $395, R12 - JMP callbackasm1(SB) - MOVV $396, R12 - JMP callbackasm1(SB) - MOVV $397, R12 - JMP callbackasm1(SB) - MOVV $398, R12 - JMP callbackasm1(SB) - MOVV $399, R12 - JMP callbackasm1(SB) - MOVV $400, R12 - JMP callbackasm1(SB) - MOVV $401, R12 - JMP callbackasm1(SB) - MOVV $402, R12 - JMP callbackasm1(SB) - MOVV $403, R12 - JMP callbackasm1(SB) - MOVV $404, R12 - JMP callbackasm1(SB) - MOVV $405, R12 - JMP callbackasm1(SB) - MOVV $406, R12 - JMP callbackasm1(SB) - MOVV $407, R12 - JMP callbackasm1(SB) - MOVV $408, R12 - JMP callbackasm1(SB) - MOVV $409, R12 - JMP callbackasm1(SB) - MOVV $410, R12 - JMP callbackasm1(SB) - MOVV $411, R12 - JMP callbackasm1(SB) - MOVV $412, R12 - JMP callbackasm1(SB) - MOVV $413, R12 - JMP callbackasm1(SB) - MOVV $414, R12 - JMP callbackasm1(SB) - MOVV $415, R12 - JMP callbackasm1(SB) - MOVV $416, R12 - JMP callbackasm1(SB) - MOVV $417, R12 - JMP callbackasm1(SB) - MOVV $418, R12 - JMP callbackasm1(SB) - MOVV $419, R12 - JMP callbackasm1(SB) - MOVV $420, R12 - JMP callbackasm1(SB) - MOVV $421, R12 - JMP callbackasm1(SB) - MOVV $422, R12 - JMP callbackasm1(SB) - MOVV $423, R12 - JMP callbackasm1(SB) - MOVV $424, R12 - JMP callbackasm1(SB) - MOVV $425, R12 - JMP callbackasm1(SB) - MOVV $426, R12 - JMP callbackasm1(SB) - MOVV $427, R12 - JMP callbackasm1(SB) - MOVV $428, R12 - JMP callbackasm1(SB) - MOVV $429, R12 - JMP callbackasm1(SB) - MOVV $430, R12 - JMP callbackasm1(SB) - MOVV $431, R12 - JMP callbackasm1(SB) - MOVV $432, R12 - JMP callbackasm1(SB) - MOVV $433, R12 - JMP callbackasm1(SB) - MOVV $434, R12 - JMP callbackasm1(SB) - MOVV $435, R12 - JMP callbackasm1(SB) - MOVV $436, R12 - JMP callbackasm1(SB) - MOVV $437, R12 - JMP callbackasm1(SB) - MOVV $438, R12 - JMP callbackasm1(SB) - MOVV $439, R12 - JMP callbackasm1(SB) - MOVV $440, R12 - JMP callbackasm1(SB) - MOVV $441, R12 - JMP callbackasm1(SB) - MOVV $442, R12 - JMP callbackasm1(SB) - MOVV $443, R12 - JMP callbackasm1(SB) - MOVV $444, R12 - JMP callbackasm1(SB) - MOVV $445, R12 - JMP callbackasm1(SB) - MOVV $446, R12 - JMP callbackasm1(SB) - MOVV $447, R12 - JMP callbackasm1(SB) - MOVV $448, R12 - JMP callbackasm1(SB) - MOVV $449, R12 - JMP callbackasm1(SB) - MOVV $450, R12 - JMP callbackasm1(SB) - MOVV $451, R12 - JMP callbackasm1(SB) - MOVV $452, R12 - JMP callbackasm1(SB) - MOVV $453, R12 - JMP callbackasm1(SB) - MOVV $454, R12 - JMP callbackasm1(SB) - MOVV $455, R12 - JMP callbackasm1(SB) - MOVV $456, R12 - JMP callbackasm1(SB) - MOVV $457, R12 - JMP callbackasm1(SB) - MOVV $458, R12 - JMP callbackasm1(SB) - MOVV $459, R12 - JMP callbackasm1(SB) - MOVV $460, R12 - JMP callbackasm1(SB) - MOVV $461, R12 - JMP callbackasm1(SB) - MOVV $462, R12 - JMP callbackasm1(SB) - MOVV $463, R12 - JMP callbackasm1(SB) - MOVV $464, R12 - JMP callbackasm1(SB) - MOVV $465, R12 - JMP callbackasm1(SB) - MOVV $466, R12 - JMP callbackasm1(SB) - MOVV $467, R12 - JMP callbackasm1(SB) - MOVV $468, R12 - JMP callbackasm1(SB) - MOVV $469, R12 - JMP callbackasm1(SB) - MOVV $470, R12 - JMP callbackasm1(SB) - MOVV $471, R12 - JMP callbackasm1(SB) - MOVV $472, R12 - JMP callbackasm1(SB) - MOVV $473, R12 - JMP callbackasm1(SB) - MOVV $474, R12 - JMP callbackasm1(SB) - MOVV $475, R12 - JMP callbackasm1(SB) - MOVV $476, R12 - JMP callbackasm1(SB) - MOVV $477, R12 - JMP callbackasm1(SB) - MOVV $478, R12 - JMP callbackasm1(SB) - MOVV $479, R12 - JMP callbackasm1(SB) - MOVV $480, R12 - JMP callbackasm1(SB) - MOVV $481, R12 - JMP callbackasm1(SB) - MOVV $482, R12 - JMP callbackasm1(SB) - MOVV $483, R12 - JMP callbackasm1(SB) - MOVV $484, R12 - JMP callbackasm1(SB) - MOVV $485, R12 - JMP callbackasm1(SB) - MOVV $486, R12 - JMP callbackasm1(SB) - MOVV $487, R12 - JMP callbackasm1(SB) - MOVV $488, R12 - JMP callbackasm1(SB) - MOVV $489, R12 - JMP callbackasm1(SB) - MOVV $490, R12 - JMP callbackasm1(SB) - MOVV $491, R12 - JMP callbackasm1(SB) - MOVV $492, R12 - JMP callbackasm1(SB) - MOVV $493, R12 - JMP callbackasm1(SB) - MOVV $494, R12 - JMP callbackasm1(SB) - MOVV $495, R12 - JMP callbackasm1(SB) - MOVV $496, R12 - JMP callbackasm1(SB) - MOVV $497, R12 - JMP callbackasm1(SB) - MOVV $498, R12 - JMP callbackasm1(SB) - MOVV $499, R12 - JMP callbackasm1(SB) - MOVV $500, R12 - JMP callbackasm1(SB) - MOVV $501, R12 - JMP callbackasm1(SB) - MOVV $502, R12 - JMP callbackasm1(SB) - MOVV $503, R12 - JMP callbackasm1(SB) - MOVV $504, R12 - JMP callbackasm1(SB) - MOVV $505, R12 - JMP callbackasm1(SB) - MOVV $506, R12 - JMP callbackasm1(SB) - MOVV $507, R12 - JMP callbackasm1(SB) - MOVV $508, R12 - JMP callbackasm1(SB) - MOVV $509, R12 - JMP callbackasm1(SB) - MOVV $510, R12 - JMP callbackasm1(SB) - MOVV $511, R12 - JMP callbackasm1(SB) - MOVV $512, R12 - JMP callbackasm1(SB) - MOVV $513, R12 - JMP callbackasm1(SB) - MOVV $514, R12 - JMP callbackasm1(SB) - MOVV $515, R12 - JMP callbackasm1(SB) - MOVV $516, R12 - JMP callbackasm1(SB) - MOVV $517, R12 - JMP callbackasm1(SB) - MOVV $518, R12 - JMP callbackasm1(SB) - MOVV $519, R12 - JMP callbackasm1(SB) - MOVV $520, R12 - JMP callbackasm1(SB) - MOVV $521, R12 - JMP callbackasm1(SB) - MOVV $522, R12 - JMP callbackasm1(SB) - MOVV $523, R12 - JMP callbackasm1(SB) - MOVV $524, R12 - JMP callbackasm1(SB) - MOVV $525, R12 - JMP callbackasm1(SB) - MOVV $526, R12 - JMP callbackasm1(SB) - MOVV $527, R12 - JMP callbackasm1(SB) - MOVV $528, R12 - JMP callbackasm1(SB) - MOVV $529, R12 - JMP callbackasm1(SB) - MOVV $530, R12 - JMP callbackasm1(SB) - MOVV $531, R12 - JMP callbackasm1(SB) - MOVV $532, R12 - JMP callbackasm1(SB) - MOVV $533, R12 - JMP callbackasm1(SB) - MOVV $534, R12 - JMP callbackasm1(SB) - MOVV $535, R12 - JMP callbackasm1(SB) - MOVV $536, R12 - JMP callbackasm1(SB) - MOVV $537, R12 - JMP callbackasm1(SB) - MOVV $538, R12 - JMP callbackasm1(SB) - MOVV $539, R12 - JMP callbackasm1(SB) - MOVV $540, R12 - JMP callbackasm1(SB) - MOVV $541, R12 - JMP callbackasm1(SB) - MOVV $542, R12 - JMP callbackasm1(SB) - MOVV $543, R12 - JMP callbackasm1(SB) - MOVV $544, R12 - JMP callbackasm1(SB) - MOVV $545, R12 - JMP callbackasm1(SB) - MOVV $546, R12 - JMP callbackasm1(SB) - MOVV $547, R12 - JMP callbackasm1(SB) - MOVV $548, R12 - JMP callbackasm1(SB) - MOVV $549, R12 - JMP callbackasm1(SB) - MOVV $550, R12 - JMP callbackasm1(SB) - MOVV $551, R12 - JMP callbackasm1(SB) - MOVV $552, R12 - JMP callbackasm1(SB) - MOVV $553, R12 - JMP callbackasm1(SB) - MOVV $554, R12 - JMP callbackasm1(SB) - MOVV $555, R12 - JMP callbackasm1(SB) - MOVV $556, R12 - JMP callbackasm1(SB) - MOVV $557, R12 - JMP callbackasm1(SB) - MOVV $558, R12 - JMP callbackasm1(SB) - MOVV $559, R12 - JMP callbackasm1(SB) - MOVV $560, R12 - JMP callbackasm1(SB) - MOVV $561, R12 - JMP callbackasm1(SB) - MOVV $562, R12 - JMP callbackasm1(SB) - MOVV $563, R12 - JMP callbackasm1(SB) - MOVV $564, R12 - JMP callbackasm1(SB) - MOVV $565, R12 - JMP callbackasm1(SB) - MOVV $566, R12 - JMP callbackasm1(SB) - MOVV $567, R12 - JMP callbackasm1(SB) - MOVV $568, R12 - JMP callbackasm1(SB) - MOVV $569, R12 - JMP callbackasm1(SB) - MOVV $570, R12 - JMP callbackasm1(SB) - MOVV $571, R12 - JMP callbackasm1(SB) - MOVV $572, R12 - JMP callbackasm1(SB) - MOVV $573, R12 - JMP callbackasm1(SB) - MOVV $574, R12 - JMP callbackasm1(SB) - MOVV $575, R12 - JMP callbackasm1(SB) - MOVV $576, R12 - JMP callbackasm1(SB) - MOVV $577, R12 - JMP callbackasm1(SB) - MOVV $578, R12 - JMP callbackasm1(SB) - MOVV $579, R12 - JMP callbackasm1(SB) - MOVV $580, R12 - JMP callbackasm1(SB) - MOVV $581, R12 - JMP callbackasm1(SB) - MOVV $582, R12 - JMP callbackasm1(SB) - MOVV $583, R12 - JMP callbackasm1(SB) - MOVV $584, R12 - JMP callbackasm1(SB) - MOVV $585, R12 - JMP callbackasm1(SB) - MOVV $586, R12 - JMP callbackasm1(SB) - MOVV $587, R12 - JMP callbackasm1(SB) - MOVV $588, R12 - JMP callbackasm1(SB) - MOVV $589, R12 - JMP callbackasm1(SB) - MOVV $590, R12 - JMP callbackasm1(SB) - MOVV $591, R12 - JMP callbackasm1(SB) - MOVV $592, R12 - JMP callbackasm1(SB) - MOVV $593, R12 - JMP callbackasm1(SB) - MOVV $594, R12 - JMP callbackasm1(SB) - MOVV $595, R12 - JMP callbackasm1(SB) - MOVV $596, R12 - JMP callbackasm1(SB) - MOVV $597, R12 - JMP callbackasm1(SB) - MOVV $598, R12 - JMP callbackasm1(SB) - MOVV $599, R12 - JMP callbackasm1(SB) - MOVV $600, R12 - JMP callbackasm1(SB) - MOVV $601, R12 - JMP callbackasm1(SB) - MOVV $602, R12 - JMP callbackasm1(SB) - MOVV $603, R12 - JMP callbackasm1(SB) - MOVV $604, R12 - JMP callbackasm1(SB) - MOVV $605, R12 - JMP callbackasm1(SB) - MOVV $606, R12 - JMP callbackasm1(SB) - MOVV $607, R12 - JMP callbackasm1(SB) - MOVV $608, R12 - JMP callbackasm1(SB) - MOVV $609, R12 - JMP callbackasm1(SB) - MOVV $610, R12 - JMP callbackasm1(SB) - MOVV $611, R12 - JMP callbackasm1(SB) - MOVV $612, R12 - JMP callbackasm1(SB) - MOVV $613, R12 - JMP callbackasm1(SB) - MOVV $614, R12 - JMP callbackasm1(SB) - MOVV $615, R12 - JMP callbackasm1(SB) - MOVV $616, R12 - JMP callbackasm1(SB) - MOVV $617, R12 - JMP callbackasm1(SB) - MOVV $618, R12 - JMP callbackasm1(SB) - MOVV $619, R12 - JMP callbackasm1(SB) - MOVV $620, R12 - JMP callbackasm1(SB) - MOVV $621, R12 - JMP callbackasm1(SB) - MOVV $622, R12 - JMP callbackasm1(SB) - MOVV $623, R12 - JMP callbackasm1(SB) - MOVV $624, R12 - JMP callbackasm1(SB) - MOVV $625, R12 - JMP callbackasm1(SB) - MOVV $626, R12 - JMP callbackasm1(SB) - MOVV $627, R12 - JMP callbackasm1(SB) - MOVV $628, R12 - JMP callbackasm1(SB) - MOVV $629, R12 - JMP callbackasm1(SB) - MOVV $630, R12 - JMP callbackasm1(SB) - MOVV $631, R12 - JMP callbackasm1(SB) - MOVV $632, R12 - JMP callbackasm1(SB) - MOVV $633, R12 - JMP callbackasm1(SB) - MOVV $634, R12 - JMP callbackasm1(SB) - MOVV $635, R12 - JMP callbackasm1(SB) - MOVV $636, R12 - JMP callbackasm1(SB) - MOVV $637, R12 - JMP callbackasm1(SB) - MOVV $638, R12 - JMP callbackasm1(SB) - MOVV $639, R12 - JMP callbackasm1(SB) - MOVV $640, R12 - JMP callbackasm1(SB) - MOVV $641, R12 - JMP callbackasm1(SB) - MOVV $642, R12 - JMP callbackasm1(SB) - MOVV $643, R12 - JMP callbackasm1(SB) - MOVV $644, R12 - JMP callbackasm1(SB) - MOVV $645, R12 - JMP callbackasm1(SB) - MOVV $646, R12 - JMP callbackasm1(SB) - MOVV $647, R12 - JMP callbackasm1(SB) - MOVV $648, R12 - JMP callbackasm1(SB) - MOVV $649, R12 - JMP callbackasm1(SB) - MOVV $650, R12 - JMP callbackasm1(SB) - MOVV $651, R12 - JMP callbackasm1(SB) - MOVV $652, R12 - JMP callbackasm1(SB) - MOVV $653, R12 - JMP callbackasm1(SB) - MOVV $654, R12 - JMP callbackasm1(SB) - MOVV $655, R12 - JMP callbackasm1(SB) - MOVV $656, R12 - JMP callbackasm1(SB) - MOVV $657, R12 - JMP callbackasm1(SB) - MOVV $658, R12 - JMP callbackasm1(SB) - MOVV $659, R12 - JMP callbackasm1(SB) - MOVV $660, R12 - JMP callbackasm1(SB) - MOVV $661, R12 - JMP callbackasm1(SB) - MOVV $662, R12 - JMP callbackasm1(SB) - MOVV $663, R12 - JMP callbackasm1(SB) - MOVV $664, R12 - JMP callbackasm1(SB) - MOVV $665, R12 - JMP callbackasm1(SB) - MOVV $666, R12 - JMP callbackasm1(SB) - MOVV $667, R12 - JMP callbackasm1(SB) - MOVV $668, R12 - JMP callbackasm1(SB) - MOVV $669, R12 - JMP callbackasm1(SB) - MOVV $670, R12 - JMP callbackasm1(SB) - MOVV $671, R12 - JMP callbackasm1(SB) - MOVV $672, R12 - JMP callbackasm1(SB) - MOVV $673, R12 - JMP callbackasm1(SB) - MOVV $674, R12 - JMP callbackasm1(SB) - MOVV $675, R12 - JMP callbackasm1(SB) - MOVV $676, R12 - JMP callbackasm1(SB) - MOVV $677, R12 - JMP callbackasm1(SB) - MOVV $678, R12 - JMP callbackasm1(SB) - MOVV $679, R12 - JMP callbackasm1(SB) - MOVV $680, R12 - JMP callbackasm1(SB) - MOVV $681, R12 - JMP callbackasm1(SB) - MOVV $682, R12 - JMP callbackasm1(SB) - MOVV $683, R12 - JMP callbackasm1(SB) - MOVV $684, R12 - JMP callbackasm1(SB) - MOVV $685, R12 - JMP callbackasm1(SB) - MOVV $686, R12 - JMP callbackasm1(SB) - MOVV $687, R12 - JMP callbackasm1(SB) - MOVV $688, R12 - JMP callbackasm1(SB) - MOVV $689, R12 - JMP callbackasm1(SB) - MOVV $690, R12 - JMP callbackasm1(SB) - MOVV $691, R12 - JMP callbackasm1(SB) - MOVV $692, R12 - JMP callbackasm1(SB) - MOVV $693, R12 - JMP callbackasm1(SB) - MOVV $694, R12 - JMP callbackasm1(SB) - MOVV $695, R12 - JMP callbackasm1(SB) - MOVV $696, R12 - JMP callbackasm1(SB) - MOVV $697, R12 - JMP callbackasm1(SB) - MOVV $698, R12 - JMP callbackasm1(SB) - MOVV $699, R12 - JMP callbackasm1(SB) - MOVV $700, R12 - JMP callbackasm1(SB) - MOVV $701, R12 - JMP callbackasm1(SB) - MOVV $702, R12 - JMP callbackasm1(SB) - MOVV $703, R12 - JMP callbackasm1(SB) - MOVV $704, R12 - JMP callbackasm1(SB) - MOVV $705, R12 - JMP callbackasm1(SB) - MOVV $706, R12 - JMP callbackasm1(SB) - MOVV $707, R12 - JMP callbackasm1(SB) - MOVV $708, R12 - JMP callbackasm1(SB) - MOVV $709, R12 - JMP callbackasm1(SB) - MOVV $710, R12 - JMP callbackasm1(SB) - MOVV $711, R12 - JMP callbackasm1(SB) - MOVV $712, R12 - JMP callbackasm1(SB) - MOVV $713, R12 - JMP callbackasm1(SB) - MOVV $714, R12 - JMP callbackasm1(SB) - MOVV $715, R12 - JMP callbackasm1(SB) - MOVV $716, R12 - JMP callbackasm1(SB) - MOVV $717, R12 - JMP callbackasm1(SB) - MOVV $718, R12 - JMP callbackasm1(SB) - MOVV $719, R12 - JMP callbackasm1(SB) - MOVV $720, R12 - JMP callbackasm1(SB) - MOVV $721, R12 - JMP callbackasm1(SB) - MOVV $722, R12 - JMP callbackasm1(SB) - MOVV $723, R12 - JMP callbackasm1(SB) - MOVV $724, R12 - JMP callbackasm1(SB) - MOVV $725, R12 - JMP callbackasm1(SB) - MOVV $726, R12 - JMP callbackasm1(SB) - MOVV $727, R12 - JMP callbackasm1(SB) - MOVV $728, R12 - JMP callbackasm1(SB) - MOVV $729, R12 - JMP callbackasm1(SB) - MOVV $730, R12 - JMP callbackasm1(SB) - MOVV $731, R12 - JMP callbackasm1(SB) - MOVV $732, R12 - JMP callbackasm1(SB) - MOVV $733, R12 - JMP callbackasm1(SB) - MOVV $734, R12 - JMP callbackasm1(SB) - MOVV $735, R12 - JMP callbackasm1(SB) - MOVV $736, R12 - JMP callbackasm1(SB) - MOVV $737, R12 - JMP callbackasm1(SB) - MOVV $738, R12 - JMP callbackasm1(SB) - MOVV $739, R12 - JMP callbackasm1(SB) - MOVV $740, R12 - JMP callbackasm1(SB) - MOVV $741, R12 - JMP callbackasm1(SB) - MOVV $742, R12 - JMP callbackasm1(SB) - MOVV $743, R12 - JMP callbackasm1(SB) - MOVV $744, R12 - JMP callbackasm1(SB) - MOVV $745, R12 - JMP callbackasm1(SB) - MOVV $746, R12 - JMP callbackasm1(SB) - MOVV $747, R12 - JMP callbackasm1(SB) - MOVV $748, R12 - JMP callbackasm1(SB) - MOVV $749, R12 - JMP callbackasm1(SB) - MOVV $750, R12 - JMP callbackasm1(SB) - MOVV $751, R12 - JMP callbackasm1(SB) - MOVV $752, R12 - JMP callbackasm1(SB) - MOVV $753, R12 - JMP callbackasm1(SB) - MOVV $754, R12 - JMP callbackasm1(SB) - MOVV $755, R12 - JMP callbackasm1(SB) - MOVV $756, R12 - JMP callbackasm1(SB) - MOVV $757, R12 - JMP callbackasm1(SB) - MOVV $758, R12 - JMP callbackasm1(SB) - MOVV $759, R12 - JMP callbackasm1(SB) - MOVV $760, R12 - JMP callbackasm1(SB) - MOVV $761, R12 - JMP callbackasm1(SB) - MOVV $762, R12 - JMP callbackasm1(SB) - MOVV $763, R12 - JMP callbackasm1(SB) - MOVV $764, R12 - JMP callbackasm1(SB) - MOVV $765, R12 - JMP callbackasm1(SB) - MOVV $766, R12 - JMP callbackasm1(SB) - MOVV $767, R12 - JMP callbackasm1(SB) - MOVV $768, R12 - JMP callbackasm1(SB) - MOVV $769, R12 - JMP callbackasm1(SB) - MOVV $770, R12 - JMP callbackasm1(SB) - MOVV $771, R12 - JMP callbackasm1(SB) - MOVV $772, R12 - JMP callbackasm1(SB) - MOVV $773, R12 - JMP callbackasm1(SB) - MOVV $774, R12 - JMP callbackasm1(SB) - MOVV $775, R12 - JMP callbackasm1(SB) - MOVV $776, R12 - JMP callbackasm1(SB) - MOVV $777, R12 - JMP callbackasm1(SB) - MOVV $778, R12 - JMP callbackasm1(SB) - MOVV $779, R12 - JMP callbackasm1(SB) - MOVV $780, R12 - JMP callbackasm1(SB) - MOVV $781, R12 - JMP callbackasm1(SB) - MOVV $782, R12 - JMP callbackasm1(SB) - MOVV $783, R12 - JMP callbackasm1(SB) - MOVV $784, R12 - JMP callbackasm1(SB) - MOVV $785, R12 - JMP callbackasm1(SB) - MOVV $786, R12 - JMP callbackasm1(SB) - MOVV $787, R12 - JMP callbackasm1(SB) - MOVV $788, R12 - JMP callbackasm1(SB) - MOVV $789, R12 - JMP callbackasm1(SB) - MOVV $790, R12 - JMP callbackasm1(SB) - MOVV $791, R12 - JMP callbackasm1(SB) - MOVV $792, R12 - JMP callbackasm1(SB) - MOVV $793, R12 - JMP callbackasm1(SB) - MOVV $794, R12 - JMP callbackasm1(SB) - MOVV $795, R12 - JMP callbackasm1(SB) - MOVV $796, R12 - JMP callbackasm1(SB) - MOVV $797, R12 - JMP callbackasm1(SB) - MOVV $798, R12 - JMP callbackasm1(SB) - MOVV $799, R12 - JMP callbackasm1(SB) - MOVV $800, R12 - JMP callbackasm1(SB) - MOVV $801, R12 - JMP callbackasm1(SB) - MOVV $802, R12 - JMP callbackasm1(SB) - MOVV $803, R12 - JMP callbackasm1(SB) - MOVV $804, R12 - JMP callbackasm1(SB) - MOVV $805, R12 - JMP callbackasm1(SB) - MOVV $806, R12 - JMP callbackasm1(SB) - MOVV $807, R12 - JMP callbackasm1(SB) - MOVV $808, R12 - JMP callbackasm1(SB) - MOVV $809, R12 - JMP callbackasm1(SB) - MOVV $810, R12 - JMP callbackasm1(SB) - MOVV $811, R12 - JMP callbackasm1(SB) - MOVV $812, R12 - JMP callbackasm1(SB) - MOVV $813, R12 - JMP callbackasm1(SB) - MOVV $814, R12 - JMP callbackasm1(SB) - MOVV $815, R12 - JMP callbackasm1(SB) - MOVV $816, R12 - JMP callbackasm1(SB) - MOVV $817, R12 - JMP callbackasm1(SB) - MOVV $818, R12 - JMP callbackasm1(SB) - MOVV $819, R12 - JMP callbackasm1(SB) - MOVV $820, R12 - JMP callbackasm1(SB) - MOVV $821, R12 - JMP callbackasm1(SB) - MOVV $822, R12 - JMP callbackasm1(SB) - MOVV $823, R12 - JMP callbackasm1(SB) - MOVV $824, R12 - JMP callbackasm1(SB) - MOVV $825, R12 - JMP callbackasm1(SB) - MOVV $826, R12 - JMP callbackasm1(SB) - MOVV $827, R12 - JMP callbackasm1(SB) - MOVV $828, R12 - JMP callbackasm1(SB) - MOVV $829, R12 - JMP callbackasm1(SB) - MOVV $830, R12 - JMP callbackasm1(SB) - MOVV $831, R12 - JMP callbackasm1(SB) - MOVV $832, R12 - JMP callbackasm1(SB) - MOVV $833, R12 - JMP callbackasm1(SB) - MOVV $834, R12 - JMP callbackasm1(SB) - MOVV $835, R12 - JMP callbackasm1(SB) - MOVV $836, R12 - JMP callbackasm1(SB) - MOVV $837, R12 - JMP callbackasm1(SB) - MOVV $838, R12 - JMP callbackasm1(SB) - MOVV $839, R12 - JMP callbackasm1(SB) - MOVV $840, R12 - JMP callbackasm1(SB) - MOVV $841, R12 - JMP callbackasm1(SB) - MOVV $842, R12 - JMP callbackasm1(SB) - MOVV $843, R12 - JMP callbackasm1(SB) - MOVV $844, R12 - JMP callbackasm1(SB) - MOVV $845, R12 - JMP callbackasm1(SB) - MOVV $846, R12 - JMP callbackasm1(SB) - MOVV $847, R12 - JMP callbackasm1(SB) - MOVV $848, R12 - JMP callbackasm1(SB) - MOVV $849, R12 - JMP callbackasm1(SB) - MOVV $850, R12 - JMP callbackasm1(SB) - MOVV $851, R12 - JMP callbackasm1(SB) - MOVV $852, R12 - JMP callbackasm1(SB) - MOVV $853, R12 - JMP callbackasm1(SB) - MOVV $854, R12 - JMP callbackasm1(SB) - MOVV $855, R12 - JMP callbackasm1(SB) - MOVV $856, R12 - JMP callbackasm1(SB) - MOVV $857, R12 - JMP callbackasm1(SB) - MOVV $858, R12 - JMP callbackasm1(SB) - MOVV $859, R12 - JMP callbackasm1(SB) - MOVV $860, R12 - JMP callbackasm1(SB) - MOVV $861, R12 - JMP callbackasm1(SB) - MOVV $862, R12 - JMP callbackasm1(SB) - MOVV $863, R12 - JMP callbackasm1(SB) - MOVV $864, R12 - JMP callbackasm1(SB) - MOVV $865, R12 - JMP callbackasm1(SB) - MOVV $866, R12 - JMP callbackasm1(SB) - MOVV $867, R12 - JMP callbackasm1(SB) - MOVV $868, R12 - JMP callbackasm1(SB) - MOVV $869, R12 - JMP callbackasm1(SB) - MOVV $870, R12 - JMP callbackasm1(SB) - MOVV $871, R12 - JMP callbackasm1(SB) - MOVV $872, R12 - JMP callbackasm1(SB) - MOVV $873, R12 - JMP callbackasm1(SB) - MOVV $874, R12 - JMP callbackasm1(SB) - MOVV $875, R12 - JMP callbackasm1(SB) - MOVV $876, R12 - JMP callbackasm1(SB) - MOVV $877, R12 - JMP callbackasm1(SB) - MOVV $878, R12 - JMP callbackasm1(SB) - MOVV $879, R12 - JMP callbackasm1(SB) - MOVV $880, R12 - JMP callbackasm1(SB) - MOVV $881, R12 - JMP callbackasm1(SB) - MOVV $882, R12 - JMP callbackasm1(SB) - MOVV $883, R12 - JMP callbackasm1(SB) - MOVV $884, R12 - JMP callbackasm1(SB) - MOVV $885, R12 - JMP callbackasm1(SB) - MOVV $886, R12 - JMP callbackasm1(SB) - MOVV $887, R12 - JMP callbackasm1(SB) - MOVV $888, R12 - JMP callbackasm1(SB) - MOVV $889, R12 - JMP callbackasm1(SB) - MOVV $890, R12 - JMP callbackasm1(SB) - MOVV $891, R12 - JMP callbackasm1(SB) - MOVV $892, R12 - JMP callbackasm1(SB) - MOVV $893, R12 - JMP callbackasm1(SB) - MOVV $894, R12 - JMP callbackasm1(SB) - MOVV $895, R12 - JMP callbackasm1(SB) - MOVV $896, R12 - JMP callbackasm1(SB) - MOVV $897, R12 - JMP callbackasm1(SB) - MOVV $898, R12 - JMP callbackasm1(SB) - MOVV $899, R12 - JMP callbackasm1(SB) - MOVV $900, R12 - JMP callbackasm1(SB) - MOVV $901, R12 - JMP callbackasm1(SB) - MOVV $902, R12 - JMP callbackasm1(SB) - MOVV $903, R12 - JMP callbackasm1(SB) - MOVV $904, R12 - JMP callbackasm1(SB) - MOVV $905, R12 - JMP callbackasm1(SB) - MOVV $906, R12 - JMP callbackasm1(SB) - MOVV $907, R12 - JMP callbackasm1(SB) - MOVV $908, R12 - JMP callbackasm1(SB) - MOVV $909, R12 - JMP callbackasm1(SB) - MOVV $910, R12 - JMP callbackasm1(SB) - MOVV $911, R12 - JMP callbackasm1(SB) - MOVV $912, R12 - JMP callbackasm1(SB) - MOVV $913, R12 - JMP callbackasm1(SB) - MOVV $914, R12 - JMP callbackasm1(SB) - MOVV $915, R12 - JMP callbackasm1(SB) - MOVV $916, R12 - JMP callbackasm1(SB) - MOVV $917, R12 - JMP callbackasm1(SB) - MOVV $918, R12 - JMP callbackasm1(SB) - MOVV $919, R12 - JMP callbackasm1(SB) - MOVV $920, R12 - JMP callbackasm1(SB) - MOVV $921, R12 - JMP callbackasm1(SB) - MOVV $922, R12 - JMP callbackasm1(SB) - MOVV $923, R12 - JMP callbackasm1(SB) - MOVV $924, R12 - JMP callbackasm1(SB) - MOVV $925, R12 - JMP callbackasm1(SB) - MOVV $926, R12 - JMP callbackasm1(SB) - MOVV $927, R12 - JMP callbackasm1(SB) - MOVV $928, R12 - JMP callbackasm1(SB) - MOVV $929, R12 - JMP callbackasm1(SB) - MOVV $930, R12 - JMP callbackasm1(SB) - MOVV $931, R12 - JMP callbackasm1(SB) - MOVV $932, R12 - JMP callbackasm1(SB) - MOVV $933, R12 - JMP callbackasm1(SB) - MOVV $934, R12 - JMP callbackasm1(SB) - MOVV $935, R12 - JMP callbackasm1(SB) - MOVV $936, R12 - JMP callbackasm1(SB) - MOVV $937, R12 - JMP callbackasm1(SB) - MOVV $938, R12 - JMP callbackasm1(SB) - MOVV $939, R12 - JMP callbackasm1(SB) - MOVV $940, R12 - JMP callbackasm1(SB) - MOVV $941, R12 - JMP callbackasm1(SB) - MOVV $942, R12 - JMP callbackasm1(SB) - MOVV $943, R12 - JMP callbackasm1(SB) - MOVV $944, R12 - JMP callbackasm1(SB) - MOVV $945, R12 - JMP callbackasm1(SB) - MOVV $946, R12 - JMP callbackasm1(SB) - MOVV $947, R12 - JMP callbackasm1(SB) - MOVV $948, R12 - JMP callbackasm1(SB) - MOVV $949, R12 - JMP callbackasm1(SB) - MOVV $950, R12 - JMP callbackasm1(SB) - MOVV $951, R12 - JMP callbackasm1(SB) - MOVV $952, R12 - JMP callbackasm1(SB) - MOVV $953, R12 - JMP callbackasm1(SB) - MOVV $954, R12 - JMP callbackasm1(SB) - MOVV $955, R12 - JMP callbackasm1(SB) - MOVV $956, R12 - JMP callbackasm1(SB) - MOVV $957, R12 - JMP callbackasm1(SB) - MOVV $958, R12 - JMP callbackasm1(SB) - MOVV $959, R12 - JMP callbackasm1(SB) - MOVV $960, R12 - JMP callbackasm1(SB) - MOVV $961, R12 - JMP callbackasm1(SB) - MOVV $962, R12 - JMP callbackasm1(SB) - MOVV $963, R12 - JMP callbackasm1(SB) - MOVV $964, R12 - JMP callbackasm1(SB) - MOVV $965, R12 - JMP callbackasm1(SB) - MOVV $966, R12 - JMP callbackasm1(SB) - MOVV $967, R12 - JMP callbackasm1(SB) - MOVV $968, R12 - JMP callbackasm1(SB) - MOVV $969, R12 - JMP callbackasm1(SB) - MOVV $970, R12 - JMP callbackasm1(SB) - MOVV $971, R12 - JMP callbackasm1(SB) - MOVV $972, R12 - JMP callbackasm1(SB) - MOVV $973, R12 - JMP callbackasm1(SB) - MOVV $974, R12 - JMP callbackasm1(SB) - MOVV $975, R12 - JMP callbackasm1(SB) - MOVV $976, R12 - JMP callbackasm1(SB) - MOVV $977, R12 - JMP callbackasm1(SB) - MOVV $978, R12 - JMP callbackasm1(SB) - MOVV $979, R12 - JMP callbackasm1(SB) - MOVV $980, R12 - JMP callbackasm1(SB) - MOVV $981, R12 - JMP callbackasm1(SB) - MOVV $982, R12 - JMP callbackasm1(SB) - MOVV $983, R12 - JMP callbackasm1(SB) - MOVV $984, R12 - JMP callbackasm1(SB) - MOVV $985, R12 - JMP callbackasm1(SB) - MOVV $986, R12 - JMP callbackasm1(SB) - MOVV $987, R12 - JMP callbackasm1(SB) - MOVV $988, R12 - JMP callbackasm1(SB) - MOVV $989, R12 - JMP callbackasm1(SB) - MOVV $990, R12 - JMP callbackasm1(SB) - MOVV $991, R12 - JMP callbackasm1(SB) - MOVV $992, R12 - JMP callbackasm1(SB) - MOVV $993, R12 - JMP callbackasm1(SB) - MOVV $994, R12 - JMP callbackasm1(SB) - MOVV $995, R12 - JMP callbackasm1(SB) - MOVV $996, R12 - JMP callbackasm1(SB) - MOVV $997, R12 - JMP callbackasm1(SB) - MOVV $998, R12 - JMP callbackasm1(SB) - MOVV $999, R12 - JMP callbackasm1(SB) - MOVV $1000, R12 - JMP callbackasm1(SB) - MOVV $1001, R12 - JMP callbackasm1(SB) - MOVV $1002, R12 - JMP callbackasm1(SB) - MOVV $1003, R12 - JMP callbackasm1(SB) - MOVV $1004, R12 - JMP callbackasm1(SB) - MOVV $1005, R12 - JMP callbackasm1(SB) - MOVV $1006, R12 - JMP callbackasm1(SB) - MOVV $1007, R12 - JMP callbackasm1(SB) - MOVV $1008, R12 - JMP callbackasm1(SB) - MOVV $1009, R12 - JMP callbackasm1(SB) - MOVV $1010, R12 - JMP callbackasm1(SB) - MOVV $1011, R12 - JMP callbackasm1(SB) - MOVV $1012, R12 - JMP callbackasm1(SB) - MOVV $1013, R12 - JMP callbackasm1(SB) - MOVV $1014, R12 - JMP callbackasm1(SB) - MOVV $1015, R12 - JMP callbackasm1(SB) - MOVV $1016, R12 - JMP callbackasm1(SB) - MOVV $1017, R12 - JMP callbackasm1(SB) - MOVV $1018, R12 - JMP callbackasm1(SB) - MOVV $1019, R12 - JMP callbackasm1(SB) - MOVV $1020, R12 - JMP callbackasm1(SB) - MOVV $1021, R12 - JMP callbackasm1(SB) - MOVV $1022, R12 - JMP callbackasm1(SB) - MOVV $1023, R12 - JMP callbackasm1(SB) - MOVV $1024, R12 - JMP callbackasm1(SB) - MOVV $1025, R12 - JMP callbackasm1(SB) - MOVV $1026, R12 - JMP callbackasm1(SB) - MOVV $1027, R12 - JMP callbackasm1(SB) - MOVV $1028, R12 - JMP callbackasm1(SB) - MOVV $1029, R12 - JMP callbackasm1(SB) - MOVV $1030, R12 - JMP callbackasm1(SB) - MOVV $1031, R12 - JMP callbackasm1(SB) - MOVV $1032, R12 - JMP callbackasm1(SB) - MOVV $1033, R12 - JMP callbackasm1(SB) - MOVV $1034, R12 - JMP callbackasm1(SB) - MOVV $1035, R12 - JMP callbackasm1(SB) - MOVV $1036, R12 - JMP callbackasm1(SB) - MOVV $1037, R12 - JMP callbackasm1(SB) - MOVV $1038, R12 - JMP callbackasm1(SB) - MOVV $1039, R12 - JMP callbackasm1(SB) - MOVV $1040, R12 - JMP callbackasm1(SB) - MOVV $1041, R12 - JMP callbackasm1(SB) - MOVV $1042, R12 - JMP callbackasm1(SB) - MOVV $1043, R12 - JMP callbackasm1(SB) - MOVV $1044, R12 - JMP callbackasm1(SB) - MOVV $1045, R12 - JMP callbackasm1(SB) - MOVV $1046, R12 - JMP callbackasm1(SB) - MOVV $1047, R12 - JMP callbackasm1(SB) - MOVV $1048, R12 - JMP callbackasm1(SB) - MOVV $1049, R12 - JMP callbackasm1(SB) - MOVV $1050, R12 - JMP callbackasm1(SB) - MOVV $1051, R12 - JMP callbackasm1(SB) - MOVV $1052, R12 - JMP callbackasm1(SB) - MOVV $1053, R12 - JMP callbackasm1(SB) - MOVV $1054, R12 - JMP callbackasm1(SB) - MOVV $1055, R12 - JMP callbackasm1(SB) - MOVV $1056, R12 - JMP callbackasm1(SB) - MOVV $1057, R12 - JMP callbackasm1(SB) - MOVV $1058, R12 - JMP callbackasm1(SB) - MOVV $1059, R12 - JMP callbackasm1(SB) - MOVV $1060, R12 - JMP callbackasm1(SB) - MOVV $1061, R12 - JMP callbackasm1(SB) - MOVV $1062, R12 - JMP callbackasm1(SB) - MOVV $1063, R12 - JMP callbackasm1(SB) - MOVV $1064, R12 - JMP callbackasm1(SB) - MOVV $1065, R12 - JMP callbackasm1(SB) - MOVV $1066, R12 - JMP callbackasm1(SB) - MOVV $1067, R12 - JMP callbackasm1(SB) - MOVV $1068, R12 - JMP callbackasm1(SB) - MOVV $1069, R12 - JMP callbackasm1(SB) - MOVV $1070, R12 - JMP callbackasm1(SB) - MOVV $1071, R12 - JMP callbackasm1(SB) - MOVV $1072, R12 - JMP callbackasm1(SB) - MOVV $1073, R12 - JMP callbackasm1(SB) - MOVV $1074, R12 - JMP callbackasm1(SB) - MOVV $1075, R12 - JMP callbackasm1(SB) - MOVV $1076, R12 - JMP callbackasm1(SB) - MOVV $1077, R12 - JMP callbackasm1(SB) - MOVV $1078, R12 - JMP callbackasm1(SB) - MOVV $1079, R12 - JMP callbackasm1(SB) - MOVV $1080, R12 - JMP callbackasm1(SB) - MOVV $1081, R12 - JMP callbackasm1(SB) - MOVV $1082, R12 - JMP callbackasm1(SB) - MOVV $1083, R12 - JMP callbackasm1(SB) - MOVV $1084, R12 - JMP callbackasm1(SB) - MOVV $1085, R12 - JMP callbackasm1(SB) - MOVV $1086, R12 - JMP callbackasm1(SB) - MOVV $1087, R12 - JMP callbackasm1(SB) - MOVV $1088, R12 - JMP callbackasm1(SB) - MOVV $1089, R12 - JMP callbackasm1(SB) - MOVV $1090, R12 - JMP callbackasm1(SB) - MOVV $1091, R12 - JMP callbackasm1(SB) - MOVV $1092, R12 - JMP callbackasm1(SB) - MOVV $1093, R12 - JMP callbackasm1(SB) - MOVV $1094, R12 - JMP callbackasm1(SB) - MOVV $1095, R12 - JMP callbackasm1(SB) - MOVV $1096, R12 - JMP callbackasm1(SB) - MOVV $1097, R12 - JMP callbackasm1(SB) - MOVV $1098, R12 - JMP callbackasm1(SB) - MOVV $1099, R12 - JMP callbackasm1(SB) - MOVV $1100, R12 - JMP callbackasm1(SB) - MOVV $1101, R12 - JMP callbackasm1(SB) - MOVV $1102, R12 - JMP callbackasm1(SB) - MOVV $1103, R12 - JMP callbackasm1(SB) - MOVV $1104, R12 - JMP callbackasm1(SB) - MOVV $1105, R12 - JMP callbackasm1(SB) - MOVV $1106, R12 - JMP callbackasm1(SB) - MOVV $1107, R12 - JMP callbackasm1(SB) - MOVV $1108, R12 - JMP callbackasm1(SB) - MOVV $1109, R12 - JMP callbackasm1(SB) - MOVV $1110, R12 - JMP callbackasm1(SB) - MOVV $1111, R12 - JMP callbackasm1(SB) - MOVV $1112, R12 - JMP callbackasm1(SB) - MOVV $1113, R12 - JMP callbackasm1(SB) - MOVV $1114, R12 - JMP callbackasm1(SB) - MOVV $1115, R12 - JMP callbackasm1(SB) - MOVV $1116, R12 - JMP callbackasm1(SB) - MOVV $1117, R12 - JMP callbackasm1(SB) - MOVV $1118, R12 - JMP callbackasm1(SB) - MOVV $1119, R12 - JMP callbackasm1(SB) - MOVV $1120, R12 - JMP callbackasm1(SB) - MOVV $1121, R12 - JMP callbackasm1(SB) - MOVV $1122, R12 - JMP callbackasm1(SB) - MOVV $1123, R12 - JMP callbackasm1(SB) - MOVV $1124, R12 - JMP callbackasm1(SB) - MOVV $1125, R12 - JMP callbackasm1(SB) - MOVV $1126, R12 - JMP callbackasm1(SB) - MOVV $1127, R12 - JMP callbackasm1(SB) - MOVV $1128, R12 - JMP callbackasm1(SB) - MOVV $1129, R12 - JMP callbackasm1(SB) - MOVV $1130, R12 - JMP callbackasm1(SB) - MOVV $1131, R12 - JMP callbackasm1(SB) - MOVV $1132, R12 - JMP callbackasm1(SB) - MOVV $1133, R12 - JMP callbackasm1(SB) - MOVV $1134, R12 - JMP callbackasm1(SB) - MOVV $1135, R12 - JMP callbackasm1(SB) - MOVV $1136, R12 - JMP callbackasm1(SB) - MOVV $1137, R12 - JMP callbackasm1(SB) - MOVV $1138, R12 - JMP callbackasm1(SB) - MOVV $1139, R12 - JMP callbackasm1(SB) - MOVV $1140, R12 - JMP callbackasm1(SB) - MOVV $1141, R12 - JMP callbackasm1(SB) - MOVV $1142, R12 - JMP callbackasm1(SB) - MOVV $1143, R12 - JMP callbackasm1(SB) - MOVV $1144, R12 - JMP callbackasm1(SB) - MOVV $1145, R12 - JMP callbackasm1(SB) - MOVV $1146, R12 - JMP callbackasm1(SB) - MOVV $1147, R12 - JMP callbackasm1(SB) - MOVV $1148, R12 - JMP callbackasm1(SB) - MOVV $1149, R12 - JMP callbackasm1(SB) - MOVV $1150, R12 - JMP callbackasm1(SB) - MOVV $1151, R12 - JMP callbackasm1(SB) - MOVV $1152, R12 - JMP callbackasm1(SB) - MOVV $1153, R12 - JMP callbackasm1(SB) - MOVV $1154, R12 - JMP callbackasm1(SB) - MOVV $1155, R12 - JMP callbackasm1(SB) - MOVV $1156, R12 - JMP callbackasm1(SB) - MOVV $1157, R12 - JMP callbackasm1(SB) - MOVV $1158, R12 - JMP callbackasm1(SB) - MOVV $1159, R12 - JMP callbackasm1(SB) - MOVV $1160, R12 - JMP callbackasm1(SB) - MOVV $1161, R12 - JMP callbackasm1(SB) - MOVV $1162, R12 - JMP callbackasm1(SB) - MOVV $1163, R12 - JMP callbackasm1(SB) - MOVV $1164, R12 - JMP callbackasm1(SB) - MOVV $1165, R12 - JMP callbackasm1(SB) - MOVV $1166, R12 - JMP callbackasm1(SB) - MOVV $1167, R12 - JMP callbackasm1(SB) - MOVV $1168, R12 - JMP callbackasm1(SB) - MOVV $1169, R12 - JMP callbackasm1(SB) - MOVV $1170, R12 - JMP callbackasm1(SB) - MOVV $1171, R12 - JMP callbackasm1(SB) - MOVV $1172, R12 - JMP callbackasm1(SB) - MOVV $1173, R12 - JMP callbackasm1(SB) - MOVV $1174, R12 - JMP callbackasm1(SB) - MOVV $1175, R12 - JMP callbackasm1(SB) - MOVV $1176, R12 - JMP callbackasm1(SB) - MOVV $1177, R12 - JMP callbackasm1(SB) - MOVV $1178, R12 - JMP callbackasm1(SB) - MOVV $1179, R12 - JMP callbackasm1(SB) - MOVV $1180, R12 - JMP callbackasm1(SB) - MOVV $1181, R12 - JMP callbackasm1(SB) - MOVV $1182, R12 - JMP callbackasm1(SB) - MOVV $1183, R12 - JMP callbackasm1(SB) - MOVV $1184, R12 - JMP callbackasm1(SB) - MOVV $1185, R12 - JMP callbackasm1(SB) - MOVV $1186, R12 - JMP callbackasm1(SB) - MOVV $1187, R12 - JMP callbackasm1(SB) - MOVV $1188, R12 - JMP callbackasm1(SB) - MOVV $1189, R12 - JMP callbackasm1(SB) - MOVV $1190, R12 - JMP callbackasm1(SB) - MOVV $1191, R12 - JMP callbackasm1(SB) - MOVV $1192, R12 - JMP callbackasm1(SB) - MOVV $1193, R12 - JMP callbackasm1(SB) - MOVV $1194, R12 - JMP callbackasm1(SB) - MOVV $1195, R12 - JMP callbackasm1(SB) - MOVV $1196, R12 - JMP callbackasm1(SB) - MOVV $1197, R12 - JMP callbackasm1(SB) - MOVV $1198, R12 - JMP callbackasm1(SB) - MOVV $1199, R12 - JMP callbackasm1(SB) - MOVV $1200, R12 - JMP callbackasm1(SB) - MOVV $1201, R12 - JMP callbackasm1(SB) - MOVV $1202, R12 - JMP callbackasm1(SB) - MOVV $1203, R12 - JMP callbackasm1(SB) - MOVV $1204, R12 - JMP callbackasm1(SB) - MOVV $1205, R12 - JMP callbackasm1(SB) - MOVV $1206, R12 - JMP callbackasm1(SB) - MOVV $1207, R12 - JMP callbackasm1(SB) - MOVV $1208, R12 - JMP callbackasm1(SB) - MOVV $1209, R12 - JMP callbackasm1(SB) - MOVV $1210, R12 - JMP callbackasm1(SB) - MOVV $1211, R12 - JMP callbackasm1(SB) - MOVV $1212, R12 - JMP callbackasm1(SB) - MOVV $1213, R12 - JMP callbackasm1(SB) - MOVV $1214, R12 - JMP callbackasm1(SB) - MOVV $1215, R12 - JMP callbackasm1(SB) - MOVV $1216, R12 - JMP callbackasm1(SB) - MOVV $1217, R12 - JMP callbackasm1(SB) - MOVV $1218, R12 - JMP callbackasm1(SB) - MOVV $1219, R12 - JMP callbackasm1(SB) - MOVV $1220, R12 - JMP callbackasm1(SB) - MOVV $1221, R12 - JMP callbackasm1(SB) - MOVV $1222, R12 - JMP callbackasm1(SB) - MOVV $1223, R12 - JMP callbackasm1(SB) - MOVV $1224, R12 - JMP callbackasm1(SB) - MOVV $1225, R12 - JMP callbackasm1(SB) - MOVV $1226, R12 - JMP callbackasm1(SB) - MOVV $1227, R12 - JMP callbackasm1(SB) - MOVV $1228, R12 - JMP callbackasm1(SB) - MOVV $1229, R12 - JMP callbackasm1(SB) - MOVV $1230, R12 - JMP callbackasm1(SB) - MOVV $1231, R12 - JMP callbackasm1(SB) - MOVV $1232, R12 - JMP callbackasm1(SB) - MOVV $1233, R12 - JMP callbackasm1(SB) - MOVV $1234, R12 - JMP callbackasm1(SB) - MOVV $1235, R12 - JMP callbackasm1(SB) - MOVV $1236, R12 - JMP callbackasm1(SB) - MOVV $1237, R12 - JMP callbackasm1(SB) - MOVV $1238, R12 - JMP callbackasm1(SB) - MOVV $1239, R12 - JMP callbackasm1(SB) - MOVV $1240, R12 - JMP callbackasm1(SB) - MOVV $1241, R12 - JMP callbackasm1(SB) - MOVV $1242, R12 - JMP callbackasm1(SB) - MOVV $1243, R12 - JMP callbackasm1(SB) - MOVV $1244, R12 - JMP callbackasm1(SB) - MOVV $1245, R12 - JMP callbackasm1(SB) - MOVV $1246, R12 - JMP callbackasm1(SB) - MOVV $1247, R12 - JMP callbackasm1(SB) - MOVV $1248, R12 - JMP callbackasm1(SB) - MOVV $1249, R12 - JMP callbackasm1(SB) - MOVV $1250, R12 - JMP callbackasm1(SB) - MOVV $1251, R12 - JMP callbackasm1(SB) - MOVV $1252, R12 - JMP callbackasm1(SB) - MOVV $1253, R12 - JMP callbackasm1(SB) - MOVV $1254, R12 - JMP callbackasm1(SB) - MOVV $1255, R12 - JMP callbackasm1(SB) - MOVV $1256, R12 - JMP callbackasm1(SB) - MOVV $1257, R12 - JMP callbackasm1(SB) - MOVV $1258, R12 - JMP callbackasm1(SB) - MOVV $1259, R12 - JMP callbackasm1(SB) - MOVV $1260, R12 - JMP callbackasm1(SB) - MOVV $1261, R12 - JMP callbackasm1(SB) - MOVV $1262, R12 - JMP callbackasm1(SB) - MOVV $1263, R12 - JMP callbackasm1(SB) - MOVV $1264, R12 - JMP callbackasm1(SB) - MOVV $1265, R12 - JMP callbackasm1(SB) - MOVV $1266, R12 - JMP callbackasm1(SB) - MOVV $1267, R12 - JMP callbackasm1(SB) - MOVV $1268, R12 - JMP callbackasm1(SB) - MOVV $1269, R12 - JMP callbackasm1(SB) - MOVV $1270, R12 - JMP callbackasm1(SB) - MOVV $1271, R12 - JMP callbackasm1(SB) - MOVV $1272, R12 - JMP callbackasm1(SB) - MOVV $1273, R12 - JMP callbackasm1(SB) - MOVV $1274, R12 - JMP callbackasm1(SB) - MOVV $1275, R12 - JMP callbackasm1(SB) - MOVV $1276, R12 - JMP callbackasm1(SB) - MOVV $1277, R12 - JMP callbackasm1(SB) - MOVV $1278, R12 - JMP callbackasm1(SB) - MOVV $1279, R12 - JMP callbackasm1(SB) - MOVV $1280, R12 - JMP callbackasm1(SB) - MOVV $1281, R12 - JMP callbackasm1(SB) - MOVV $1282, R12 - JMP callbackasm1(SB) - MOVV $1283, R12 - JMP callbackasm1(SB) - MOVV $1284, R12 - JMP callbackasm1(SB) - MOVV $1285, R12 - JMP callbackasm1(SB) - MOVV $1286, R12 - JMP callbackasm1(SB) - MOVV $1287, R12 - JMP callbackasm1(SB) - MOVV $1288, R12 - JMP callbackasm1(SB) - MOVV $1289, R12 - JMP callbackasm1(SB) - MOVV $1290, R12 - JMP callbackasm1(SB) - MOVV $1291, R12 - JMP callbackasm1(SB) - MOVV $1292, R12 - JMP callbackasm1(SB) - MOVV $1293, R12 - JMP callbackasm1(SB) - MOVV $1294, R12 - JMP callbackasm1(SB) - MOVV $1295, R12 - JMP callbackasm1(SB) - MOVV $1296, R12 - JMP callbackasm1(SB) - MOVV $1297, R12 - JMP callbackasm1(SB) - MOVV $1298, R12 - JMP callbackasm1(SB) - MOVV $1299, R12 - JMP callbackasm1(SB) - MOVV $1300, R12 - JMP callbackasm1(SB) - MOVV $1301, R12 - JMP callbackasm1(SB) - MOVV $1302, R12 - JMP callbackasm1(SB) - MOVV $1303, R12 - JMP callbackasm1(SB) - MOVV $1304, R12 - JMP callbackasm1(SB) - MOVV $1305, R12 - JMP callbackasm1(SB) - MOVV $1306, R12 - JMP callbackasm1(SB) - MOVV $1307, R12 - JMP callbackasm1(SB) - MOVV $1308, R12 - JMP callbackasm1(SB) - MOVV $1309, R12 - JMP callbackasm1(SB) - MOVV $1310, R12 - JMP callbackasm1(SB) - MOVV $1311, R12 - JMP callbackasm1(SB) - MOVV $1312, R12 - JMP callbackasm1(SB) - MOVV $1313, R12 - JMP callbackasm1(SB) - MOVV $1314, R12 - JMP callbackasm1(SB) - MOVV $1315, R12 - JMP callbackasm1(SB) - MOVV $1316, R12 - JMP callbackasm1(SB) - MOVV $1317, R12 - JMP callbackasm1(SB) - MOVV $1318, R12 - JMP callbackasm1(SB) - MOVV $1319, R12 - JMP callbackasm1(SB) - MOVV $1320, R12 - JMP callbackasm1(SB) - MOVV $1321, R12 - JMP callbackasm1(SB) - MOVV $1322, R12 - JMP callbackasm1(SB) - MOVV $1323, R12 - JMP callbackasm1(SB) - MOVV $1324, R12 - JMP callbackasm1(SB) - MOVV $1325, R12 - JMP callbackasm1(SB) - MOVV $1326, R12 - JMP callbackasm1(SB) - MOVV $1327, R12 - JMP callbackasm1(SB) - MOVV $1328, R12 - JMP callbackasm1(SB) - MOVV $1329, R12 - JMP callbackasm1(SB) - MOVV $1330, R12 - JMP callbackasm1(SB) - MOVV $1331, R12 - JMP callbackasm1(SB) - MOVV $1332, R12 - JMP callbackasm1(SB) - MOVV $1333, R12 - JMP callbackasm1(SB) - MOVV $1334, R12 - JMP callbackasm1(SB) - MOVV $1335, R12 - JMP callbackasm1(SB) - MOVV $1336, R12 - JMP callbackasm1(SB) - MOVV $1337, R12 - JMP callbackasm1(SB) - MOVV $1338, R12 - JMP callbackasm1(SB) - MOVV $1339, R12 - JMP callbackasm1(SB) - MOVV $1340, R12 - JMP callbackasm1(SB) - MOVV $1341, R12 - JMP callbackasm1(SB) - MOVV $1342, R12 - JMP callbackasm1(SB) - MOVV $1343, R12 - JMP callbackasm1(SB) - MOVV $1344, R12 - JMP callbackasm1(SB) - MOVV $1345, R12 - JMP callbackasm1(SB) - MOVV $1346, R12 - JMP callbackasm1(SB) - MOVV $1347, R12 - JMP callbackasm1(SB) - MOVV $1348, R12 - JMP callbackasm1(SB) - MOVV $1349, R12 - JMP callbackasm1(SB) - MOVV $1350, R12 - JMP callbackasm1(SB) - MOVV $1351, R12 - JMP callbackasm1(SB) - MOVV $1352, R12 - JMP callbackasm1(SB) - MOVV $1353, R12 - JMP callbackasm1(SB) - MOVV $1354, R12 - JMP callbackasm1(SB) - MOVV $1355, R12 - JMP callbackasm1(SB) - MOVV $1356, R12 - JMP callbackasm1(SB) - MOVV $1357, R12 - JMP callbackasm1(SB) - MOVV $1358, R12 - JMP callbackasm1(SB) - MOVV $1359, R12 - JMP callbackasm1(SB) - MOVV $1360, R12 - JMP callbackasm1(SB) - MOVV $1361, R12 - JMP callbackasm1(SB) - MOVV $1362, R12 - JMP callbackasm1(SB) - MOVV $1363, R12 - JMP callbackasm1(SB) - MOVV $1364, R12 - JMP callbackasm1(SB) - MOVV $1365, R12 - JMP callbackasm1(SB) - MOVV $1366, R12 - JMP callbackasm1(SB) - MOVV $1367, R12 - JMP callbackasm1(SB) - MOVV $1368, R12 - JMP callbackasm1(SB) - MOVV $1369, R12 - JMP callbackasm1(SB) - MOVV $1370, R12 - JMP callbackasm1(SB) - MOVV $1371, R12 - JMP callbackasm1(SB) - MOVV $1372, R12 - JMP callbackasm1(SB) - MOVV $1373, R12 - JMP callbackasm1(SB) - MOVV $1374, R12 - JMP callbackasm1(SB) - MOVV $1375, R12 - JMP callbackasm1(SB) - MOVV $1376, R12 - JMP callbackasm1(SB) - MOVV $1377, R12 - JMP callbackasm1(SB) - MOVV $1378, R12 - JMP callbackasm1(SB) - MOVV $1379, R12 - JMP callbackasm1(SB) - MOVV $1380, R12 - JMP callbackasm1(SB) - MOVV $1381, R12 - JMP callbackasm1(SB) - MOVV $1382, R12 - JMP callbackasm1(SB) - MOVV $1383, R12 - JMP callbackasm1(SB) - MOVV $1384, R12 - JMP callbackasm1(SB) - MOVV $1385, R12 - JMP callbackasm1(SB) - MOVV $1386, R12 - JMP callbackasm1(SB) - MOVV $1387, R12 - JMP callbackasm1(SB) - MOVV $1388, R12 - JMP callbackasm1(SB) - MOVV $1389, R12 - JMP callbackasm1(SB) - MOVV $1390, R12 - JMP callbackasm1(SB) - MOVV $1391, R12 - JMP callbackasm1(SB) - MOVV $1392, R12 - JMP callbackasm1(SB) - MOVV $1393, R12 - JMP callbackasm1(SB) - MOVV $1394, R12 - JMP callbackasm1(SB) - MOVV $1395, R12 - JMP callbackasm1(SB) - MOVV $1396, R12 - JMP callbackasm1(SB) - MOVV $1397, R12 - JMP callbackasm1(SB) - MOVV $1398, R12 - JMP callbackasm1(SB) - MOVV $1399, R12 - JMP callbackasm1(SB) - MOVV $1400, R12 - JMP callbackasm1(SB) - MOVV $1401, R12 - JMP callbackasm1(SB) - MOVV $1402, R12 - JMP callbackasm1(SB) - MOVV $1403, R12 - JMP callbackasm1(SB) - MOVV $1404, R12 - JMP callbackasm1(SB) - MOVV $1405, R12 - JMP callbackasm1(SB) - MOVV $1406, R12 - JMP callbackasm1(SB) - MOVV $1407, R12 - JMP callbackasm1(SB) - MOVV $1408, R12 - JMP callbackasm1(SB) - MOVV $1409, R12 - JMP callbackasm1(SB) - MOVV $1410, R12 - JMP callbackasm1(SB) - MOVV $1411, R12 - JMP callbackasm1(SB) - MOVV $1412, R12 - JMP callbackasm1(SB) - MOVV $1413, R12 - JMP callbackasm1(SB) - MOVV $1414, R12 - JMP callbackasm1(SB) - MOVV $1415, R12 - JMP callbackasm1(SB) - MOVV $1416, R12 - JMP callbackasm1(SB) - MOVV $1417, R12 - JMP callbackasm1(SB) - MOVV $1418, R12 - JMP callbackasm1(SB) - MOVV $1419, R12 - JMP callbackasm1(SB) - MOVV $1420, R12 - JMP callbackasm1(SB) - MOVV $1421, R12 - JMP callbackasm1(SB) - MOVV $1422, R12 - JMP callbackasm1(SB) - MOVV $1423, R12 - JMP callbackasm1(SB) - MOVV $1424, R12 - JMP callbackasm1(SB) - MOVV $1425, R12 - JMP callbackasm1(SB) - MOVV $1426, R12 - JMP callbackasm1(SB) - MOVV $1427, R12 - JMP callbackasm1(SB) - MOVV $1428, R12 - JMP callbackasm1(SB) - MOVV $1429, R12 - JMP callbackasm1(SB) - MOVV $1430, R12 - JMP callbackasm1(SB) - MOVV $1431, R12 - JMP callbackasm1(SB) - MOVV $1432, R12 - JMP callbackasm1(SB) - MOVV $1433, R12 - JMP callbackasm1(SB) - MOVV $1434, R12 - JMP callbackasm1(SB) - MOVV $1435, R12 - JMP callbackasm1(SB) - MOVV $1436, R12 - JMP callbackasm1(SB) - MOVV $1437, R12 - JMP callbackasm1(SB) - MOVV $1438, R12 - JMP callbackasm1(SB) - MOVV $1439, R12 - JMP callbackasm1(SB) - MOVV $1440, R12 - JMP callbackasm1(SB) - MOVV $1441, R12 - JMP callbackasm1(SB) - MOVV $1442, R12 - JMP callbackasm1(SB) - MOVV $1443, R12 - JMP callbackasm1(SB) - MOVV $1444, R12 - JMP callbackasm1(SB) - MOVV $1445, R12 - JMP callbackasm1(SB) - MOVV $1446, R12 - JMP callbackasm1(SB) - MOVV $1447, R12 - JMP callbackasm1(SB) - MOVV $1448, R12 - JMP callbackasm1(SB) - MOVV $1449, R12 - JMP callbackasm1(SB) - MOVV $1450, R12 - JMP callbackasm1(SB) - MOVV $1451, R12 - JMP callbackasm1(SB) - MOVV $1452, R12 - JMP callbackasm1(SB) - MOVV $1453, R12 - JMP callbackasm1(SB) - MOVV $1454, R12 - JMP callbackasm1(SB) - MOVV $1455, R12 - JMP callbackasm1(SB) - MOVV $1456, R12 - JMP callbackasm1(SB) - MOVV $1457, R12 - JMP callbackasm1(SB) - MOVV $1458, R12 - JMP callbackasm1(SB) - MOVV $1459, R12 - JMP callbackasm1(SB) - MOVV $1460, R12 - JMP callbackasm1(SB) - MOVV $1461, R12 - JMP callbackasm1(SB) - MOVV $1462, R12 - JMP callbackasm1(SB) - MOVV $1463, R12 - JMP callbackasm1(SB) - MOVV $1464, R12 - JMP callbackasm1(SB) - MOVV $1465, R12 - JMP callbackasm1(SB) - MOVV $1466, R12 - JMP callbackasm1(SB) - MOVV $1467, R12 - JMP callbackasm1(SB) - MOVV $1468, R12 - JMP callbackasm1(SB) - MOVV $1469, R12 - JMP callbackasm1(SB) - MOVV $1470, R12 - JMP callbackasm1(SB) - MOVV $1471, R12 - JMP callbackasm1(SB) - MOVV $1472, R12 - JMP callbackasm1(SB) - MOVV $1473, R12 - JMP callbackasm1(SB) - MOVV $1474, R12 - JMP callbackasm1(SB) - MOVV $1475, R12 - JMP callbackasm1(SB) - MOVV $1476, R12 - JMP callbackasm1(SB) - MOVV $1477, R12 - JMP callbackasm1(SB) - MOVV $1478, R12 - JMP callbackasm1(SB) - MOVV $1479, R12 - JMP callbackasm1(SB) - MOVV $1480, R12 - JMP callbackasm1(SB) - MOVV $1481, R12 - JMP callbackasm1(SB) - MOVV $1482, R12 - JMP callbackasm1(SB) - MOVV $1483, R12 - JMP callbackasm1(SB) - MOVV $1484, R12 - JMP callbackasm1(SB) - MOVV $1485, R12 - JMP callbackasm1(SB) - MOVV $1486, R12 - JMP callbackasm1(SB) - MOVV $1487, R12 - JMP callbackasm1(SB) - MOVV $1488, R12 - JMP callbackasm1(SB) - MOVV $1489, R12 - JMP callbackasm1(SB) - MOVV $1490, R12 - JMP callbackasm1(SB) - MOVV $1491, R12 - JMP callbackasm1(SB) - MOVV $1492, R12 - JMP callbackasm1(SB) - MOVV $1493, R12 - JMP callbackasm1(SB) - MOVV $1494, R12 - JMP callbackasm1(SB) - MOVV $1495, R12 - JMP callbackasm1(SB) - MOVV $1496, R12 - JMP callbackasm1(SB) - MOVV $1497, R12 - JMP callbackasm1(SB) - MOVV $1498, R12 - JMP callbackasm1(SB) - MOVV $1499, R12 - JMP callbackasm1(SB) - MOVV $1500, R12 - JMP callbackasm1(SB) - MOVV $1501, R12 - JMP callbackasm1(SB) - MOVV $1502, R12 - JMP callbackasm1(SB) - MOVV $1503, R12 - JMP callbackasm1(SB) - MOVV $1504, R12 - JMP callbackasm1(SB) - MOVV $1505, R12 - JMP callbackasm1(SB) - MOVV $1506, R12 - JMP callbackasm1(SB) - MOVV $1507, R12 - JMP callbackasm1(SB) - MOVV $1508, R12 - JMP callbackasm1(SB) - MOVV $1509, R12 - JMP callbackasm1(SB) - MOVV $1510, R12 - JMP callbackasm1(SB) - MOVV $1511, R12 - JMP callbackasm1(SB) - MOVV $1512, R12 - JMP callbackasm1(SB) - MOVV $1513, R12 - JMP callbackasm1(SB) - MOVV $1514, R12 - JMP callbackasm1(SB) - MOVV $1515, R12 - JMP callbackasm1(SB) - MOVV $1516, R12 - JMP callbackasm1(SB) - MOVV $1517, R12 - JMP callbackasm1(SB) - MOVV $1518, R12 - JMP callbackasm1(SB) - MOVV $1519, R12 - JMP callbackasm1(SB) - MOVV $1520, R12 - JMP callbackasm1(SB) - MOVV $1521, R12 - JMP callbackasm1(SB) - MOVV $1522, R12 - JMP callbackasm1(SB) - MOVV $1523, R12 - JMP callbackasm1(SB) - MOVV $1524, R12 - JMP callbackasm1(SB) - MOVV $1525, R12 - JMP callbackasm1(SB) - MOVV $1526, R12 - JMP callbackasm1(SB) - MOVV $1527, R12 - JMP callbackasm1(SB) - MOVV $1528, R12 - JMP callbackasm1(SB) - MOVV $1529, R12 - JMP callbackasm1(SB) - MOVV $1530, R12 - JMP callbackasm1(SB) - MOVV $1531, R12 - JMP callbackasm1(SB) - MOVV $1532, R12 - JMP callbackasm1(SB) - MOVV $1533, R12 - JMP callbackasm1(SB) - MOVV $1534, R12 - JMP callbackasm1(SB) - MOVV $1535, R12 - JMP callbackasm1(SB) - MOVV $1536, R12 - JMP callbackasm1(SB) - MOVV $1537, R12 - JMP callbackasm1(SB) - MOVV $1538, R12 - JMP callbackasm1(SB) - MOVV $1539, R12 - JMP callbackasm1(SB) - MOVV $1540, R12 - JMP callbackasm1(SB) - MOVV $1541, R12 - JMP callbackasm1(SB) - MOVV $1542, R12 - JMP callbackasm1(SB) - MOVV $1543, R12 - JMP callbackasm1(SB) - MOVV $1544, R12 - JMP callbackasm1(SB) - MOVV $1545, R12 - JMP callbackasm1(SB) - MOVV $1546, R12 - JMP callbackasm1(SB) - MOVV $1547, R12 - JMP callbackasm1(SB) - MOVV $1548, R12 - JMP callbackasm1(SB) - MOVV $1549, R12 - JMP callbackasm1(SB) - MOVV $1550, R12 - JMP callbackasm1(SB) - MOVV $1551, R12 - JMP callbackasm1(SB) - MOVV $1552, R12 - JMP callbackasm1(SB) - MOVV $1553, R12 - JMP callbackasm1(SB) - MOVV $1554, R12 - JMP callbackasm1(SB) - MOVV $1555, R12 - JMP callbackasm1(SB) - MOVV $1556, R12 - JMP callbackasm1(SB) - MOVV $1557, R12 - JMP callbackasm1(SB) - MOVV $1558, R12 - JMP callbackasm1(SB) - MOVV $1559, R12 - JMP callbackasm1(SB) - MOVV $1560, R12 - JMP callbackasm1(SB) - MOVV $1561, R12 - JMP callbackasm1(SB) - MOVV $1562, R12 - JMP callbackasm1(SB) - MOVV $1563, R12 - JMP callbackasm1(SB) - MOVV $1564, R12 - JMP callbackasm1(SB) - MOVV $1565, R12 - JMP callbackasm1(SB) - MOVV $1566, R12 - JMP callbackasm1(SB) - MOVV $1567, R12 - JMP callbackasm1(SB) - MOVV $1568, R12 - JMP callbackasm1(SB) - MOVV $1569, R12 - JMP callbackasm1(SB) - MOVV $1570, R12 - JMP callbackasm1(SB) - MOVV $1571, R12 - JMP callbackasm1(SB) - MOVV $1572, R12 - JMP callbackasm1(SB) - MOVV $1573, R12 - JMP callbackasm1(SB) - MOVV $1574, R12 - JMP callbackasm1(SB) - MOVV $1575, R12 - JMP callbackasm1(SB) - MOVV $1576, R12 - JMP callbackasm1(SB) - MOVV $1577, R12 - JMP callbackasm1(SB) - MOVV $1578, R12 - JMP callbackasm1(SB) - MOVV $1579, R12 - JMP callbackasm1(SB) - MOVV $1580, R12 - JMP callbackasm1(SB) - MOVV $1581, R12 - JMP callbackasm1(SB) - MOVV $1582, R12 - JMP callbackasm1(SB) - MOVV $1583, R12 - JMP callbackasm1(SB) - MOVV $1584, R12 - JMP callbackasm1(SB) - MOVV $1585, R12 - JMP callbackasm1(SB) - MOVV $1586, R12 - JMP callbackasm1(SB) - MOVV $1587, R12 - JMP callbackasm1(SB) - MOVV $1588, R12 - JMP callbackasm1(SB) - MOVV $1589, R12 - JMP callbackasm1(SB) - MOVV $1590, R12 - JMP callbackasm1(SB) - MOVV $1591, R12 - JMP callbackasm1(SB) - MOVV $1592, R12 - JMP callbackasm1(SB) - MOVV $1593, R12 - JMP callbackasm1(SB) - MOVV $1594, R12 - JMP callbackasm1(SB) - MOVV $1595, R12 - JMP callbackasm1(SB) - MOVV $1596, R12 - JMP callbackasm1(SB) - MOVV $1597, R12 - JMP callbackasm1(SB) - MOVV $1598, R12 - JMP callbackasm1(SB) - MOVV $1599, R12 - JMP callbackasm1(SB) - MOVV $1600, R12 - JMP callbackasm1(SB) - MOVV $1601, R12 - JMP callbackasm1(SB) - MOVV $1602, R12 - JMP callbackasm1(SB) - MOVV $1603, R12 - JMP callbackasm1(SB) - MOVV $1604, R12 - JMP callbackasm1(SB) - MOVV $1605, R12 - JMP callbackasm1(SB) - MOVV $1606, R12 - JMP callbackasm1(SB) - MOVV $1607, R12 - JMP callbackasm1(SB) - MOVV $1608, R12 - JMP callbackasm1(SB) - MOVV $1609, R12 - JMP callbackasm1(SB) - MOVV $1610, R12 - JMP callbackasm1(SB) - MOVV $1611, R12 - JMP callbackasm1(SB) - MOVV $1612, R12 - JMP callbackasm1(SB) - MOVV $1613, R12 - JMP callbackasm1(SB) - MOVV $1614, R12 - JMP callbackasm1(SB) - MOVV $1615, R12 - JMP callbackasm1(SB) - MOVV $1616, R12 - JMP callbackasm1(SB) - MOVV $1617, R12 - JMP callbackasm1(SB) - MOVV $1618, R12 - JMP callbackasm1(SB) - MOVV $1619, R12 - JMP callbackasm1(SB) - MOVV $1620, R12 - JMP callbackasm1(SB) - MOVV $1621, R12 - JMP callbackasm1(SB) - MOVV $1622, R12 - JMP callbackasm1(SB) - MOVV $1623, R12 - JMP callbackasm1(SB) - MOVV $1624, R12 - JMP callbackasm1(SB) - MOVV $1625, R12 - JMP callbackasm1(SB) - MOVV $1626, R12 - JMP callbackasm1(SB) - MOVV $1627, R12 - JMP callbackasm1(SB) - MOVV $1628, R12 - JMP callbackasm1(SB) - MOVV $1629, R12 - JMP callbackasm1(SB) - MOVV $1630, R12 - JMP callbackasm1(SB) - MOVV $1631, R12 - JMP callbackasm1(SB) - MOVV $1632, R12 - JMP callbackasm1(SB) - MOVV $1633, R12 - JMP callbackasm1(SB) - MOVV $1634, R12 - JMP callbackasm1(SB) - MOVV $1635, R12 - JMP callbackasm1(SB) - MOVV $1636, R12 - JMP callbackasm1(SB) - MOVV $1637, R12 - JMP callbackasm1(SB) - MOVV $1638, R12 - JMP callbackasm1(SB) - MOVV $1639, R12 - JMP callbackasm1(SB) - MOVV $1640, R12 - JMP callbackasm1(SB) - MOVV $1641, R12 - JMP callbackasm1(SB) - MOVV $1642, R12 - JMP callbackasm1(SB) - MOVV $1643, R12 - JMP callbackasm1(SB) - MOVV $1644, R12 - JMP callbackasm1(SB) - MOVV $1645, R12 - JMP callbackasm1(SB) - MOVV $1646, R12 - JMP callbackasm1(SB) - MOVV $1647, R12 - JMP callbackasm1(SB) - MOVV $1648, R12 - JMP callbackasm1(SB) - MOVV $1649, R12 - JMP callbackasm1(SB) - MOVV $1650, R12 - JMP callbackasm1(SB) - MOVV $1651, R12 - JMP callbackasm1(SB) - MOVV $1652, R12 - JMP callbackasm1(SB) - MOVV $1653, R12 - JMP callbackasm1(SB) - MOVV $1654, R12 - JMP callbackasm1(SB) - MOVV $1655, R12 - JMP callbackasm1(SB) - MOVV $1656, R12 - JMP callbackasm1(SB) - MOVV $1657, R12 - JMP callbackasm1(SB) - MOVV $1658, R12 - JMP callbackasm1(SB) - MOVV $1659, R12 - JMP callbackasm1(SB) - MOVV $1660, R12 - JMP callbackasm1(SB) - MOVV $1661, R12 - JMP callbackasm1(SB) - MOVV $1662, R12 - JMP callbackasm1(SB) - MOVV $1663, R12 - JMP callbackasm1(SB) - MOVV $1664, R12 - JMP callbackasm1(SB) - MOVV $1665, R12 - JMP callbackasm1(SB) - MOVV $1666, R12 - JMP callbackasm1(SB) - MOVV $1667, R12 - JMP callbackasm1(SB) - MOVV $1668, R12 - JMP callbackasm1(SB) - MOVV $1669, R12 - JMP callbackasm1(SB) - MOVV $1670, R12 - JMP callbackasm1(SB) - MOVV $1671, R12 - JMP callbackasm1(SB) - MOVV $1672, R12 - JMP callbackasm1(SB) - MOVV $1673, R12 - JMP callbackasm1(SB) - MOVV $1674, R12 - JMP callbackasm1(SB) - MOVV $1675, R12 - JMP callbackasm1(SB) - MOVV $1676, R12 - JMP callbackasm1(SB) - MOVV $1677, R12 - JMP callbackasm1(SB) - MOVV $1678, R12 - JMP callbackasm1(SB) - MOVV $1679, R12 - JMP callbackasm1(SB) - MOVV $1680, R12 - JMP callbackasm1(SB) - MOVV $1681, R12 - JMP callbackasm1(SB) - MOVV $1682, R12 - JMP callbackasm1(SB) - MOVV $1683, R12 - JMP callbackasm1(SB) - MOVV $1684, R12 - JMP callbackasm1(SB) - MOVV $1685, R12 - JMP callbackasm1(SB) - MOVV $1686, R12 - JMP callbackasm1(SB) - MOVV $1687, R12 - JMP callbackasm1(SB) - MOVV $1688, R12 - JMP callbackasm1(SB) - MOVV $1689, R12 - JMP callbackasm1(SB) - MOVV $1690, R12 - JMP callbackasm1(SB) - MOVV $1691, R12 - JMP callbackasm1(SB) - MOVV $1692, R12 - JMP callbackasm1(SB) - MOVV $1693, R12 - JMP callbackasm1(SB) - MOVV $1694, R12 - JMP callbackasm1(SB) - MOVV $1695, R12 - JMP callbackasm1(SB) - MOVV $1696, R12 - JMP callbackasm1(SB) - MOVV $1697, R12 - JMP callbackasm1(SB) - MOVV $1698, R12 - JMP callbackasm1(SB) - MOVV $1699, R12 - JMP callbackasm1(SB) - MOVV $1700, R12 - JMP callbackasm1(SB) - MOVV $1701, R12 - JMP callbackasm1(SB) - MOVV $1702, R12 - JMP callbackasm1(SB) - MOVV $1703, R12 - JMP callbackasm1(SB) - MOVV $1704, R12 - JMP callbackasm1(SB) - MOVV $1705, R12 - JMP callbackasm1(SB) - MOVV $1706, R12 - JMP callbackasm1(SB) - MOVV $1707, R12 - JMP callbackasm1(SB) - MOVV $1708, R12 - JMP callbackasm1(SB) - MOVV $1709, R12 - JMP callbackasm1(SB) - MOVV $1710, R12 - JMP callbackasm1(SB) - MOVV $1711, R12 - JMP callbackasm1(SB) - MOVV $1712, R12 - JMP callbackasm1(SB) - MOVV $1713, R12 - JMP callbackasm1(SB) - MOVV $1714, R12 - JMP callbackasm1(SB) - MOVV $1715, R12 - JMP callbackasm1(SB) - MOVV $1716, R12 - JMP callbackasm1(SB) - MOVV $1717, R12 - JMP callbackasm1(SB) - MOVV $1718, R12 - JMP callbackasm1(SB) - MOVV $1719, R12 - JMP callbackasm1(SB) - MOVV $1720, R12 - JMP callbackasm1(SB) - MOVV $1721, R12 - JMP callbackasm1(SB) - MOVV $1722, R12 - JMP callbackasm1(SB) - MOVV $1723, R12 - JMP callbackasm1(SB) - MOVV $1724, R12 - JMP callbackasm1(SB) - MOVV $1725, R12 - JMP callbackasm1(SB) - MOVV $1726, R12 - JMP callbackasm1(SB) - MOVV $1727, R12 - JMP callbackasm1(SB) - MOVV $1728, R12 - JMP callbackasm1(SB) - MOVV $1729, R12 - JMP callbackasm1(SB) - MOVV $1730, R12 - JMP callbackasm1(SB) - MOVV $1731, R12 - JMP callbackasm1(SB) - MOVV $1732, R12 - JMP callbackasm1(SB) - MOVV $1733, R12 - JMP callbackasm1(SB) - MOVV $1734, R12 - JMP callbackasm1(SB) - MOVV $1735, R12 - JMP callbackasm1(SB) - MOVV $1736, R12 - JMP callbackasm1(SB) - MOVV $1737, R12 - JMP callbackasm1(SB) - MOVV $1738, R12 - JMP callbackasm1(SB) - MOVV $1739, R12 - JMP callbackasm1(SB) - MOVV $1740, R12 - JMP callbackasm1(SB) - MOVV $1741, R12 - JMP callbackasm1(SB) - MOVV $1742, R12 - JMP callbackasm1(SB) - MOVV $1743, R12 - JMP callbackasm1(SB) - MOVV $1744, R12 - JMP callbackasm1(SB) - MOVV $1745, R12 - JMP callbackasm1(SB) - MOVV $1746, R12 - JMP callbackasm1(SB) - MOVV $1747, R12 - JMP callbackasm1(SB) - MOVV $1748, R12 - JMP callbackasm1(SB) - MOVV $1749, R12 - JMP callbackasm1(SB) - MOVV $1750, R12 - JMP callbackasm1(SB) - MOVV $1751, R12 - JMP callbackasm1(SB) - MOVV $1752, R12 - JMP callbackasm1(SB) - MOVV $1753, R12 - JMP callbackasm1(SB) - MOVV $1754, R12 - JMP callbackasm1(SB) - MOVV $1755, R12 - JMP callbackasm1(SB) - MOVV $1756, R12 - JMP callbackasm1(SB) - MOVV $1757, R12 - JMP callbackasm1(SB) - MOVV $1758, R12 - JMP callbackasm1(SB) - MOVV $1759, R12 - JMP callbackasm1(SB) - MOVV $1760, R12 - JMP callbackasm1(SB) - MOVV $1761, R12 - JMP callbackasm1(SB) - MOVV $1762, R12 - JMP callbackasm1(SB) - MOVV $1763, R12 - JMP callbackasm1(SB) - MOVV $1764, R12 - JMP callbackasm1(SB) - MOVV $1765, R12 - JMP callbackasm1(SB) - MOVV $1766, R12 - JMP callbackasm1(SB) - MOVV $1767, R12 - JMP callbackasm1(SB) - MOVV $1768, R12 - JMP callbackasm1(SB) - MOVV $1769, R12 - JMP callbackasm1(SB) - MOVV $1770, R12 - JMP callbackasm1(SB) - MOVV $1771, R12 - JMP callbackasm1(SB) - MOVV $1772, R12 - JMP callbackasm1(SB) - MOVV $1773, R12 - JMP callbackasm1(SB) - MOVV $1774, R12 - JMP callbackasm1(SB) - MOVV $1775, R12 - JMP callbackasm1(SB) - MOVV $1776, R12 - JMP callbackasm1(SB) - MOVV $1777, R12 - JMP callbackasm1(SB) - MOVV $1778, R12 - JMP callbackasm1(SB) - MOVV $1779, R12 - JMP callbackasm1(SB) - MOVV $1780, R12 - JMP callbackasm1(SB) - MOVV $1781, R12 - JMP callbackasm1(SB) - MOVV $1782, R12 - JMP callbackasm1(SB) - MOVV $1783, R12 - JMP callbackasm1(SB) - MOVV $1784, R12 - JMP callbackasm1(SB) - MOVV $1785, R12 - JMP callbackasm1(SB) - MOVV $1786, R12 - JMP callbackasm1(SB) - MOVV $1787, R12 - JMP callbackasm1(SB) - MOVV $1788, R12 - JMP callbackasm1(SB) - MOVV $1789, R12 - JMP callbackasm1(SB) - MOVV $1790, R12 - JMP callbackasm1(SB) - MOVV $1791, R12 - JMP callbackasm1(SB) - MOVV $1792, R12 - JMP callbackasm1(SB) - MOVV $1793, R12 - JMP callbackasm1(SB) - MOVV $1794, R12 - JMP callbackasm1(SB) - MOVV $1795, R12 - JMP callbackasm1(SB) - MOVV $1796, R12 - JMP callbackasm1(SB) - MOVV $1797, R12 - JMP callbackasm1(SB) - MOVV $1798, R12 - JMP callbackasm1(SB) - MOVV $1799, R12 - JMP callbackasm1(SB) - MOVV $1800, R12 - JMP callbackasm1(SB) - MOVV $1801, R12 - JMP callbackasm1(SB) - MOVV $1802, R12 - JMP callbackasm1(SB) - MOVV $1803, R12 - JMP callbackasm1(SB) - MOVV $1804, R12 - JMP callbackasm1(SB) - MOVV $1805, R12 - JMP callbackasm1(SB) - MOVV $1806, R12 - JMP callbackasm1(SB) - MOVV $1807, R12 - JMP callbackasm1(SB) - MOVV $1808, R12 - JMP callbackasm1(SB) - MOVV $1809, R12 - JMP callbackasm1(SB) - MOVV $1810, R12 - JMP callbackasm1(SB) - MOVV $1811, R12 - JMP callbackasm1(SB) - MOVV $1812, R12 - JMP callbackasm1(SB) - MOVV $1813, R12 - JMP callbackasm1(SB) - MOVV $1814, R12 - JMP callbackasm1(SB) - MOVV $1815, R12 - JMP callbackasm1(SB) - MOVV $1816, R12 - JMP callbackasm1(SB) - MOVV $1817, R12 - JMP callbackasm1(SB) - MOVV $1818, R12 - JMP callbackasm1(SB) - MOVV $1819, R12 - JMP callbackasm1(SB) - MOVV $1820, R12 - JMP callbackasm1(SB) - MOVV $1821, R12 - JMP callbackasm1(SB) - MOVV $1822, R12 - JMP callbackasm1(SB) - MOVV $1823, R12 - JMP callbackasm1(SB) - MOVV $1824, R12 - JMP callbackasm1(SB) - MOVV $1825, R12 - JMP callbackasm1(SB) - MOVV $1826, R12 - JMP callbackasm1(SB) - MOVV $1827, R12 - JMP callbackasm1(SB) - MOVV $1828, R12 - JMP callbackasm1(SB) - MOVV $1829, R12 - JMP callbackasm1(SB) - MOVV $1830, R12 - JMP callbackasm1(SB) - MOVV $1831, R12 - JMP callbackasm1(SB) - MOVV $1832, R12 - JMP callbackasm1(SB) - MOVV $1833, R12 - JMP callbackasm1(SB) - MOVV $1834, R12 - JMP callbackasm1(SB) - MOVV $1835, R12 - JMP callbackasm1(SB) - MOVV $1836, R12 - JMP callbackasm1(SB) - MOVV $1837, R12 - JMP callbackasm1(SB) - MOVV $1838, R12 - JMP callbackasm1(SB) - MOVV $1839, R12 - JMP callbackasm1(SB) - MOVV $1840, R12 - JMP callbackasm1(SB) - MOVV $1841, R12 - JMP callbackasm1(SB) - MOVV $1842, R12 - JMP callbackasm1(SB) - MOVV $1843, R12 - JMP callbackasm1(SB) - MOVV $1844, R12 - JMP callbackasm1(SB) - MOVV $1845, R12 - JMP callbackasm1(SB) - MOVV $1846, R12 - JMP callbackasm1(SB) - MOVV $1847, R12 - JMP callbackasm1(SB) - MOVV $1848, R12 - JMP callbackasm1(SB) - MOVV $1849, R12 - JMP callbackasm1(SB) - MOVV $1850, R12 - JMP callbackasm1(SB) - MOVV $1851, R12 - JMP callbackasm1(SB) - MOVV $1852, R12 - JMP callbackasm1(SB) - MOVV $1853, R12 - JMP callbackasm1(SB) - MOVV $1854, R12 - JMP callbackasm1(SB) - MOVV $1855, R12 - JMP callbackasm1(SB) - MOVV $1856, R12 - JMP callbackasm1(SB) - MOVV $1857, R12 - JMP callbackasm1(SB) - MOVV $1858, R12 - JMP callbackasm1(SB) - MOVV $1859, R12 - JMP callbackasm1(SB) - MOVV $1860, R12 - JMP callbackasm1(SB) - MOVV $1861, R12 - JMP callbackasm1(SB) - MOVV $1862, R12 - JMP callbackasm1(SB) - MOVV $1863, R12 - JMP callbackasm1(SB) - MOVV $1864, R12 - JMP callbackasm1(SB) - MOVV $1865, R12 - JMP callbackasm1(SB) - MOVV $1866, R12 - JMP callbackasm1(SB) - MOVV $1867, R12 - JMP callbackasm1(SB) - MOVV $1868, R12 - JMP callbackasm1(SB) - MOVV $1869, R12 - JMP callbackasm1(SB) - MOVV $1870, R12 - JMP callbackasm1(SB) - MOVV $1871, R12 - JMP callbackasm1(SB) - MOVV $1872, R12 - JMP callbackasm1(SB) - MOVV $1873, R12 - JMP callbackasm1(SB) - MOVV $1874, R12 - JMP callbackasm1(SB) - MOVV $1875, R12 - JMP callbackasm1(SB) - MOVV $1876, R12 - JMP callbackasm1(SB) - MOVV $1877, R12 - JMP callbackasm1(SB) - MOVV $1878, R12 - JMP callbackasm1(SB) - MOVV $1879, R12 - JMP callbackasm1(SB) - MOVV $1880, R12 - JMP callbackasm1(SB) - MOVV $1881, R12 - JMP callbackasm1(SB) - MOVV $1882, R12 - JMP callbackasm1(SB) - MOVV $1883, R12 - JMP callbackasm1(SB) - MOVV $1884, R12 - JMP callbackasm1(SB) - MOVV $1885, R12 - JMP callbackasm1(SB) - MOVV $1886, R12 - JMP callbackasm1(SB) - MOVV $1887, R12 - JMP callbackasm1(SB) - MOVV $1888, R12 - JMP callbackasm1(SB) - MOVV $1889, R12 - JMP callbackasm1(SB) - MOVV $1890, R12 - JMP callbackasm1(SB) - MOVV $1891, R12 - JMP callbackasm1(SB) - MOVV $1892, R12 - JMP callbackasm1(SB) - MOVV $1893, R12 - JMP callbackasm1(SB) - MOVV $1894, R12 - JMP callbackasm1(SB) - MOVV $1895, R12 - JMP callbackasm1(SB) - MOVV $1896, R12 - JMP callbackasm1(SB) - MOVV $1897, R12 - JMP callbackasm1(SB) - MOVV $1898, R12 - JMP callbackasm1(SB) - MOVV $1899, R12 - JMP callbackasm1(SB) - MOVV $1900, R12 - JMP callbackasm1(SB) - MOVV $1901, R12 - JMP callbackasm1(SB) - MOVV $1902, R12 - JMP callbackasm1(SB) - MOVV $1903, R12 - JMP callbackasm1(SB) - MOVV $1904, R12 - JMP callbackasm1(SB) - MOVV $1905, R12 - JMP callbackasm1(SB) - MOVV $1906, R12 - JMP callbackasm1(SB) - MOVV $1907, R12 - JMP callbackasm1(SB) - MOVV $1908, R12 - JMP callbackasm1(SB) - MOVV $1909, R12 - JMP callbackasm1(SB) - MOVV $1910, R12 - JMP callbackasm1(SB) - MOVV $1911, R12 - JMP callbackasm1(SB) - MOVV $1912, R12 - JMP callbackasm1(SB) - MOVV $1913, R12 - JMP callbackasm1(SB) - MOVV $1914, R12 - JMP callbackasm1(SB) - MOVV $1915, R12 - JMP callbackasm1(SB) - MOVV $1916, R12 - JMP callbackasm1(SB) - MOVV $1917, R12 - JMP callbackasm1(SB) - MOVV $1918, R12 - JMP callbackasm1(SB) - MOVV $1919, R12 - JMP callbackasm1(SB) - MOVV $1920, R12 - JMP callbackasm1(SB) - MOVV $1921, R12 - JMP callbackasm1(SB) - MOVV $1922, R12 - JMP callbackasm1(SB) - MOVV $1923, R12 - JMP callbackasm1(SB) - MOVV $1924, R12 - JMP callbackasm1(SB) - MOVV $1925, R12 - JMP callbackasm1(SB) - MOVV $1926, R12 - JMP callbackasm1(SB) - MOVV $1927, R12 - JMP callbackasm1(SB) - MOVV $1928, R12 - JMP callbackasm1(SB) - MOVV $1929, R12 - JMP callbackasm1(SB) - MOVV $1930, R12 - JMP callbackasm1(SB) - MOVV $1931, R12 - JMP callbackasm1(SB) - MOVV $1932, R12 - JMP callbackasm1(SB) - MOVV $1933, R12 - JMP callbackasm1(SB) - MOVV $1934, R12 - JMP callbackasm1(SB) - MOVV $1935, R12 - JMP callbackasm1(SB) - MOVV $1936, R12 - JMP callbackasm1(SB) - MOVV $1937, R12 - JMP callbackasm1(SB) - MOVV $1938, R12 - JMP callbackasm1(SB) - MOVV $1939, R12 - JMP callbackasm1(SB) - MOVV $1940, R12 - JMP callbackasm1(SB) - MOVV $1941, R12 - JMP callbackasm1(SB) - MOVV $1942, R12 - JMP callbackasm1(SB) - MOVV $1943, R12 - JMP callbackasm1(SB) - MOVV $1944, R12 - JMP callbackasm1(SB) - MOVV $1945, R12 - JMP callbackasm1(SB) - MOVV $1946, R12 - JMP callbackasm1(SB) - MOVV $1947, R12 - JMP callbackasm1(SB) - MOVV $1948, R12 - JMP callbackasm1(SB) - MOVV $1949, R12 - JMP callbackasm1(SB) - MOVV $1950, R12 - JMP callbackasm1(SB) - MOVV $1951, R12 - JMP callbackasm1(SB) - MOVV $1952, R12 - JMP callbackasm1(SB) - MOVV $1953, R12 - JMP callbackasm1(SB) - MOVV $1954, R12 - JMP callbackasm1(SB) - MOVV $1955, R12 - JMP callbackasm1(SB) - MOVV $1956, R12 - JMP callbackasm1(SB) - MOVV $1957, R12 - JMP callbackasm1(SB) - MOVV $1958, R12 - JMP callbackasm1(SB) - MOVV $1959, R12 - JMP callbackasm1(SB) - MOVV $1960, R12 - JMP callbackasm1(SB) - MOVV $1961, R12 - JMP callbackasm1(SB) - MOVV $1962, R12 - JMP callbackasm1(SB) - MOVV $1963, R12 - JMP callbackasm1(SB) - MOVV $1964, R12 - JMP callbackasm1(SB) - MOVV $1965, R12 - JMP callbackasm1(SB) - MOVV $1966, R12 - JMP callbackasm1(SB) - MOVV $1967, R12 - JMP callbackasm1(SB) - MOVV $1968, R12 - JMP callbackasm1(SB) - MOVV $1969, R12 - JMP callbackasm1(SB) - MOVV $1970, R12 - JMP callbackasm1(SB) - MOVV $1971, R12 - JMP callbackasm1(SB) - MOVV $1972, R12 - JMP callbackasm1(SB) - MOVV $1973, R12 - JMP callbackasm1(SB) - MOVV $1974, R12 - JMP callbackasm1(SB) - MOVV $1975, R12 - JMP callbackasm1(SB) - MOVV $1976, R12 - JMP callbackasm1(SB) - MOVV $1977, R12 - JMP callbackasm1(SB) - MOVV $1978, R12 - JMP callbackasm1(SB) - MOVV $1979, R12 - JMP callbackasm1(SB) - MOVV $1980, R12 - JMP callbackasm1(SB) - MOVV $1981, R12 - JMP callbackasm1(SB) - MOVV $1982, R12 - JMP callbackasm1(SB) - MOVV $1983, R12 - JMP callbackasm1(SB) - MOVV $1984, R12 - JMP callbackasm1(SB) - MOVV $1985, R12 - JMP callbackasm1(SB) - MOVV $1986, R12 - JMP callbackasm1(SB) - MOVV $1987, R12 - JMP callbackasm1(SB) - MOVV $1988, R12 - JMP callbackasm1(SB) - MOVV $1989, R12 - JMP callbackasm1(SB) - MOVV $1990, R12 - JMP callbackasm1(SB) - MOVV $1991, R12 - JMP callbackasm1(SB) - MOVV $1992, R12 - JMP callbackasm1(SB) - MOVV $1993, R12 - JMP callbackasm1(SB) - MOVV $1994, R12 - JMP callbackasm1(SB) - MOVV $1995, R12 - JMP callbackasm1(SB) - MOVV $1996, R12 - JMP callbackasm1(SB) - MOVV $1997, R12 - JMP callbackasm1(SB) - MOVV $1998, R12 - JMP callbackasm1(SB) - MOVV $1999, R12 - JMP callbackasm1(SB) diff --git a/vendor/github.com/ebitengine/purego/zcallback_ppc64le.s b/vendor/github.com/ebitengine/purego/zcallback_ppc64le.s deleted file mode 100644 index 702243b1e51..00000000000 --- a/vendor/github.com/ebitengine/purego/zcallback_ppc64le.s +++ /dev/null @@ -1,4014 +0,0 @@ -// Code generated by wincallback.go using 'go generate'. DO NOT EDIT. - -//go:build linux - -// External code calls into callbackasm at an offset corresponding -// to the callback index. Callbackasm is a table of MOVD and BR instructions. -// The MOVD instruction loads R11 with the callback index, and the -// BR instruction branches to callbackasm1. -// callbackasm1 takes the callback index from R11 and -// indexes into an array that stores information about each callback. -// It then calls the Go implementation for that callback. -#include "textflag.h" - -TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0 - MOVD $0, R11 - BR callbackasm1(SB) - MOVD $1, R11 - BR callbackasm1(SB) - MOVD $2, R11 - BR callbackasm1(SB) - MOVD $3, R11 - BR callbackasm1(SB) - MOVD $4, R11 - BR callbackasm1(SB) - MOVD $5, R11 - BR callbackasm1(SB) - MOVD $6, R11 - BR callbackasm1(SB) - MOVD $7, R11 - BR callbackasm1(SB) - MOVD $8, R11 - BR callbackasm1(SB) - MOVD $9, R11 - BR callbackasm1(SB) - MOVD $10, R11 - BR callbackasm1(SB) - MOVD $11, R11 - BR callbackasm1(SB) - MOVD $12, R11 - BR callbackasm1(SB) - MOVD $13, R11 - BR callbackasm1(SB) - MOVD $14, R11 - BR callbackasm1(SB) - MOVD $15, R11 - BR callbackasm1(SB) - MOVD $16, R11 - BR callbackasm1(SB) - MOVD $17, R11 - BR callbackasm1(SB) - MOVD $18, R11 - BR callbackasm1(SB) - MOVD $19, R11 - BR callbackasm1(SB) - MOVD $20, R11 - BR callbackasm1(SB) - MOVD $21, R11 - BR callbackasm1(SB) - MOVD $22, R11 - BR callbackasm1(SB) - MOVD $23, R11 - BR callbackasm1(SB) - MOVD $24, R11 - BR callbackasm1(SB) - MOVD $25, R11 - BR callbackasm1(SB) - MOVD $26, R11 - BR callbackasm1(SB) - MOVD $27, R11 - BR callbackasm1(SB) - MOVD $28, R11 - BR callbackasm1(SB) - MOVD $29, R11 - BR callbackasm1(SB) - MOVD $30, R11 - BR callbackasm1(SB) - MOVD $31, R11 - BR callbackasm1(SB) - MOVD $32, R11 - BR callbackasm1(SB) - MOVD $33, R11 - BR callbackasm1(SB) - MOVD $34, R11 - BR callbackasm1(SB) - MOVD $35, R11 - BR callbackasm1(SB) - MOVD $36, R11 - BR callbackasm1(SB) - MOVD $37, R11 - BR callbackasm1(SB) - MOVD $38, R11 - BR callbackasm1(SB) - MOVD $39, R11 - BR callbackasm1(SB) - MOVD $40, R11 - BR callbackasm1(SB) - MOVD $41, R11 - BR callbackasm1(SB) - MOVD $42, R11 - BR callbackasm1(SB) - MOVD $43, R11 - BR callbackasm1(SB) - MOVD $44, R11 - BR callbackasm1(SB) - MOVD $45, R11 - BR callbackasm1(SB) - MOVD $46, R11 - BR callbackasm1(SB) - MOVD $47, R11 - BR callbackasm1(SB) - MOVD $48, R11 - BR callbackasm1(SB) - MOVD $49, R11 - BR callbackasm1(SB) - MOVD $50, R11 - BR callbackasm1(SB) - MOVD $51, R11 - BR callbackasm1(SB) - MOVD $52, R11 - BR callbackasm1(SB) - MOVD $53, R11 - BR callbackasm1(SB) - MOVD $54, R11 - BR callbackasm1(SB) - MOVD $55, R11 - BR callbackasm1(SB) - MOVD $56, R11 - BR callbackasm1(SB) - MOVD $57, R11 - BR callbackasm1(SB) - MOVD $58, R11 - BR callbackasm1(SB) - MOVD $59, R11 - BR callbackasm1(SB) - MOVD $60, R11 - BR callbackasm1(SB) - MOVD $61, R11 - BR callbackasm1(SB) - MOVD $62, R11 - BR callbackasm1(SB) - MOVD $63, R11 - BR callbackasm1(SB) - MOVD $64, R11 - BR callbackasm1(SB) - MOVD $65, R11 - BR callbackasm1(SB) - MOVD $66, R11 - BR callbackasm1(SB) - MOVD $67, R11 - BR callbackasm1(SB) - MOVD $68, R11 - BR callbackasm1(SB) - MOVD $69, R11 - BR callbackasm1(SB) - MOVD $70, R11 - BR callbackasm1(SB) - MOVD $71, R11 - BR callbackasm1(SB) - MOVD $72, R11 - BR callbackasm1(SB) - MOVD $73, R11 - BR callbackasm1(SB) - MOVD $74, R11 - BR callbackasm1(SB) - MOVD $75, R11 - BR callbackasm1(SB) - MOVD $76, R11 - BR callbackasm1(SB) - MOVD $77, R11 - BR callbackasm1(SB) - MOVD $78, R11 - BR callbackasm1(SB) - MOVD $79, R11 - BR callbackasm1(SB) - MOVD $80, R11 - BR callbackasm1(SB) - MOVD $81, R11 - BR callbackasm1(SB) - MOVD $82, R11 - BR callbackasm1(SB) - MOVD $83, R11 - BR callbackasm1(SB) - MOVD $84, R11 - BR callbackasm1(SB) - MOVD $85, R11 - BR callbackasm1(SB) - MOVD $86, R11 - BR callbackasm1(SB) - MOVD $87, R11 - BR callbackasm1(SB) - MOVD $88, R11 - BR callbackasm1(SB) - MOVD $89, R11 - BR callbackasm1(SB) - MOVD $90, R11 - BR callbackasm1(SB) - MOVD $91, R11 - BR callbackasm1(SB) - MOVD $92, R11 - BR callbackasm1(SB) - MOVD $93, R11 - BR callbackasm1(SB) - MOVD $94, R11 - BR callbackasm1(SB) - MOVD $95, R11 - BR callbackasm1(SB) - MOVD $96, R11 - BR callbackasm1(SB) - MOVD $97, R11 - BR callbackasm1(SB) - MOVD $98, R11 - BR callbackasm1(SB) - MOVD $99, R11 - BR callbackasm1(SB) - MOVD $100, R11 - BR callbackasm1(SB) - MOVD $101, R11 - BR callbackasm1(SB) - MOVD $102, R11 - BR callbackasm1(SB) - MOVD $103, R11 - BR callbackasm1(SB) - MOVD $104, R11 - BR callbackasm1(SB) - MOVD $105, R11 - BR callbackasm1(SB) - MOVD $106, R11 - BR callbackasm1(SB) - MOVD $107, R11 - BR callbackasm1(SB) - MOVD $108, R11 - BR callbackasm1(SB) - MOVD $109, R11 - BR callbackasm1(SB) - MOVD $110, R11 - BR callbackasm1(SB) - MOVD $111, R11 - BR callbackasm1(SB) - MOVD $112, R11 - BR callbackasm1(SB) - MOVD $113, R11 - BR callbackasm1(SB) - MOVD $114, R11 - BR callbackasm1(SB) - MOVD $115, R11 - BR callbackasm1(SB) - MOVD $116, R11 - BR callbackasm1(SB) - MOVD $117, R11 - BR callbackasm1(SB) - MOVD $118, R11 - BR callbackasm1(SB) - MOVD $119, R11 - BR callbackasm1(SB) - MOVD $120, R11 - BR callbackasm1(SB) - MOVD $121, R11 - BR callbackasm1(SB) - MOVD $122, R11 - BR callbackasm1(SB) - MOVD $123, R11 - BR callbackasm1(SB) - MOVD $124, R11 - BR callbackasm1(SB) - MOVD $125, R11 - BR callbackasm1(SB) - MOVD $126, R11 - BR callbackasm1(SB) - MOVD $127, R11 - BR callbackasm1(SB) - MOVD $128, R11 - BR callbackasm1(SB) - MOVD $129, R11 - BR callbackasm1(SB) - MOVD $130, R11 - BR callbackasm1(SB) - MOVD $131, R11 - BR callbackasm1(SB) - MOVD $132, R11 - BR callbackasm1(SB) - MOVD $133, R11 - BR callbackasm1(SB) - MOVD $134, R11 - BR callbackasm1(SB) - MOVD $135, R11 - BR callbackasm1(SB) - MOVD $136, R11 - BR callbackasm1(SB) - MOVD $137, R11 - BR callbackasm1(SB) - MOVD $138, R11 - BR callbackasm1(SB) - MOVD $139, R11 - BR callbackasm1(SB) - MOVD $140, R11 - BR callbackasm1(SB) - MOVD $141, R11 - BR callbackasm1(SB) - MOVD $142, R11 - BR callbackasm1(SB) - MOVD $143, R11 - BR callbackasm1(SB) - MOVD $144, R11 - BR callbackasm1(SB) - MOVD $145, R11 - BR callbackasm1(SB) - MOVD $146, R11 - BR callbackasm1(SB) - MOVD $147, R11 - BR callbackasm1(SB) - MOVD $148, R11 - BR callbackasm1(SB) - MOVD $149, R11 - BR callbackasm1(SB) - MOVD $150, R11 - BR callbackasm1(SB) - MOVD $151, R11 - BR callbackasm1(SB) - MOVD $152, R11 - BR callbackasm1(SB) - MOVD $153, R11 - BR callbackasm1(SB) - MOVD $154, R11 - BR callbackasm1(SB) - MOVD $155, R11 - BR callbackasm1(SB) - MOVD $156, R11 - BR callbackasm1(SB) - MOVD $157, R11 - BR callbackasm1(SB) - MOVD $158, R11 - BR callbackasm1(SB) - MOVD $159, R11 - BR callbackasm1(SB) - MOVD $160, R11 - BR callbackasm1(SB) - MOVD $161, R11 - BR callbackasm1(SB) - MOVD $162, R11 - BR callbackasm1(SB) - MOVD $163, R11 - BR callbackasm1(SB) - MOVD $164, R11 - BR callbackasm1(SB) - MOVD $165, R11 - BR callbackasm1(SB) - MOVD $166, R11 - BR callbackasm1(SB) - MOVD $167, R11 - BR callbackasm1(SB) - MOVD $168, R11 - BR callbackasm1(SB) - MOVD $169, R11 - BR callbackasm1(SB) - MOVD $170, R11 - BR callbackasm1(SB) - MOVD $171, R11 - BR callbackasm1(SB) - MOVD $172, R11 - BR callbackasm1(SB) - MOVD $173, R11 - BR callbackasm1(SB) - MOVD $174, R11 - BR callbackasm1(SB) - MOVD $175, R11 - BR callbackasm1(SB) - MOVD $176, R11 - BR callbackasm1(SB) - MOVD $177, R11 - BR callbackasm1(SB) - MOVD $178, R11 - BR callbackasm1(SB) - MOVD $179, R11 - BR callbackasm1(SB) - MOVD $180, R11 - BR callbackasm1(SB) - MOVD $181, R11 - BR callbackasm1(SB) - MOVD $182, R11 - BR callbackasm1(SB) - MOVD $183, R11 - BR callbackasm1(SB) - MOVD $184, R11 - BR callbackasm1(SB) - MOVD $185, R11 - BR callbackasm1(SB) - MOVD $186, R11 - BR callbackasm1(SB) - MOVD $187, R11 - BR callbackasm1(SB) - MOVD $188, R11 - BR callbackasm1(SB) - MOVD $189, R11 - BR callbackasm1(SB) - MOVD $190, R11 - BR callbackasm1(SB) - MOVD $191, R11 - BR callbackasm1(SB) - MOVD $192, R11 - BR callbackasm1(SB) - MOVD $193, R11 - BR callbackasm1(SB) - MOVD $194, R11 - BR callbackasm1(SB) - MOVD $195, R11 - BR callbackasm1(SB) - MOVD $196, R11 - BR callbackasm1(SB) - MOVD $197, R11 - BR callbackasm1(SB) - MOVD $198, R11 - BR callbackasm1(SB) - MOVD $199, R11 - BR callbackasm1(SB) - MOVD $200, R11 - BR callbackasm1(SB) - MOVD $201, R11 - BR callbackasm1(SB) - MOVD $202, R11 - BR callbackasm1(SB) - MOVD $203, R11 - BR callbackasm1(SB) - MOVD $204, R11 - BR callbackasm1(SB) - MOVD $205, R11 - BR callbackasm1(SB) - MOVD $206, R11 - BR callbackasm1(SB) - MOVD $207, R11 - BR callbackasm1(SB) - MOVD $208, R11 - BR callbackasm1(SB) - MOVD $209, R11 - BR callbackasm1(SB) - MOVD $210, R11 - BR callbackasm1(SB) - MOVD $211, R11 - BR callbackasm1(SB) - MOVD $212, R11 - BR callbackasm1(SB) - MOVD $213, R11 - BR callbackasm1(SB) - MOVD $214, R11 - BR callbackasm1(SB) - MOVD $215, R11 - BR callbackasm1(SB) - MOVD $216, R11 - BR callbackasm1(SB) - MOVD $217, R11 - BR callbackasm1(SB) - MOVD $218, R11 - BR callbackasm1(SB) - MOVD $219, R11 - BR callbackasm1(SB) - MOVD $220, R11 - BR callbackasm1(SB) - MOVD $221, R11 - BR callbackasm1(SB) - MOVD $222, R11 - BR callbackasm1(SB) - MOVD $223, R11 - BR callbackasm1(SB) - MOVD $224, R11 - BR callbackasm1(SB) - MOVD $225, R11 - BR callbackasm1(SB) - MOVD $226, R11 - BR callbackasm1(SB) - MOVD $227, R11 - BR callbackasm1(SB) - MOVD $228, R11 - BR callbackasm1(SB) - MOVD $229, R11 - BR callbackasm1(SB) - MOVD $230, R11 - BR callbackasm1(SB) - MOVD $231, R11 - BR callbackasm1(SB) - MOVD $232, R11 - BR callbackasm1(SB) - MOVD $233, R11 - BR callbackasm1(SB) - MOVD $234, R11 - BR callbackasm1(SB) - MOVD $235, R11 - BR callbackasm1(SB) - MOVD $236, R11 - BR callbackasm1(SB) - MOVD $237, R11 - BR callbackasm1(SB) - MOVD $238, R11 - BR callbackasm1(SB) - MOVD $239, R11 - BR callbackasm1(SB) - MOVD $240, R11 - BR callbackasm1(SB) - MOVD $241, R11 - BR callbackasm1(SB) - MOVD $242, R11 - BR callbackasm1(SB) - MOVD $243, R11 - BR callbackasm1(SB) - MOVD $244, R11 - BR callbackasm1(SB) - MOVD $245, R11 - BR callbackasm1(SB) - MOVD $246, R11 - BR callbackasm1(SB) - MOVD $247, R11 - BR callbackasm1(SB) - MOVD $248, R11 - BR callbackasm1(SB) - MOVD $249, R11 - BR callbackasm1(SB) - MOVD $250, R11 - BR callbackasm1(SB) - MOVD $251, R11 - BR callbackasm1(SB) - MOVD $252, R11 - BR callbackasm1(SB) - MOVD $253, R11 - BR callbackasm1(SB) - MOVD $254, R11 - BR callbackasm1(SB) - MOVD $255, R11 - BR callbackasm1(SB) - MOVD $256, R11 - BR callbackasm1(SB) - MOVD $257, R11 - BR callbackasm1(SB) - MOVD $258, R11 - BR callbackasm1(SB) - MOVD $259, R11 - BR callbackasm1(SB) - MOVD $260, R11 - BR callbackasm1(SB) - MOVD $261, R11 - BR callbackasm1(SB) - MOVD $262, R11 - BR callbackasm1(SB) - MOVD $263, R11 - BR callbackasm1(SB) - MOVD $264, R11 - BR callbackasm1(SB) - MOVD $265, R11 - BR callbackasm1(SB) - MOVD $266, R11 - BR callbackasm1(SB) - MOVD $267, R11 - BR callbackasm1(SB) - MOVD $268, R11 - BR callbackasm1(SB) - MOVD $269, R11 - BR callbackasm1(SB) - MOVD $270, R11 - BR callbackasm1(SB) - MOVD $271, R11 - BR callbackasm1(SB) - MOVD $272, R11 - BR callbackasm1(SB) - MOVD $273, R11 - BR callbackasm1(SB) - MOVD $274, R11 - BR callbackasm1(SB) - MOVD $275, R11 - BR callbackasm1(SB) - MOVD $276, R11 - BR callbackasm1(SB) - MOVD $277, R11 - BR callbackasm1(SB) - MOVD $278, R11 - BR callbackasm1(SB) - MOVD $279, R11 - BR callbackasm1(SB) - MOVD $280, R11 - BR callbackasm1(SB) - MOVD $281, R11 - BR callbackasm1(SB) - MOVD $282, R11 - BR callbackasm1(SB) - MOVD $283, R11 - BR callbackasm1(SB) - MOVD $284, R11 - BR callbackasm1(SB) - MOVD $285, R11 - BR callbackasm1(SB) - MOVD $286, R11 - BR callbackasm1(SB) - MOVD $287, R11 - BR callbackasm1(SB) - MOVD $288, R11 - BR callbackasm1(SB) - MOVD $289, R11 - BR callbackasm1(SB) - MOVD $290, R11 - BR callbackasm1(SB) - MOVD $291, R11 - BR callbackasm1(SB) - MOVD $292, R11 - BR callbackasm1(SB) - MOVD $293, R11 - BR callbackasm1(SB) - MOVD $294, R11 - BR callbackasm1(SB) - MOVD $295, R11 - BR callbackasm1(SB) - MOVD $296, R11 - BR callbackasm1(SB) - MOVD $297, R11 - BR callbackasm1(SB) - MOVD $298, R11 - BR callbackasm1(SB) - MOVD $299, R11 - BR callbackasm1(SB) - MOVD $300, R11 - BR callbackasm1(SB) - MOVD $301, R11 - BR callbackasm1(SB) - MOVD $302, R11 - BR callbackasm1(SB) - MOVD $303, R11 - BR callbackasm1(SB) - MOVD $304, R11 - BR callbackasm1(SB) - MOVD $305, R11 - BR callbackasm1(SB) - MOVD $306, R11 - BR callbackasm1(SB) - MOVD $307, R11 - BR callbackasm1(SB) - MOVD $308, R11 - BR callbackasm1(SB) - MOVD $309, R11 - BR callbackasm1(SB) - MOVD $310, R11 - BR callbackasm1(SB) - MOVD $311, R11 - BR callbackasm1(SB) - MOVD $312, R11 - BR callbackasm1(SB) - MOVD $313, R11 - BR callbackasm1(SB) - MOVD $314, R11 - BR callbackasm1(SB) - MOVD $315, R11 - BR callbackasm1(SB) - MOVD $316, R11 - BR callbackasm1(SB) - MOVD $317, R11 - BR callbackasm1(SB) - MOVD $318, R11 - BR callbackasm1(SB) - MOVD $319, R11 - BR callbackasm1(SB) - MOVD $320, R11 - BR callbackasm1(SB) - MOVD $321, R11 - BR callbackasm1(SB) - MOVD $322, R11 - BR callbackasm1(SB) - MOVD $323, R11 - BR callbackasm1(SB) - MOVD $324, R11 - BR callbackasm1(SB) - MOVD $325, R11 - BR callbackasm1(SB) - MOVD $326, R11 - BR callbackasm1(SB) - MOVD $327, R11 - BR callbackasm1(SB) - MOVD $328, R11 - BR callbackasm1(SB) - MOVD $329, R11 - BR callbackasm1(SB) - MOVD $330, R11 - BR callbackasm1(SB) - MOVD $331, R11 - BR callbackasm1(SB) - MOVD $332, R11 - BR callbackasm1(SB) - MOVD $333, R11 - BR callbackasm1(SB) - MOVD $334, R11 - BR callbackasm1(SB) - MOVD $335, R11 - BR callbackasm1(SB) - MOVD $336, R11 - BR callbackasm1(SB) - MOVD $337, R11 - BR callbackasm1(SB) - MOVD $338, R11 - BR callbackasm1(SB) - MOVD $339, R11 - BR callbackasm1(SB) - MOVD $340, R11 - BR callbackasm1(SB) - MOVD $341, R11 - BR callbackasm1(SB) - MOVD $342, R11 - BR callbackasm1(SB) - MOVD $343, R11 - BR callbackasm1(SB) - MOVD $344, R11 - BR callbackasm1(SB) - MOVD $345, R11 - BR callbackasm1(SB) - MOVD $346, R11 - BR callbackasm1(SB) - MOVD $347, R11 - BR callbackasm1(SB) - MOVD $348, R11 - BR callbackasm1(SB) - MOVD $349, R11 - BR callbackasm1(SB) - MOVD $350, R11 - BR callbackasm1(SB) - MOVD $351, R11 - BR callbackasm1(SB) - MOVD $352, R11 - BR callbackasm1(SB) - MOVD $353, R11 - BR callbackasm1(SB) - MOVD $354, R11 - BR callbackasm1(SB) - MOVD $355, R11 - BR callbackasm1(SB) - MOVD $356, R11 - BR callbackasm1(SB) - MOVD $357, R11 - BR callbackasm1(SB) - MOVD $358, R11 - BR callbackasm1(SB) - MOVD $359, R11 - BR callbackasm1(SB) - MOVD $360, R11 - BR callbackasm1(SB) - MOVD $361, R11 - BR callbackasm1(SB) - MOVD $362, R11 - BR callbackasm1(SB) - MOVD $363, R11 - BR callbackasm1(SB) - MOVD $364, R11 - BR callbackasm1(SB) - MOVD $365, R11 - BR callbackasm1(SB) - MOVD $366, R11 - BR callbackasm1(SB) - MOVD $367, R11 - BR callbackasm1(SB) - MOVD $368, R11 - BR callbackasm1(SB) - MOVD $369, R11 - BR callbackasm1(SB) - MOVD $370, R11 - BR callbackasm1(SB) - MOVD $371, R11 - BR callbackasm1(SB) - MOVD $372, R11 - BR callbackasm1(SB) - MOVD $373, R11 - BR callbackasm1(SB) - MOVD $374, R11 - BR callbackasm1(SB) - MOVD $375, R11 - BR callbackasm1(SB) - MOVD $376, R11 - BR callbackasm1(SB) - MOVD $377, R11 - BR callbackasm1(SB) - MOVD $378, R11 - BR callbackasm1(SB) - MOVD $379, R11 - BR callbackasm1(SB) - MOVD $380, R11 - BR callbackasm1(SB) - MOVD $381, R11 - BR callbackasm1(SB) - MOVD $382, R11 - BR callbackasm1(SB) - MOVD $383, R11 - BR callbackasm1(SB) - MOVD $384, R11 - BR callbackasm1(SB) - MOVD $385, R11 - BR callbackasm1(SB) - MOVD $386, R11 - BR callbackasm1(SB) - MOVD $387, R11 - BR callbackasm1(SB) - MOVD $388, R11 - BR callbackasm1(SB) - MOVD $389, R11 - BR callbackasm1(SB) - MOVD $390, R11 - BR callbackasm1(SB) - MOVD $391, R11 - BR callbackasm1(SB) - MOVD $392, R11 - BR callbackasm1(SB) - MOVD $393, R11 - BR callbackasm1(SB) - MOVD $394, R11 - BR callbackasm1(SB) - MOVD $395, R11 - BR callbackasm1(SB) - MOVD $396, R11 - BR callbackasm1(SB) - MOVD $397, R11 - BR callbackasm1(SB) - MOVD $398, R11 - BR callbackasm1(SB) - MOVD $399, R11 - BR callbackasm1(SB) - MOVD $400, R11 - BR callbackasm1(SB) - MOVD $401, R11 - BR callbackasm1(SB) - MOVD $402, R11 - BR callbackasm1(SB) - MOVD $403, R11 - BR callbackasm1(SB) - MOVD $404, R11 - BR callbackasm1(SB) - MOVD $405, R11 - BR callbackasm1(SB) - MOVD $406, R11 - BR callbackasm1(SB) - MOVD $407, R11 - BR callbackasm1(SB) - MOVD $408, R11 - BR callbackasm1(SB) - MOVD $409, R11 - BR callbackasm1(SB) - MOVD $410, R11 - BR callbackasm1(SB) - MOVD $411, R11 - BR callbackasm1(SB) - MOVD $412, R11 - BR callbackasm1(SB) - MOVD $413, R11 - BR callbackasm1(SB) - MOVD $414, R11 - BR callbackasm1(SB) - MOVD $415, R11 - BR callbackasm1(SB) - MOVD $416, R11 - BR callbackasm1(SB) - MOVD $417, R11 - BR callbackasm1(SB) - MOVD $418, R11 - BR callbackasm1(SB) - MOVD $419, R11 - BR callbackasm1(SB) - MOVD $420, R11 - BR callbackasm1(SB) - MOVD $421, R11 - BR callbackasm1(SB) - MOVD $422, R11 - BR callbackasm1(SB) - MOVD $423, R11 - BR callbackasm1(SB) - MOVD $424, R11 - BR callbackasm1(SB) - MOVD $425, R11 - BR callbackasm1(SB) - MOVD $426, R11 - BR callbackasm1(SB) - MOVD $427, R11 - BR callbackasm1(SB) - MOVD $428, R11 - BR callbackasm1(SB) - MOVD $429, R11 - BR callbackasm1(SB) - MOVD $430, R11 - BR callbackasm1(SB) - MOVD $431, R11 - BR callbackasm1(SB) - MOVD $432, R11 - BR callbackasm1(SB) - MOVD $433, R11 - BR callbackasm1(SB) - MOVD $434, R11 - BR callbackasm1(SB) - MOVD $435, R11 - BR callbackasm1(SB) - MOVD $436, R11 - BR callbackasm1(SB) - MOVD $437, R11 - BR callbackasm1(SB) - MOVD $438, R11 - BR callbackasm1(SB) - MOVD $439, R11 - BR callbackasm1(SB) - MOVD $440, R11 - BR callbackasm1(SB) - MOVD $441, R11 - BR callbackasm1(SB) - MOVD $442, R11 - BR callbackasm1(SB) - MOVD $443, R11 - BR callbackasm1(SB) - MOVD $444, R11 - BR callbackasm1(SB) - MOVD $445, R11 - BR callbackasm1(SB) - MOVD $446, R11 - BR callbackasm1(SB) - MOVD $447, R11 - BR callbackasm1(SB) - MOVD $448, R11 - BR callbackasm1(SB) - MOVD $449, R11 - BR callbackasm1(SB) - MOVD $450, R11 - BR callbackasm1(SB) - MOVD $451, R11 - BR callbackasm1(SB) - MOVD $452, R11 - BR callbackasm1(SB) - MOVD $453, R11 - BR callbackasm1(SB) - MOVD $454, R11 - BR callbackasm1(SB) - MOVD $455, R11 - BR callbackasm1(SB) - MOVD $456, R11 - BR callbackasm1(SB) - MOVD $457, R11 - BR callbackasm1(SB) - MOVD $458, R11 - BR callbackasm1(SB) - MOVD $459, R11 - BR callbackasm1(SB) - MOVD $460, R11 - BR callbackasm1(SB) - MOVD $461, R11 - BR callbackasm1(SB) - MOVD $462, R11 - BR callbackasm1(SB) - MOVD $463, R11 - BR callbackasm1(SB) - MOVD $464, R11 - BR callbackasm1(SB) - MOVD $465, R11 - BR callbackasm1(SB) - MOVD $466, R11 - BR callbackasm1(SB) - MOVD $467, R11 - BR callbackasm1(SB) - MOVD $468, R11 - BR callbackasm1(SB) - MOVD $469, R11 - BR callbackasm1(SB) - MOVD $470, R11 - BR callbackasm1(SB) - MOVD $471, R11 - BR callbackasm1(SB) - MOVD $472, R11 - BR callbackasm1(SB) - MOVD $473, R11 - BR callbackasm1(SB) - MOVD $474, R11 - BR callbackasm1(SB) - MOVD $475, R11 - BR callbackasm1(SB) - MOVD $476, R11 - BR callbackasm1(SB) - MOVD $477, R11 - BR callbackasm1(SB) - MOVD $478, R11 - BR callbackasm1(SB) - MOVD $479, R11 - BR callbackasm1(SB) - MOVD $480, R11 - BR callbackasm1(SB) - MOVD $481, R11 - BR callbackasm1(SB) - MOVD $482, R11 - BR callbackasm1(SB) - MOVD $483, R11 - BR callbackasm1(SB) - MOVD $484, R11 - BR callbackasm1(SB) - MOVD $485, R11 - BR callbackasm1(SB) - MOVD $486, R11 - BR callbackasm1(SB) - MOVD $487, R11 - BR callbackasm1(SB) - MOVD $488, R11 - BR callbackasm1(SB) - MOVD $489, R11 - BR callbackasm1(SB) - MOVD $490, R11 - BR callbackasm1(SB) - MOVD $491, R11 - BR callbackasm1(SB) - MOVD $492, R11 - BR callbackasm1(SB) - MOVD $493, R11 - BR callbackasm1(SB) - MOVD $494, R11 - BR callbackasm1(SB) - MOVD $495, R11 - BR callbackasm1(SB) - MOVD $496, R11 - BR callbackasm1(SB) - MOVD $497, R11 - BR callbackasm1(SB) - MOVD $498, R11 - BR callbackasm1(SB) - MOVD $499, R11 - BR callbackasm1(SB) - MOVD $500, R11 - BR callbackasm1(SB) - MOVD $501, R11 - BR callbackasm1(SB) - MOVD $502, R11 - BR callbackasm1(SB) - MOVD $503, R11 - BR callbackasm1(SB) - MOVD $504, R11 - BR callbackasm1(SB) - MOVD $505, R11 - BR callbackasm1(SB) - MOVD $506, R11 - BR callbackasm1(SB) - MOVD $507, R11 - BR callbackasm1(SB) - MOVD $508, R11 - BR callbackasm1(SB) - MOVD $509, R11 - BR callbackasm1(SB) - MOVD $510, R11 - BR callbackasm1(SB) - MOVD $511, R11 - BR callbackasm1(SB) - MOVD $512, R11 - BR callbackasm1(SB) - MOVD $513, R11 - BR callbackasm1(SB) - MOVD $514, R11 - BR callbackasm1(SB) - MOVD $515, R11 - BR callbackasm1(SB) - MOVD $516, R11 - BR callbackasm1(SB) - MOVD $517, R11 - BR callbackasm1(SB) - MOVD $518, R11 - BR callbackasm1(SB) - MOVD $519, R11 - BR callbackasm1(SB) - MOVD $520, R11 - BR callbackasm1(SB) - MOVD $521, R11 - BR callbackasm1(SB) - MOVD $522, R11 - BR callbackasm1(SB) - MOVD $523, R11 - BR callbackasm1(SB) - MOVD $524, R11 - BR callbackasm1(SB) - MOVD $525, R11 - BR callbackasm1(SB) - MOVD $526, R11 - BR callbackasm1(SB) - MOVD $527, R11 - BR callbackasm1(SB) - MOVD $528, R11 - BR callbackasm1(SB) - MOVD $529, R11 - BR callbackasm1(SB) - MOVD $530, R11 - BR callbackasm1(SB) - MOVD $531, R11 - BR callbackasm1(SB) - MOVD $532, R11 - BR callbackasm1(SB) - MOVD $533, R11 - BR callbackasm1(SB) - MOVD $534, R11 - BR callbackasm1(SB) - MOVD $535, R11 - BR callbackasm1(SB) - MOVD $536, R11 - BR callbackasm1(SB) - MOVD $537, R11 - BR callbackasm1(SB) - MOVD $538, R11 - BR callbackasm1(SB) - MOVD $539, R11 - BR callbackasm1(SB) - MOVD $540, R11 - BR callbackasm1(SB) - MOVD $541, R11 - BR callbackasm1(SB) - MOVD $542, R11 - BR callbackasm1(SB) - MOVD $543, R11 - BR callbackasm1(SB) - MOVD $544, R11 - BR callbackasm1(SB) - MOVD $545, R11 - BR callbackasm1(SB) - MOVD $546, R11 - BR callbackasm1(SB) - MOVD $547, R11 - BR callbackasm1(SB) - MOVD $548, R11 - BR callbackasm1(SB) - MOVD $549, R11 - BR callbackasm1(SB) - MOVD $550, R11 - BR callbackasm1(SB) - MOVD $551, R11 - BR callbackasm1(SB) - MOVD $552, R11 - BR callbackasm1(SB) - MOVD $553, R11 - BR callbackasm1(SB) - MOVD $554, R11 - BR callbackasm1(SB) - MOVD $555, R11 - BR callbackasm1(SB) - MOVD $556, R11 - BR callbackasm1(SB) - MOVD $557, R11 - BR callbackasm1(SB) - MOVD $558, R11 - BR callbackasm1(SB) - MOVD $559, R11 - BR callbackasm1(SB) - MOVD $560, R11 - BR callbackasm1(SB) - MOVD $561, R11 - BR callbackasm1(SB) - MOVD $562, R11 - BR callbackasm1(SB) - MOVD $563, R11 - BR callbackasm1(SB) - MOVD $564, R11 - BR callbackasm1(SB) - MOVD $565, R11 - BR callbackasm1(SB) - MOVD $566, R11 - BR callbackasm1(SB) - MOVD $567, R11 - BR callbackasm1(SB) - MOVD $568, R11 - BR callbackasm1(SB) - MOVD $569, R11 - BR callbackasm1(SB) - MOVD $570, R11 - BR callbackasm1(SB) - MOVD $571, R11 - BR callbackasm1(SB) - MOVD $572, R11 - BR callbackasm1(SB) - MOVD $573, R11 - BR callbackasm1(SB) - MOVD $574, R11 - BR callbackasm1(SB) - MOVD $575, R11 - BR callbackasm1(SB) - MOVD $576, R11 - BR callbackasm1(SB) - MOVD $577, R11 - BR callbackasm1(SB) - MOVD $578, R11 - BR callbackasm1(SB) - MOVD $579, R11 - BR callbackasm1(SB) - MOVD $580, R11 - BR callbackasm1(SB) - MOVD $581, R11 - BR callbackasm1(SB) - MOVD $582, R11 - BR callbackasm1(SB) - MOVD $583, R11 - BR callbackasm1(SB) - MOVD $584, R11 - BR callbackasm1(SB) - MOVD $585, R11 - BR callbackasm1(SB) - MOVD $586, R11 - BR callbackasm1(SB) - MOVD $587, R11 - BR callbackasm1(SB) - MOVD $588, R11 - BR callbackasm1(SB) - MOVD $589, R11 - BR callbackasm1(SB) - MOVD $590, R11 - BR callbackasm1(SB) - MOVD $591, R11 - BR callbackasm1(SB) - MOVD $592, R11 - BR callbackasm1(SB) - MOVD $593, R11 - BR callbackasm1(SB) - MOVD $594, R11 - BR callbackasm1(SB) - MOVD $595, R11 - BR callbackasm1(SB) - MOVD $596, R11 - BR callbackasm1(SB) - MOVD $597, R11 - BR callbackasm1(SB) - MOVD $598, R11 - BR callbackasm1(SB) - MOVD $599, R11 - BR callbackasm1(SB) - MOVD $600, R11 - BR callbackasm1(SB) - MOVD $601, R11 - BR callbackasm1(SB) - MOVD $602, R11 - BR callbackasm1(SB) - MOVD $603, R11 - BR callbackasm1(SB) - MOVD $604, R11 - BR callbackasm1(SB) - MOVD $605, R11 - BR callbackasm1(SB) - MOVD $606, R11 - BR callbackasm1(SB) - MOVD $607, R11 - BR callbackasm1(SB) - MOVD $608, R11 - BR callbackasm1(SB) - MOVD $609, R11 - BR callbackasm1(SB) - MOVD $610, R11 - BR callbackasm1(SB) - MOVD $611, R11 - BR callbackasm1(SB) - MOVD $612, R11 - BR callbackasm1(SB) - MOVD $613, R11 - BR callbackasm1(SB) - MOVD $614, R11 - BR callbackasm1(SB) - MOVD $615, R11 - BR callbackasm1(SB) - MOVD $616, R11 - BR callbackasm1(SB) - MOVD $617, R11 - BR callbackasm1(SB) - MOVD $618, R11 - BR callbackasm1(SB) - MOVD $619, R11 - BR callbackasm1(SB) - MOVD $620, R11 - BR callbackasm1(SB) - MOVD $621, R11 - BR callbackasm1(SB) - MOVD $622, R11 - BR callbackasm1(SB) - MOVD $623, R11 - BR callbackasm1(SB) - MOVD $624, R11 - BR callbackasm1(SB) - MOVD $625, R11 - BR callbackasm1(SB) - MOVD $626, R11 - BR callbackasm1(SB) - MOVD $627, R11 - BR callbackasm1(SB) - MOVD $628, R11 - BR callbackasm1(SB) - MOVD $629, R11 - BR callbackasm1(SB) - MOVD $630, R11 - BR callbackasm1(SB) - MOVD $631, R11 - BR callbackasm1(SB) - MOVD $632, R11 - BR callbackasm1(SB) - MOVD $633, R11 - BR callbackasm1(SB) - MOVD $634, R11 - BR callbackasm1(SB) - MOVD $635, R11 - BR callbackasm1(SB) - MOVD $636, R11 - BR callbackasm1(SB) - MOVD $637, R11 - BR callbackasm1(SB) - MOVD $638, R11 - BR callbackasm1(SB) - MOVD $639, R11 - BR callbackasm1(SB) - MOVD $640, R11 - BR callbackasm1(SB) - MOVD $641, R11 - BR callbackasm1(SB) - MOVD $642, R11 - BR callbackasm1(SB) - MOVD $643, R11 - BR callbackasm1(SB) - MOVD $644, R11 - BR callbackasm1(SB) - MOVD $645, R11 - BR callbackasm1(SB) - MOVD $646, R11 - BR callbackasm1(SB) - MOVD $647, R11 - BR callbackasm1(SB) - MOVD $648, R11 - BR callbackasm1(SB) - MOVD $649, R11 - BR callbackasm1(SB) - MOVD $650, R11 - BR callbackasm1(SB) - MOVD $651, R11 - BR callbackasm1(SB) - MOVD $652, R11 - BR callbackasm1(SB) - MOVD $653, R11 - BR callbackasm1(SB) - MOVD $654, R11 - BR callbackasm1(SB) - MOVD $655, R11 - BR callbackasm1(SB) - MOVD $656, R11 - BR callbackasm1(SB) - MOVD $657, R11 - BR callbackasm1(SB) - MOVD $658, R11 - BR callbackasm1(SB) - MOVD $659, R11 - BR callbackasm1(SB) - MOVD $660, R11 - BR callbackasm1(SB) - MOVD $661, R11 - BR callbackasm1(SB) - MOVD $662, R11 - BR callbackasm1(SB) - MOVD $663, R11 - BR callbackasm1(SB) - MOVD $664, R11 - BR callbackasm1(SB) - MOVD $665, R11 - BR callbackasm1(SB) - MOVD $666, R11 - BR callbackasm1(SB) - MOVD $667, R11 - BR callbackasm1(SB) - MOVD $668, R11 - BR callbackasm1(SB) - MOVD $669, R11 - BR callbackasm1(SB) - MOVD $670, R11 - BR callbackasm1(SB) - MOVD $671, R11 - BR callbackasm1(SB) - MOVD $672, R11 - BR callbackasm1(SB) - MOVD $673, R11 - BR callbackasm1(SB) - MOVD $674, R11 - BR callbackasm1(SB) - MOVD $675, R11 - BR callbackasm1(SB) - MOVD $676, R11 - BR callbackasm1(SB) - MOVD $677, R11 - BR callbackasm1(SB) - MOVD $678, R11 - BR callbackasm1(SB) - MOVD $679, R11 - BR callbackasm1(SB) - MOVD $680, R11 - BR callbackasm1(SB) - MOVD $681, R11 - BR callbackasm1(SB) - MOVD $682, R11 - BR callbackasm1(SB) - MOVD $683, R11 - BR callbackasm1(SB) - MOVD $684, R11 - BR callbackasm1(SB) - MOVD $685, R11 - BR callbackasm1(SB) - MOVD $686, R11 - BR callbackasm1(SB) - MOVD $687, R11 - BR callbackasm1(SB) - MOVD $688, R11 - BR callbackasm1(SB) - MOVD $689, R11 - BR callbackasm1(SB) - MOVD $690, R11 - BR callbackasm1(SB) - MOVD $691, R11 - BR callbackasm1(SB) - MOVD $692, R11 - BR callbackasm1(SB) - MOVD $693, R11 - BR callbackasm1(SB) - MOVD $694, R11 - BR callbackasm1(SB) - MOVD $695, R11 - BR callbackasm1(SB) - MOVD $696, R11 - BR callbackasm1(SB) - MOVD $697, R11 - BR callbackasm1(SB) - MOVD $698, R11 - BR callbackasm1(SB) - MOVD $699, R11 - BR callbackasm1(SB) - MOVD $700, R11 - BR callbackasm1(SB) - MOVD $701, R11 - BR callbackasm1(SB) - MOVD $702, R11 - BR callbackasm1(SB) - MOVD $703, R11 - BR callbackasm1(SB) - MOVD $704, R11 - BR callbackasm1(SB) - MOVD $705, R11 - BR callbackasm1(SB) - MOVD $706, R11 - BR callbackasm1(SB) - MOVD $707, R11 - BR callbackasm1(SB) - MOVD $708, R11 - BR callbackasm1(SB) - MOVD $709, R11 - BR callbackasm1(SB) - MOVD $710, R11 - BR callbackasm1(SB) - MOVD $711, R11 - BR callbackasm1(SB) - MOVD $712, R11 - BR callbackasm1(SB) - MOVD $713, R11 - BR callbackasm1(SB) - MOVD $714, R11 - BR callbackasm1(SB) - MOVD $715, R11 - BR callbackasm1(SB) - MOVD $716, R11 - BR callbackasm1(SB) - MOVD $717, R11 - BR callbackasm1(SB) - MOVD $718, R11 - BR callbackasm1(SB) - MOVD $719, R11 - BR callbackasm1(SB) - MOVD $720, R11 - BR callbackasm1(SB) - MOVD $721, R11 - BR callbackasm1(SB) - MOVD $722, R11 - BR callbackasm1(SB) - MOVD $723, R11 - BR callbackasm1(SB) - MOVD $724, R11 - BR callbackasm1(SB) - MOVD $725, R11 - BR callbackasm1(SB) - MOVD $726, R11 - BR callbackasm1(SB) - MOVD $727, R11 - BR callbackasm1(SB) - MOVD $728, R11 - BR callbackasm1(SB) - MOVD $729, R11 - BR callbackasm1(SB) - MOVD $730, R11 - BR callbackasm1(SB) - MOVD $731, R11 - BR callbackasm1(SB) - MOVD $732, R11 - BR callbackasm1(SB) - MOVD $733, R11 - BR callbackasm1(SB) - MOVD $734, R11 - BR callbackasm1(SB) - MOVD $735, R11 - BR callbackasm1(SB) - MOVD $736, R11 - BR callbackasm1(SB) - MOVD $737, R11 - BR callbackasm1(SB) - MOVD $738, R11 - BR callbackasm1(SB) - MOVD $739, R11 - BR callbackasm1(SB) - MOVD $740, R11 - BR callbackasm1(SB) - MOVD $741, R11 - BR callbackasm1(SB) - MOVD $742, R11 - BR callbackasm1(SB) - MOVD $743, R11 - BR callbackasm1(SB) - MOVD $744, R11 - BR callbackasm1(SB) - MOVD $745, R11 - BR callbackasm1(SB) - MOVD $746, R11 - BR callbackasm1(SB) - MOVD $747, R11 - BR callbackasm1(SB) - MOVD $748, R11 - BR callbackasm1(SB) - MOVD $749, R11 - BR callbackasm1(SB) - MOVD $750, R11 - BR callbackasm1(SB) - MOVD $751, R11 - BR callbackasm1(SB) - MOVD $752, R11 - BR callbackasm1(SB) - MOVD $753, R11 - BR callbackasm1(SB) - MOVD $754, R11 - BR callbackasm1(SB) - MOVD $755, R11 - BR callbackasm1(SB) - MOVD $756, R11 - BR callbackasm1(SB) - MOVD $757, R11 - BR callbackasm1(SB) - MOVD $758, R11 - BR callbackasm1(SB) - MOVD $759, R11 - BR callbackasm1(SB) - MOVD $760, R11 - BR callbackasm1(SB) - MOVD $761, R11 - BR callbackasm1(SB) - MOVD $762, R11 - BR callbackasm1(SB) - MOVD $763, R11 - BR callbackasm1(SB) - MOVD $764, R11 - BR callbackasm1(SB) - MOVD $765, R11 - BR callbackasm1(SB) - MOVD $766, R11 - BR callbackasm1(SB) - MOVD $767, R11 - BR callbackasm1(SB) - MOVD $768, R11 - BR callbackasm1(SB) - MOVD $769, R11 - BR callbackasm1(SB) - MOVD $770, R11 - BR callbackasm1(SB) - MOVD $771, R11 - BR callbackasm1(SB) - MOVD $772, R11 - BR callbackasm1(SB) - MOVD $773, R11 - BR callbackasm1(SB) - MOVD $774, R11 - BR callbackasm1(SB) - MOVD $775, R11 - BR callbackasm1(SB) - MOVD $776, R11 - BR callbackasm1(SB) - MOVD $777, R11 - BR callbackasm1(SB) - MOVD $778, R11 - BR callbackasm1(SB) - MOVD $779, R11 - BR callbackasm1(SB) - MOVD $780, R11 - BR callbackasm1(SB) - MOVD $781, R11 - BR callbackasm1(SB) - MOVD $782, R11 - BR callbackasm1(SB) - MOVD $783, R11 - BR callbackasm1(SB) - MOVD $784, R11 - BR callbackasm1(SB) - MOVD $785, R11 - BR callbackasm1(SB) - MOVD $786, R11 - BR callbackasm1(SB) - MOVD $787, R11 - BR callbackasm1(SB) - MOVD $788, R11 - BR callbackasm1(SB) - MOVD $789, R11 - BR callbackasm1(SB) - MOVD $790, R11 - BR callbackasm1(SB) - MOVD $791, R11 - BR callbackasm1(SB) - MOVD $792, R11 - BR callbackasm1(SB) - MOVD $793, R11 - BR callbackasm1(SB) - MOVD $794, R11 - BR callbackasm1(SB) - MOVD $795, R11 - BR callbackasm1(SB) - MOVD $796, R11 - BR callbackasm1(SB) - MOVD $797, R11 - BR callbackasm1(SB) - MOVD $798, R11 - BR callbackasm1(SB) - MOVD $799, R11 - BR callbackasm1(SB) - MOVD $800, R11 - BR callbackasm1(SB) - MOVD $801, R11 - BR callbackasm1(SB) - MOVD $802, R11 - BR callbackasm1(SB) - MOVD $803, R11 - BR callbackasm1(SB) - MOVD $804, R11 - BR callbackasm1(SB) - MOVD $805, R11 - BR callbackasm1(SB) - MOVD $806, R11 - BR callbackasm1(SB) - MOVD $807, R11 - BR callbackasm1(SB) - MOVD $808, R11 - BR callbackasm1(SB) - MOVD $809, R11 - BR callbackasm1(SB) - MOVD $810, R11 - BR callbackasm1(SB) - MOVD $811, R11 - BR callbackasm1(SB) - MOVD $812, R11 - BR callbackasm1(SB) - MOVD $813, R11 - BR callbackasm1(SB) - MOVD $814, R11 - BR callbackasm1(SB) - MOVD $815, R11 - BR callbackasm1(SB) - MOVD $816, R11 - BR callbackasm1(SB) - MOVD $817, R11 - BR callbackasm1(SB) - MOVD $818, R11 - BR callbackasm1(SB) - MOVD $819, R11 - BR callbackasm1(SB) - MOVD $820, R11 - BR callbackasm1(SB) - MOVD $821, R11 - BR callbackasm1(SB) - MOVD $822, R11 - BR callbackasm1(SB) - MOVD $823, R11 - BR callbackasm1(SB) - MOVD $824, R11 - BR callbackasm1(SB) - MOVD $825, R11 - BR callbackasm1(SB) - MOVD $826, R11 - BR callbackasm1(SB) - MOVD $827, R11 - BR callbackasm1(SB) - MOVD $828, R11 - BR callbackasm1(SB) - MOVD $829, R11 - BR callbackasm1(SB) - MOVD $830, R11 - BR callbackasm1(SB) - MOVD $831, R11 - BR callbackasm1(SB) - MOVD $832, R11 - BR callbackasm1(SB) - MOVD $833, R11 - BR callbackasm1(SB) - MOVD $834, R11 - BR callbackasm1(SB) - MOVD $835, R11 - BR callbackasm1(SB) - MOVD $836, R11 - BR callbackasm1(SB) - MOVD $837, R11 - BR callbackasm1(SB) - MOVD $838, R11 - BR callbackasm1(SB) - MOVD $839, R11 - BR callbackasm1(SB) - MOVD $840, R11 - BR callbackasm1(SB) - MOVD $841, R11 - BR callbackasm1(SB) - MOVD $842, R11 - BR callbackasm1(SB) - MOVD $843, R11 - BR callbackasm1(SB) - MOVD $844, R11 - BR callbackasm1(SB) - MOVD $845, R11 - BR callbackasm1(SB) - MOVD $846, R11 - BR callbackasm1(SB) - MOVD $847, R11 - BR callbackasm1(SB) - MOVD $848, R11 - BR callbackasm1(SB) - MOVD $849, R11 - BR callbackasm1(SB) - MOVD $850, R11 - BR callbackasm1(SB) - MOVD $851, R11 - BR callbackasm1(SB) - MOVD $852, R11 - BR callbackasm1(SB) - MOVD $853, R11 - BR callbackasm1(SB) - MOVD $854, R11 - BR callbackasm1(SB) - MOVD $855, R11 - BR callbackasm1(SB) - MOVD $856, R11 - BR callbackasm1(SB) - MOVD $857, R11 - BR callbackasm1(SB) - MOVD $858, R11 - BR callbackasm1(SB) - MOVD $859, R11 - BR callbackasm1(SB) - MOVD $860, R11 - BR callbackasm1(SB) - MOVD $861, R11 - BR callbackasm1(SB) - MOVD $862, R11 - BR callbackasm1(SB) - MOVD $863, R11 - BR callbackasm1(SB) - MOVD $864, R11 - BR callbackasm1(SB) - MOVD $865, R11 - BR callbackasm1(SB) - MOVD $866, R11 - BR callbackasm1(SB) - MOVD $867, R11 - BR callbackasm1(SB) - MOVD $868, R11 - BR callbackasm1(SB) - MOVD $869, R11 - BR callbackasm1(SB) - MOVD $870, R11 - BR callbackasm1(SB) - MOVD $871, R11 - BR callbackasm1(SB) - MOVD $872, R11 - BR callbackasm1(SB) - MOVD $873, R11 - BR callbackasm1(SB) - MOVD $874, R11 - BR callbackasm1(SB) - MOVD $875, R11 - BR callbackasm1(SB) - MOVD $876, R11 - BR callbackasm1(SB) - MOVD $877, R11 - BR callbackasm1(SB) - MOVD $878, R11 - BR callbackasm1(SB) - MOVD $879, R11 - BR callbackasm1(SB) - MOVD $880, R11 - BR callbackasm1(SB) - MOVD $881, R11 - BR callbackasm1(SB) - MOVD $882, R11 - BR callbackasm1(SB) - MOVD $883, R11 - BR callbackasm1(SB) - MOVD $884, R11 - BR callbackasm1(SB) - MOVD $885, R11 - BR callbackasm1(SB) - MOVD $886, R11 - BR callbackasm1(SB) - MOVD $887, R11 - BR callbackasm1(SB) - MOVD $888, R11 - BR callbackasm1(SB) - MOVD $889, R11 - BR callbackasm1(SB) - MOVD $890, R11 - BR callbackasm1(SB) - MOVD $891, R11 - BR callbackasm1(SB) - MOVD $892, R11 - BR callbackasm1(SB) - MOVD $893, R11 - BR callbackasm1(SB) - MOVD $894, R11 - BR callbackasm1(SB) - MOVD $895, R11 - BR callbackasm1(SB) - MOVD $896, R11 - BR callbackasm1(SB) - MOVD $897, R11 - BR callbackasm1(SB) - MOVD $898, R11 - BR callbackasm1(SB) - MOVD $899, R11 - BR callbackasm1(SB) - MOVD $900, R11 - BR callbackasm1(SB) - MOVD $901, R11 - BR callbackasm1(SB) - MOVD $902, R11 - BR callbackasm1(SB) - MOVD $903, R11 - BR callbackasm1(SB) - MOVD $904, R11 - BR callbackasm1(SB) - MOVD $905, R11 - BR callbackasm1(SB) - MOVD $906, R11 - BR callbackasm1(SB) - MOVD $907, R11 - BR callbackasm1(SB) - MOVD $908, R11 - BR callbackasm1(SB) - MOVD $909, R11 - BR callbackasm1(SB) - MOVD $910, R11 - BR callbackasm1(SB) - MOVD $911, R11 - BR callbackasm1(SB) - MOVD $912, R11 - BR callbackasm1(SB) - MOVD $913, R11 - BR callbackasm1(SB) - MOVD $914, R11 - BR callbackasm1(SB) - MOVD $915, R11 - BR callbackasm1(SB) - MOVD $916, R11 - BR callbackasm1(SB) - MOVD $917, R11 - BR callbackasm1(SB) - MOVD $918, R11 - BR callbackasm1(SB) - MOVD $919, R11 - BR callbackasm1(SB) - MOVD $920, R11 - BR callbackasm1(SB) - MOVD $921, R11 - BR callbackasm1(SB) - MOVD $922, R11 - BR callbackasm1(SB) - MOVD $923, R11 - BR callbackasm1(SB) - MOVD $924, R11 - BR callbackasm1(SB) - MOVD $925, R11 - BR callbackasm1(SB) - MOVD $926, R11 - BR callbackasm1(SB) - MOVD $927, R11 - BR callbackasm1(SB) - MOVD $928, R11 - BR callbackasm1(SB) - MOVD $929, R11 - BR callbackasm1(SB) - MOVD $930, R11 - BR callbackasm1(SB) - MOVD $931, R11 - BR callbackasm1(SB) - MOVD $932, R11 - BR callbackasm1(SB) - MOVD $933, R11 - BR callbackasm1(SB) - MOVD $934, R11 - BR callbackasm1(SB) - MOVD $935, R11 - BR callbackasm1(SB) - MOVD $936, R11 - BR callbackasm1(SB) - MOVD $937, R11 - BR callbackasm1(SB) - MOVD $938, R11 - BR callbackasm1(SB) - MOVD $939, R11 - BR callbackasm1(SB) - MOVD $940, R11 - BR callbackasm1(SB) - MOVD $941, R11 - BR callbackasm1(SB) - MOVD $942, R11 - BR callbackasm1(SB) - MOVD $943, R11 - BR callbackasm1(SB) - MOVD $944, R11 - BR callbackasm1(SB) - MOVD $945, R11 - BR callbackasm1(SB) - MOVD $946, R11 - BR callbackasm1(SB) - MOVD $947, R11 - BR callbackasm1(SB) - MOVD $948, R11 - BR callbackasm1(SB) - MOVD $949, R11 - BR callbackasm1(SB) - MOVD $950, R11 - BR callbackasm1(SB) - MOVD $951, R11 - BR callbackasm1(SB) - MOVD $952, R11 - BR callbackasm1(SB) - MOVD $953, R11 - BR callbackasm1(SB) - MOVD $954, R11 - BR callbackasm1(SB) - MOVD $955, R11 - BR callbackasm1(SB) - MOVD $956, R11 - BR callbackasm1(SB) - MOVD $957, R11 - BR callbackasm1(SB) - MOVD $958, R11 - BR callbackasm1(SB) - MOVD $959, R11 - BR callbackasm1(SB) - MOVD $960, R11 - BR callbackasm1(SB) - MOVD $961, R11 - BR callbackasm1(SB) - MOVD $962, R11 - BR callbackasm1(SB) - MOVD $963, R11 - BR callbackasm1(SB) - MOVD $964, R11 - BR callbackasm1(SB) - MOVD $965, R11 - BR callbackasm1(SB) - MOVD $966, R11 - BR callbackasm1(SB) - MOVD $967, R11 - BR callbackasm1(SB) - MOVD $968, R11 - BR callbackasm1(SB) - MOVD $969, R11 - BR callbackasm1(SB) - MOVD $970, R11 - BR callbackasm1(SB) - MOVD $971, R11 - BR callbackasm1(SB) - MOVD $972, R11 - BR callbackasm1(SB) - MOVD $973, R11 - BR callbackasm1(SB) - MOVD $974, R11 - BR callbackasm1(SB) - MOVD $975, R11 - BR callbackasm1(SB) - MOVD $976, R11 - BR callbackasm1(SB) - MOVD $977, R11 - BR callbackasm1(SB) - MOVD $978, R11 - BR callbackasm1(SB) - MOVD $979, R11 - BR callbackasm1(SB) - MOVD $980, R11 - BR callbackasm1(SB) - MOVD $981, R11 - BR callbackasm1(SB) - MOVD $982, R11 - BR callbackasm1(SB) - MOVD $983, R11 - BR callbackasm1(SB) - MOVD $984, R11 - BR callbackasm1(SB) - MOVD $985, R11 - BR callbackasm1(SB) - MOVD $986, R11 - BR callbackasm1(SB) - MOVD $987, R11 - BR callbackasm1(SB) - MOVD $988, R11 - BR callbackasm1(SB) - MOVD $989, R11 - BR callbackasm1(SB) - MOVD $990, R11 - BR callbackasm1(SB) - MOVD $991, R11 - BR callbackasm1(SB) - MOVD $992, R11 - BR callbackasm1(SB) - MOVD $993, R11 - BR callbackasm1(SB) - MOVD $994, R11 - BR callbackasm1(SB) - MOVD $995, R11 - BR callbackasm1(SB) - MOVD $996, R11 - BR callbackasm1(SB) - MOVD $997, R11 - BR callbackasm1(SB) - MOVD $998, R11 - BR callbackasm1(SB) - MOVD $999, R11 - BR callbackasm1(SB) - MOVD $1000, R11 - BR callbackasm1(SB) - MOVD $1001, R11 - BR callbackasm1(SB) - MOVD $1002, R11 - BR callbackasm1(SB) - MOVD $1003, R11 - BR callbackasm1(SB) - MOVD $1004, R11 - BR callbackasm1(SB) - MOVD $1005, R11 - BR callbackasm1(SB) - MOVD $1006, R11 - BR callbackasm1(SB) - MOVD $1007, R11 - BR callbackasm1(SB) - MOVD $1008, R11 - BR callbackasm1(SB) - MOVD $1009, R11 - BR callbackasm1(SB) - MOVD $1010, R11 - BR callbackasm1(SB) - MOVD $1011, R11 - BR callbackasm1(SB) - MOVD $1012, R11 - BR callbackasm1(SB) - MOVD $1013, R11 - BR callbackasm1(SB) - MOVD $1014, R11 - BR callbackasm1(SB) - MOVD $1015, R11 - BR callbackasm1(SB) - MOVD $1016, R11 - BR callbackasm1(SB) - MOVD $1017, R11 - BR callbackasm1(SB) - MOVD $1018, R11 - BR callbackasm1(SB) - MOVD $1019, R11 - BR callbackasm1(SB) - MOVD $1020, R11 - BR callbackasm1(SB) - MOVD $1021, R11 - BR callbackasm1(SB) - MOVD $1022, R11 - BR callbackasm1(SB) - MOVD $1023, R11 - BR callbackasm1(SB) - MOVD $1024, R11 - BR callbackasm1(SB) - MOVD $1025, R11 - BR callbackasm1(SB) - MOVD $1026, R11 - BR callbackasm1(SB) - MOVD $1027, R11 - BR callbackasm1(SB) - MOVD $1028, R11 - BR callbackasm1(SB) - MOVD $1029, R11 - BR callbackasm1(SB) - MOVD $1030, R11 - BR callbackasm1(SB) - MOVD $1031, R11 - BR callbackasm1(SB) - MOVD $1032, R11 - BR callbackasm1(SB) - MOVD $1033, R11 - BR callbackasm1(SB) - MOVD $1034, R11 - BR callbackasm1(SB) - MOVD $1035, R11 - BR callbackasm1(SB) - MOVD $1036, R11 - BR callbackasm1(SB) - MOVD $1037, R11 - BR callbackasm1(SB) - MOVD $1038, R11 - BR callbackasm1(SB) - MOVD $1039, R11 - BR callbackasm1(SB) - MOVD $1040, R11 - BR callbackasm1(SB) - MOVD $1041, R11 - BR callbackasm1(SB) - MOVD $1042, R11 - BR callbackasm1(SB) - MOVD $1043, R11 - BR callbackasm1(SB) - MOVD $1044, R11 - BR callbackasm1(SB) - MOVD $1045, R11 - BR callbackasm1(SB) - MOVD $1046, R11 - BR callbackasm1(SB) - MOVD $1047, R11 - BR callbackasm1(SB) - MOVD $1048, R11 - BR callbackasm1(SB) - MOVD $1049, R11 - BR callbackasm1(SB) - MOVD $1050, R11 - BR callbackasm1(SB) - MOVD $1051, R11 - BR callbackasm1(SB) - MOVD $1052, R11 - BR callbackasm1(SB) - MOVD $1053, R11 - BR callbackasm1(SB) - MOVD $1054, R11 - BR callbackasm1(SB) - MOVD $1055, R11 - BR callbackasm1(SB) - MOVD $1056, R11 - BR callbackasm1(SB) - MOVD $1057, R11 - BR callbackasm1(SB) - MOVD $1058, R11 - BR callbackasm1(SB) - MOVD $1059, R11 - BR callbackasm1(SB) - MOVD $1060, R11 - BR callbackasm1(SB) - MOVD $1061, R11 - BR callbackasm1(SB) - MOVD $1062, R11 - BR callbackasm1(SB) - MOVD $1063, R11 - BR callbackasm1(SB) - MOVD $1064, R11 - BR callbackasm1(SB) - MOVD $1065, R11 - BR callbackasm1(SB) - MOVD $1066, R11 - BR callbackasm1(SB) - MOVD $1067, R11 - BR callbackasm1(SB) - MOVD $1068, R11 - BR callbackasm1(SB) - MOVD $1069, R11 - BR callbackasm1(SB) - MOVD $1070, R11 - BR callbackasm1(SB) - MOVD $1071, R11 - BR callbackasm1(SB) - MOVD $1072, R11 - BR callbackasm1(SB) - MOVD $1073, R11 - BR callbackasm1(SB) - MOVD $1074, R11 - BR callbackasm1(SB) - MOVD $1075, R11 - BR callbackasm1(SB) - MOVD $1076, R11 - BR callbackasm1(SB) - MOVD $1077, R11 - BR callbackasm1(SB) - MOVD $1078, R11 - BR callbackasm1(SB) - MOVD $1079, R11 - BR callbackasm1(SB) - MOVD $1080, R11 - BR callbackasm1(SB) - MOVD $1081, R11 - BR callbackasm1(SB) - MOVD $1082, R11 - BR callbackasm1(SB) - MOVD $1083, R11 - BR callbackasm1(SB) - MOVD $1084, R11 - BR callbackasm1(SB) - MOVD $1085, R11 - BR callbackasm1(SB) - MOVD $1086, R11 - BR callbackasm1(SB) - MOVD $1087, R11 - BR callbackasm1(SB) - MOVD $1088, R11 - BR callbackasm1(SB) - MOVD $1089, R11 - BR callbackasm1(SB) - MOVD $1090, R11 - BR callbackasm1(SB) - MOVD $1091, R11 - BR callbackasm1(SB) - MOVD $1092, R11 - BR callbackasm1(SB) - MOVD $1093, R11 - BR callbackasm1(SB) - MOVD $1094, R11 - BR callbackasm1(SB) - MOVD $1095, R11 - BR callbackasm1(SB) - MOVD $1096, R11 - BR callbackasm1(SB) - MOVD $1097, R11 - BR callbackasm1(SB) - MOVD $1098, R11 - BR callbackasm1(SB) - MOVD $1099, R11 - BR callbackasm1(SB) - MOVD $1100, R11 - BR callbackasm1(SB) - MOVD $1101, R11 - BR callbackasm1(SB) - MOVD $1102, R11 - BR callbackasm1(SB) - MOVD $1103, R11 - BR callbackasm1(SB) - MOVD $1104, R11 - BR callbackasm1(SB) - MOVD $1105, R11 - BR callbackasm1(SB) - MOVD $1106, R11 - BR callbackasm1(SB) - MOVD $1107, R11 - BR callbackasm1(SB) - MOVD $1108, R11 - BR callbackasm1(SB) - MOVD $1109, R11 - BR callbackasm1(SB) - MOVD $1110, R11 - BR callbackasm1(SB) - MOVD $1111, R11 - BR callbackasm1(SB) - MOVD $1112, R11 - BR callbackasm1(SB) - MOVD $1113, R11 - BR callbackasm1(SB) - MOVD $1114, R11 - BR callbackasm1(SB) - MOVD $1115, R11 - BR callbackasm1(SB) - MOVD $1116, R11 - BR callbackasm1(SB) - MOVD $1117, R11 - BR callbackasm1(SB) - MOVD $1118, R11 - BR callbackasm1(SB) - MOVD $1119, R11 - BR callbackasm1(SB) - MOVD $1120, R11 - BR callbackasm1(SB) - MOVD $1121, R11 - BR callbackasm1(SB) - MOVD $1122, R11 - BR callbackasm1(SB) - MOVD $1123, R11 - BR callbackasm1(SB) - MOVD $1124, R11 - BR callbackasm1(SB) - MOVD $1125, R11 - BR callbackasm1(SB) - MOVD $1126, R11 - BR callbackasm1(SB) - MOVD $1127, R11 - BR callbackasm1(SB) - MOVD $1128, R11 - BR callbackasm1(SB) - MOVD $1129, R11 - BR callbackasm1(SB) - MOVD $1130, R11 - BR callbackasm1(SB) - MOVD $1131, R11 - BR callbackasm1(SB) - MOVD $1132, R11 - BR callbackasm1(SB) - MOVD $1133, R11 - BR callbackasm1(SB) - MOVD $1134, R11 - BR callbackasm1(SB) - MOVD $1135, R11 - BR callbackasm1(SB) - MOVD $1136, R11 - BR callbackasm1(SB) - MOVD $1137, R11 - BR callbackasm1(SB) - MOVD $1138, R11 - BR callbackasm1(SB) - MOVD $1139, R11 - BR callbackasm1(SB) - MOVD $1140, R11 - BR callbackasm1(SB) - MOVD $1141, R11 - BR callbackasm1(SB) - MOVD $1142, R11 - BR callbackasm1(SB) - MOVD $1143, R11 - BR callbackasm1(SB) - MOVD $1144, R11 - BR callbackasm1(SB) - MOVD $1145, R11 - BR callbackasm1(SB) - MOVD $1146, R11 - BR callbackasm1(SB) - MOVD $1147, R11 - BR callbackasm1(SB) - MOVD $1148, R11 - BR callbackasm1(SB) - MOVD $1149, R11 - BR callbackasm1(SB) - MOVD $1150, R11 - BR callbackasm1(SB) - MOVD $1151, R11 - BR callbackasm1(SB) - MOVD $1152, R11 - BR callbackasm1(SB) - MOVD $1153, R11 - BR callbackasm1(SB) - MOVD $1154, R11 - BR callbackasm1(SB) - MOVD $1155, R11 - BR callbackasm1(SB) - MOVD $1156, R11 - BR callbackasm1(SB) - MOVD $1157, R11 - BR callbackasm1(SB) - MOVD $1158, R11 - BR callbackasm1(SB) - MOVD $1159, R11 - BR callbackasm1(SB) - MOVD $1160, R11 - BR callbackasm1(SB) - MOVD $1161, R11 - BR callbackasm1(SB) - MOVD $1162, R11 - BR callbackasm1(SB) - MOVD $1163, R11 - BR callbackasm1(SB) - MOVD $1164, R11 - BR callbackasm1(SB) - MOVD $1165, R11 - BR callbackasm1(SB) - MOVD $1166, R11 - BR callbackasm1(SB) - MOVD $1167, R11 - BR callbackasm1(SB) - MOVD $1168, R11 - BR callbackasm1(SB) - MOVD $1169, R11 - BR callbackasm1(SB) - MOVD $1170, R11 - BR callbackasm1(SB) - MOVD $1171, R11 - BR callbackasm1(SB) - MOVD $1172, R11 - BR callbackasm1(SB) - MOVD $1173, R11 - BR callbackasm1(SB) - MOVD $1174, R11 - BR callbackasm1(SB) - MOVD $1175, R11 - BR callbackasm1(SB) - MOVD $1176, R11 - BR callbackasm1(SB) - MOVD $1177, R11 - BR callbackasm1(SB) - MOVD $1178, R11 - BR callbackasm1(SB) - MOVD $1179, R11 - BR callbackasm1(SB) - MOVD $1180, R11 - BR callbackasm1(SB) - MOVD $1181, R11 - BR callbackasm1(SB) - MOVD $1182, R11 - BR callbackasm1(SB) - MOVD $1183, R11 - BR callbackasm1(SB) - MOVD $1184, R11 - BR callbackasm1(SB) - MOVD $1185, R11 - BR callbackasm1(SB) - MOVD $1186, R11 - BR callbackasm1(SB) - MOVD $1187, R11 - BR callbackasm1(SB) - MOVD $1188, R11 - BR callbackasm1(SB) - MOVD $1189, R11 - BR callbackasm1(SB) - MOVD $1190, R11 - BR callbackasm1(SB) - MOVD $1191, R11 - BR callbackasm1(SB) - MOVD $1192, R11 - BR callbackasm1(SB) - MOVD $1193, R11 - BR callbackasm1(SB) - MOVD $1194, R11 - BR callbackasm1(SB) - MOVD $1195, R11 - BR callbackasm1(SB) - MOVD $1196, R11 - BR callbackasm1(SB) - MOVD $1197, R11 - BR callbackasm1(SB) - MOVD $1198, R11 - BR callbackasm1(SB) - MOVD $1199, R11 - BR callbackasm1(SB) - MOVD $1200, R11 - BR callbackasm1(SB) - MOVD $1201, R11 - BR callbackasm1(SB) - MOVD $1202, R11 - BR callbackasm1(SB) - MOVD $1203, R11 - BR callbackasm1(SB) - MOVD $1204, R11 - BR callbackasm1(SB) - MOVD $1205, R11 - BR callbackasm1(SB) - MOVD $1206, R11 - BR callbackasm1(SB) - MOVD $1207, R11 - BR callbackasm1(SB) - MOVD $1208, R11 - BR callbackasm1(SB) - MOVD $1209, R11 - BR callbackasm1(SB) - MOVD $1210, R11 - BR callbackasm1(SB) - MOVD $1211, R11 - BR callbackasm1(SB) - MOVD $1212, R11 - BR callbackasm1(SB) - MOVD $1213, R11 - BR callbackasm1(SB) - MOVD $1214, R11 - BR callbackasm1(SB) - MOVD $1215, R11 - BR callbackasm1(SB) - MOVD $1216, R11 - BR callbackasm1(SB) - MOVD $1217, R11 - BR callbackasm1(SB) - MOVD $1218, R11 - BR callbackasm1(SB) - MOVD $1219, R11 - BR callbackasm1(SB) - MOVD $1220, R11 - BR callbackasm1(SB) - MOVD $1221, R11 - BR callbackasm1(SB) - MOVD $1222, R11 - BR callbackasm1(SB) - MOVD $1223, R11 - BR callbackasm1(SB) - MOVD $1224, R11 - BR callbackasm1(SB) - MOVD $1225, R11 - BR callbackasm1(SB) - MOVD $1226, R11 - BR callbackasm1(SB) - MOVD $1227, R11 - BR callbackasm1(SB) - MOVD $1228, R11 - BR callbackasm1(SB) - MOVD $1229, R11 - BR callbackasm1(SB) - MOVD $1230, R11 - BR callbackasm1(SB) - MOVD $1231, R11 - BR callbackasm1(SB) - MOVD $1232, R11 - BR callbackasm1(SB) - MOVD $1233, R11 - BR callbackasm1(SB) - MOVD $1234, R11 - BR callbackasm1(SB) - MOVD $1235, R11 - BR callbackasm1(SB) - MOVD $1236, R11 - BR callbackasm1(SB) - MOVD $1237, R11 - BR callbackasm1(SB) - MOVD $1238, R11 - BR callbackasm1(SB) - MOVD $1239, R11 - BR callbackasm1(SB) - MOVD $1240, R11 - BR callbackasm1(SB) - MOVD $1241, R11 - BR callbackasm1(SB) - MOVD $1242, R11 - BR callbackasm1(SB) - MOVD $1243, R11 - BR callbackasm1(SB) - MOVD $1244, R11 - BR callbackasm1(SB) - MOVD $1245, R11 - BR callbackasm1(SB) - MOVD $1246, R11 - BR callbackasm1(SB) - MOVD $1247, R11 - BR callbackasm1(SB) - MOVD $1248, R11 - BR callbackasm1(SB) - MOVD $1249, R11 - BR callbackasm1(SB) - MOVD $1250, R11 - BR callbackasm1(SB) - MOVD $1251, R11 - BR callbackasm1(SB) - MOVD $1252, R11 - BR callbackasm1(SB) - MOVD $1253, R11 - BR callbackasm1(SB) - MOVD $1254, R11 - BR callbackasm1(SB) - MOVD $1255, R11 - BR callbackasm1(SB) - MOVD $1256, R11 - BR callbackasm1(SB) - MOVD $1257, R11 - BR callbackasm1(SB) - MOVD $1258, R11 - BR callbackasm1(SB) - MOVD $1259, R11 - BR callbackasm1(SB) - MOVD $1260, R11 - BR callbackasm1(SB) - MOVD $1261, R11 - BR callbackasm1(SB) - MOVD $1262, R11 - BR callbackasm1(SB) - MOVD $1263, R11 - BR callbackasm1(SB) - MOVD $1264, R11 - BR callbackasm1(SB) - MOVD $1265, R11 - BR callbackasm1(SB) - MOVD $1266, R11 - BR callbackasm1(SB) - MOVD $1267, R11 - BR callbackasm1(SB) - MOVD $1268, R11 - BR callbackasm1(SB) - MOVD $1269, R11 - BR callbackasm1(SB) - MOVD $1270, R11 - BR callbackasm1(SB) - MOVD $1271, R11 - BR callbackasm1(SB) - MOVD $1272, R11 - BR callbackasm1(SB) - MOVD $1273, R11 - BR callbackasm1(SB) - MOVD $1274, R11 - BR callbackasm1(SB) - MOVD $1275, R11 - BR callbackasm1(SB) - MOVD $1276, R11 - BR callbackasm1(SB) - MOVD $1277, R11 - BR callbackasm1(SB) - MOVD $1278, R11 - BR callbackasm1(SB) - MOVD $1279, R11 - BR callbackasm1(SB) - MOVD $1280, R11 - BR callbackasm1(SB) - MOVD $1281, R11 - BR callbackasm1(SB) - MOVD $1282, R11 - BR callbackasm1(SB) - MOVD $1283, R11 - BR callbackasm1(SB) - MOVD $1284, R11 - BR callbackasm1(SB) - MOVD $1285, R11 - BR callbackasm1(SB) - MOVD $1286, R11 - BR callbackasm1(SB) - MOVD $1287, R11 - BR callbackasm1(SB) - MOVD $1288, R11 - BR callbackasm1(SB) - MOVD $1289, R11 - BR callbackasm1(SB) - MOVD $1290, R11 - BR callbackasm1(SB) - MOVD $1291, R11 - BR callbackasm1(SB) - MOVD $1292, R11 - BR callbackasm1(SB) - MOVD $1293, R11 - BR callbackasm1(SB) - MOVD $1294, R11 - BR callbackasm1(SB) - MOVD $1295, R11 - BR callbackasm1(SB) - MOVD $1296, R11 - BR callbackasm1(SB) - MOVD $1297, R11 - BR callbackasm1(SB) - MOVD $1298, R11 - BR callbackasm1(SB) - MOVD $1299, R11 - BR callbackasm1(SB) - MOVD $1300, R11 - BR callbackasm1(SB) - MOVD $1301, R11 - BR callbackasm1(SB) - MOVD $1302, R11 - BR callbackasm1(SB) - MOVD $1303, R11 - BR callbackasm1(SB) - MOVD $1304, R11 - BR callbackasm1(SB) - MOVD $1305, R11 - BR callbackasm1(SB) - MOVD $1306, R11 - BR callbackasm1(SB) - MOVD $1307, R11 - BR callbackasm1(SB) - MOVD $1308, R11 - BR callbackasm1(SB) - MOVD $1309, R11 - BR callbackasm1(SB) - MOVD $1310, R11 - BR callbackasm1(SB) - MOVD $1311, R11 - BR callbackasm1(SB) - MOVD $1312, R11 - BR callbackasm1(SB) - MOVD $1313, R11 - BR callbackasm1(SB) - MOVD $1314, R11 - BR callbackasm1(SB) - MOVD $1315, R11 - BR callbackasm1(SB) - MOVD $1316, R11 - BR callbackasm1(SB) - MOVD $1317, R11 - BR callbackasm1(SB) - MOVD $1318, R11 - BR callbackasm1(SB) - MOVD $1319, R11 - BR callbackasm1(SB) - MOVD $1320, R11 - BR callbackasm1(SB) - MOVD $1321, R11 - BR callbackasm1(SB) - MOVD $1322, R11 - BR callbackasm1(SB) - MOVD $1323, R11 - BR callbackasm1(SB) - MOVD $1324, R11 - BR callbackasm1(SB) - MOVD $1325, R11 - BR callbackasm1(SB) - MOVD $1326, R11 - BR callbackasm1(SB) - MOVD $1327, R11 - BR callbackasm1(SB) - MOVD $1328, R11 - BR callbackasm1(SB) - MOVD $1329, R11 - BR callbackasm1(SB) - MOVD $1330, R11 - BR callbackasm1(SB) - MOVD $1331, R11 - BR callbackasm1(SB) - MOVD $1332, R11 - BR callbackasm1(SB) - MOVD $1333, R11 - BR callbackasm1(SB) - MOVD $1334, R11 - BR callbackasm1(SB) - MOVD $1335, R11 - BR callbackasm1(SB) - MOVD $1336, R11 - BR callbackasm1(SB) - MOVD $1337, R11 - BR callbackasm1(SB) - MOVD $1338, R11 - BR callbackasm1(SB) - MOVD $1339, R11 - BR callbackasm1(SB) - MOVD $1340, R11 - BR callbackasm1(SB) - MOVD $1341, R11 - BR callbackasm1(SB) - MOVD $1342, R11 - BR callbackasm1(SB) - MOVD $1343, R11 - BR callbackasm1(SB) - MOVD $1344, R11 - BR callbackasm1(SB) - MOVD $1345, R11 - BR callbackasm1(SB) - MOVD $1346, R11 - BR callbackasm1(SB) - MOVD $1347, R11 - BR callbackasm1(SB) - MOVD $1348, R11 - BR callbackasm1(SB) - MOVD $1349, R11 - BR callbackasm1(SB) - MOVD $1350, R11 - BR callbackasm1(SB) - MOVD $1351, R11 - BR callbackasm1(SB) - MOVD $1352, R11 - BR callbackasm1(SB) - MOVD $1353, R11 - BR callbackasm1(SB) - MOVD $1354, R11 - BR callbackasm1(SB) - MOVD $1355, R11 - BR callbackasm1(SB) - MOVD $1356, R11 - BR callbackasm1(SB) - MOVD $1357, R11 - BR callbackasm1(SB) - MOVD $1358, R11 - BR callbackasm1(SB) - MOVD $1359, R11 - BR callbackasm1(SB) - MOVD $1360, R11 - BR callbackasm1(SB) - MOVD $1361, R11 - BR callbackasm1(SB) - MOVD $1362, R11 - BR callbackasm1(SB) - MOVD $1363, R11 - BR callbackasm1(SB) - MOVD $1364, R11 - BR callbackasm1(SB) - MOVD $1365, R11 - BR callbackasm1(SB) - MOVD $1366, R11 - BR callbackasm1(SB) - MOVD $1367, R11 - BR callbackasm1(SB) - MOVD $1368, R11 - BR callbackasm1(SB) - MOVD $1369, R11 - BR callbackasm1(SB) - MOVD $1370, R11 - BR callbackasm1(SB) - MOVD $1371, R11 - BR callbackasm1(SB) - MOVD $1372, R11 - BR callbackasm1(SB) - MOVD $1373, R11 - BR callbackasm1(SB) - MOVD $1374, R11 - BR callbackasm1(SB) - MOVD $1375, R11 - BR callbackasm1(SB) - MOVD $1376, R11 - BR callbackasm1(SB) - MOVD $1377, R11 - BR callbackasm1(SB) - MOVD $1378, R11 - BR callbackasm1(SB) - MOVD $1379, R11 - BR callbackasm1(SB) - MOVD $1380, R11 - BR callbackasm1(SB) - MOVD $1381, R11 - BR callbackasm1(SB) - MOVD $1382, R11 - BR callbackasm1(SB) - MOVD $1383, R11 - BR callbackasm1(SB) - MOVD $1384, R11 - BR callbackasm1(SB) - MOVD $1385, R11 - BR callbackasm1(SB) - MOVD $1386, R11 - BR callbackasm1(SB) - MOVD $1387, R11 - BR callbackasm1(SB) - MOVD $1388, R11 - BR callbackasm1(SB) - MOVD $1389, R11 - BR callbackasm1(SB) - MOVD $1390, R11 - BR callbackasm1(SB) - MOVD $1391, R11 - BR callbackasm1(SB) - MOVD $1392, R11 - BR callbackasm1(SB) - MOVD $1393, R11 - BR callbackasm1(SB) - MOVD $1394, R11 - BR callbackasm1(SB) - MOVD $1395, R11 - BR callbackasm1(SB) - MOVD $1396, R11 - BR callbackasm1(SB) - MOVD $1397, R11 - BR callbackasm1(SB) - MOVD $1398, R11 - BR callbackasm1(SB) - MOVD $1399, R11 - BR callbackasm1(SB) - MOVD $1400, R11 - BR callbackasm1(SB) - MOVD $1401, R11 - BR callbackasm1(SB) - MOVD $1402, R11 - BR callbackasm1(SB) - MOVD $1403, R11 - BR callbackasm1(SB) - MOVD $1404, R11 - BR callbackasm1(SB) - MOVD $1405, R11 - BR callbackasm1(SB) - MOVD $1406, R11 - BR callbackasm1(SB) - MOVD $1407, R11 - BR callbackasm1(SB) - MOVD $1408, R11 - BR callbackasm1(SB) - MOVD $1409, R11 - BR callbackasm1(SB) - MOVD $1410, R11 - BR callbackasm1(SB) - MOVD $1411, R11 - BR callbackasm1(SB) - MOVD $1412, R11 - BR callbackasm1(SB) - MOVD $1413, R11 - BR callbackasm1(SB) - MOVD $1414, R11 - BR callbackasm1(SB) - MOVD $1415, R11 - BR callbackasm1(SB) - MOVD $1416, R11 - BR callbackasm1(SB) - MOVD $1417, R11 - BR callbackasm1(SB) - MOVD $1418, R11 - BR callbackasm1(SB) - MOVD $1419, R11 - BR callbackasm1(SB) - MOVD $1420, R11 - BR callbackasm1(SB) - MOVD $1421, R11 - BR callbackasm1(SB) - MOVD $1422, R11 - BR callbackasm1(SB) - MOVD $1423, R11 - BR callbackasm1(SB) - MOVD $1424, R11 - BR callbackasm1(SB) - MOVD $1425, R11 - BR callbackasm1(SB) - MOVD $1426, R11 - BR callbackasm1(SB) - MOVD $1427, R11 - BR callbackasm1(SB) - MOVD $1428, R11 - BR callbackasm1(SB) - MOVD $1429, R11 - BR callbackasm1(SB) - MOVD $1430, R11 - BR callbackasm1(SB) - MOVD $1431, R11 - BR callbackasm1(SB) - MOVD $1432, R11 - BR callbackasm1(SB) - MOVD $1433, R11 - BR callbackasm1(SB) - MOVD $1434, R11 - BR callbackasm1(SB) - MOVD $1435, R11 - BR callbackasm1(SB) - MOVD $1436, R11 - BR callbackasm1(SB) - MOVD $1437, R11 - BR callbackasm1(SB) - MOVD $1438, R11 - BR callbackasm1(SB) - MOVD $1439, R11 - BR callbackasm1(SB) - MOVD $1440, R11 - BR callbackasm1(SB) - MOVD $1441, R11 - BR callbackasm1(SB) - MOVD $1442, R11 - BR callbackasm1(SB) - MOVD $1443, R11 - BR callbackasm1(SB) - MOVD $1444, R11 - BR callbackasm1(SB) - MOVD $1445, R11 - BR callbackasm1(SB) - MOVD $1446, R11 - BR callbackasm1(SB) - MOVD $1447, R11 - BR callbackasm1(SB) - MOVD $1448, R11 - BR callbackasm1(SB) - MOVD $1449, R11 - BR callbackasm1(SB) - MOVD $1450, R11 - BR callbackasm1(SB) - MOVD $1451, R11 - BR callbackasm1(SB) - MOVD $1452, R11 - BR callbackasm1(SB) - MOVD $1453, R11 - BR callbackasm1(SB) - MOVD $1454, R11 - BR callbackasm1(SB) - MOVD $1455, R11 - BR callbackasm1(SB) - MOVD $1456, R11 - BR callbackasm1(SB) - MOVD $1457, R11 - BR callbackasm1(SB) - MOVD $1458, R11 - BR callbackasm1(SB) - MOVD $1459, R11 - BR callbackasm1(SB) - MOVD $1460, R11 - BR callbackasm1(SB) - MOVD $1461, R11 - BR callbackasm1(SB) - MOVD $1462, R11 - BR callbackasm1(SB) - MOVD $1463, R11 - BR callbackasm1(SB) - MOVD $1464, R11 - BR callbackasm1(SB) - MOVD $1465, R11 - BR callbackasm1(SB) - MOVD $1466, R11 - BR callbackasm1(SB) - MOVD $1467, R11 - BR callbackasm1(SB) - MOVD $1468, R11 - BR callbackasm1(SB) - MOVD $1469, R11 - BR callbackasm1(SB) - MOVD $1470, R11 - BR callbackasm1(SB) - MOVD $1471, R11 - BR callbackasm1(SB) - MOVD $1472, R11 - BR callbackasm1(SB) - MOVD $1473, R11 - BR callbackasm1(SB) - MOVD $1474, R11 - BR callbackasm1(SB) - MOVD $1475, R11 - BR callbackasm1(SB) - MOVD $1476, R11 - BR callbackasm1(SB) - MOVD $1477, R11 - BR callbackasm1(SB) - MOVD $1478, R11 - BR callbackasm1(SB) - MOVD $1479, R11 - BR callbackasm1(SB) - MOVD $1480, R11 - BR callbackasm1(SB) - MOVD $1481, R11 - BR callbackasm1(SB) - MOVD $1482, R11 - BR callbackasm1(SB) - MOVD $1483, R11 - BR callbackasm1(SB) - MOVD $1484, R11 - BR callbackasm1(SB) - MOVD $1485, R11 - BR callbackasm1(SB) - MOVD $1486, R11 - BR callbackasm1(SB) - MOVD $1487, R11 - BR callbackasm1(SB) - MOVD $1488, R11 - BR callbackasm1(SB) - MOVD $1489, R11 - BR callbackasm1(SB) - MOVD $1490, R11 - BR callbackasm1(SB) - MOVD $1491, R11 - BR callbackasm1(SB) - MOVD $1492, R11 - BR callbackasm1(SB) - MOVD $1493, R11 - BR callbackasm1(SB) - MOVD $1494, R11 - BR callbackasm1(SB) - MOVD $1495, R11 - BR callbackasm1(SB) - MOVD $1496, R11 - BR callbackasm1(SB) - MOVD $1497, R11 - BR callbackasm1(SB) - MOVD $1498, R11 - BR callbackasm1(SB) - MOVD $1499, R11 - BR callbackasm1(SB) - MOVD $1500, R11 - BR callbackasm1(SB) - MOVD $1501, R11 - BR callbackasm1(SB) - MOVD $1502, R11 - BR callbackasm1(SB) - MOVD $1503, R11 - BR callbackasm1(SB) - MOVD $1504, R11 - BR callbackasm1(SB) - MOVD $1505, R11 - BR callbackasm1(SB) - MOVD $1506, R11 - BR callbackasm1(SB) - MOVD $1507, R11 - BR callbackasm1(SB) - MOVD $1508, R11 - BR callbackasm1(SB) - MOVD $1509, R11 - BR callbackasm1(SB) - MOVD $1510, R11 - BR callbackasm1(SB) - MOVD $1511, R11 - BR callbackasm1(SB) - MOVD $1512, R11 - BR callbackasm1(SB) - MOVD $1513, R11 - BR callbackasm1(SB) - MOVD $1514, R11 - BR callbackasm1(SB) - MOVD $1515, R11 - BR callbackasm1(SB) - MOVD $1516, R11 - BR callbackasm1(SB) - MOVD $1517, R11 - BR callbackasm1(SB) - MOVD $1518, R11 - BR callbackasm1(SB) - MOVD $1519, R11 - BR callbackasm1(SB) - MOVD $1520, R11 - BR callbackasm1(SB) - MOVD $1521, R11 - BR callbackasm1(SB) - MOVD $1522, R11 - BR callbackasm1(SB) - MOVD $1523, R11 - BR callbackasm1(SB) - MOVD $1524, R11 - BR callbackasm1(SB) - MOVD $1525, R11 - BR callbackasm1(SB) - MOVD $1526, R11 - BR callbackasm1(SB) - MOVD $1527, R11 - BR callbackasm1(SB) - MOVD $1528, R11 - BR callbackasm1(SB) - MOVD $1529, R11 - BR callbackasm1(SB) - MOVD $1530, R11 - BR callbackasm1(SB) - MOVD $1531, R11 - BR callbackasm1(SB) - MOVD $1532, R11 - BR callbackasm1(SB) - MOVD $1533, R11 - BR callbackasm1(SB) - MOVD $1534, R11 - BR callbackasm1(SB) - MOVD $1535, R11 - BR callbackasm1(SB) - MOVD $1536, R11 - BR callbackasm1(SB) - MOVD $1537, R11 - BR callbackasm1(SB) - MOVD $1538, R11 - BR callbackasm1(SB) - MOVD $1539, R11 - BR callbackasm1(SB) - MOVD $1540, R11 - BR callbackasm1(SB) - MOVD $1541, R11 - BR callbackasm1(SB) - MOVD $1542, R11 - BR callbackasm1(SB) - MOVD $1543, R11 - BR callbackasm1(SB) - MOVD $1544, R11 - BR callbackasm1(SB) - MOVD $1545, R11 - BR callbackasm1(SB) - MOVD $1546, R11 - BR callbackasm1(SB) - MOVD $1547, R11 - BR callbackasm1(SB) - MOVD $1548, R11 - BR callbackasm1(SB) - MOVD $1549, R11 - BR callbackasm1(SB) - MOVD $1550, R11 - BR callbackasm1(SB) - MOVD $1551, R11 - BR callbackasm1(SB) - MOVD $1552, R11 - BR callbackasm1(SB) - MOVD $1553, R11 - BR callbackasm1(SB) - MOVD $1554, R11 - BR callbackasm1(SB) - MOVD $1555, R11 - BR callbackasm1(SB) - MOVD $1556, R11 - BR callbackasm1(SB) - MOVD $1557, R11 - BR callbackasm1(SB) - MOVD $1558, R11 - BR callbackasm1(SB) - MOVD $1559, R11 - BR callbackasm1(SB) - MOVD $1560, R11 - BR callbackasm1(SB) - MOVD $1561, R11 - BR callbackasm1(SB) - MOVD $1562, R11 - BR callbackasm1(SB) - MOVD $1563, R11 - BR callbackasm1(SB) - MOVD $1564, R11 - BR callbackasm1(SB) - MOVD $1565, R11 - BR callbackasm1(SB) - MOVD $1566, R11 - BR callbackasm1(SB) - MOVD $1567, R11 - BR callbackasm1(SB) - MOVD $1568, R11 - BR callbackasm1(SB) - MOVD $1569, R11 - BR callbackasm1(SB) - MOVD $1570, R11 - BR callbackasm1(SB) - MOVD $1571, R11 - BR callbackasm1(SB) - MOVD $1572, R11 - BR callbackasm1(SB) - MOVD $1573, R11 - BR callbackasm1(SB) - MOVD $1574, R11 - BR callbackasm1(SB) - MOVD $1575, R11 - BR callbackasm1(SB) - MOVD $1576, R11 - BR callbackasm1(SB) - MOVD $1577, R11 - BR callbackasm1(SB) - MOVD $1578, R11 - BR callbackasm1(SB) - MOVD $1579, R11 - BR callbackasm1(SB) - MOVD $1580, R11 - BR callbackasm1(SB) - MOVD $1581, R11 - BR callbackasm1(SB) - MOVD $1582, R11 - BR callbackasm1(SB) - MOVD $1583, R11 - BR callbackasm1(SB) - MOVD $1584, R11 - BR callbackasm1(SB) - MOVD $1585, R11 - BR callbackasm1(SB) - MOVD $1586, R11 - BR callbackasm1(SB) - MOVD $1587, R11 - BR callbackasm1(SB) - MOVD $1588, R11 - BR callbackasm1(SB) - MOVD $1589, R11 - BR callbackasm1(SB) - MOVD $1590, R11 - BR callbackasm1(SB) - MOVD $1591, R11 - BR callbackasm1(SB) - MOVD $1592, R11 - BR callbackasm1(SB) - MOVD $1593, R11 - BR callbackasm1(SB) - MOVD $1594, R11 - BR callbackasm1(SB) - MOVD $1595, R11 - BR callbackasm1(SB) - MOVD $1596, R11 - BR callbackasm1(SB) - MOVD $1597, R11 - BR callbackasm1(SB) - MOVD $1598, R11 - BR callbackasm1(SB) - MOVD $1599, R11 - BR callbackasm1(SB) - MOVD $1600, R11 - BR callbackasm1(SB) - MOVD $1601, R11 - BR callbackasm1(SB) - MOVD $1602, R11 - BR callbackasm1(SB) - MOVD $1603, R11 - BR callbackasm1(SB) - MOVD $1604, R11 - BR callbackasm1(SB) - MOVD $1605, R11 - BR callbackasm1(SB) - MOVD $1606, R11 - BR callbackasm1(SB) - MOVD $1607, R11 - BR callbackasm1(SB) - MOVD $1608, R11 - BR callbackasm1(SB) - MOVD $1609, R11 - BR callbackasm1(SB) - MOVD $1610, R11 - BR callbackasm1(SB) - MOVD $1611, R11 - BR callbackasm1(SB) - MOVD $1612, R11 - BR callbackasm1(SB) - MOVD $1613, R11 - BR callbackasm1(SB) - MOVD $1614, R11 - BR callbackasm1(SB) - MOVD $1615, R11 - BR callbackasm1(SB) - MOVD $1616, R11 - BR callbackasm1(SB) - MOVD $1617, R11 - BR callbackasm1(SB) - MOVD $1618, R11 - BR callbackasm1(SB) - MOVD $1619, R11 - BR callbackasm1(SB) - MOVD $1620, R11 - BR callbackasm1(SB) - MOVD $1621, R11 - BR callbackasm1(SB) - MOVD $1622, R11 - BR callbackasm1(SB) - MOVD $1623, R11 - BR callbackasm1(SB) - MOVD $1624, R11 - BR callbackasm1(SB) - MOVD $1625, R11 - BR callbackasm1(SB) - MOVD $1626, R11 - BR callbackasm1(SB) - MOVD $1627, R11 - BR callbackasm1(SB) - MOVD $1628, R11 - BR callbackasm1(SB) - MOVD $1629, R11 - BR callbackasm1(SB) - MOVD $1630, R11 - BR callbackasm1(SB) - MOVD $1631, R11 - BR callbackasm1(SB) - MOVD $1632, R11 - BR callbackasm1(SB) - MOVD $1633, R11 - BR callbackasm1(SB) - MOVD $1634, R11 - BR callbackasm1(SB) - MOVD $1635, R11 - BR callbackasm1(SB) - MOVD $1636, R11 - BR callbackasm1(SB) - MOVD $1637, R11 - BR callbackasm1(SB) - MOVD $1638, R11 - BR callbackasm1(SB) - MOVD $1639, R11 - BR callbackasm1(SB) - MOVD $1640, R11 - BR callbackasm1(SB) - MOVD $1641, R11 - BR callbackasm1(SB) - MOVD $1642, R11 - BR callbackasm1(SB) - MOVD $1643, R11 - BR callbackasm1(SB) - MOVD $1644, R11 - BR callbackasm1(SB) - MOVD $1645, R11 - BR callbackasm1(SB) - MOVD $1646, R11 - BR callbackasm1(SB) - MOVD $1647, R11 - BR callbackasm1(SB) - MOVD $1648, R11 - BR callbackasm1(SB) - MOVD $1649, R11 - BR callbackasm1(SB) - MOVD $1650, R11 - BR callbackasm1(SB) - MOVD $1651, R11 - BR callbackasm1(SB) - MOVD $1652, R11 - BR callbackasm1(SB) - MOVD $1653, R11 - BR callbackasm1(SB) - MOVD $1654, R11 - BR callbackasm1(SB) - MOVD $1655, R11 - BR callbackasm1(SB) - MOVD $1656, R11 - BR callbackasm1(SB) - MOVD $1657, R11 - BR callbackasm1(SB) - MOVD $1658, R11 - BR callbackasm1(SB) - MOVD $1659, R11 - BR callbackasm1(SB) - MOVD $1660, R11 - BR callbackasm1(SB) - MOVD $1661, R11 - BR callbackasm1(SB) - MOVD $1662, R11 - BR callbackasm1(SB) - MOVD $1663, R11 - BR callbackasm1(SB) - MOVD $1664, R11 - BR callbackasm1(SB) - MOVD $1665, R11 - BR callbackasm1(SB) - MOVD $1666, R11 - BR callbackasm1(SB) - MOVD $1667, R11 - BR callbackasm1(SB) - MOVD $1668, R11 - BR callbackasm1(SB) - MOVD $1669, R11 - BR callbackasm1(SB) - MOVD $1670, R11 - BR callbackasm1(SB) - MOVD $1671, R11 - BR callbackasm1(SB) - MOVD $1672, R11 - BR callbackasm1(SB) - MOVD $1673, R11 - BR callbackasm1(SB) - MOVD $1674, R11 - BR callbackasm1(SB) - MOVD $1675, R11 - BR callbackasm1(SB) - MOVD $1676, R11 - BR callbackasm1(SB) - MOVD $1677, R11 - BR callbackasm1(SB) - MOVD $1678, R11 - BR callbackasm1(SB) - MOVD $1679, R11 - BR callbackasm1(SB) - MOVD $1680, R11 - BR callbackasm1(SB) - MOVD $1681, R11 - BR callbackasm1(SB) - MOVD $1682, R11 - BR callbackasm1(SB) - MOVD $1683, R11 - BR callbackasm1(SB) - MOVD $1684, R11 - BR callbackasm1(SB) - MOVD $1685, R11 - BR callbackasm1(SB) - MOVD $1686, R11 - BR callbackasm1(SB) - MOVD $1687, R11 - BR callbackasm1(SB) - MOVD $1688, R11 - BR callbackasm1(SB) - MOVD $1689, R11 - BR callbackasm1(SB) - MOVD $1690, R11 - BR callbackasm1(SB) - MOVD $1691, R11 - BR callbackasm1(SB) - MOVD $1692, R11 - BR callbackasm1(SB) - MOVD $1693, R11 - BR callbackasm1(SB) - MOVD $1694, R11 - BR callbackasm1(SB) - MOVD $1695, R11 - BR callbackasm1(SB) - MOVD $1696, R11 - BR callbackasm1(SB) - MOVD $1697, R11 - BR callbackasm1(SB) - MOVD $1698, R11 - BR callbackasm1(SB) - MOVD $1699, R11 - BR callbackasm1(SB) - MOVD $1700, R11 - BR callbackasm1(SB) - MOVD $1701, R11 - BR callbackasm1(SB) - MOVD $1702, R11 - BR callbackasm1(SB) - MOVD $1703, R11 - BR callbackasm1(SB) - MOVD $1704, R11 - BR callbackasm1(SB) - MOVD $1705, R11 - BR callbackasm1(SB) - MOVD $1706, R11 - BR callbackasm1(SB) - MOVD $1707, R11 - BR callbackasm1(SB) - MOVD $1708, R11 - BR callbackasm1(SB) - MOVD $1709, R11 - BR callbackasm1(SB) - MOVD $1710, R11 - BR callbackasm1(SB) - MOVD $1711, R11 - BR callbackasm1(SB) - MOVD $1712, R11 - BR callbackasm1(SB) - MOVD $1713, R11 - BR callbackasm1(SB) - MOVD $1714, R11 - BR callbackasm1(SB) - MOVD $1715, R11 - BR callbackasm1(SB) - MOVD $1716, R11 - BR callbackasm1(SB) - MOVD $1717, R11 - BR callbackasm1(SB) - MOVD $1718, R11 - BR callbackasm1(SB) - MOVD $1719, R11 - BR callbackasm1(SB) - MOVD $1720, R11 - BR callbackasm1(SB) - MOVD $1721, R11 - BR callbackasm1(SB) - MOVD $1722, R11 - BR callbackasm1(SB) - MOVD $1723, R11 - BR callbackasm1(SB) - MOVD $1724, R11 - BR callbackasm1(SB) - MOVD $1725, R11 - BR callbackasm1(SB) - MOVD $1726, R11 - BR callbackasm1(SB) - MOVD $1727, R11 - BR callbackasm1(SB) - MOVD $1728, R11 - BR callbackasm1(SB) - MOVD $1729, R11 - BR callbackasm1(SB) - MOVD $1730, R11 - BR callbackasm1(SB) - MOVD $1731, R11 - BR callbackasm1(SB) - MOVD $1732, R11 - BR callbackasm1(SB) - MOVD $1733, R11 - BR callbackasm1(SB) - MOVD $1734, R11 - BR callbackasm1(SB) - MOVD $1735, R11 - BR callbackasm1(SB) - MOVD $1736, R11 - BR callbackasm1(SB) - MOVD $1737, R11 - BR callbackasm1(SB) - MOVD $1738, R11 - BR callbackasm1(SB) - MOVD $1739, R11 - BR callbackasm1(SB) - MOVD $1740, R11 - BR callbackasm1(SB) - MOVD $1741, R11 - BR callbackasm1(SB) - MOVD $1742, R11 - BR callbackasm1(SB) - MOVD $1743, R11 - BR callbackasm1(SB) - MOVD $1744, R11 - BR callbackasm1(SB) - MOVD $1745, R11 - BR callbackasm1(SB) - MOVD $1746, R11 - BR callbackasm1(SB) - MOVD $1747, R11 - BR callbackasm1(SB) - MOVD $1748, R11 - BR callbackasm1(SB) - MOVD $1749, R11 - BR callbackasm1(SB) - MOVD $1750, R11 - BR callbackasm1(SB) - MOVD $1751, R11 - BR callbackasm1(SB) - MOVD $1752, R11 - BR callbackasm1(SB) - MOVD $1753, R11 - BR callbackasm1(SB) - MOVD $1754, R11 - BR callbackasm1(SB) - MOVD $1755, R11 - BR callbackasm1(SB) - MOVD $1756, R11 - BR callbackasm1(SB) - MOVD $1757, R11 - BR callbackasm1(SB) - MOVD $1758, R11 - BR callbackasm1(SB) - MOVD $1759, R11 - BR callbackasm1(SB) - MOVD $1760, R11 - BR callbackasm1(SB) - MOVD $1761, R11 - BR callbackasm1(SB) - MOVD $1762, R11 - BR callbackasm1(SB) - MOVD $1763, R11 - BR callbackasm1(SB) - MOVD $1764, R11 - BR callbackasm1(SB) - MOVD $1765, R11 - BR callbackasm1(SB) - MOVD $1766, R11 - BR callbackasm1(SB) - MOVD $1767, R11 - BR callbackasm1(SB) - MOVD $1768, R11 - BR callbackasm1(SB) - MOVD $1769, R11 - BR callbackasm1(SB) - MOVD $1770, R11 - BR callbackasm1(SB) - MOVD $1771, R11 - BR callbackasm1(SB) - MOVD $1772, R11 - BR callbackasm1(SB) - MOVD $1773, R11 - BR callbackasm1(SB) - MOVD $1774, R11 - BR callbackasm1(SB) - MOVD $1775, R11 - BR callbackasm1(SB) - MOVD $1776, R11 - BR callbackasm1(SB) - MOVD $1777, R11 - BR callbackasm1(SB) - MOVD $1778, R11 - BR callbackasm1(SB) - MOVD $1779, R11 - BR callbackasm1(SB) - MOVD $1780, R11 - BR callbackasm1(SB) - MOVD $1781, R11 - BR callbackasm1(SB) - MOVD $1782, R11 - BR callbackasm1(SB) - MOVD $1783, R11 - BR callbackasm1(SB) - MOVD $1784, R11 - BR callbackasm1(SB) - MOVD $1785, R11 - BR callbackasm1(SB) - MOVD $1786, R11 - BR callbackasm1(SB) - MOVD $1787, R11 - BR callbackasm1(SB) - MOVD $1788, R11 - BR callbackasm1(SB) - MOVD $1789, R11 - BR callbackasm1(SB) - MOVD $1790, R11 - BR callbackasm1(SB) - MOVD $1791, R11 - BR callbackasm1(SB) - MOVD $1792, R11 - BR callbackasm1(SB) - MOVD $1793, R11 - BR callbackasm1(SB) - MOVD $1794, R11 - BR callbackasm1(SB) - MOVD $1795, R11 - BR callbackasm1(SB) - MOVD $1796, R11 - BR callbackasm1(SB) - MOVD $1797, R11 - BR callbackasm1(SB) - MOVD $1798, R11 - BR callbackasm1(SB) - MOVD $1799, R11 - BR callbackasm1(SB) - MOVD $1800, R11 - BR callbackasm1(SB) - MOVD $1801, R11 - BR callbackasm1(SB) - MOVD $1802, R11 - BR callbackasm1(SB) - MOVD $1803, R11 - BR callbackasm1(SB) - MOVD $1804, R11 - BR callbackasm1(SB) - MOVD $1805, R11 - BR callbackasm1(SB) - MOVD $1806, R11 - BR callbackasm1(SB) - MOVD $1807, R11 - BR callbackasm1(SB) - MOVD $1808, R11 - BR callbackasm1(SB) - MOVD $1809, R11 - BR callbackasm1(SB) - MOVD $1810, R11 - BR callbackasm1(SB) - MOVD $1811, R11 - BR callbackasm1(SB) - MOVD $1812, R11 - BR callbackasm1(SB) - MOVD $1813, R11 - BR callbackasm1(SB) - MOVD $1814, R11 - BR callbackasm1(SB) - MOVD $1815, R11 - BR callbackasm1(SB) - MOVD $1816, R11 - BR callbackasm1(SB) - MOVD $1817, R11 - BR callbackasm1(SB) - MOVD $1818, R11 - BR callbackasm1(SB) - MOVD $1819, R11 - BR callbackasm1(SB) - MOVD $1820, R11 - BR callbackasm1(SB) - MOVD $1821, R11 - BR callbackasm1(SB) - MOVD $1822, R11 - BR callbackasm1(SB) - MOVD $1823, R11 - BR callbackasm1(SB) - MOVD $1824, R11 - BR callbackasm1(SB) - MOVD $1825, R11 - BR callbackasm1(SB) - MOVD $1826, R11 - BR callbackasm1(SB) - MOVD $1827, R11 - BR callbackasm1(SB) - MOVD $1828, R11 - BR callbackasm1(SB) - MOVD $1829, R11 - BR callbackasm1(SB) - MOVD $1830, R11 - BR callbackasm1(SB) - MOVD $1831, R11 - BR callbackasm1(SB) - MOVD $1832, R11 - BR callbackasm1(SB) - MOVD $1833, R11 - BR callbackasm1(SB) - MOVD $1834, R11 - BR callbackasm1(SB) - MOVD $1835, R11 - BR callbackasm1(SB) - MOVD $1836, R11 - BR callbackasm1(SB) - MOVD $1837, R11 - BR callbackasm1(SB) - MOVD $1838, R11 - BR callbackasm1(SB) - MOVD $1839, R11 - BR callbackasm1(SB) - MOVD $1840, R11 - BR callbackasm1(SB) - MOVD $1841, R11 - BR callbackasm1(SB) - MOVD $1842, R11 - BR callbackasm1(SB) - MOVD $1843, R11 - BR callbackasm1(SB) - MOVD $1844, R11 - BR callbackasm1(SB) - MOVD $1845, R11 - BR callbackasm1(SB) - MOVD $1846, R11 - BR callbackasm1(SB) - MOVD $1847, R11 - BR callbackasm1(SB) - MOVD $1848, R11 - BR callbackasm1(SB) - MOVD $1849, R11 - BR callbackasm1(SB) - MOVD $1850, R11 - BR callbackasm1(SB) - MOVD $1851, R11 - BR callbackasm1(SB) - MOVD $1852, R11 - BR callbackasm1(SB) - MOVD $1853, R11 - BR callbackasm1(SB) - MOVD $1854, R11 - BR callbackasm1(SB) - MOVD $1855, R11 - BR callbackasm1(SB) - MOVD $1856, R11 - BR callbackasm1(SB) - MOVD $1857, R11 - BR callbackasm1(SB) - MOVD $1858, R11 - BR callbackasm1(SB) - MOVD $1859, R11 - BR callbackasm1(SB) - MOVD $1860, R11 - BR callbackasm1(SB) - MOVD $1861, R11 - BR callbackasm1(SB) - MOVD $1862, R11 - BR callbackasm1(SB) - MOVD $1863, R11 - BR callbackasm1(SB) - MOVD $1864, R11 - BR callbackasm1(SB) - MOVD $1865, R11 - BR callbackasm1(SB) - MOVD $1866, R11 - BR callbackasm1(SB) - MOVD $1867, R11 - BR callbackasm1(SB) - MOVD $1868, R11 - BR callbackasm1(SB) - MOVD $1869, R11 - BR callbackasm1(SB) - MOVD $1870, R11 - BR callbackasm1(SB) - MOVD $1871, R11 - BR callbackasm1(SB) - MOVD $1872, R11 - BR callbackasm1(SB) - MOVD $1873, R11 - BR callbackasm1(SB) - MOVD $1874, R11 - BR callbackasm1(SB) - MOVD $1875, R11 - BR callbackasm1(SB) - MOVD $1876, R11 - BR callbackasm1(SB) - MOVD $1877, R11 - BR callbackasm1(SB) - MOVD $1878, R11 - BR callbackasm1(SB) - MOVD $1879, R11 - BR callbackasm1(SB) - MOVD $1880, R11 - BR callbackasm1(SB) - MOVD $1881, R11 - BR callbackasm1(SB) - MOVD $1882, R11 - BR callbackasm1(SB) - MOVD $1883, R11 - BR callbackasm1(SB) - MOVD $1884, R11 - BR callbackasm1(SB) - MOVD $1885, R11 - BR callbackasm1(SB) - MOVD $1886, R11 - BR callbackasm1(SB) - MOVD $1887, R11 - BR callbackasm1(SB) - MOVD $1888, R11 - BR callbackasm1(SB) - MOVD $1889, R11 - BR callbackasm1(SB) - MOVD $1890, R11 - BR callbackasm1(SB) - MOVD $1891, R11 - BR callbackasm1(SB) - MOVD $1892, R11 - BR callbackasm1(SB) - MOVD $1893, R11 - BR callbackasm1(SB) - MOVD $1894, R11 - BR callbackasm1(SB) - MOVD $1895, R11 - BR callbackasm1(SB) - MOVD $1896, R11 - BR callbackasm1(SB) - MOVD $1897, R11 - BR callbackasm1(SB) - MOVD $1898, R11 - BR callbackasm1(SB) - MOVD $1899, R11 - BR callbackasm1(SB) - MOVD $1900, R11 - BR callbackasm1(SB) - MOVD $1901, R11 - BR callbackasm1(SB) - MOVD $1902, R11 - BR callbackasm1(SB) - MOVD $1903, R11 - BR callbackasm1(SB) - MOVD $1904, R11 - BR callbackasm1(SB) - MOVD $1905, R11 - BR callbackasm1(SB) - MOVD $1906, R11 - BR callbackasm1(SB) - MOVD $1907, R11 - BR callbackasm1(SB) - MOVD $1908, R11 - BR callbackasm1(SB) - MOVD $1909, R11 - BR callbackasm1(SB) - MOVD $1910, R11 - BR callbackasm1(SB) - MOVD $1911, R11 - BR callbackasm1(SB) - MOVD $1912, R11 - BR callbackasm1(SB) - MOVD $1913, R11 - BR callbackasm1(SB) - MOVD $1914, R11 - BR callbackasm1(SB) - MOVD $1915, R11 - BR callbackasm1(SB) - MOVD $1916, R11 - BR callbackasm1(SB) - MOVD $1917, R11 - BR callbackasm1(SB) - MOVD $1918, R11 - BR callbackasm1(SB) - MOVD $1919, R11 - BR callbackasm1(SB) - MOVD $1920, R11 - BR callbackasm1(SB) - MOVD $1921, R11 - BR callbackasm1(SB) - MOVD $1922, R11 - BR callbackasm1(SB) - MOVD $1923, R11 - BR callbackasm1(SB) - MOVD $1924, R11 - BR callbackasm1(SB) - MOVD $1925, R11 - BR callbackasm1(SB) - MOVD $1926, R11 - BR callbackasm1(SB) - MOVD $1927, R11 - BR callbackasm1(SB) - MOVD $1928, R11 - BR callbackasm1(SB) - MOVD $1929, R11 - BR callbackasm1(SB) - MOVD $1930, R11 - BR callbackasm1(SB) - MOVD $1931, R11 - BR callbackasm1(SB) - MOVD $1932, R11 - BR callbackasm1(SB) - MOVD $1933, R11 - BR callbackasm1(SB) - MOVD $1934, R11 - BR callbackasm1(SB) - MOVD $1935, R11 - BR callbackasm1(SB) - MOVD $1936, R11 - BR callbackasm1(SB) - MOVD $1937, R11 - BR callbackasm1(SB) - MOVD $1938, R11 - BR callbackasm1(SB) - MOVD $1939, R11 - BR callbackasm1(SB) - MOVD $1940, R11 - BR callbackasm1(SB) - MOVD $1941, R11 - BR callbackasm1(SB) - MOVD $1942, R11 - BR callbackasm1(SB) - MOVD $1943, R11 - BR callbackasm1(SB) - MOVD $1944, R11 - BR callbackasm1(SB) - MOVD $1945, R11 - BR callbackasm1(SB) - MOVD $1946, R11 - BR callbackasm1(SB) - MOVD $1947, R11 - BR callbackasm1(SB) - MOVD $1948, R11 - BR callbackasm1(SB) - MOVD $1949, R11 - BR callbackasm1(SB) - MOVD $1950, R11 - BR callbackasm1(SB) - MOVD $1951, R11 - BR callbackasm1(SB) - MOVD $1952, R11 - BR callbackasm1(SB) - MOVD $1953, R11 - BR callbackasm1(SB) - MOVD $1954, R11 - BR callbackasm1(SB) - MOVD $1955, R11 - BR callbackasm1(SB) - MOVD $1956, R11 - BR callbackasm1(SB) - MOVD $1957, R11 - BR callbackasm1(SB) - MOVD $1958, R11 - BR callbackasm1(SB) - MOVD $1959, R11 - BR callbackasm1(SB) - MOVD $1960, R11 - BR callbackasm1(SB) - MOVD $1961, R11 - BR callbackasm1(SB) - MOVD $1962, R11 - BR callbackasm1(SB) - MOVD $1963, R11 - BR callbackasm1(SB) - MOVD $1964, R11 - BR callbackasm1(SB) - MOVD $1965, R11 - BR callbackasm1(SB) - MOVD $1966, R11 - BR callbackasm1(SB) - MOVD $1967, R11 - BR callbackasm1(SB) - MOVD $1968, R11 - BR callbackasm1(SB) - MOVD $1969, R11 - BR callbackasm1(SB) - MOVD $1970, R11 - BR callbackasm1(SB) - MOVD $1971, R11 - BR callbackasm1(SB) - MOVD $1972, R11 - BR callbackasm1(SB) - MOVD $1973, R11 - BR callbackasm1(SB) - MOVD $1974, R11 - BR callbackasm1(SB) - MOVD $1975, R11 - BR callbackasm1(SB) - MOVD $1976, R11 - BR callbackasm1(SB) - MOVD $1977, R11 - BR callbackasm1(SB) - MOVD $1978, R11 - BR callbackasm1(SB) - MOVD $1979, R11 - BR callbackasm1(SB) - MOVD $1980, R11 - BR callbackasm1(SB) - MOVD $1981, R11 - BR callbackasm1(SB) - MOVD $1982, R11 - BR callbackasm1(SB) - MOVD $1983, R11 - BR callbackasm1(SB) - MOVD $1984, R11 - BR callbackasm1(SB) - MOVD $1985, R11 - BR callbackasm1(SB) - MOVD $1986, R11 - BR callbackasm1(SB) - MOVD $1987, R11 - BR callbackasm1(SB) - MOVD $1988, R11 - BR callbackasm1(SB) - MOVD $1989, R11 - BR callbackasm1(SB) - MOVD $1990, R11 - BR callbackasm1(SB) - MOVD $1991, R11 - BR callbackasm1(SB) - MOVD $1992, R11 - BR callbackasm1(SB) - MOVD $1993, R11 - BR callbackasm1(SB) - MOVD $1994, R11 - BR callbackasm1(SB) - MOVD $1995, R11 - BR callbackasm1(SB) - MOVD $1996, R11 - BR callbackasm1(SB) - MOVD $1997, R11 - BR callbackasm1(SB) - MOVD $1998, R11 - BR callbackasm1(SB) - MOVD $1999, R11 - BR callbackasm1(SB) diff --git a/vendor/github.com/ebitengine/purego/zcallback_riscv64.s b/vendor/github.com/ebitengine/purego/zcallback_riscv64.s deleted file mode 100644 index f341a87eefa..00000000000 --- a/vendor/github.com/ebitengine/purego/zcallback_riscv64.s +++ /dev/null @@ -1,4051 +0,0 @@ -// Code generated by wincallback.go using 'go generate'. DO NOT EDIT. - -//go:build darwin || freebsd || linux || netbsd - -// External code calls into callbackasm at an offset corresponding -// to the callback index. Callbackasm is a table of MOV and JMP instructions. -// Since Go 1.26, MOV instructions with immediate values lower than or equal to 32 -// are encoded in 2 bytes rather than 4 bytes, which breaks the assumption that each -// callback entry is 8 bytes long. Therefore, for callback indices less than or equal to 32, -// add a PCALIGN directive to align the next instruction to an 8-byte boundary. -// The MOV instruction loads X7 with the callback index, and the -// JMP instruction branches to callbackasm1. -// callbackasm1 takes the callback index from X7 and -// indexes into an array that stores information about each callback. -// It then calls the Go implementation for that callback. -#include "textflag.h" - -TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0 - PCALIGN $8 - MOV $0, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $1, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $2, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $3, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $4, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $5, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $6, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $7, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $8, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $9, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $10, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $11, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $12, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $13, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $14, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $15, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $16, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $17, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $18, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $19, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $20, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $21, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $22, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $23, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $24, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $25, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $26, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $27, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $28, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $29, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $30, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $31, X7 - JMP callbackasm1(SB) - PCALIGN $8 - MOV $32, X7 - JMP callbackasm1(SB) - MOV $33, X7 - JMP callbackasm1(SB) - MOV $34, X7 - JMP callbackasm1(SB) - MOV $35, X7 - JMP callbackasm1(SB) - MOV $36, X7 - JMP callbackasm1(SB) - MOV $37, X7 - JMP callbackasm1(SB) - MOV $38, X7 - JMP callbackasm1(SB) - MOV $39, X7 - JMP callbackasm1(SB) - MOV $40, X7 - JMP callbackasm1(SB) - MOV $41, X7 - JMP callbackasm1(SB) - MOV $42, X7 - JMP callbackasm1(SB) - MOV $43, X7 - JMP callbackasm1(SB) - MOV $44, X7 - JMP callbackasm1(SB) - MOV $45, X7 - JMP callbackasm1(SB) - MOV $46, X7 - JMP callbackasm1(SB) - MOV $47, X7 - JMP callbackasm1(SB) - MOV $48, X7 - JMP callbackasm1(SB) - MOV $49, X7 - JMP callbackasm1(SB) - MOV $50, X7 - JMP callbackasm1(SB) - MOV $51, X7 - JMP callbackasm1(SB) - MOV $52, X7 - JMP callbackasm1(SB) - MOV $53, X7 - JMP callbackasm1(SB) - MOV $54, X7 - JMP callbackasm1(SB) - MOV $55, X7 - JMP callbackasm1(SB) - MOV $56, X7 - JMP callbackasm1(SB) - MOV $57, X7 - JMP callbackasm1(SB) - MOV $58, X7 - JMP callbackasm1(SB) - MOV $59, X7 - JMP callbackasm1(SB) - MOV $60, X7 - JMP callbackasm1(SB) - MOV $61, X7 - JMP callbackasm1(SB) - MOV $62, X7 - JMP callbackasm1(SB) - MOV $63, X7 - JMP callbackasm1(SB) - MOV $64, X7 - JMP callbackasm1(SB) - MOV $65, X7 - JMP callbackasm1(SB) - MOV $66, X7 - JMP callbackasm1(SB) - MOV $67, X7 - JMP callbackasm1(SB) - MOV $68, X7 - JMP callbackasm1(SB) - MOV $69, X7 - JMP callbackasm1(SB) - MOV $70, X7 - JMP callbackasm1(SB) - MOV $71, X7 - JMP callbackasm1(SB) - MOV $72, X7 - JMP callbackasm1(SB) - MOV $73, X7 - JMP callbackasm1(SB) - MOV $74, X7 - JMP callbackasm1(SB) - MOV $75, X7 - JMP callbackasm1(SB) - MOV $76, X7 - JMP callbackasm1(SB) - MOV $77, X7 - JMP callbackasm1(SB) - MOV $78, X7 - JMP callbackasm1(SB) - MOV $79, X7 - JMP callbackasm1(SB) - MOV $80, X7 - JMP callbackasm1(SB) - MOV $81, X7 - JMP callbackasm1(SB) - MOV $82, X7 - JMP callbackasm1(SB) - MOV $83, X7 - JMP callbackasm1(SB) - MOV $84, X7 - JMP callbackasm1(SB) - MOV $85, X7 - JMP callbackasm1(SB) - MOV $86, X7 - JMP callbackasm1(SB) - MOV $87, X7 - JMP callbackasm1(SB) - MOV $88, X7 - JMP callbackasm1(SB) - MOV $89, X7 - JMP callbackasm1(SB) - MOV $90, X7 - JMP callbackasm1(SB) - MOV $91, X7 - JMP callbackasm1(SB) - MOV $92, X7 - JMP callbackasm1(SB) - MOV $93, X7 - JMP callbackasm1(SB) - MOV $94, X7 - JMP callbackasm1(SB) - MOV $95, X7 - JMP callbackasm1(SB) - MOV $96, X7 - JMP callbackasm1(SB) - MOV $97, X7 - JMP callbackasm1(SB) - MOV $98, X7 - JMP callbackasm1(SB) - MOV $99, X7 - JMP callbackasm1(SB) - MOV $100, X7 - JMP callbackasm1(SB) - MOV $101, X7 - JMP callbackasm1(SB) - MOV $102, X7 - JMP callbackasm1(SB) - MOV $103, X7 - JMP callbackasm1(SB) - MOV $104, X7 - JMP callbackasm1(SB) - MOV $105, X7 - JMP callbackasm1(SB) - MOV $106, X7 - JMP callbackasm1(SB) - MOV $107, X7 - JMP callbackasm1(SB) - MOV $108, X7 - JMP callbackasm1(SB) - MOV $109, X7 - JMP callbackasm1(SB) - MOV $110, X7 - JMP callbackasm1(SB) - MOV $111, X7 - JMP callbackasm1(SB) - MOV $112, X7 - JMP callbackasm1(SB) - MOV $113, X7 - JMP callbackasm1(SB) - MOV $114, X7 - JMP callbackasm1(SB) - MOV $115, X7 - JMP callbackasm1(SB) - MOV $116, X7 - JMP callbackasm1(SB) - MOV $117, X7 - JMP callbackasm1(SB) - MOV $118, X7 - JMP callbackasm1(SB) - MOV $119, X7 - JMP callbackasm1(SB) - MOV $120, X7 - JMP callbackasm1(SB) - MOV $121, X7 - JMP callbackasm1(SB) - MOV $122, X7 - JMP callbackasm1(SB) - MOV $123, X7 - JMP callbackasm1(SB) - MOV $124, X7 - JMP callbackasm1(SB) - MOV $125, X7 - JMP callbackasm1(SB) - MOV $126, X7 - JMP callbackasm1(SB) - MOV $127, X7 - JMP callbackasm1(SB) - MOV $128, X7 - JMP callbackasm1(SB) - MOV $129, X7 - JMP callbackasm1(SB) - MOV $130, X7 - JMP callbackasm1(SB) - MOV $131, X7 - JMP callbackasm1(SB) - MOV $132, X7 - JMP callbackasm1(SB) - MOV $133, X7 - JMP callbackasm1(SB) - MOV $134, X7 - JMP callbackasm1(SB) - MOV $135, X7 - JMP callbackasm1(SB) - MOV $136, X7 - JMP callbackasm1(SB) - MOV $137, X7 - JMP callbackasm1(SB) - MOV $138, X7 - JMP callbackasm1(SB) - MOV $139, X7 - JMP callbackasm1(SB) - MOV $140, X7 - JMP callbackasm1(SB) - MOV $141, X7 - JMP callbackasm1(SB) - MOV $142, X7 - JMP callbackasm1(SB) - MOV $143, X7 - JMP callbackasm1(SB) - MOV $144, X7 - JMP callbackasm1(SB) - MOV $145, X7 - JMP callbackasm1(SB) - MOV $146, X7 - JMP callbackasm1(SB) - MOV $147, X7 - JMP callbackasm1(SB) - MOV $148, X7 - JMP callbackasm1(SB) - MOV $149, X7 - JMP callbackasm1(SB) - MOV $150, X7 - JMP callbackasm1(SB) - MOV $151, X7 - JMP callbackasm1(SB) - MOV $152, X7 - JMP callbackasm1(SB) - MOV $153, X7 - JMP callbackasm1(SB) - MOV $154, X7 - JMP callbackasm1(SB) - MOV $155, X7 - JMP callbackasm1(SB) - MOV $156, X7 - JMP callbackasm1(SB) - MOV $157, X7 - JMP callbackasm1(SB) - MOV $158, X7 - JMP callbackasm1(SB) - MOV $159, X7 - JMP callbackasm1(SB) - MOV $160, X7 - JMP callbackasm1(SB) - MOV $161, X7 - JMP callbackasm1(SB) - MOV $162, X7 - JMP callbackasm1(SB) - MOV $163, X7 - JMP callbackasm1(SB) - MOV $164, X7 - JMP callbackasm1(SB) - MOV $165, X7 - JMP callbackasm1(SB) - MOV $166, X7 - JMP callbackasm1(SB) - MOV $167, X7 - JMP callbackasm1(SB) - MOV $168, X7 - JMP callbackasm1(SB) - MOV $169, X7 - JMP callbackasm1(SB) - MOV $170, X7 - JMP callbackasm1(SB) - MOV $171, X7 - JMP callbackasm1(SB) - MOV $172, X7 - JMP callbackasm1(SB) - MOV $173, X7 - JMP callbackasm1(SB) - MOV $174, X7 - JMP callbackasm1(SB) - MOV $175, X7 - JMP callbackasm1(SB) - MOV $176, X7 - JMP callbackasm1(SB) - MOV $177, X7 - JMP callbackasm1(SB) - MOV $178, X7 - JMP callbackasm1(SB) - MOV $179, X7 - JMP callbackasm1(SB) - MOV $180, X7 - JMP callbackasm1(SB) - MOV $181, X7 - JMP callbackasm1(SB) - MOV $182, X7 - JMP callbackasm1(SB) - MOV $183, X7 - JMP callbackasm1(SB) - MOV $184, X7 - JMP callbackasm1(SB) - MOV $185, X7 - JMP callbackasm1(SB) - MOV $186, X7 - JMP callbackasm1(SB) - MOV $187, X7 - JMP callbackasm1(SB) - MOV $188, X7 - JMP callbackasm1(SB) - MOV $189, X7 - JMP callbackasm1(SB) - MOV $190, X7 - JMP callbackasm1(SB) - MOV $191, X7 - JMP callbackasm1(SB) - MOV $192, X7 - JMP callbackasm1(SB) - MOV $193, X7 - JMP callbackasm1(SB) - MOV $194, X7 - JMP callbackasm1(SB) - MOV $195, X7 - JMP callbackasm1(SB) - MOV $196, X7 - JMP callbackasm1(SB) - MOV $197, X7 - JMP callbackasm1(SB) - MOV $198, X7 - JMP callbackasm1(SB) - MOV $199, X7 - JMP callbackasm1(SB) - MOV $200, X7 - JMP callbackasm1(SB) - MOV $201, X7 - JMP callbackasm1(SB) - MOV $202, X7 - JMP callbackasm1(SB) - MOV $203, X7 - JMP callbackasm1(SB) - MOV $204, X7 - JMP callbackasm1(SB) - MOV $205, X7 - JMP callbackasm1(SB) - MOV $206, X7 - JMP callbackasm1(SB) - MOV $207, X7 - JMP callbackasm1(SB) - MOV $208, X7 - JMP callbackasm1(SB) - MOV $209, X7 - JMP callbackasm1(SB) - MOV $210, X7 - JMP callbackasm1(SB) - MOV $211, X7 - JMP callbackasm1(SB) - MOV $212, X7 - JMP callbackasm1(SB) - MOV $213, X7 - JMP callbackasm1(SB) - MOV $214, X7 - JMP callbackasm1(SB) - MOV $215, X7 - JMP callbackasm1(SB) - MOV $216, X7 - JMP callbackasm1(SB) - MOV $217, X7 - JMP callbackasm1(SB) - MOV $218, X7 - JMP callbackasm1(SB) - MOV $219, X7 - JMP callbackasm1(SB) - MOV $220, X7 - JMP callbackasm1(SB) - MOV $221, X7 - JMP callbackasm1(SB) - MOV $222, X7 - JMP callbackasm1(SB) - MOV $223, X7 - JMP callbackasm1(SB) - MOV $224, X7 - JMP callbackasm1(SB) - MOV $225, X7 - JMP callbackasm1(SB) - MOV $226, X7 - JMP callbackasm1(SB) - MOV $227, X7 - JMP callbackasm1(SB) - MOV $228, X7 - JMP callbackasm1(SB) - MOV $229, X7 - JMP callbackasm1(SB) - MOV $230, X7 - JMP callbackasm1(SB) - MOV $231, X7 - JMP callbackasm1(SB) - MOV $232, X7 - JMP callbackasm1(SB) - MOV $233, X7 - JMP callbackasm1(SB) - MOV $234, X7 - JMP callbackasm1(SB) - MOV $235, X7 - JMP callbackasm1(SB) - MOV $236, X7 - JMP callbackasm1(SB) - MOV $237, X7 - JMP callbackasm1(SB) - MOV $238, X7 - JMP callbackasm1(SB) - MOV $239, X7 - JMP callbackasm1(SB) - MOV $240, X7 - JMP callbackasm1(SB) - MOV $241, X7 - JMP callbackasm1(SB) - MOV $242, X7 - JMP callbackasm1(SB) - MOV $243, X7 - JMP callbackasm1(SB) - MOV $244, X7 - JMP callbackasm1(SB) - MOV $245, X7 - JMP callbackasm1(SB) - MOV $246, X7 - JMP callbackasm1(SB) - MOV $247, X7 - JMP callbackasm1(SB) - MOV $248, X7 - JMP callbackasm1(SB) - MOV $249, X7 - JMP callbackasm1(SB) - MOV $250, X7 - JMP callbackasm1(SB) - MOV $251, X7 - JMP callbackasm1(SB) - MOV $252, X7 - JMP callbackasm1(SB) - MOV $253, X7 - JMP callbackasm1(SB) - MOV $254, X7 - JMP callbackasm1(SB) - MOV $255, X7 - JMP callbackasm1(SB) - MOV $256, X7 - JMP callbackasm1(SB) - MOV $257, X7 - JMP callbackasm1(SB) - MOV $258, X7 - JMP callbackasm1(SB) - MOV $259, X7 - JMP callbackasm1(SB) - MOV $260, X7 - JMP callbackasm1(SB) - MOV $261, X7 - JMP callbackasm1(SB) - MOV $262, X7 - JMP callbackasm1(SB) - MOV $263, X7 - JMP callbackasm1(SB) - MOV $264, X7 - JMP callbackasm1(SB) - MOV $265, X7 - JMP callbackasm1(SB) - MOV $266, X7 - JMP callbackasm1(SB) - MOV $267, X7 - JMP callbackasm1(SB) - MOV $268, X7 - JMP callbackasm1(SB) - MOV $269, X7 - JMP callbackasm1(SB) - MOV $270, X7 - JMP callbackasm1(SB) - MOV $271, X7 - JMP callbackasm1(SB) - MOV $272, X7 - JMP callbackasm1(SB) - MOV $273, X7 - JMP callbackasm1(SB) - MOV $274, X7 - JMP callbackasm1(SB) - MOV $275, X7 - JMP callbackasm1(SB) - MOV $276, X7 - JMP callbackasm1(SB) - MOV $277, X7 - JMP callbackasm1(SB) - MOV $278, X7 - JMP callbackasm1(SB) - MOV $279, X7 - JMP callbackasm1(SB) - MOV $280, X7 - JMP callbackasm1(SB) - MOV $281, X7 - JMP callbackasm1(SB) - MOV $282, X7 - JMP callbackasm1(SB) - MOV $283, X7 - JMP callbackasm1(SB) - MOV $284, X7 - JMP callbackasm1(SB) - MOV $285, X7 - JMP callbackasm1(SB) - MOV $286, X7 - JMP callbackasm1(SB) - MOV $287, X7 - JMP callbackasm1(SB) - MOV $288, X7 - JMP callbackasm1(SB) - MOV $289, X7 - JMP callbackasm1(SB) - MOV $290, X7 - JMP callbackasm1(SB) - MOV $291, X7 - JMP callbackasm1(SB) - MOV $292, X7 - JMP callbackasm1(SB) - MOV $293, X7 - JMP callbackasm1(SB) - MOV $294, X7 - JMP callbackasm1(SB) - MOV $295, X7 - JMP callbackasm1(SB) - MOV $296, X7 - JMP callbackasm1(SB) - MOV $297, X7 - JMP callbackasm1(SB) - MOV $298, X7 - JMP callbackasm1(SB) - MOV $299, X7 - JMP callbackasm1(SB) - MOV $300, X7 - JMP callbackasm1(SB) - MOV $301, X7 - JMP callbackasm1(SB) - MOV $302, X7 - JMP callbackasm1(SB) - MOV $303, X7 - JMP callbackasm1(SB) - MOV $304, X7 - JMP callbackasm1(SB) - MOV $305, X7 - JMP callbackasm1(SB) - MOV $306, X7 - JMP callbackasm1(SB) - MOV $307, X7 - JMP callbackasm1(SB) - MOV $308, X7 - JMP callbackasm1(SB) - MOV $309, X7 - JMP callbackasm1(SB) - MOV $310, X7 - JMP callbackasm1(SB) - MOV $311, X7 - JMP callbackasm1(SB) - MOV $312, X7 - JMP callbackasm1(SB) - MOV $313, X7 - JMP callbackasm1(SB) - MOV $314, X7 - JMP callbackasm1(SB) - MOV $315, X7 - JMP callbackasm1(SB) - MOV $316, X7 - JMP callbackasm1(SB) - MOV $317, X7 - JMP callbackasm1(SB) - MOV $318, X7 - JMP callbackasm1(SB) - MOV $319, X7 - JMP callbackasm1(SB) - MOV $320, X7 - JMP callbackasm1(SB) - MOV $321, X7 - JMP callbackasm1(SB) - MOV $322, X7 - JMP callbackasm1(SB) - MOV $323, X7 - JMP callbackasm1(SB) - MOV $324, X7 - JMP callbackasm1(SB) - MOV $325, X7 - JMP callbackasm1(SB) - MOV $326, X7 - JMP callbackasm1(SB) - MOV $327, X7 - JMP callbackasm1(SB) - MOV $328, X7 - JMP callbackasm1(SB) - MOV $329, X7 - JMP callbackasm1(SB) - MOV $330, X7 - JMP callbackasm1(SB) - MOV $331, X7 - JMP callbackasm1(SB) - MOV $332, X7 - JMP callbackasm1(SB) - MOV $333, X7 - JMP callbackasm1(SB) - MOV $334, X7 - JMP callbackasm1(SB) - MOV $335, X7 - JMP callbackasm1(SB) - MOV $336, X7 - JMP callbackasm1(SB) - MOV $337, X7 - JMP callbackasm1(SB) - MOV $338, X7 - JMP callbackasm1(SB) - MOV $339, X7 - JMP callbackasm1(SB) - MOV $340, X7 - JMP callbackasm1(SB) - MOV $341, X7 - JMP callbackasm1(SB) - MOV $342, X7 - JMP callbackasm1(SB) - MOV $343, X7 - JMP callbackasm1(SB) - MOV $344, X7 - JMP callbackasm1(SB) - MOV $345, X7 - JMP callbackasm1(SB) - MOV $346, X7 - JMP callbackasm1(SB) - MOV $347, X7 - JMP callbackasm1(SB) - MOV $348, X7 - JMP callbackasm1(SB) - MOV $349, X7 - JMP callbackasm1(SB) - MOV $350, X7 - JMP callbackasm1(SB) - MOV $351, X7 - JMP callbackasm1(SB) - MOV $352, X7 - JMP callbackasm1(SB) - MOV $353, X7 - JMP callbackasm1(SB) - MOV $354, X7 - JMP callbackasm1(SB) - MOV $355, X7 - JMP callbackasm1(SB) - MOV $356, X7 - JMP callbackasm1(SB) - MOV $357, X7 - JMP callbackasm1(SB) - MOV $358, X7 - JMP callbackasm1(SB) - MOV $359, X7 - JMP callbackasm1(SB) - MOV $360, X7 - JMP callbackasm1(SB) - MOV $361, X7 - JMP callbackasm1(SB) - MOV $362, X7 - JMP callbackasm1(SB) - MOV $363, X7 - JMP callbackasm1(SB) - MOV $364, X7 - JMP callbackasm1(SB) - MOV $365, X7 - JMP callbackasm1(SB) - MOV $366, X7 - JMP callbackasm1(SB) - MOV $367, X7 - JMP callbackasm1(SB) - MOV $368, X7 - JMP callbackasm1(SB) - MOV $369, X7 - JMP callbackasm1(SB) - MOV $370, X7 - JMP callbackasm1(SB) - MOV $371, X7 - JMP callbackasm1(SB) - MOV $372, X7 - JMP callbackasm1(SB) - MOV $373, X7 - JMP callbackasm1(SB) - MOV $374, X7 - JMP callbackasm1(SB) - MOV $375, X7 - JMP callbackasm1(SB) - MOV $376, X7 - JMP callbackasm1(SB) - MOV $377, X7 - JMP callbackasm1(SB) - MOV $378, X7 - JMP callbackasm1(SB) - MOV $379, X7 - JMP callbackasm1(SB) - MOV $380, X7 - JMP callbackasm1(SB) - MOV $381, X7 - JMP callbackasm1(SB) - MOV $382, X7 - JMP callbackasm1(SB) - MOV $383, X7 - JMP callbackasm1(SB) - MOV $384, X7 - JMP callbackasm1(SB) - MOV $385, X7 - JMP callbackasm1(SB) - MOV $386, X7 - JMP callbackasm1(SB) - MOV $387, X7 - JMP callbackasm1(SB) - MOV $388, X7 - JMP callbackasm1(SB) - MOV $389, X7 - JMP callbackasm1(SB) - MOV $390, X7 - JMP callbackasm1(SB) - MOV $391, X7 - JMP callbackasm1(SB) - MOV $392, X7 - JMP callbackasm1(SB) - MOV $393, X7 - JMP callbackasm1(SB) - MOV $394, X7 - JMP callbackasm1(SB) - MOV $395, X7 - JMP callbackasm1(SB) - MOV $396, X7 - JMP callbackasm1(SB) - MOV $397, X7 - JMP callbackasm1(SB) - MOV $398, X7 - JMP callbackasm1(SB) - MOV $399, X7 - JMP callbackasm1(SB) - MOV $400, X7 - JMP callbackasm1(SB) - MOV $401, X7 - JMP callbackasm1(SB) - MOV $402, X7 - JMP callbackasm1(SB) - MOV $403, X7 - JMP callbackasm1(SB) - MOV $404, X7 - JMP callbackasm1(SB) - MOV $405, X7 - JMP callbackasm1(SB) - MOV $406, X7 - JMP callbackasm1(SB) - MOV $407, X7 - JMP callbackasm1(SB) - MOV $408, X7 - JMP callbackasm1(SB) - MOV $409, X7 - JMP callbackasm1(SB) - MOV $410, X7 - JMP callbackasm1(SB) - MOV $411, X7 - JMP callbackasm1(SB) - MOV $412, X7 - JMP callbackasm1(SB) - MOV $413, X7 - JMP callbackasm1(SB) - MOV $414, X7 - JMP callbackasm1(SB) - MOV $415, X7 - JMP callbackasm1(SB) - MOV $416, X7 - JMP callbackasm1(SB) - MOV $417, X7 - JMP callbackasm1(SB) - MOV $418, X7 - JMP callbackasm1(SB) - MOV $419, X7 - JMP callbackasm1(SB) - MOV $420, X7 - JMP callbackasm1(SB) - MOV $421, X7 - JMP callbackasm1(SB) - MOV $422, X7 - JMP callbackasm1(SB) - MOV $423, X7 - JMP callbackasm1(SB) - MOV $424, X7 - JMP callbackasm1(SB) - MOV $425, X7 - JMP callbackasm1(SB) - MOV $426, X7 - JMP callbackasm1(SB) - MOV $427, X7 - JMP callbackasm1(SB) - MOV $428, X7 - JMP callbackasm1(SB) - MOV $429, X7 - JMP callbackasm1(SB) - MOV $430, X7 - JMP callbackasm1(SB) - MOV $431, X7 - JMP callbackasm1(SB) - MOV $432, X7 - JMP callbackasm1(SB) - MOV $433, X7 - JMP callbackasm1(SB) - MOV $434, X7 - JMP callbackasm1(SB) - MOV $435, X7 - JMP callbackasm1(SB) - MOV $436, X7 - JMP callbackasm1(SB) - MOV $437, X7 - JMP callbackasm1(SB) - MOV $438, X7 - JMP callbackasm1(SB) - MOV $439, X7 - JMP callbackasm1(SB) - MOV $440, X7 - JMP callbackasm1(SB) - MOV $441, X7 - JMP callbackasm1(SB) - MOV $442, X7 - JMP callbackasm1(SB) - MOV $443, X7 - JMP callbackasm1(SB) - MOV $444, X7 - JMP callbackasm1(SB) - MOV $445, X7 - JMP callbackasm1(SB) - MOV $446, X7 - JMP callbackasm1(SB) - MOV $447, X7 - JMP callbackasm1(SB) - MOV $448, X7 - JMP callbackasm1(SB) - MOV $449, X7 - JMP callbackasm1(SB) - MOV $450, X7 - JMP callbackasm1(SB) - MOV $451, X7 - JMP callbackasm1(SB) - MOV $452, X7 - JMP callbackasm1(SB) - MOV $453, X7 - JMP callbackasm1(SB) - MOV $454, X7 - JMP callbackasm1(SB) - MOV $455, X7 - JMP callbackasm1(SB) - MOV $456, X7 - JMP callbackasm1(SB) - MOV $457, X7 - JMP callbackasm1(SB) - MOV $458, X7 - JMP callbackasm1(SB) - MOV $459, X7 - JMP callbackasm1(SB) - MOV $460, X7 - JMP callbackasm1(SB) - MOV $461, X7 - JMP callbackasm1(SB) - MOV $462, X7 - JMP callbackasm1(SB) - MOV $463, X7 - JMP callbackasm1(SB) - MOV $464, X7 - JMP callbackasm1(SB) - MOV $465, X7 - JMP callbackasm1(SB) - MOV $466, X7 - JMP callbackasm1(SB) - MOV $467, X7 - JMP callbackasm1(SB) - MOV $468, X7 - JMP callbackasm1(SB) - MOV $469, X7 - JMP callbackasm1(SB) - MOV $470, X7 - JMP callbackasm1(SB) - MOV $471, X7 - JMP callbackasm1(SB) - MOV $472, X7 - JMP callbackasm1(SB) - MOV $473, X7 - JMP callbackasm1(SB) - MOV $474, X7 - JMP callbackasm1(SB) - MOV $475, X7 - JMP callbackasm1(SB) - MOV $476, X7 - JMP callbackasm1(SB) - MOV $477, X7 - JMP callbackasm1(SB) - MOV $478, X7 - JMP callbackasm1(SB) - MOV $479, X7 - JMP callbackasm1(SB) - MOV $480, X7 - JMP callbackasm1(SB) - MOV $481, X7 - JMP callbackasm1(SB) - MOV $482, X7 - JMP callbackasm1(SB) - MOV $483, X7 - JMP callbackasm1(SB) - MOV $484, X7 - JMP callbackasm1(SB) - MOV $485, X7 - JMP callbackasm1(SB) - MOV $486, X7 - JMP callbackasm1(SB) - MOV $487, X7 - JMP callbackasm1(SB) - MOV $488, X7 - JMP callbackasm1(SB) - MOV $489, X7 - JMP callbackasm1(SB) - MOV $490, X7 - JMP callbackasm1(SB) - MOV $491, X7 - JMP callbackasm1(SB) - MOV $492, X7 - JMP callbackasm1(SB) - MOV $493, X7 - JMP callbackasm1(SB) - MOV $494, X7 - JMP callbackasm1(SB) - MOV $495, X7 - JMP callbackasm1(SB) - MOV $496, X7 - JMP callbackasm1(SB) - MOV $497, X7 - JMP callbackasm1(SB) - MOV $498, X7 - JMP callbackasm1(SB) - MOV $499, X7 - JMP callbackasm1(SB) - MOV $500, X7 - JMP callbackasm1(SB) - MOV $501, X7 - JMP callbackasm1(SB) - MOV $502, X7 - JMP callbackasm1(SB) - MOV $503, X7 - JMP callbackasm1(SB) - MOV $504, X7 - JMP callbackasm1(SB) - MOV $505, X7 - JMP callbackasm1(SB) - MOV $506, X7 - JMP callbackasm1(SB) - MOV $507, X7 - JMP callbackasm1(SB) - MOV $508, X7 - JMP callbackasm1(SB) - MOV $509, X7 - JMP callbackasm1(SB) - MOV $510, X7 - JMP callbackasm1(SB) - MOV $511, X7 - JMP callbackasm1(SB) - MOV $512, X7 - JMP callbackasm1(SB) - MOV $513, X7 - JMP callbackasm1(SB) - MOV $514, X7 - JMP callbackasm1(SB) - MOV $515, X7 - JMP callbackasm1(SB) - MOV $516, X7 - JMP callbackasm1(SB) - MOV $517, X7 - JMP callbackasm1(SB) - MOV $518, X7 - JMP callbackasm1(SB) - MOV $519, X7 - JMP callbackasm1(SB) - MOV $520, X7 - JMP callbackasm1(SB) - MOV $521, X7 - JMP callbackasm1(SB) - MOV $522, X7 - JMP callbackasm1(SB) - MOV $523, X7 - JMP callbackasm1(SB) - MOV $524, X7 - JMP callbackasm1(SB) - MOV $525, X7 - JMP callbackasm1(SB) - MOV $526, X7 - JMP callbackasm1(SB) - MOV $527, X7 - JMP callbackasm1(SB) - MOV $528, X7 - JMP callbackasm1(SB) - MOV $529, X7 - JMP callbackasm1(SB) - MOV $530, X7 - JMP callbackasm1(SB) - MOV $531, X7 - JMP callbackasm1(SB) - MOV $532, X7 - JMP callbackasm1(SB) - MOV $533, X7 - JMP callbackasm1(SB) - MOV $534, X7 - JMP callbackasm1(SB) - MOV $535, X7 - JMP callbackasm1(SB) - MOV $536, X7 - JMP callbackasm1(SB) - MOV $537, X7 - JMP callbackasm1(SB) - MOV $538, X7 - JMP callbackasm1(SB) - MOV $539, X7 - JMP callbackasm1(SB) - MOV $540, X7 - JMP callbackasm1(SB) - MOV $541, X7 - JMP callbackasm1(SB) - MOV $542, X7 - JMP callbackasm1(SB) - MOV $543, X7 - JMP callbackasm1(SB) - MOV $544, X7 - JMP callbackasm1(SB) - MOV $545, X7 - JMP callbackasm1(SB) - MOV $546, X7 - JMP callbackasm1(SB) - MOV $547, X7 - JMP callbackasm1(SB) - MOV $548, X7 - JMP callbackasm1(SB) - MOV $549, X7 - JMP callbackasm1(SB) - MOV $550, X7 - JMP callbackasm1(SB) - MOV $551, X7 - JMP callbackasm1(SB) - MOV $552, X7 - JMP callbackasm1(SB) - MOV $553, X7 - JMP callbackasm1(SB) - MOV $554, X7 - JMP callbackasm1(SB) - MOV $555, X7 - JMP callbackasm1(SB) - MOV $556, X7 - JMP callbackasm1(SB) - MOV $557, X7 - JMP callbackasm1(SB) - MOV $558, X7 - JMP callbackasm1(SB) - MOV $559, X7 - JMP callbackasm1(SB) - MOV $560, X7 - JMP callbackasm1(SB) - MOV $561, X7 - JMP callbackasm1(SB) - MOV $562, X7 - JMP callbackasm1(SB) - MOV $563, X7 - JMP callbackasm1(SB) - MOV $564, X7 - JMP callbackasm1(SB) - MOV $565, X7 - JMP callbackasm1(SB) - MOV $566, X7 - JMP callbackasm1(SB) - MOV $567, X7 - JMP callbackasm1(SB) - MOV $568, X7 - JMP callbackasm1(SB) - MOV $569, X7 - JMP callbackasm1(SB) - MOV $570, X7 - JMP callbackasm1(SB) - MOV $571, X7 - JMP callbackasm1(SB) - MOV $572, X7 - JMP callbackasm1(SB) - MOV $573, X7 - JMP callbackasm1(SB) - MOV $574, X7 - JMP callbackasm1(SB) - MOV $575, X7 - JMP callbackasm1(SB) - MOV $576, X7 - JMP callbackasm1(SB) - MOV $577, X7 - JMP callbackasm1(SB) - MOV $578, X7 - JMP callbackasm1(SB) - MOV $579, X7 - JMP callbackasm1(SB) - MOV $580, X7 - JMP callbackasm1(SB) - MOV $581, X7 - JMP callbackasm1(SB) - MOV $582, X7 - JMP callbackasm1(SB) - MOV $583, X7 - JMP callbackasm1(SB) - MOV $584, X7 - JMP callbackasm1(SB) - MOV $585, X7 - JMP callbackasm1(SB) - MOV $586, X7 - JMP callbackasm1(SB) - MOV $587, X7 - JMP callbackasm1(SB) - MOV $588, X7 - JMP callbackasm1(SB) - MOV $589, X7 - JMP callbackasm1(SB) - MOV $590, X7 - JMP callbackasm1(SB) - MOV $591, X7 - JMP callbackasm1(SB) - MOV $592, X7 - JMP callbackasm1(SB) - MOV $593, X7 - JMP callbackasm1(SB) - MOV $594, X7 - JMP callbackasm1(SB) - MOV $595, X7 - JMP callbackasm1(SB) - MOV $596, X7 - JMP callbackasm1(SB) - MOV $597, X7 - JMP callbackasm1(SB) - MOV $598, X7 - JMP callbackasm1(SB) - MOV $599, X7 - JMP callbackasm1(SB) - MOV $600, X7 - JMP callbackasm1(SB) - MOV $601, X7 - JMP callbackasm1(SB) - MOV $602, X7 - JMP callbackasm1(SB) - MOV $603, X7 - JMP callbackasm1(SB) - MOV $604, X7 - JMP callbackasm1(SB) - MOV $605, X7 - JMP callbackasm1(SB) - MOV $606, X7 - JMP callbackasm1(SB) - MOV $607, X7 - JMP callbackasm1(SB) - MOV $608, X7 - JMP callbackasm1(SB) - MOV $609, X7 - JMP callbackasm1(SB) - MOV $610, X7 - JMP callbackasm1(SB) - MOV $611, X7 - JMP callbackasm1(SB) - MOV $612, X7 - JMP callbackasm1(SB) - MOV $613, X7 - JMP callbackasm1(SB) - MOV $614, X7 - JMP callbackasm1(SB) - MOV $615, X7 - JMP callbackasm1(SB) - MOV $616, X7 - JMP callbackasm1(SB) - MOV $617, X7 - JMP callbackasm1(SB) - MOV $618, X7 - JMP callbackasm1(SB) - MOV $619, X7 - JMP callbackasm1(SB) - MOV $620, X7 - JMP callbackasm1(SB) - MOV $621, X7 - JMP callbackasm1(SB) - MOV $622, X7 - JMP callbackasm1(SB) - MOV $623, X7 - JMP callbackasm1(SB) - MOV $624, X7 - JMP callbackasm1(SB) - MOV $625, X7 - JMP callbackasm1(SB) - MOV $626, X7 - JMP callbackasm1(SB) - MOV $627, X7 - JMP callbackasm1(SB) - MOV $628, X7 - JMP callbackasm1(SB) - MOV $629, X7 - JMP callbackasm1(SB) - MOV $630, X7 - JMP callbackasm1(SB) - MOV $631, X7 - JMP callbackasm1(SB) - MOV $632, X7 - JMP callbackasm1(SB) - MOV $633, X7 - JMP callbackasm1(SB) - MOV $634, X7 - JMP callbackasm1(SB) - MOV $635, X7 - JMP callbackasm1(SB) - MOV $636, X7 - JMP callbackasm1(SB) - MOV $637, X7 - JMP callbackasm1(SB) - MOV $638, X7 - JMP callbackasm1(SB) - MOV $639, X7 - JMP callbackasm1(SB) - MOV $640, X7 - JMP callbackasm1(SB) - MOV $641, X7 - JMP callbackasm1(SB) - MOV $642, X7 - JMP callbackasm1(SB) - MOV $643, X7 - JMP callbackasm1(SB) - MOV $644, X7 - JMP callbackasm1(SB) - MOV $645, X7 - JMP callbackasm1(SB) - MOV $646, X7 - JMP callbackasm1(SB) - MOV $647, X7 - JMP callbackasm1(SB) - MOV $648, X7 - JMP callbackasm1(SB) - MOV $649, X7 - JMP callbackasm1(SB) - MOV $650, X7 - JMP callbackasm1(SB) - MOV $651, X7 - JMP callbackasm1(SB) - MOV $652, X7 - JMP callbackasm1(SB) - MOV $653, X7 - JMP callbackasm1(SB) - MOV $654, X7 - JMP callbackasm1(SB) - MOV $655, X7 - JMP callbackasm1(SB) - MOV $656, X7 - JMP callbackasm1(SB) - MOV $657, X7 - JMP callbackasm1(SB) - MOV $658, X7 - JMP callbackasm1(SB) - MOV $659, X7 - JMP callbackasm1(SB) - MOV $660, X7 - JMP callbackasm1(SB) - MOV $661, X7 - JMP callbackasm1(SB) - MOV $662, X7 - JMP callbackasm1(SB) - MOV $663, X7 - JMP callbackasm1(SB) - MOV $664, X7 - JMP callbackasm1(SB) - MOV $665, X7 - JMP callbackasm1(SB) - MOV $666, X7 - JMP callbackasm1(SB) - MOV $667, X7 - JMP callbackasm1(SB) - MOV $668, X7 - JMP callbackasm1(SB) - MOV $669, X7 - JMP callbackasm1(SB) - MOV $670, X7 - JMP callbackasm1(SB) - MOV $671, X7 - JMP callbackasm1(SB) - MOV $672, X7 - JMP callbackasm1(SB) - MOV $673, X7 - JMP callbackasm1(SB) - MOV $674, X7 - JMP callbackasm1(SB) - MOV $675, X7 - JMP callbackasm1(SB) - MOV $676, X7 - JMP callbackasm1(SB) - MOV $677, X7 - JMP callbackasm1(SB) - MOV $678, X7 - JMP callbackasm1(SB) - MOV $679, X7 - JMP callbackasm1(SB) - MOV $680, X7 - JMP callbackasm1(SB) - MOV $681, X7 - JMP callbackasm1(SB) - MOV $682, X7 - JMP callbackasm1(SB) - MOV $683, X7 - JMP callbackasm1(SB) - MOV $684, X7 - JMP callbackasm1(SB) - MOV $685, X7 - JMP callbackasm1(SB) - MOV $686, X7 - JMP callbackasm1(SB) - MOV $687, X7 - JMP callbackasm1(SB) - MOV $688, X7 - JMP callbackasm1(SB) - MOV $689, X7 - JMP callbackasm1(SB) - MOV $690, X7 - JMP callbackasm1(SB) - MOV $691, X7 - JMP callbackasm1(SB) - MOV $692, X7 - JMP callbackasm1(SB) - MOV $693, X7 - JMP callbackasm1(SB) - MOV $694, X7 - JMP callbackasm1(SB) - MOV $695, X7 - JMP callbackasm1(SB) - MOV $696, X7 - JMP callbackasm1(SB) - MOV $697, X7 - JMP callbackasm1(SB) - MOV $698, X7 - JMP callbackasm1(SB) - MOV $699, X7 - JMP callbackasm1(SB) - MOV $700, X7 - JMP callbackasm1(SB) - MOV $701, X7 - JMP callbackasm1(SB) - MOV $702, X7 - JMP callbackasm1(SB) - MOV $703, X7 - JMP callbackasm1(SB) - MOV $704, X7 - JMP callbackasm1(SB) - MOV $705, X7 - JMP callbackasm1(SB) - MOV $706, X7 - JMP callbackasm1(SB) - MOV $707, X7 - JMP callbackasm1(SB) - MOV $708, X7 - JMP callbackasm1(SB) - MOV $709, X7 - JMP callbackasm1(SB) - MOV $710, X7 - JMP callbackasm1(SB) - MOV $711, X7 - JMP callbackasm1(SB) - MOV $712, X7 - JMP callbackasm1(SB) - MOV $713, X7 - JMP callbackasm1(SB) - MOV $714, X7 - JMP callbackasm1(SB) - MOV $715, X7 - JMP callbackasm1(SB) - MOV $716, X7 - JMP callbackasm1(SB) - MOV $717, X7 - JMP callbackasm1(SB) - MOV $718, X7 - JMP callbackasm1(SB) - MOV $719, X7 - JMP callbackasm1(SB) - MOV $720, X7 - JMP callbackasm1(SB) - MOV $721, X7 - JMP callbackasm1(SB) - MOV $722, X7 - JMP callbackasm1(SB) - MOV $723, X7 - JMP callbackasm1(SB) - MOV $724, X7 - JMP callbackasm1(SB) - MOV $725, X7 - JMP callbackasm1(SB) - MOV $726, X7 - JMP callbackasm1(SB) - MOV $727, X7 - JMP callbackasm1(SB) - MOV $728, X7 - JMP callbackasm1(SB) - MOV $729, X7 - JMP callbackasm1(SB) - MOV $730, X7 - JMP callbackasm1(SB) - MOV $731, X7 - JMP callbackasm1(SB) - MOV $732, X7 - JMP callbackasm1(SB) - MOV $733, X7 - JMP callbackasm1(SB) - MOV $734, X7 - JMP callbackasm1(SB) - MOV $735, X7 - JMP callbackasm1(SB) - MOV $736, X7 - JMP callbackasm1(SB) - MOV $737, X7 - JMP callbackasm1(SB) - MOV $738, X7 - JMP callbackasm1(SB) - MOV $739, X7 - JMP callbackasm1(SB) - MOV $740, X7 - JMP callbackasm1(SB) - MOV $741, X7 - JMP callbackasm1(SB) - MOV $742, X7 - JMP callbackasm1(SB) - MOV $743, X7 - JMP callbackasm1(SB) - MOV $744, X7 - JMP callbackasm1(SB) - MOV $745, X7 - JMP callbackasm1(SB) - MOV $746, X7 - JMP callbackasm1(SB) - MOV $747, X7 - JMP callbackasm1(SB) - MOV $748, X7 - JMP callbackasm1(SB) - MOV $749, X7 - JMP callbackasm1(SB) - MOV $750, X7 - JMP callbackasm1(SB) - MOV $751, X7 - JMP callbackasm1(SB) - MOV $752, X7 - JMP callbackasm1(SB) - MOV $753, X7 - JMP callbackasm1(SB) - MOV $754, X7 - JMP callbackasm1(SB) - MOV $755, X7 - JMP callbackasm1(SB) - MOV $756, X7 - JMP callbackasm1(SB) - MOV $757, X7 - JMP callbackasm1(SB) - MOV $758, X7 - JMP callbackasm1(SB) - MOV $759, X7 - JMP callbackasm1(SB) - MOV $760, X7 - JMP callbackasm1(SB) - MOV $761, X7 - JMP callbackasm1(SB) - MOV $762, X7 - JMP callbackasm1(SB) - MOV $763, X7 - JMP callbackasm1(SB) - MOV $764, X7 - JMP callbackasm1(SB) - MOV $765, X7 - JMP callbackasm1(SB) - MOV $766, X7 - JMP callbackasm1(SB) - MOV $767, X7 - JMP callbackasm1(SB) - MOV $768, X7 - JMP callbackasm1(SB) - MOV $769, X7 - JMP callbackasm1(SB) - MOV $770, X7 - JMP callbackasm1(SB) - MOV $771, X7 - JMP callbackasm1(SB) - MOV $772, X7 - JMP callbackasm1(SB) - MOV $773, X7 - JMP callbackasm1(SB) - MOV $774, X7 - JMP callbackasm1(SB) - MOV $775, X7 - JMP callbackasm1(SB) - MOV $776, X7 - JMP callbackasm1(SB) - MOV $777, X7 - JMP callbackasm1(SB) - MOV $778, X7 - JMP callbackasm1(SB) - MOV $779, X7 - JMP callbackasm1(SB) - MOV $780, X7 - JMP callbackasm1(SB) - MOV $781, X7 - JMP callbackasm1(SB) - MOV $782, X7 - JMP callbackasm1(SB) - MOV $783, X7 - JMP callbackasm1(SB) - MOV $784, X7 - JMP callbackasm1(SB) - MOV $785, X7 - JMP callbackasm1(SB) - MOV $786, X7 - JMP callbackasm1(SB) - MOV $787, X7 - JMP callbackasm1(SB) - MOV $788, X7 - JMP callbackasm1(SB) - MOV $789, X7 - JMP callbackasm1(SB) - MOV $790, X7 - JMP callbackasm1(SB) - MOV $791, X7 - JMP callbackasm1(SB) - MOV $792, X7 - JMP callbackasm1(SB) - MOV $793, X7 - JMP callbackasm1(SB) - MOV $794, X7 - JMP callbackasm1(SB) - MOV $795, X7 - JMP callbackasm1(SB) - MOV $796, X7 - JMP callbackasm1(SB) - MOV $797, X7 - JMP callbackasm1(SB) - MOV $798, X7 - JMP callbackasm1(SB) - MOV $799, X7 - JMP callbackasm1(SB) - MOV $800, X7 - JMP callbackasm1(SB) - MOV $801, X7 - JMP callbackasm1(SB) - MOV $802, X7 - JMP callbackasm1(SB) - MOV $803, X7 - JMP callbackasm1(SB) - MOV $804, X7 - JMP callbackasm1(SB) - MOV $805, X7 - JMP callbackasm1(SB) - MOV $806, X7 - JMP callbackasm1(SB) - MOV $807, X7 - JMP callbackasm1(SB) - MOV $808, X7 - JMP callbackasm1(SB) - MOV $809, X7 - JMP callbackasm1(SB) - MOV $810, X7 - JMP callbackasm1(SB) - MOV $811, X7 - JMP callbackasm1(SB) - MOV $812, X7 - JMP callbackasm1(SB) - MOV $813, X7 - JMP callbackasm1(SB) - MOV $814, X7 - JMP callbackasm1(SB) - MOV $815, X7 - JMP callbackasm1(SB) - MOV $816, X7 - JMP callbackasm1(SB) - MOV $817, X7 - JMP callbackasm1(SB) - MOV $818, X7 - JMP callbackasm1(SB) - MOV $819, X7 - JMP callbackasm1(SB) - MOV $820, X7 - JMP callbackasm1(SB) - MOV $821, X7 - JMP callbackasm1(SB) - MOV $822, X7 - JMP callbackasm1(SB) - MOV $823, X7 - JMP callbackasm1(SB) - MOV $824, X7 - JMP callbackasm1(SB) - MOV $825, X7 - JMP callbackasm1(SB) - MOV $826, X7 - JMP callbackasm1(SB) - MOV $827, X7 - JMP callbackasm1(SB) - MOV $828, X7 - JMP callbackasm1(SB) - MOV $829, X7 - JMP callbackasm1(SB) - MOV $830, X7 - JMP callbackasm1(SB) - MOV $831, X7 - JMP callbackasm1(SB) - MOV $832, X7 - JMP callbackasm1(SB) - MOV $833, X7 - JMP callbackasm1(SB) - MOV $834, X7 - JMP callbackasm1(SB) - MOV $835, X7 - JMP callbackasm1(SB) - MOV $836, X7 - JMP callbackasm1(SB) - MOV $837, X7 - JMP callbackasm1(SB) - MOV $838, X7 - JMP callbackasm1(SB) - MOV $839, X7 - JMP callbackasm1(SB) - MOV $840, X7 - JMP callbackasm1(SB) - MOV $841, X7 - JMP callbackasm1(SB) - MOV $842, X7 - JMP callbackasm1(SB) - MOV $843, X7 - JMP callbackasm1(SB) - MOV $844, X7 - JMP callbackasm1(SB) - MOV $845, X7 - JMP callbackasm1(SB) - MOV $846, X7 - JMP callbackasm1(SB) - MOV $847, X7 - JMP callbackasm1(SB) - MOV $848, X7 - JMP callbackasm1(SB) - MOV $849, X7 - JMP callbackasm1(SB) - MOV $850, X7 - JMP callbackasm1(SB) - MOV $851, X7 - JMP callbackasm1(SB) - MOV $852, X7 - JMP callbackasm1(SB) - MOV $853, X7 - JMP callbackasm1(SB) - MOV $854, X7 - JMP callbackasm1(SB) - MOV $855, X7 - JMP callbackasm1(SB) - MOV $856, X7 - JMP callbackasm1(SB) - MOV $857, X7 - JMP callbackasm1(SB) - MOV $858, X7 - JMP callbackasm1(SB) - MOV $859, X7 - JMP callbackasm1(SB) - MOV $860, X7 - JMP callbackasm1(SB) - MOV $861, X7 - JMP callbackasm1(SB) - MOV $862, X7 - JMP callbackasm1(SB) - MOV $863, X7 - JMP callbackasm1(SB) - MOV $864, X7 - JMP callbackasm1(SB) - MOV $865, X7 - JMP callbackasm1(SB) - MOV $866, X7 - JMP callbackasm1(SB) - MOV $867, X7 - JMP callbackasm1(SB) - MOV $868, X7 - JMP callbackasm1(SB) - MOV $869, X7 - JMP callbackasm1(SB) - MOV $870, X7 - JMP callbackasm1(SB) - MOV $871, X7 - JMP callbackasm1(SB) - MOV $872, X7 - JMP callbackasm1(SB) - MOV $873, X7 - JMP callbackasm1(SB) - MOV $874, X7 - JMP callbackasm1(SB) - MOV $875, X7 - JMP callbackasm1(SB) - MOV $876, X7 - JMP callbackasm1(SB) - MOV $877, X7 - JMP callbackasm1(SB) - MOV $878, X7 - JMP callbackasm1(SB) - MOV $879, X7 - JMP callbackasm1(SB) - MOV $880, X7 - JMP callbackasm1(SB) - MOV $881, X7 - JMP callbackasm1(SB) - MOV $882, X7 - JMP callbackasm1(SB) - MOV $883, X7 - JMP callbackasm1(SB) - MOV $884, X7 - JMP callbackasm1(SB) - MOV $885, X7 - JMP callbackasm1(SB) - MOV $886, X7 - JMP callbackasm1(SB) - MOV $887, X7 - JMP callbackasm1(SB) - MOV $888, X7 - JMP callbackasm1(SB) - MOV $889, X7 - JMP callbackasm1(SB) - MOV $890, X7 - JMP callbackasm1(SB) - MOV $891, X7 - JMP callbackasm1(SB) - MOV $892, X7 - JMP callbackasm1(SB) - MOV $893, X7 - JMP callbackasm1(SB) - MOV $894, X7 - JMP callbackasm1(SB) - MOV $895, X7 - JMP callbackasm1(SB) - MOV $896, X7 - JMP callbackasm1(SB) - MOV $897, X7 - JMP callbackasm1(SB) - MOV $898, X7 - JMP callbackasm1(SB) - MOV $899, X7 - JMP callbackasm1(SB) - MOV $900, X7 - JMP callbackasm1(SB) - MOV $901, X7 - JMP callbackasm1(SB) - MOV $902, X7 - JMP callbackasm1(SB) - MOV $903, X7 - JMP callbackasm1(SB) - MOV $904, X7 - JMP callbackasm1(SB) - MOV $905, X7 - JMP callbackasm1(SB) - MOV $906, X7 - JMP callbackasm1(SB) - MOV $907, X7 - JMP callbackasm1(SB) - MOV $908, X7 - JMP callbackasm1(SB) - MOV $909, X7 - JMP callbackasm1(SB) - MOV $910, X7 - JMP callbackasm1(SB) - MOV $911, X7 - JMP callbackasm1(SB) - MOV $912, X7 - JMP callbackasm1(SB) - MOV $913, X7 - JMP callbackasm1(SB) - MOV $914, X7 - JMP callbackasm1(SB) - MOV $915, X7 - JMP callbackasm1(SB) - MOV $916, X7 - JMP callbackasm1(SB) - MOV $917, X7 - JMP callbackasm1(SB) - MOV $918, X7 - JMP callbackasm1(SB) - MOV $919, X7 - JMP callbackasm1(SB) - MOV $920, X7 - JMP callbackasm1(SB) - MOV $921, X7 - JMP callbackasm1(SB) - MOV $922, X7 - JMP callbackasm1(SB) - MOV $923, X7 - JMP callbackasm1(SB) - MOV $924, X7 - JMP callbackasm1(SB) - MOV $925, X7 - JMP callbackasm1(SB) - MOV $926, X7 - JMP callbackasm1(SB) - MOV $927, X7 - JMP callbackasm1(SB) - MOV $928, X7 - JMP callbackasm1(SB) - MOV $929, X7 - JMP callbackasm1(SB) - MOV $930, X7 - JMP callbackasm1(SB) - MOV $931, X7 - JMP callbackasm1(SB) - MOV $932, X7 - JMP callbackasm1(SB) - MOV $933, X7 - JMP callbackasm1(SB) - MOV $934, X7 - JMP callbackasm1(SB) - MOV $935, X7 - JMP callbackasm1(SB) - MOV $936, X7 - JMP callbackasm1(SB) - MOV $937, X7 - JMP callbackasm1(SB) - MOV $938, X7 - JMP callbackasm1(SB) - MOV $939, X7 - JMP callbackasm1(SB) - MOV $940, X7 - JMP callbackasm1(SB) - MOV $941, X7 - JMP callbackasm1(SB) - MOV $942, X7 - JMP callbackasm1(SB) - MOV $943, X7 - JMP callbackasm1(SB) - MOV $944, X7 - JMP callbackasm1(SB) - MOV $945, X7 - JMP callbackasm1(SB) - MOV $946, X7 - JMP callbackasm1(SB) - MOV $947, X7 - JMP callbackasm1(SB) - MOV $948, X7 - JMP callbackasm1(SB) - MOV $949, X7 - JMP callbackasm1(SB) - MOV $950, X7 - JMP callbackasm1(SB) - MOV $951, X7 - JMP callbackasm1(SB) - MOV $952, X7 - JMP callbackasm1(SB) - MOV $953, X7 - JMP callbackasm1(SB) - MOV $954, X7 - JMP callbackasm1(SB) - MOV $955, X7 - JMP callbackasm1(SB) - MOV $956, X7 - JMP callbackasm1(SB) - MOV $957, X7 - JMP callbackasm1(SB) - MOV $958, X7 - JMP callbackasm1(SB) - MOV $959, X7 - JMP callbackasm1(SB) - MOV $960, X7 - JMP callbackasm1(SB) - MOV $961, X7 - JMP callbackasm1(SB) - MOV $962, X7 - JMP callbackasm1(SB) - MOV $963, X7 - JMP callbackasm1(SB) - MOV $964, X7 - JMP callbackasm1(SB) - MOV $965, X7 - JMP callbackasm1(SB) - MOV $966, X7 - JMP callbackasm1(SB) - MOV $967, X7 - JMP callbackasm1(SB) - MOV $968, X7 - JMP callbackasm1(SB) - MOV $969, X7 - JMP callbackasm1(SB) - MOV $970, X7 - JMP callbackasm1(SB) - MOV $971, X7 - JMP callbackasm1(SB) - MOV $972, X7 - JMP callbackasm1(SB) - MOV $973, X7 - JMP callbackasm1(SB) - MOV $974, X7 - JMP callbackasm1(SB) - MOV $975, X7 - JMP callbackasm1(SB) - MOV $976, X7 - JMP callbackasm1(SB) - MOV $977, X7 - JMP callbackasm1(SB) - MOV $978, X7 - JMP callbackasm1(SB) - MOV $979, X7 - JMP callbackasm1(SB) - MOV $980, X7 - JMP callbackasm1(SB) - MOV $981, X7 - JMP callbackasm1(SB) - MOV $982, X7 - JMP callbackasm1(SB) - MOV $983, X7 - JMP callbackasm1(SB) - MOV $984, X7 - JMP callbackasm1(SB) - MOV $985, X7 - JMP callbackasm1(SB) - MOV $986, X7 - JMP callbackasm1(SB) - MOV $987, X7 - JMP callbackasm1(SB) - MOV $988, X7 - JMP callbackasm1(SB) - MOV $989, X7 - JMP callbackasm1(SB) - MOV $990, X7 - JMP callbackasm1(SB) - MOV $991, X7 - JMP callbackasm1(SB) - MOV $992, X7 - JMP callbackasm1(SB) - MOV $993, X7 - JMP callbackasm1(SB) - MOV $994, X7 - JMP callbackasm1(SB) - MOV $995, X7 - JMP callbackasm1(SB) - MOV $996, X7 - JMP callbackasm1(SB) - MOV $997, X7 - JMP callbackasm1(SB) - MOV $998, X7 - JMP callbackasm1(SB) - MOV $999, X7 - JMP callbackasm1(SB) - MOV $1000, X7 - JMP callbackasm1(SB) - MOV $1001, X7 - JMP callbackasm1(SB) - MOV $1002, X7 - JMP callbackasm1(SB) - MOV $1003, X7 - JMP callbackasm1(SB) - MOV $1004, X7 - JMP callbackasm1(SB) - MOV $1005, X7 - JMP callbackasm1(SB) - MOV $1006, X7 - JMP callbackasm1(SB) - MOV $1007, X7 - JMP callbackasm1(SB) - MOV $1008, X7 - JMP callbackasm1(SB) - MOV $1009, X7 - JMP callbackasm1(SB) - MOV $1010, X7 - JMP callbackasm1(SB) - MOV $1011, X7 - JMP callbackasm1(SB) - MOV $1012, X7 - JMP callbackasm1(SB) - MOV $1013, X7 - JMP callbackasm1(SB) - MOV $1014, X7 - JMP callbackasm1(SB) - MOV $1015, X7 - JMP callbackasm1(SB) - MOV $1016, X7 - JMP callbackasm1(SB) - MOV $1017, X7 - JMP callbackasm1(SB) - MOV $1018, X7 - JMP callbackasm1(SB) - MOV $1019, X7 - JMP callbackasm1(SB) - MOV $1020, X7 - JMP callbackasm1(SB) - MOV $1021, X7 - JMP callbackasm1(SB) - MOV $1022, X7 - JMP callbackasm1(SB) - MOV $1023, X7 - JMP callbackasm1(SB) - MOV $1024, X7 - JMP callbackasm1(SB) - MOV $1025, X7 - JMP callbackasm1(SB) - MOV $1026, X7 - JMP callbackasm1(SB) - MOV $1027, X7 - JMP callbackasm1(SB) - MOV $1028, X7 - JMP callbackasm1(SB) - MOV $1029, X7 - JMP callbackasm1(SB) - MOV $1030, X7 - JMP callbackasm1(SB) - MOV $1031, X7 - JMP callbackasm1(SB) - MOV $1032, X7 - JMP callbackasm1(SB) - MOV $1033, X7 - JMP callbackasm1(SB) - MOV $1034, X7 - JMP callbackasm1(SB) - MOV $1035, X7 - JMP callbackasm1(SB) - MOV $1036, X7 - JMP callbackasm1(SB) - MOV $1037, X7 - JMP callbackasm1(SB) - MOV $1038, X7 - JMP callbackasm1(SB) - MOV $1039, X7 - JMP callbackasm1(SB) - MOV $1040, X7 - JMP callbackasm1(SB) - MOV $1041, X7 - JMP callbackasm1(SB) - MOV $1042, X7 - JMP callbackasm1(SB) - MOV $1043, X7 - JMP callbackasm1(SB) - MOV $1044, X7 - JMP callbackasm1(SB) - MOV $1045, X7 - JMP callbackasm1(SB) - MOV $1046, X7 - JMP callbackasm1(SB) - MOV $1047, X7 - JMP callbackasm1(SB) - MOV $1048, X7 - JMP callbackasm1(SB) - MOV $1049, X7 - JMP callbackasm1(SB) - MOV $1050, X7 - JMP callbackasm1(SB) - MOV $1051, X7 - JMP callbackasm1(SB) - MOV $1052, X7 - JMP callbackasm1(SB) - MOV $1053, X7 - JMP callbackasm1(SB) - MOV $1054, X7 - JMP callbackasm1(SB) - MOV $1055, X7 - JMP callbackasm1(SB) - MOV $1056, X7 - JMP callbackasm1(SB) - MOV $1057, X7 - JMP callbackasm1(SB) - MOV $1058, X7 - JMP callbackasm1(SB) - MOV $1059, X7 - JMP callbackasm1(SB) - MOV $1060, X7 - JMP callbackasm1(SB) - MOV $1061, X7 - JMP callbackasm1(SB) - MOV $1062, X7 - JMP callbackasm1(SB) - MOV $1063, X7 - JMP callbackasm1(SB) - MOV $1064, X7 - JMP callbackasm1(SB) - MOV $1065, X7 - JMP callbackasm1(SB) - MOV $1066, X7 - JMP callbackasm1(SB) - MOV $1067, X7 - JMP callbackasm1(SB) - MOV $1068, X7 - JMP callbackasm1(SB) - MOV $1069, X7 - JMP callbackasm1(SB) - MOV $1070, X7 - JMP callbackasm1(SB) - MOV $1071, X7 - JMP callbackasm1(SB) - MOV $1072, X7 - JMP callbackasm1(SB) - MOV $1073, X7 - JMP callbackasm1(SB) - MOV $1074, X7 - JMP callbackasm1(SB) - MOV $1075, X7 - JMP callbackasm1(SB) - MOV $1076, X7 - JMP callbackasm1(SB) - MOV $1077, X7 - JMP callbackasm1(SB) - MOV $1078, X7 - JMP callbackasm1(SB) - MOV $1079, X7 - JMP callbackasm1(SB) - MOV $1080, X7 - JMP callbackasm1(SB) - MOV $1081, X7 - JMP callbackasm1(SB) - MOV $1082, X7 - JMP callbackasm1(SB) - MOV $1083, X7 - JMP callbackasm1(SB) - MOV $1084, X7 - JMP callbackasm1(SB) - MOV $1085, X7 - JMP callbackasm1(SB) - MOV $1086, X7 - JMP callbackasm1(SB) - MOV $1087, X7 - JMP callbackasm1(SB) - MOV $1088, X7 - JMP callbackasm1(SB) - MOV $1089, X7 - JMP callbackasm1(SB) - MOV $1090, X7 - JMP callbackasm1(SB) - MOV $1091, X7 - JMP callbackasm1(SB) - MOV $1092, X7 - JMP callbackasm1(SB) - MOV $1093, X7 - JMP callbackasm1(SB) - MOV $1094, X7 - JMP callbackasm1(SB) - MOV $1095, X7 - JMP callbackasm1(SB) - MOV $1096, X7 - JMP callbackasm1(SB) - MOV $1097, X7 - JMP callbackasm1(SB) - MOV $1098, X7 - JMP callbackasm1(SB) - MOV $1099, X7 - JMP callbackasm1(SB) - MOV $1100, X7 - JMP callbackasm1(SB) - MOV $1101, X7 - JMP callbackasm1(SB) - MOV $1102, X7 - JMP callbackasm1(SB) - MOV $1103, X7 - JMP callbackasm1(SB) - MOV $1104, X7 - JMP callbackasm1(SB) - MOV $1105, X7 - JMP callbackasm1(SB) - MOV $1106, X7 - JMP callbackasm1(SB) - MOV $1107, X7 - JMP callbackasm1(SB) - MOV $1108, X7 - JMP callbackasm1(SB) - MOV $1109, X7 - JMP callbackasm1(SB) - MOV $1110, X7 - JMP callbackasm1(SB) - MOV $1111, X7 - JMP callbackasm1(SB) - MOV $1112, X7 - JMP callbackasm1(SB) - MOV $1113, X7 - JMP callbackasm1(SB) - MOV $1114, X7 - JMP callbackasm1(SB) - MOV $1115, X7 - JMP callbackasm1(SB) - MOV $1116, X7 - JMP callbackasm1(SB) - MOV $1117, X7 - JMP callbackasm1(SB) - MOV $1118, X7 - JMP callbackasm1(SB) - MOV $1119, X7 - JMP callbackasm1(SB) - MOV $1120, X7 - JMP callbackasm1(SB) - MOV $1121, X7 - JMP callbackasm1(SB) - MOV $1122, X7 - JMP callbackasm1(SB) - MOV $1123, X7 - JMP callbackasm1(SB) - MOV $1124, X7 - JMP callbackasm1(SB) - MOV $1125, X7 - JMP callbackasm1(SB) - MOV $1126, X7 - JMP callbackasm1(SB) - MOV $1127, X7 - JMP callbackasm1(SB) - MOV $1128, X7 - JMP callbackasm1(SB) - MOV $1129, X7 - JMP callbackasm1(SB) - MOV $1130, X7 - JMP callbackasm1(SB) - MOV $1131, X7 - JMP callbackasm1(SB) - MOV $1132, X7 - JMP callbackasm1(SB) - MOV $1133, X7 - JMP callbackasm1(SB) - MOV $1134, X7 - JMP callbackasm1(SB) - MOV $1135, X7 - JMP callbackasm1(SB) - MOV $1136, X7 - JMP callbackasm1(SB) - MOV $1137, X7 - JMP callbackasm1(SB) - MOV $1138, X7 - JMP callbackasm1(SB) - MOV $1139, X7 - JMP callbackasm1(SB) - MOV $1140, X7 - JMP callbackasm1(SB) - MOV $1141, X7 - JMP callbackasm1(SB) - MOV $1142, X7 - JMP callbackasm1(SB) - MOV $1143, X7 - JMP callbackasm1(SB) - MOV $1144, X7 - JMP callbackasm1(SB) - MOV $1145, X7 - JMP callbackasm1(SB) - MOV $1146, X7 - JMP callbackasm1(SB) - MOV $1147, X7 - JMP callbackasm1(SB) - MOV $1148, X7 - JMP callbackasm1(SB) - MOV $1149, X7 - JMP callbackasm1(SB) - MOV $1150, X7 - JMP callbackasm1(SB) - MOV $1151, X7 - JMP callbackasm1(SB) - MOV $1152, X7 - JMP callbackasm1(SB) - MOV $1153, X7 - JMP callbackasm1(SB) - MOV $1154, X7 - JMP callbackasm1(SB) - MOV $1155, X7 - JMP callbackasm1(SB) - MOV $1156, X7 - JMP callbackasm1(SB) - MOV $1157, X7 - JMP callbackasm1(SB) - MOV $1158, X7 - JMP callbackasm1(SB) - MOV $1159, X7 - JMP callbackasm1(SB) - MOV $1160, X7 - JMP callbackasm1(SB) - MOV $1161, X7 - JMP callbackasm1(SB) - MOV $1162, X7 - JMP callbackasm1(SB) - MOV $1163, X7 - JMP callbackasm1(SB) - MOV $1164, X7 - JMP callbackasm1(SB) - MOV $1165, X7 - JMP callbackasm1(SB) - MOV $1166, X7 - JMP callbackasm1(SB) - MOV $1167, X7 - JMP callbackasm1(SB) - MOV $1168, X7 - JMP callbackasm1(SB) - MOV $1169, X7 - JMP callbackasm1(SB) - MOV $1170, X7 - JMP callbackasm1(SB) - MOV $1171, X7 - JMP callbackasm1(SB) - MOV $1172, X7 - JMP callbackasm1(SB) - MOV $1173, X7 - JMP callbackasm1(SB) - MOV $1174, X7 - JMP callbackasm1(SB) - MOV $1175, X7 - JMP callbackasm1(SB) - MOV $1176, X7 - JMP callbackasm1(SB) - MOV $1177, X7 - JMP callbackasm1(SB) - MOV $1178, X7 - JMP callbackasm1(SB) - MOV $1179, X7 - JMP callbackasm1(SB) - MOV $1180, X7 - JMP callbackasm1(SB) - MOV $1181, X7 - JMP callbackasm1(SB) - MOV $1182, X7 - JMP callbackasm1(SB) - MOV $1183, X7 - JMP callbackasm1(SB) - MOV $1184, X7 - JMP callbackasm1(SB) - MOV $1185, X7 - JMP callbackasm1(SB) - MOV $1186, X7 - JMP callbackasm1(SB) - MOV $1187, X7 - JMP callbackasm1(SB) - MOV $1188, X7 - JMP callbackasm1(SB) - MOV $1189, X7 - JMP callbackasm1(SB) - MOV $1190, X7 - JMP callbackasm1(SB) - MOV $1191, X7 - JMP callbackasm1(SB) - MOV $1192, X7 - JMP callbackasm1(SB) - MOV $1193, X7 - JMP callbackasm1(SB) - MOV $1194, X7 - JMP callbackasm1(SB) - MOV $1195, X7 - JMP callbackasm1(SB) - MOV $1196, X7 - JMP callbackasm1(SB) - MOV $1197, X7 - JMP callbackasm1(SB) - MOV $1198, X7 - JMP callbackasm1(SB) - MOV $1199, X7 - JMP callbackasm1(SB) - MOV $1200, X7 - JMP callbackasm1(SB) - MOV $1201, X7 - JMP callbackasm1(SB) - MOV $1202, X7 - JMP callbackasm1(SB) - MOV $1203, X7 - JMP callbackasm1(SB) - MOV $1204, X7 - JMP callbackasm1(SB) - MOV $1205, X7 - JMP callbackasm1(SB) - MOV $1206, X7 - JMP callbackasm1(SB) - MOV $1207, X7 - JMP callbackasm1(SB) - MOV $1208, X7 - JMP callbackasm1(SB) - MOV $1209, X7 - JMP callbackasm1(SB) - MOV $1210, X7 - JMP callbackasm1(SB) - MOV $1211, X7 - JMP callbackasm1(SB) - MOV $1212, X7 - JMP callbackasm1(SB) - MOV $1213, X7 - JMP callbackasm1(SB) - MOV $1214, X7 - JMP callbackasm1(SB) - MOV $1215, X7 - JMP callbackasm1(SB) - MOV $1216, X7 - JMP callbackasm1(SB) - MOV $1217, X7 - JMP callbackasm1(SB) - MOV $1218, X7 - JMP callbackasm1(SB) - MOV $1219, X7 - JMP callbackasm1(SB) - MOV $1220, X7 - JMP callbackasm1(SB) - MOV $1221, X7 - JMP callbackasm1(SB) - MOV $1222, X7 - JMP callbackasm1(SB) - MOV $1223, X7 - JMP callbackasm1(SB) - MOV $1224, X7 - JMP callbackasm1(SB) - MOV $1225, X7 - JMP callbackasm1(SB) - MOV $1226, X7 - JMP callbackasm1(SB) - MOV $1227, X7 - JMP callbackasm1(SB) - MOV $1228, X7 - JMP callbackasm1(SB) - MOV $1229, X7 - JMP callbackasm1(SB) - MOV $1230, X7 - JMP callbackasm1(SB) - MOV $1231, X7 - JMP callbackasm1(SB) - MOV $1232, X7 - JMP callbackasm1(SB) - MOV $1233, X7 - JMP callbackasm1(SB) - MOV $1234, X7 - JMP callbackasm1(SB) - MOV $1235, X7 - JMP callbackasm1(SB) - MOV $1236, X7 - JMP callbackasm1(SB) - MOV $1237, X7 - JMP callbackasm1(SB) - MOV $1238, X7 - JMP callbackasm1(SB) - MOV $1239, X7 - JMP callbackasm1(SB) - MOV $1240, X7 - JMP callbackasm1(SB) - MOV $1241, X7 - JMP callbackasm1(SB) - MOV $1242, X7 - JMP callbackasm1(SB) - MOV $1243, X7 - JMP callbackasm1(SB) - MOV $1244, X7 - JMP callbackasm1(SB) - MOV $1245, X7 - JMP callbackasm1(SB) - MOV $1246, X7 - JMP callbackasm1(SB) - MOV $1247, X7 - JMP callbackasm1(SB) - MOV $1248, X7 - JMP callbackasm1(SB) - MOV $1249, X7 - JMP callbackasm1(SB) - MOV $1250, X7 - JMP callbackasm1(SB) - MOV $1251, X7 - JMP callbackasm1(SB) - MOV $1252, X7 - JMP callbackasm1(SB) - MOV $1253, X7 - JMP callbackasm1(SB) - MOV $1254, X7 - JMP callbackasm1(SB) - MOV $1255, X7 - JMP callbackasm1(SB) - MOV $1256, X7 - JMP callbackasm1(SB) - MOV $1257, X7 - JMP callbackasm1(SB) - MOV $1258, X7 - JMP callbackasm1(SB) - MOV $1259, X7 - JMP callbackasm1(SB) - MOV $1260, X7 - JMP callbackasm1(SB) - MOV $1261, X7 - JMP callbackasm1(SB) - MOV $1262, X7 - JMP callbackasm1(SB) - MOV $1263, X7 - JMP callbackasm1(SB) - MOV $1264, X7 - JMP callbackasm1(SB) - MOV $1265, X7 - JMP callbackasm1(SB) - MOV $1266, X7 - JMP callbackasm1(SB) - MOV $1267, X7 - JMP callbackasm1(SB) - MOV $1268, X7 - JMP callbackasm1(SB) - MOV $1269, X7 - JMP callbackasm1(SB) - MOV $1270, X7 - JMP callbackasm1(SB) - MOV $1271, X7 - JMP callbackasm1(SB) - MOV $1272, X7 - JMP callbackasm1(SB) - MOV $1273, X7 - JMP callbackasm1(SB) - MOV $1274, X7 - JMP callbackasm1(SB) - MOV $1275, X7 - JMP callbackasm1(SB) - MOV $1276, X7 - JMP callbackasm1(SB) - MOV $1277, X7 - JMP callbackasm1(SB) - MOV $1278, X7 - JMP callbackasm1(SB) - MOV $1279, X7 - JMP callbackasm1(SB) - MOV $1280, X7 - JMP callbackasm1(SB) - MOV $1281, X7 - JMP callbackasm1(SB) - MOV $1282, X7 - JMP callbackasm1(SB) - MOV $1283, X7 - JMP callbackasm1(SB) - MOV $1284, X7 - JMP callbackasm1(SB) - MOV $1285, X7 - JMP callbackasm1(SB) - MOV $1286, X7 - JMP callbackasm1(SB) - MOV $1287, X7 - JMP callbackasm1(SB) - MOV $1288, X7 - JMP callbackasm1(SB) - MOV $1289, X7 - JMP callbackasm1(SB) - MOV $1290, X7 - JMP callbackasm1(SB) - MOV $1291, X7 - JMP callbackasm1(SB) - MOV $1292, X7 - JMP callbackasm1(SB) - MOV $1293, X7 - JMP callbackasm1(SB) - MOV $1294, X7 - JMP callbackasm1(SB) - MOV $1295, X7 - JMP callbackasm1(SB) - MOV $1296, X7 - JMP callbackasm1(SB) - MOV $1297, X7 - JMP callbackasm1(SB) - MOV $1298, X7 - JMP callbackasm1(SB) - MOV $1299, X7 - JMP callbackasm1(SB) - MOV $1300, X7 - JMP callbackasm1(SB) - MOV $1301, X7 - JMP callbackasm1(SB) - MOV $1302, X7 - JMP callbackasm1(SB) - MOV $1303, X7 - JMP callbackasm1(SB) - MOV $1304, X7 - JMP callbackasm1(SB) - MOV $1305, X7 - JMP callbackasm1(SB) - MOV $1306, X7 - JMP callbackasm1(SB) - MOV $1307, X7 - JMP callbackasm1(SB) - MOV $1308, X7 - JMP callbackasm1(SB) - MOV $1309, X7 - JMP callbackasm1(SB) - MOV $1310, X7 - JMP callbackasm1(SB) - MOV $1311, X7 - JMP callbackasm1(SB) - MOV $1312, X7 - JMP callbackasm1(SB) - MOV $1313, X7 - JMP callbackasm1(SB) - MOV $1314, X7 - JMP callbackasm1(SB) - MOV $1315, X7 - JMP callbackasm1(SB) - MOV $1316, X7 - JMP callbackasm1(SB) - MOV $1317, X7 - JMP callbackasm1(SB) - MOV $1318, X7 - JMP callbackasm1(SB) - MOV $1319, X7 - JMP callbackasm1(SB) - MOV $1320, X7 - JMP callbackasm1(SB) - MOV $1321, X7 - JMP callbackasm1(SB) - MOV $1322, X7 - JMP callbackasm1(SB) - MOV $1323, X7 - JMP callbackasm1(SB) - MOV $1324, X7 - JMP callbackasm1(SB) - MOV $1325, X7 - JMP callbackasm1(SB) - MOV $1326, X7 - JMP callbackasm1(SB) - MOV $1327, X7 - JMP callbackasm1(SB) - MOV $1328, X7 - JMP callbackasm1(SB) - MOV $1329, X7 - JMP callbackasm1(SB) - MOV $1330, X7 - JMP callbackasm1(SB) - MOV $1331, X7 - JMP callbackasm1(SB) - MOV $1332, X7 - JMP callbackasm1(SB) - MOV $1333, X7 - JMP callbackasm1(SB) - MOV $1334, X7 - JMP callbackasm1(SB) - MOV $1335, X7 - JMP callbackasm1(SB) - MOV $1336, X7 - JMP callbackasm1(SB) - MOV $1337, X7 - JMP callbackasm1(SB) - MOV $1338, X7 - JMP callbackasm1(SB) - MOV $1339, X7 - JMP callbackasm1(SB) - MOV $1340, X7 - JMP callbackasm1(SB) - MOV $1341, X7 - JMP callbackasm1(SB) - MOV $1342, X7 - JMP callbackasm1(SB) - MOV $1343, X7 - JMP callbackasm1(SB) - MOV $1344, X7 - JMP callbackasm1(SB) - MOV $1345, X7 - JMP callbackasm1(SB) - MOV $1346, X7 - JMP callbackasm1(SB) - MOV $1347, X7 - JMP callbackasm1(SB) - MOV $1348, X7 - JMP callbackasm1(SB) - MOV $1349, X7 - JMP callbackasm1(SB) - MOV $1350, X7 - JMP callbackasm1(SB) - MOV $1351, X7 - JMP callbackasm1(SB) - MOV $1352, X7 - JMP callbackasm1(SB) - MOV $1353, X7 - JMP callbackasm1(SB) - MOV $1354, X7 - JMP callbackasm1(SB) - MOV $1355, X7 - JMP callbackasm1(SB) - MOV $1356, X7 - JMP callbackasm1(SB) - MOV $1357, X7 - JMP callbackasm1(SB) - MOV $1358, X7 - JMP callbackasm1(SB) - MOV $1359, X7 - JMP callbackasm1(SB) - MOV $1360, X7 - JMP callbackasm1(SB) - MOV $1361, X7 - JMP callbackasm1(SB) - MOV $1362, X7 - JMP callbackasm1(SB) - MOV $1363, X7 - JMP callbackasm1(SB) - MOV $1364, X7 - JMP callbackasm1(SB) - MOV $1365, X7 - JMP callbackasm1(SB) - MOV $1366, X7 - JMP callbackasm1(SB) - MOV $1367, X7 - JMP callbackasm1(SB) - MOV $1368, X7 - JMP callbackasm1(SB) - MOV $1369, X7 - JMP callbackasm1(SB) - MOV $1370, X7 - JMP callbackasm1(SB) - MOV $1371, X7 - JMP callbackasm1(SB) - MOV $1372, X7 - JMP callbackasm1(SB) - MOV $1373, X7 - JMP callbackasm1(SB) - MOV $1374, X7 - JMP callbackasm1(SB) - MOV $1375, X7 - JMP callbackasm1(SB) - MOV $1376, X7 - JMP callbackasm1(SB) - MOV $1377, X7 - JMP callbackasm1(SB) - MOV $1378, X7 - JMP callbackasm1(SB) - MOV $1379, X7 - JMP callbackasm1(SB) - MOV $1380, X7 - JMP callbackasm1(SB) - MOV $1381, X7 - JMP callbackasm1(SB) - MOV $1382, X7 - JMP callbackasm1(SB) - MOV $1383, X7 - JMP callbackasm1(SB) - MOV $1384, X7 - JMP callbackasm1(SB) - MOV $1385, X7 - JMP callbackasm1(SB) - MOV $1386, X7 - JMP callbackasm1(SB) - MOV $1387, X7 - JMP callbackasm1(SB) - MOV $1388, X7 - JMP callbackasm1(SB) - MOV $1389, X7 - JMP callbackasm1(SB) - MOV $1390, X7 - JMP callbackasm1(SB) - MOV $1391, X7 - JMP callbackasm1(SB) - MOV $1392, X7 - JMP callbackasm1(SB) - MOV $1393, X7 - JMP callbackasm1(SB) - MOV $1394, X7 - JMP callbackasm1(SB) - MOV $1395, X7 - JMP callbackasm1(SB) - MOV $1396, X7 - JMP callbackasm1(SB) - MOV $1397, X7 - JMP callbackasm1(SB) - MOV $1398, X7 - JMP callbackasm1(SB) - MOV $1399, X7 - JMP callbackasm1(SB) - MOV $1400, X7 - JMP callbackasm1(SB) - MOV $1401, X7 - JMP callbackasm1(SB) - MOV $1402, X7 - JMP callbackasm1(SB) - MOV $1403, X7 - JMP callbackasm1(SB) - MOV $1404, X7 - JMP callbackasm1(SB) - MOV $1405, X7 - JMP callbackasm1(SB) - MOV $1406, X7 - JMP callbackasm1(SB) - MOV $1407, X7 - JMP callbackasm1(SB) - MOV $1408, X7 - JMP callbackasm1(SB) - MOV $1409, X7 - JMP callbackasm1(SB) - MOV $1410, X7 - JMP callbackasm1(SB) - MOV $1411, X7 - JMP callbackasm1(SB) - MOV $1412, X7 - JMP callbackasm1(SB) - MOV $1413, X7 - JMP callbackasm1(SB) - MOV $1414, X7 - JMP callbackasm1(SB) - MOV $1415, X7 - JMP callbackasm1(SB) - MOV $1416, X7 - JMP callbackasm1(SB) - MOV $1417, X7 - JMP callbackasm1(SB) - MOV $1418, X7 - JMP callbackasm1(SB) - MOV $1419, X7 - JMP callbackasm1(SB) - MOV $1420, X7 - JMP callbackasm1(SB) - MOV $1421, X7 - JMP callbackasm1(SB) - MOV $1422, X7 - JMP callbackasm1(SB) - MOV $1423, X7 - JMP callbackasm1(SB) - MOV $1424, X7 - JMP callbackasm1(SB) - MOV $1425, X7 - JMP callbackasm1(SB) - MOV $1426, X7 - JMP callbackasm1(SB) - MOV $1427, X7 - JMP callbackasm1(SB) - MOV $1428, X7 - JMP callbackasm1(SB) - MOV $1429, X7 - JMP callbackasm1(SB) - MOV $1430, X7 - JMP callbackasm1(SB) - MOV $1431, X7 - JMP callbackasm1(SB) - MOV $1432, X7 - JMP callbackasm1(SB) - MOV $1433, X7 - JMP callbackasm1(SB) - MOV $1434, X7 - JMP callbackasm1(SB) - MOV $1435, X7 - JMP callbackasm1(SB) - MOV $1436, X7 - JMP callbackasm1(SB) - MOV $1437, X7 - JMP callbackasm1(SB) - MOV $1438, X7 - JMP callbackasm1(SB) - MOV $1439, X7 - JMP callbackasm1(SB) - MOV $1440, X7 - JMP callbackasm1(SB) - MOV $1441, X7 - JMP callbackasm1(SB) - MOV $1442, X7 - JMP callbackasm1(SB) - MOV $1443, X7 - JMP callbackasm1(SB) - MOV $1444, X7 - JMP callbackasm1(SB) - MOV $1445, X7 - JMP callbackasm1(SB) - MOV $1446, X7 - JMP callbackasm1(SB) - MOV $1447, X7 - JMP callbackasm1(SB) - MOV $1448, X7 - JMP callbackasm1(SB) - MOV $1449, X7 - JMP callbackasm1(SB) - MOV $1450, X7 - JMP callbackasm1(SB) - MOV $1451, X7 - JMP callbackasm1(SB) - MOV $1452, X7 - JMP callbackasm1(SB) - MOV $1453, X7 - JMP callbackasm1(SB) - MOV $1454, X7 - JMP callbackasm1(SB) - MOV $1455, X7 - JMP callbackasm1(SB) - MOV $1456, X7 - JMP callbackasm1(SB) - MOV $1457, X7 - JMP callbackasm1(SB) - MOV $1458, X7 - JMP callbackasm1(SB) - MOV $1459, X7 - JMP callbackasm1(SB) - MOV $1460, X7 - JMP callbackasm1(SB) - MOV $1461, X7 - JMP callbackasm1(SB) - MOV $1462, X7 - JMP callbackasm1(SB) - MOV $1463, X7 - JMP callbackasm1(SB) - MOV $1464, X7 - JMP callbackasm1(SB) - MOV $1465, X7 - JMP callbackasm1(SB) - MOV $1466, X7 - JMP callbackasm1(SB) - MOV $1467, X7 - JMP callbackasm1(SB) - MOV $1468, X7 - JMP callbackasm1(SB) - MOV $1469, X7 - JMP callbackasm1(SB) - MOV $1470, X7 - JMP callbackasm1(SB) - MOV $1471, X7 - JMP callbackasm1(SB) - MOV $1472, X7 - JMP callbackasm1(SB) - MOV $1473, X7 - JMP callbackasm1(SB) - MOV $1474, X7 - JMP callbackasm1(SB) - MOV $1475, X7 - JMP callbackasm1(SB) - MOV $1476, X7 - JMP callbackasm1(SB) - MOV $1477, X7 - JMP callbackasm1(SB) - MOV $1478, X7 - JMP callbackasm1(SB) - MOV $1479, X7 - JMP callbackasm1(SB) - MOV $1480, X7 - JMP callbackasm1(SB) - MOV $1481, X7 - JMP callbackasm1(SB) - MOV $1482, X7 - JMP callbackasm1(SB) - MOV $1483, X7 - JMP callbackasm1(SB) - MOV $1484, X7 - JMP callbackasm1(SB) - MOV $1485, X7 - JMP callbackasm1(SB) - MOV $1486, X7 - JMP callbackasm1(SB) - MOV $1487, X7 - JMP callbackasm1(SB) - MOV $1488, X7 - JMP callbackasm1(SB) - MOV $1489, X7 - JMP callbackasm1(SB) - MOV $1490, X7 - JMP callbackasm1(SB) - MOV $1491, X7 - JMP callbackasm1(SB) - MOV $1492, X7 - JMP callbackasm1(SB) - MOV $1493, X7 - JMP callbackasm1(SB) - MOV $1494, X7 - JMP callbackasm1(SB) - MOV $1495, X7 - JMP callbackasm1(SB) - MOV $1496, X7 - JMP callbackasm1(SB) - MOV $1497, X7 - JMP callbackasm1(SB) - MOV $1498, X7 - JMP callbackasm1(SB) - MOV $1499, X7 - JMP callbackasm1(SB) - MOV $1500, X7 - JMP callbackasm1(SB) - MOV $1501, X7 - JMP callbackasm1(SB) - MOV $1502, X7 - JMP callbackasm1(SB) - MOV $1503, X7 - JMP callbackasm1(SB) - MOV $1504, X7 - JMP callbackasm1(SB) - MOV $1505, X7 - JMP callbackasm1(SB) - MOV $1506, X7 - JMP callbackasm1(SB) - MOV $1507, X7 - JMP callbackasm1(SB) - MOV $1508, X7 - JMP callbackasm1(SB) - MOV $1509, X7 - JMP callbackasm1(SB) - MOV $1510, X7 - JMP callbackasm1(SB) - MOV $1511, X7 - JMP callbackasm1(SB) - MOV $1512, X7 - JMP callbackasm1(SB) - MOV $1513, X7 - JMP callbackasm1(SB) - MOV $1514, X7 - JMP callbackasm1(SB) - MOV $1515, X7 - JMP callbackasm1(SB) - MOV $1516, X7 - JMP callbackasm1(SB) - MOV $1517, X7 - JMP callbackasm1(SB) - MOV $1518, X7 - JMP callbackasm1(SB) - MOV $1519, X7 - JMP callbackasm1(SB) - MOV $1520, X7 - JMP callbackasm1(SB) - MOV $1521, X7 - JMP callbackasm1(SB) - MOV $1522, X7 - JMP callbackasm1(SB) - MOV $1523, X7 - JMP callbackasm1(SB) - MOV $1524, X7 - JMP callbackasm1(SB) - MOV $1525, X7 - JMP callbackasm1(SB) - MOV $1526, X7 - JMP callbackasm1(SB) - MOV $1527, X7 - JMP callbackasm1(SB) - MOV $1528, X7 - JMP callbackasm1(SB) - MOV $1529, X7 - JMP callbackasm1(SB) - MOV $1530, X7 - JMP callbackasm1(SB) - MOV $1531, X7 - JMP callbackasm1(SB) - MOV $1532, X7 - JMP callbackasm1(SB) - MOV $1533, X7 - JMP callbackasm1(SB) - MOV $1534, X7 - JMP callbackasm1(SB) - MOV $1535, X7 - JMP callbackasm1(SB) - MOV $1536, X7 - JMP callbackasm1(SB) - MOV $1537, X7 - JMP callbackasm1(SB) - MOV $1538, X7 - JMP callbackasm1(SB) - MOV $1539, X7 - JMP callbackasm1(SB) - MOV $1540, X7 - JMP callbackasm1(SB) - MOV $1541, X7 - JMP callbackasm1(SB) - MOV $1542, X7 - JMP callbackasm1(SB) - MOV $1543, X7 - JMP callbackasm1(SB) - MOV $1544, X7 - JMP callbackasm1(SB) - MOV $1545, X7 - JMP callbackasm1(SB) - MOV $1546, X7 - JMP callbackasm1(SB) - MOV $1547, X7 - JMP callbackasm1(SB) - MOV $1548, X7 - JMP callbackasm1(SB) - MOV $1549, X7 - JMP callbackasm1(SB) - MOV $1550, X7 - JMP callbackasm1(SB) - MOV $1551, X7 - JMP callbackasm1(SB) - MOV $1552, X7 - JMP callbackasm1(SB) - MOV $1553, X7 - JMP callbackasm1(SB) - MOV $1554, X7 - JMP callbackasm1(SB) - MOV $1555, X7 - JMP callbackasm1(SB) - MOV $1556, X7 - JMP callbackasm1(SB) - MOV $1557, X7 - JMP callbackasm1(SB) - MOV $1558, X7 - JMP callbackasm1(SB) - MOV $1559, X7 - JMP callbackasm1(SB) - MOV $1560, X7 - JMP callbackasm1(SB) - MOV $1561, X7 - JMP callbackasm1(SB) - MOV $1562, X7 - JMP callbackasm1(SB) - MOV $1563, X7 - JMP callbackasm1(SB) - MOV $1564, X7 - JMP callbackasm1(SB) - MOV $1565, X7 - JMP callbackasm1(SB) - MOV $1566, X7 - JMP callbackasm1(SB) - MOV $1567, X7 - JMP callbackasm1(SB) - MOV $1568, X7 - JMP callbackasm1(SB) - MOV $1569, X7 - JMP callbackasm1(SB) - MOV $1570, X7 - JMP callbackasm1(SB) - MOV $1571, X7 - JMP callbackasm1(SB) - MOV $1572, X7 - JMP callbackasm1(SB) - MOV $1573, X7 - JMP callbackasm1(SB) - MOV $1574, X7 - JMP callbackasm1(SB) - MOV $1575, X7 - JMP callbackasm1(SB) - MOV $1576, X7 - JMP callbackasm1(SB) - MOV $1577, X7 - JMP callbackasm1(SB) - MOV $1578, X7 - JMP callbackasm1(SB) - MOV $1579, X7 - JMP callbackasm1(SB) - MOV $1580, X7 - JMP callbackasm1(SB) - MOV $1581, X7 - JMP callbackasm1(SB) - MOV $1582, X7 - JMP callbackasm1(SB) - MOV $1583, X7 - JMP callbackasm1(SB) - MOV $1584, X7 - JMP callbackasm1(SB) - MOV $1585, X7 - JMP callbackasm1(SB) - MOV $1586, X7 - JMP callbackasm1(SB) - MOV $1587, X7 - JMP callbackasm1(SB) - MOV $1588, X7 - JMP callbackasm1(SB) - MOV $1589, X7 - JMP callbackasm1(SB) - MOV $1590, X7 - JMP callbackasm1(SB) - MOV $1591, X7 - JMP callbackasm1(SB) - MOV $1592, X7 - JMP callbackasm1(SB) - MOV $1593, X7 - JMP callbackasm1(SB) - MOV $1594, X7 - JMP callbackasm1(SB) - MOV $1595, X7 - JMP callbackasm1(SB) - MOV $1596, X7 - JMP callbackasm1(SB) - MOV $1597, X7 - JMP callbackasm1(SB) - MOV $1598, X7 - JMP callbackasm1(SB) - MOV $1599, X7 - JMP callbackasm1(SB) - MOV $1600, X7 - JMP callbackasm1(SB) - MOV $1601, X7 - JMP callbackasm1(SB) - MOV $1602, X7 - JMP callbackasm1(SB) - MOV $1603, X7 - JMP callbackasm1(SB) - MOV $1604, X7 - JMP callbackasm1(SB) - MOV $1605, X7 - JMP callbackasm1(SB) - MOV $1606, X7 - JMP callbackasm1(SB) - MOV $1607, X7 - JMP callbackasm1(SB) - MOV $1608, X7 - JMP callbackasm1(SB) - MOV $1609, X7 - JMP callbackasm1(SB) - MOV $1610, X7 - JMP callbackasm1(SB) - MOV $1611, X7 - JMP callbackasm1(SB) - MOV $1612, X7 - JMP callbackasm1(SB) - MOV $1613, X7 - JMP callbackasm1(SB) - MOV $1614, X7 - JMP callbackasm1(SB) - MOV $1615, X7 - JMP callbackasm1(SB) - MOV $1616, X7 - JMP callbackasm1(SB) - MOV $1617, X7 - JMP callbackasm1(SB) - MOV $1618, X7 - JMP callbackasm1(SB) - MOV $1619, X7 - JMP callbackasm1(SB) - MOV $1620, X7 - JMP callbackasm1(SB) - MOV $1621, X7 - JMP callbackasm1(SB) - MOV $1622, X7 - JMP callbackasm1(SB) - MOV $1623, X7 - JMP callbackasm1(SB) - MOV $1624, X7 - JMP callbackasm1(SB) - MOV $1625, X7 - JMP callbackasm1(SB) - MOV $1626, X7 - JMP callbackasm1(SB) - MOV $1627, X7 - JMP callbackasm1(SB) - MOV $1628, X7 - JMP callbackasm1(SB) - MOV $1629, X7 - JMP callbackasm1(SB) - MOV $1630, X7 - JMP callbackasm1(SB) - MOV $1631, X7 - JMP callbackasm1(SB) - MOV $1632, X7 - JMP callbackasm1(SB) - MOV $1633, X7 - JMP callbackasm1(SB) - MOV $1634, X7 - JMP callbackasm1(SB) - MOV $1635, X7 - JMP callbackasm1(SB) - MOV $1636, X7 - JMP callbackasm1(SB) - MOV $1637, X7 - JMP callbackasm1(SB) - MOV $1638, X7 - JMP callbackasm1(SB) - MOV $1639, X7 - JMP callbackasm1(SB) - MOV $1640, X7 - JMP callbackasm1(SB) - MOV $1641, X7 - JMP callbackasm1(SB) - MOV $1642, X7 - JMP callbackasm1(SB) - MOV $1643, X7 - JMP callbackasm1(SB) - MOV $1644, X7 - JMP callbackasm1(SB) - MOV $1645, X7 - JMP callbackasm1(SB) - MOV $1646, X7 - JMP callbackasm1(SB) - MOV $1647, X7 - JMP callbackasm1(SB) - MOV $1648, X7 - JMP callbackasm1(SB) - MOV $1649, X7 - JMP callbackasm1(SB) - MOV $1650, X7 - JMP callbackasm1(SB) - MOV $1651, X7 - JMP callbackasm1(SB) - MOV $1652, X7 - JMP callbackasm1(SB) - MOV $1653, X7 - JMP callbackasm1(SB) - MOV $1654, X7 - JMP callbackasm1(SB) - MOV $1655, X7 - JMP callbackasm1(SB) - MOV $1656, X7 - JMP callbackasm1(SB) - MOV $1657, X7 - JMP callbackasm1(SB) - MOV $1658, X7 - JMP callbackasm1(SB) - MOV $1659, X7 - JMP callbackasm1(SB) - MOV $1660, X7 - JMP callbackasm1(SB) - MOV $1661, X7 - JMP callbackasm1(SB) - MOV $1662, X7 - JMP callbackasm1(SB) - MOV $1663, X7 - JMP callbackasm1(SB) - MOV $1664, X7 - JMP callbackasm1(SB) - MOV $1665, X7 - JMP callbackasm1(SB) - MOV $1666, X7 - JMP callbackasm1(SB) - MOV $1667, X7 - JMP callbackasm1(SB) - MOV $1668, X7 - JMP callbackasm1(SB) - MOV $1669, X7 - JMP callbackasm1(SB) - MOV $1670, X7 - JMP callbackasm1(SB) - MOV $1671, X7 - JMP callbackasm1(SB) - MOV $1672, X7 - JMP callbackasm1(SB) - MOV $1673, X7 - JMP callbackasm1(SB) - MOV $1674, X7 - JMP callbackasm1(SB) - MOV $1675, X7 - JMP callbackasm1(SB) - MOV $1676, X7 - JMP callbackasm1(SB) - MOV $1677, X7 - JMP callbackasm1(SB) - MOV $1678, X7 - JMP callbackasm1(SB) - MOV $1679, X7 - JMP callbackasm1(SB) - MOV $1680, X7 - JMP callbackasm1(SB) - MOV $1681, X7 - JMP callbackasm1(SB) - MOV $1682, X7 - JMP callbackasm1(SB) - MOV $1683, X7 - JMP callbackasm1(SB) - MOV $1684, X7 - JMP callbackasm1(SB) - MOV $1685, X7 - JMP callbackasm1(SB) - MOV $1686, X7 - JMP callbackasm1(SB) - MOV $1687, X7 - JMP callbackasm1(SB) - MOV $1688, X7 - JMP callbackasm1(SB) - MOV $1689, X7 - JMP callbackasm1(SB) - MOV $1690, X7 - JMP callbackasm1(SB) - MOV $1691, X7 - JMP callbackasm1(SB) - MOV $1692, X7 - JMP callbackasm1(SB) - MOV $1693, X7 - JMP callbackasm1(SB) - MOV $1694, X7 - JMP callbackasm1(SB) - MOV $1695, X7 - JMP callbackasm1(SB) - MOV $1696, X7 - JMP callbackasm1(SB) - MOV $1697, X7 - JMP callbackasm1(SB) - MOV $1698, X7 - JMP callbackasm1(SB) - MOV $1699, X7 - JMP callbackasm1(SB) - MOV $1700, X7 - JMP callbackasm1(SB) - MOV $1701, X7 - JMP callbackasm1(SB) - MOV $1702, X7 - JMP callbackasm1(SB) - MOV $1703, X7 - JMP callbackasm1(SB) - MOV $1704, X7 - JMP callbackasm1(SB) - MOV $1705, X7 - JMP callbackasm1(SB) - MOV $1706, X7 - JMP callbackasm1(SB) - MOV $1707, X7 - JMP callbackasm1(SB) - MOV $1708, X7 - JMP callbackasm1(SB) - MOV $1709, X7 - JMP callbackasm1(SB) - MOV $1710, X7 - JMP callbackasm1(SB) - MOV $1711, X7 - JMP callbackasm1(SB) - MOV $1712, X7 - JMP callbackasm1(SB) - MOV $1713, X7 - JMP callbackasm1(SB) - MOV $1714, X7 - JMP callbackasm1(SB) - MOV $1715, X7 - JMP callbackasm1(SB) - MOV $1716, X7 - JMP callbackasm1(SB) - MOV $1717, X7 - JMP callbackasm1(SB) - MOV $1718, X7 - JMP callbackasm1(SB) - MOV $1719, X7 - JMP callbackasm1(SB) - MOV $1720, X7 - JMP callbackasm1(SB) - MOV $1721, X7 - JMP callbackasm1(SB) - MOV $1722, X7 - JMP callbackasm1(SB) - MOV $1723, X7 - JMP callbackasm1(SB) - MOV $1724, X7 - JMP callbackasm1(SB) - MOV $1725, X7 - JMP callbackasm1(SB) - MOV $1726, X7 - JMP callbackasm1(SB) - MOV $1727, X7 - JMP callbackasm1(SB) - MOV $1728, X7 - JMP callbackasm1(SB) - MOV $1729, X7 - JMP callbackasm1(SB) - MOV $1730, X7 - JMP callbackasm1(SB) - MOV $1731, X7 - JMP callbackasm1(SB) - MOV $1732, X7 - JMP callbackasm1(SB) - MOV $1733, X7 - JMP callbackasm1(SB) - MOV $1734, X7 - JMP callbackasm1(SB) - MOV $1735, X7 - JMP callbackasm1(SB) - MOV $1736, X7 - JMP callbackasm1(SB) - MOV $1737, X7 - JMP callbackasm1(SB) - MOV $1738, X7 - JMP callbackasm1(SB) - MOV $1739, X7 - JMP callbackasm1(SB) - MOV $1740, X7 - JMP callbackasm1(SB) - MOV $1741, X7 - JMP callbackasm1(SB) - MOV $1742, X7 - JMP callbackasm1(SB) - MOV $1743, X7 - JMP callbackasm1(SB) - MOV $1744, X7 - JMP callbackasm1(SB) - MOV $1745, X7 - JMP callbackasm1(SB) - MOV $1746, X7 - JMP callbackasm1(SB) - MOV $1747, X7 - JMP callbackasm1(SB) - MOV $1748, X7 - JMP callbackasm1(SB) - MOV $1749, X7 - JMP callbackasm1(SB) - MOV $1750, X7 - JMP callbackasm1(SB) - MOV $1751, X7 - JMP callbackasm1(SB) - MOV $1752, X7 - JMP callbackasm1(SB) - MOV $1753, X7 - JMP callbackasm1(SB) - MOV $1754, X7 - JMP callbackasm1(SB) - MOV $1755, X7 - JMP callbackasm1(SB) - MOV $1756, X7 - JMP callbackasm1(SB) - MOV $1757, X7 - JMP callbackasm1(SB) - MOV $1758, X7 - JMP callbackasm1(SB) - MOV $1759, X7 - JMP callbackasm1(SB) - MOV $1760, X7 - JMP callbackasm1(SB) - MOV $1761, X7 - JMP callbackasm1(SB) - MOV $1762, X7 - JMP callbackasm1(SB) - MOV $1763, X7 - JMP callbackasm1(SB) - MOV $1764, X7 - JMP callbackasm1(SB) - MOV $1765, X7 - JMP callbackasm1(SB) - MOV $1766, X7 - JMP callbackasm1(SB) - MOV $1767, X7 - JMP callbackasm1(SB) - MOV $1768, X7 - JMP callbackasm1(SB) - MOV $1769, X7 - JMP callbackasm1(SB) - MOV $1770, X7 - JMP callbackasm1(SB) - MOV $1771, X7 - JMP callbackasm1(SB) - MOV $1772, X7 - JMP callbackasm1(SB) - MOV $1773, X7 - JMP callbackasm1(SB) - MOV $1774, X7 - JMP callbackasm1(SB) - MOV $1775, X7 - JMP callbackasm1(SB) - MOV $1776, X7 - JMP callbackasm1(SB) - MOV $1777, X7 - JMP callbackasm1(SB) - MOV $1778, X7 - JMP callbackasm1(SB) - MOV $1779, X7 - JMP callbackasm1(SB) - MOV $1780, X7 - JMP callbackasm1(SB) - MOV $1781, X7 - JMP callbackasm1(SB) - MOV $1782, X7 - JMP callbackasm1(SB) - MOV $1783, X7 - JMP callbackasm1(SB) - MOV $1784, X7 - JMP callbackasm1(SB) - MOV $1785, X7 - JMP callbackasm1(SB) - MOV $1786, X7 - JMP callbackasm1(SB) - MOV $1787, X7 - JMP callbackasm1(SB) - MOV $1788, X7 - JMP callbackasm1(SB) - MOV $1789, X7 - JMP callbackasm1(SB) - MOV $1790, X7 - JMP callbackasm1(SB) - MOV $1791, X7 - JMP callbackasm1(SB) - MOV $1792, X7 - JMP callbackasm1(SB) - MOV $1793, X7 - JMP callbackasm1(SB) - MOV $1794, X7 - JMP callbackasm1(SB) - MOV $1795, X7 - JMP callbackasm1(SB) - MOV $1796, X7 - JMP callbackasm1(SB) - MOV $1797, X7 - JMP callbackasm1(SB) - MOV $1798, X7 - JMP callbackasm1(SB) - MOV $1799, X7 - JMP callbackasm1(SB) - MOV $1800, X7 - JMP callbackasm1(SB) - MOV $1801, X7 - JMP callbackasm1(SB) - MOV $1802, X7 - JMP callbackasm1(SB) - MOV $1803, X7 - JMP callbackasm1(SB) - MOV $1804, X7 - JMP callbackasm1(SB) - MOV $1805, X7 - JMP callbackasm1(SB) - MOV $1806, X7 - JMP callbackasm1(SB) - MOV $1807, X7 - JMP callbackasm1(SB) - MOV $1808, X7 - JMP callbackasm1(SB) - MOV $1809, X7 - JMP callbackasm1(SB) - MOV $1810, X7 - JMP callbackasm1(SB) - MOV $1811, X7 - JMP callbackasm1(SB) - MOV $1812, X7 - JMP callbackasm1(SB) - MOV $1813, X7 - JMP callbackasm1(SB) - MOV $1814, X7 - JMP callbackasm1(SB) - MOV $1815, X7 - JMP callbackasm1(SB) - MOV $1816, X7 - JMP callbackasm1(SB) - MOV $1817, X7 - JMP callbackasm1(SB) - MOV $1818, X7 - JMP callbackasm1(SB) - MOV $1819, X7 - JMP callbackasm1(SB) - MOV $1820, X7 - JMP callbackasm1(SB) - MOV $1821, X7 - JMP callbackasm1(SB) - MOV $1822, X7 - JMP callbackasm1(SB) - MOV $1823, X7 - JMP callbackasm1(SB) - MOV $1824, X7 - JMP callbackasm1(SB) - MOV $1825, X7 - JMP callbackasm1(SB) - MOV $1826, X7 - JMP callbackasm1(SB) - MOV $1827, X7 - JMP callbackasm1(SB) - MOV $1828, X7 - JMP callbackasm1(SB) - MOV $1829, X7 - JMP callbackasm1(SB) - MOV $1830, X7 - JMP callbackasm1(SB) - MOV $1831, X7 - JMP callbackasm1(SB) - MOV $1832, X7 - JMP callbackasm1(SB) - MOV $1833, X7 - JMP callbackasm1(SB) - MOV $1834, X7 - JMP callbackasm1(SB) - MOV $1835, X7 - JMP callbackasm1(SB) - MOV $1836, X7 - JMP callbackasm1(SB) - MOV $1837, X7 - JMP callbackasm1(SB) - MOV $1838, X7 - JMP callbackasm1(SB) - MOV $1839, X7 - JMP callbackasm1(SB) - MOV $1840, X7 - JMP callbackasm1(SB) - MOV $1841, X7 - JMP callbackasm1(SB) - MOV $1842, X7 - JMP callbackasm1(SB) - MOV $1843, X7 - JMP callbackasm1(SB) - MOV $1844, X7 - JMP callbackasm1(SB) - MOV $1845, X7 - JMP callbackasm1(SB) - MOV $1846, X7 - JMP callbackasm1(SB) - MOV $1847, X7 - JMP callbackasm1(SB) - MOV $1848, X7 - JMP callbackasm1(SB) - MOV $1849, X7 - JMP callbackasm1(SB) - MOV $1850, X7 - JMP callbackasm1(SB) - MOV $1851, X7 - JMP callbackasm1(SB) - MOV $1852, X7 - JMP callbackasm1(SB) - MOV $1853, X7 - JMP callbackasm1(SB) - MOV $1854, X7 - JMP callbackasm1(SB) - MOV $1855, X7 - JMP callbackasm1(SB) - MOV $1856, X7 - JMP callbackasm1(SB) - MOV $1857, X7 - JMP callbackasm1(SB) - MOV $1858, X7 - JMP callbackasm1(SB) - MOV $1859, X7 - JMP callbackasm1(SB) - MOV $1860, X7 - JMP callbackasm1(SB) - MOV $1861, X7 - JMP callbackasm1(SB) - MOV $1862, X7 - JMP callbackasm1(SB) - MOV $1863, X7 - JMP callbackasm1(SB) - MOV $1864, X7 - JMP callbackasm1(SB) - MOV $1865, X7 - JMP callbackasm1(SB) - MOV $1866, X7 - JMP callbackasm1(SB) - MOV $1867, X7 - JMP callbackasm1(SB) - MOV $1868, X7 - JMP callbackasm1(SB) - MOV $1869, X7 - JMP callbackasm1(SB) - MOV $1870, X7 - JMP callbackasm1(SB) - MOV $1871, X7 - JMP callbackasm1(SB) - MOV $1872, X7 - JMP callbackasm1(SB) - MOV $1873, X7 - JMP callbackasm1(SB) - MOV $1874, X7 - JMP callbackasm1(SB) - MOV $1875, X7 - JMP callbackasm1(SB) - MOV $1876, X7 - JMP callbackasm1(SB) - MOV $1877, X7 - JMP callbackasm1(SB) - MOV $1878, X7 - JMP callbackasm1(SB) - MOV $1879, X7 - JMP callbackasm1(SB) - MOV $1880, X7 - JMP callbackasm1(SB) - MOV $1881, X7 - JMP callbackasm1(SB) - MOV $1882, X7 - JMP callbackasm1(SB) - MOV $1883, X7 - JMP callbackasm1(SB) - MOV $1884, X7 - JMP callbackasm1(SB) - MOV $1885, X7 - JMP callbackasm1(SB) - MOV $1886, X7 - JMP callbackasm1(SB) - MOV $1887, X7 - JMP callbackasm1(SB) - MOV $1888, X7 - JMP callbackasm1(SB) - MOV $1889, X7 - JMP callbackasm1(SB) - MOV $1890, X7 - JMP callbackasm1(SB) - MOV $1891, X7 - JMP callbackasm1(SB) - MOV $1892, X7 - JMP callbackasm1(SB) - MOV $1893, X7 - JMP callbackasm1(SB) - MOV $1894, X7 - JMP callbackasm1(SB) - MOV $1895, X7 - JMP callbackasm1(SB) - MOV $1896, X7 - JMP callbackasm1(SB) - MOV $1897, X7 - JMP callbackasm1(SB) - MOV $1898, X7 - JMP callbackasm1(SB) - MOV $1899, X7 - JMP callbackasm1(SB) - MOV $1900, X7 - JMP callbackasm1(SB) - MOV $1901, X7 - JMP callbackasm1(SB) - MOV $1902, X7 - JMP callbackasm1(SB) - MOV $1903, X7 - JMP callbackasm1(SB) - MOV $1904, X7 - JMP callbackasm1(SB) - MOV $1905, X7 - JMP callbackasm1(SB) - MOV $1906, X7 - JMP callbackasm1(SB) - MOV $1907, X7 - JMP callbackasm1(SB) - MOV $1908, X7 - JMP callbackasm1(SB) - MOV $1909, X7 - JMP callbackasm1(SB) - MOV $1910, X7 - JMP callbackasm1(SB) - MOV $1911, X7 - JMP callbackasm1(SB) - MOV $1912, X7 - JMP callbackasm1(SB) - MOV $1913, X7 - JMP callbackasm1(SB) - MOV $1914, X7 - JMP callbackasm1(SB) - MOV $1915, X7 - JMP callbackasm1(SB) - MOV $1916, X7 - JMP callbackasm1(SB) - MOV $1917, X7 - JMP callbackasm1(SB) - MOV $1918, X7 - JMP callbackasm1(SB) - MOV $1919, X7 - JMP callbackasm1(SB) - MOV $1920, X7 - JMP callbackasm1(SB) - MOV $1921, X7 - JMP callbackasm1(SB) - MOV $1922, X7 - JMP callbackasm1(SB) - MOV $1923, X7 - JMP callbackasm1(SB) - MOV $1924, X7 - JMP callbackasm1(SB) - MOV $1925, X7 - JMP callbackasm1(SB) - MOV $1926, X7 - JMP callbackasm1(SB) - MOV $1927, X7 - JMP callbackasm1(SB) - MOV $1928, X7 - JMP callbackasm1(SB) - MOV $1929, X7 - JMP callbackasm1(SB) - MOV $1930, X7 - JMP callbackasm1(SB) - MOV $1931, X7 - JMP callbackasm1(SB) - MOV $1932, X7 - JMP callbackasm1(SB) - MOV $1933, X7 - JMP callbackasm1(SB) - MOV $1934, X7 - JMP callbackasm1(SB) - MOV $1935, X7 - JMP callbackasm1(SB) - MOV $1936, X7 - JMP callbackasm1(SB) - MOV $1937, X7 - JMP callbackasm1(SB) - MOV $1938, X7 - JMP callbackasm1(SB) - MOV $1939, X7 - JMP callbackasm1(SB) - MOV $1940, X7 - JMP callbackasm1(SB) - MOV $1941, X7 - JMP callbackasm1(SB) - MOV $1942, X7 - JMP callbackasm1(SB) - MOV $1943, X7 - JMP callbackasm1(SB) - MOV $1944, X7 - JMP callbackasm1(SB) - MOV $1945, X7 - JMP callbackasm1(SB) - MOV $1946, X7 - JMP callbackasm1(SB) - MOV $1947, X7 - JMP callbackasm1(SB) - MOV $1948, X7 - JMP callbackasm1(SB) - MOV $1949, X7 - JMP callbackasm1(SB) - MOV $1950, X7 - JMP callbackasm1(SB) - MOV $1951, X7 - JMP callbackasm1(SB) - MOV $1952, X7 - JMP callbackasm1(SB) - MOV $1953, X7 - JMP callbackasm1(SB) - MOV $1954, X7 - JMP callbackasm1(SB) - MOV $1955, X7 - JMP callbackasm1(SB) - MOV $1956, X7 - JMP callbackasm1(SB) - MOV $1957, X7 - JMP callbackasm1(SB) - MOV $1958, X7 - JMP callbackasm1(SB) - MOV $1959, X7 - JMP callbackasm1(SB) - MOV $1960, X7 - JMP callbackasm1(SB) - MOV $1961, X7 - JMP callbackasm1(SB) - MOV $1962, X7 - JMP callbackasm1(SB) - MOV $1963, X7 - JMP callbackasm1(SB) - MOV $1964, X7 - JMP callbackasm1(SB) - MOV $1965, X7 - JMP callbackasm1(SB) - MOV $1966, X7 - JMP callbackasm1(SB) - MOV $1967, X7 - JMP callbackasm1(SB) - MOV $1968, X7 - JMP callbackasm1(SB) - MOV $1969, X7 - JMP callbackasm1(SB) - MOV $1970, X7 - JMP callbackasm1(SB) - MOV $1971, X7 - JMP callbackasm1(SB) - MOV $1972, X7 - JMP callbackasm1(SB) - MOV $1973, X7 - JMP callbackasm1(SB) - MOV $1974, X7 - JMP callbackasm1(SB) - MOV $1975, X7 - JMP callbackasm1(SB) - MOV $1976, X7 - JMP callbackasm1(SB) - MOV $1977, X7 - JMP callbackasm1(SB) - MOV $1978, X7 - JMP callbackasm1(SB) - MOV $1979, X7 - JMP callbackasm1(SB) - MOV $1980, X7 - JMP callbackasm1(SB) - MOV $1981, X7 - JMP callbackasm1(SB) - MOV $1982, X7 - JMP callbackasm1(SB) - MOV $1983, X7 - JMP callbackasm1(SB) - MOV $1984, X7 - JMP callbackasm1(SB) - MOV $1985, X7 - JMP callbackasm1(SB) - MOV $1986, X7 - JMP callbackasm1(SB) - MOV $1987, X7 - JMP callbackasm1(SB) - MOV $1988, X7 - JMP callbackasm1(SB) - MOV $1989, X7 - JMP callbackasm1(SB) - MOV $1990, X7 - JMP callbackasm1(SB) - MOV $1991, X7 - JMP callbackasm1(SB) - MOV $1992, X7 - JMP callbackasm1(SB) - MOV $1993, X7 - JMP callbackasm1(SB) - MOV $1994, X7 - JMP callbackasm1(SB) - MOV $1995, X7 - JMP callbackasm1(SB) - MOV $1996, X7 - JMP callbackasm1(SB) - MOV $1997, X7 - JMP callbackasm1(SB) - MOV $1998, X7 - JMP callbackasm1(SB) - MOV $1999, X7 - JMP callbackasm1(SB) diff --git a/vendor/github.com/ebitengine/purego/zcallback_s390x.s b/vendor/github.com/ebitengine/purego/zcallback_s390x.s deleted file mode 100644 index 6b5e2b0380b..00000000000 --- a/vendor/github.com/ebitengine/purego/zcallback_s390x.s +++ /dev/null @@ -1,4015 +0,0 @@ -// Code generated by wincallback.go using 'go generate'. DO NOT EDIT. - -//go:build linux - -// External code calls into callbackasm at an offset corresponding -// to the callback index. Callbackasm is a table of MOVD and BR instructions. -// The MOVD instruction loads R0 with the callback index, and the -// BR instruction branches to callbackasm1. -// callbackasm1 takes the callback index from R0 and -// indexes into an array that stores information about each callback. -// It then calls the Go implementation for that callback. -// NOTE: We use R0 instead of R11 because R11 is callee-saved on S390X. -#include "textflag.h" - -TEXT callbackasm(SB), NOSPLIT|NOFRAME, $0 - MOVD $0, R0 - BR callbackasm1(SB) - MOVD $1, R0 - BR callbackasm1(SB) - MOVD $2, R0 - BR callbackasm1(SB) - MOVD $3, R0 - BR callbackasm1(SB) - MOVD $4, R0 - BR callbackasm1(SB) - MOVD $5, R0 - BR callbackasm1(SB) - MOVD $6, R0 - BR callbackasm1(SB) - MOVD $7, R0 - BR callbackasm1(SB) - MOVD $8, R0 - BR callbackasm1(SB) - MOVD $9, R0 - BR callbackasm1(SB) - MOVD $10, R0 - BR callbackasm1(SB) - MOVD $11, R0 - BR callbackasm1(SB) - MOVD $12, R0 - BR callbackasm1(SB) - MOVD $13, R0 - BR callbackasm1(SB) - MOVD $14, R0 - BR callbackasm1(SB) - MOVD $15, R0 - BR callbackasm1(SB) - MOVD $16, R0 - BR callbackasm1(SB) - MOVD $17, R0 - BR callbackasm1(SB) - MOVD $18, R0 - BR callbackasm1(SB) - MOVD $19, R0 - BR callbackasm1(SB) - MOVD $20, R0 - BR callbackasm1(SB) - MOVD $21, R0 - BR callbackasm1(SB) - MOVD $22, R0 - BR callbackasm1(SB) - MOVD $23, R0 - BR callbackasm1(SB) - MOVD $24, R0 - BR callbackasm1(SB) - MOVD $25, R0 - BR callbackasm1(SB) - MOVD $26, R0 - BR callbackasm1(SB) - MOVD $27, R0 - BR callbackasm1(SB) - MOVD $28, R0 - BR callbackasm1(SB) - MOVD $29, R0 - BR callbackasm1(SB) - MOVD $30, R0 - BR callbackasm1(SB) - MOVD $31, R0 - BR callbackasm1(SB) - MOVD $32, R0 - BR callbackasm1(SB) - MOVD $33, R0 - BR callbackasm1(SB) - MOVD $34, R0 - BR callbackasm1(SB) - MOVD $35, R0 - BR callbackasm1(SB) - MOVD $36, R0 - BR callbackasm1(SB) - MOVD $37, R0 - BR callbackasm1(SB) - MOVD $38, R0 - BR callbackasm1(SB) - MOVD $39, R0 - BR callbackasm1(SB) - MOVD $40, R0 - BR callbackasm1(SB) - MOVD $41, R0 - BR callbackasm1(SB) - MOVD $42, R0 - BR callbackasm1(SB) - MOVD $43, R0 - BR callbackasm1(SB) - MOVD $44, R0 - BR callbackasm1(SB) - MOVD $45, R0 - BR callbackasm1(SB) - MOVD $46, R0 - BR callbackasm1(SB) - MOVD $47, R0 - BR callbackasm1(SB) - MOVD $48, R0 - BR callbackasm1(SB) - MOVD $49, R0 - BR callbackasm1(SB) - MOVD $50, R0 - BR callbackasm1(SB) - MOVD $51, R0 - BR callbackasm1(SB) - MOVD $52, R0 - BR callbackasm1(SB) - MOVD $53, R0 - BR callbackasm1(SB) - MOVD $54, R0 - BR callbackasm1(SB) - MOVD $55, R0 - BR callbackasm1(SB) - MOVD $56, R0 - BR callbackasm1(SB) - MOVD $57, R0 - BR callbackasm1(SB) - MOVD $58, R0 - BR callbackasm1(SB) - MOVD $59, R0 - BR callbackasm1(SB) - MOVD $60, R0 - BR callbackasm1(SB) - MOVD $61, R0 - BR callbackasm1(SB) - MOVD $62, R0 - BR callbackasm1(SB) - MOVD $63, R0 - BR callbackasm1(SB) - MOVD $64, R0 - BR callbackasm1(SB) - MOVD $65, R0 - BR callbackasm1(SB) - MOVD $66, R0 - BR callbackasm1(SB) - MOVD $67, R0 - BR callbackasm1(SB) - MOVD $68, R0 - BR callbackasm1(SB) - MOVD $69, R0 - BR callbackasm1(SB) - MOVD $70, R0 - BR callbackasm1(SB) - MOVD $71, R0 - BR callbackasm1(SB) - MOVD $72, R0 - BR callbackasm1(SB) - MOVD $73, R0 - BR callbackasm1(SB) - MOVD $74, R0 - BR callbackasm1(SB) - MOVD $75, R0 - BR callbackasm1(SB) - MOVD $76, R0 - BR callbackasm1(SB) - MOVD $77, R0 - BR callbackasm1(SB) - MOVD $78, R0 - BR callbackasm1(SB) - MOVD $79, R0 - BR callbackasm1(SB) - MOVD $80, R0 - BR callbackasm1(SB) - MOVD $81, R0 - BR callbackasm1(SB) - MOVD $82, R0 - BR callbackasm1(SB) - MOVD $83, R0 - BR callbackasm1(SB) - MOVD $84, R0 - BR callbackasm1(SB) - MOVD $85, R0 - BR callbackasm1(SB) - MOVD $86, R0 - BR callbackasm1(SB) - MOVD $87, R0 - BR callbackasm1(SB) - MOVD $88, R0 - BR callbackasm1(SB) - MOVD $89, R0 - BR callbackasm1(SB) - MOVD $90, R0 - BR callbackasm1(SB) - MOVD $91, R0 - BR callbackasm1(SB) - MOVD $92, R0 - BR callbackasm1(SB) - MOVD $93, R0 - BR callbackasm1(SB) - MOVD $94, R0 - BR callbackasm1(SB) - MOVD $95, R0 - BR callbackasm1(SB) - MOVD $96, R0 - BR callbackasm1(SB) - MOVD $97, R0 - BR callbackasm1(SB) - MOVD $98, R0 - BR callbackasm1(SB) - MOVD $99, R0 - BR callbackasm1(SB) - MOVD $100, R0 - BR callbackasm1(SB) - MOVD $101, R0 - BR callbackasm1(SB) - MOVD $102, R0 - BR callbackasm1(SB) - MOVD $103, R0 - BR callbackasm1(SB) - MOVD $104, R0 - BR callbackasm1(SB) - MOVD $105, R0 - BR callbackasm1(SB) - MOVD $106, R0 - BR callbackasm1(SB) - MOVD $107, R0 - BR callbackasm1(SB) - MOVD $108, R0 - BR callbackasm1(SB) - MOVD $109, R0 - BR callbackasm1(SB) - MOVD $110, R0 - BR callbackasm1(SB) - MOVD $111, R0 - BR callbackasm1(SB) - MOVD $112, R0 - BR callbackasm1(SB) - MOVD $113, R0 - BR callbackasm1(SB) - MOVD $114, R0 - BR callbackasm1(SB) - MOVD $115, R0 - BR callbackasm1(SB) - MOVD $116, R0 - BR callbackasm1(SB) - MOVD $117, R0 - BR callbackasm1(SB) - MOVD $118, R0 - BR callbackasm1(SB) - MOVD $119, R0 - BR callbackasm1(SB) - MOVD $120, R0 - BR callbackasm1(SB) - MOVD $121, R0 - BR callbackasm1(SB) - MOVD $122, R0 - BR callbackasm1(SB) - MOVD $123, R0 - BR callbackasm1(SB) - MOVD $124, R0 - BR callbackasm1(SB) - MOVD $125, R0 - BR callbackasm1(SB) - MOVD $126, R0 - BR callbackasm1(SB) - MOVD $127, R0 - BR callbackasm1(SB) - MOVD $128, R0 - BR callbackasm1(SB) - MOVD $129, R0 - BR callbackasm1(SB) - MOVD $130, R0 - BR callbackasm1(SB) - MOVD $131, R0 - BR callbackasm1(SB) - MOVD $132, R0 - BR callbackasm1(SB) - MOVD $133, R0 - BR callbackasm1(SB) - MOVD $134, R0 - BR callbackasm1(SB) - MOVD $135, R0 - BR callbackasm1(SB) - MOVD $136, R0 - BR callbackasm1(SB) - MOVD $137, R0 - BR callbackasm1(SB) - MOVD $138, R0 - BR callbackasm1(SB) - MOVD $139, R0 - BR callbackasm1(SB) - MOVD $140, R0 - BR callbackasm1(SB) - MOVD $141, R0 - BR callbackasm1(SB) - MOVD $142, R0 - BR callbackasm1(SB) - MOVD $143, R0 - BR callbackasm1(SB) - MOVD $144, R0 - BR callbackasm1(SB) - MOVD $145, R0 - BR callbackasm1(SB) - MOVD $146, R0 - BR callbackasm1(SB) - MOVD $147, R0 - BR callbackasm1(SB) - MOVD $148, R0 - BR callbackasm1(SB) - MOVD $149, R0 - BR callbackasm1(SB) - MOVD $150, R0 - BR callbackasm1(SB) - MOVD $151, R0 - BR callbackasm1(SB) - MOVD $152, R0 - BR callbackasm1(SB) - MOVD $153, R0 - BR callbackasm1(SB) - MOVD $154, R0 - BR callbackasm1(SB) - MOVD $155, R0 - BR callbackasm1(SB) - MOVD $156, R0 - BR callbackasm1(SB) - MOVD $157, R0 - BR callbackasm1(SB) - MOVD $158, R0 - BR callbackasm1(SB) - MOVD $159, R0 - BR callbackasm1(SB) - MOVD $160, R0 - BR callbackasm1(SB) - MOVD $161, R0 - BR callbackasm1(SB) - MOVD $162, R0 - BR callbackasm1(SB) - MOVD $163, R0 - BR callbackasm1(SB) - MOVD $164, R0 - BR callbackasm1(SB) - MOVD $165, R0 - BR callbackasm1(SB) - MOVD $166, R0 - BR callbackasm1(SB) - MOVD $167, R0 - BR callbackasm1(SB) - MOVD $168, R0 - BR callbackasm1(SB) - MOVD $169, R0 - BR callbackasm1(SB) - MOVD $170, R0 - BR callbackasm1(SB) - MOVD $171, R0 - BR callbackasm1(SB) - MOVD $172, R0 - BR callbackasm1(SB) - MOVD $173, R0 - BR callbackasm1(SB) - MOVD $174, R0 - BR callbackasm1(SB) - MOVD $175, R0 - BR callbackasm1(SB) - MOVD $176, R0 - BR callbackasm1(SB) - MOVD $177, R0 - BR callbackasm1(SB) - MOVD $178, R0 - BR callbackasm1(SB) - MOVD $179, R0 - BR callbackasm1(SB) - MOVD $180, R0 - BR callbackasm1(SB) - MOVD $181, R0 - BR callbackasm1(SB) - MOVD $182, R0 - BR callbackasm1(SB) - MOVD $183, R0 - BR callbackasm1(SB) - MOVD $184, R0 - BR callbackasm1(SB) - MOVD $185, R0 - BR callbackasm1(SB) - MOVD $186, R0 - BR callbackasm1(SB) - MOVD $187, R0 - BR callbackasm1(SB) - MOVD $188, R0 - BR callbackasm1(SB) - MOVD $189, R0 - BR callbackasm1(SB) - MOVD $190, R0 - BR callbackasm1(SB) - MOVD $191, R0 - BR callbackasm1(SB) - MOVD $192, R0 - BR callbackasm1(SB) - MOVD $193, R0 - BR callbackasm1(SB) - MOVD $194, R0 - BR callbackasm1(SB) - MOVD $195, R0 - BR callbackasm1(SB) - MOVD $196, R0 - BR callbackasm1(SB) - MOVD $197, R0 - BR callbackasm1(SB) - MOVD $198, R0 - BR callbackasm1(SB) - MOVD $199, R0 - BR callbackasm1(SB) - MOVD $200, R0 - BR callbackasm1(SB) - MOVD $201, R0 - BR callbackasm1(SB) - MOVD $202, R0 - BR callbackasm1(SB) - MOVD $203, R0 - BR callbackasm1(SB) - MOVD $204, R0 - BR callbackasm1(SB) - MOVD $205, R0 - BR callbackasm1(SB) - MOVD $206, R0 - BR callbackasm1(SB) - MOVD $207, R0 - BR callbackasm1(SB) - MOVD $208, R0 - BR callbackasm1(SB) - MOVD $209, R0 - BR callbackasm1(SB) - MOVD $210, R0 - BR callbackasm1(SB) - MOVD $211, R0 - BR callbackasm1(SB) - MOVD $212, R0 - BR callbackasm1(SB) - MOVD $213, R0 - BR callbackasm1(SB) - MOVD $214, R0 - BR callbackasm1(SB) - MOVD $215, R0 - BR callbackasm1(SB) - MOVD $216, R0 - BR callbackasm1(SB) - MOVD $217, R0 - BR callbackasm1(SB) - MOVD $218, R0 - BR callbackasm1(SB) - MOVD $219, R0 - BR callbackasm1(SB) - MOVD $220, R0 - BR callbackasm1(SB) - MOVD $221, R0 - BR callbackasm1(SB) - MOVD $222, R0 - BR callbackasm1(SB) - MOVD $223, R0 - BR callbackasm1(SB) - MOVD $224, R0 - BR callbackasm1(SB) - MOVD $225, R0 - BR callbackasm1(SB) - MOVD $226, R0 - BR callbackasm1(SB) - MOVD $227, R0 - BR callbackasm1(SB) - MOVD $228, R0 - BR callbackasm1(SB) - MOVD $229, R0 - BR callbackasm1(SB) - MOVD $230, R0 - BR callbackasm1(SB) - MOVD $231, R0 - BR callbackasm1(SB) - MOVD $232, R0 - BR callbackasm1(SB) - MOVD $233, R0 - BR callbackasm1(SB) - MOVD $234, R0 - BR callbackasm1(SB) - MOVD $235, R0 - BR callbackasm1(SB) - MOVD $236, R0 - BR callbackasm1(SB) - MOVD $237, R0 - BR callbackasm1(SB) - MOVD $238, R0 - BR callbackasm1(SB) - MOVD $239, R0 - BR callbackasm1(SB) - MOVD $240, R0 - BR callbackasm1(SB) - MOVD $241, R0 - BR callbackasm1(SB) - MOVD $242, R0 - BR callbackasm1(SB) - MOVD $243, R0 - BR callbackasm1(SB) - MOVD $244, R0 - BR callbackasm1(SB) - MOVD $245, R0 - BR callbackasm1(SB) - MOVD $246, R0 - BR callbackasm1(SB) - MOVD $247, R0 - BR callbackasm1(SB) - MOVD $248, R0 - BR callbackasm1(SB) - MOVD $249, R0 - BR callbackasm1(SB) - MOVD $250, R0 - BR callbackasm1(SB) - MOVD $251, R0 - BR callbackasm1(SB) - MOVD $252, R0 - BR callbackasm1(SB) - MOVD $253, R0 - BR callbackasm1(SB) - MOVD $254, R0 - BR callbackasm1(SB) - MOVD $255, R0 - BR callbackasm1(SB) - MOVD $256, R0 - BR callbackasm1(SB) - MOVD $257, R0 - BR callbackasm1(SB) - MOVD $258, R0 - BR callbackasm1(SB) - MOVD $259, R0 - BR callbackasm1(SB) - MOVD $260, R0 - BR callbackasm1(SB) - MOVD $261, R0 - BR callbackasm1(SB) - MOVD $262, R0 - BR callbackasm1(SB) - MOVD $263, R0 - BR callbackasm1(SB) - MOVD $264, R0 - BR callbackasm1(SB) - MOVD $265, R0 - BR callbackasm1(SB) - MOVD $266, R0 - BR callbackasm1(SB) - MOVD $267, R0 - BR callbackasm1(SB) - MOVD $268, R0 - BR callbackasm1(SB) - MOVD $269, R0 - BR callbackasm1(SB) - MOVD $270, R0 - BR callbackasm1(SB) - MOVD $271, R0 - BR callbackasm1(SB) - MOVD $272, R0 - BR callbackasm1(SB) - MOVD $273, R0 - BR callbackasm1(SB) - MOVD $274, R0 - BR callbackasm1(SB) - MOVD $275, R0 - BR callbackasm1(SB) - MOVD $276, R0 - BR callbackasm1(SB) - MOVD $277, R0 - BR callbackasm1(SB) - MOVD $278, R0 - BR callbackasm1(SB) - MOVD $279, R0 - BR callbackasm1(SB) - MOVD $280, R0 - BR callbackasm1(SB) - MOVD $281, R0 - BR callbackasm1(SB) - MOVD $282, R0 - BR callbackasm1(SB) - MOVD $283, R0 - BR callbackasm1(SB) - MOVD $284, R0 - BR callbackasm1(SB) - MOVD $285, R0 - BR callbackasm1(SB) - MOVD $286, R0 - BR callbackasm1(SB) - MOVD $287, R0 - BR callbackasm1(SB) - MOVD $288, R0 - BR callbackasm1(SB) - MOVD $289, R0 - BR callbackasm1(SB) - MOVD $290, R0 - BR callbackasm1(SB) - MOVD $291, R0 - BR callbackasm1(SB) - MOVD $292, R0 - BR callbackasm1(SB) - MOVD $293, R0 - BR callbackasm1(SB) - MOVD $294, R0 - BR callbackasm1(SB) - MOVD $295, R0 - BR callbackasm1(SB) - MOVD $296, R0 - BR callbackasm1(SB) - MOVD $297, R0 - BR callbackasm1(SB) - MOVD $298, R0 - BR callbackasm1(SB) - MOVD $299, R0 - BR callbackasm1(SB) - MOVD $300, R0 - BR callbackasm1(SB) - MOVD $301, R0 - BR callbackasm1(SB) - MOVD $302, R0 - BR callbackasm1(SB) - MOVD $303, R0 - BR callbackasm1(SB) - MOVD $304, R0 - BR callbackasm1(SB) - MOVD $305, R0 - BR callbackasm1(SB) - MOVD $306, R0 - BR callbackasm1(SB) - MOVD $307, R0 - BR callbackasm1(SB) - MOVD $308, R0 - BR callbackasm1(SB) - MOVD $309, R0 - BR callbackasm1(SB) - MOVD $310, R0 - BR callbackasm1(SB) - MOVD $311, R0 - BR callbackasm1(SB) - MOVD $312, R0 - BR callbackasm1(SB) - MOVD $313, R0 - BR callbackasm1(SB) - MOVD $314, R0 - BR callbackasm1(SB) - MOVD $315, R0 - BR callbackasm1(SB) - MOVD $316, R0 - BR callbackasm1(SB) - MOVD $317, R0 - BR callbackasm1(SB) - MOVD $318, R0 - BR callbackasm1(SB) - MOVD $319, R0 - BR callbackasm1(SB) - MOVD $320, R0 - BR callbackasm1(SB) - MOVD $321, R0 - BR callbackasm1(SB) - MOVD $322, R0 - BR callbackasm1(SB) - MOVD $323, R0 - BR callbackasm1(SB) - MOVD $324, R0 - BR callbackasm1(SB) - MOVD $325, R0 - BR callbackasm1(SB) - MOVD $326, R0 - BR callbackasm1(SB) - MOVD $327, R0 - BR callbackasm1(SB) - MOVD $328, R0 - BR callbackasm1(SB) - MOVD $329, R0 - BR callbackasm1(SB) - MOVD $330, R0 - BR callbackasm1(SB) - MOVD $331, R0 - BR callbackasm1(SB) - MOVD $332, R0 - BR callbackasm1(SB) - MOVD $333, R0 - BR callbackasm1(SB) - MOVD $334, R0 - BR callbackasm1(SB) - MOVD $335, R0 - BR callbackasm1(SB) - MOVD $336, R0 - BR callbackasm1(SB) - MOVD $337, R0 - BR callbackasm1(SB) - MOVD $338, R0 - BR callbackasm1(SB) - MOVD $339, R0 - BR callbackasm1(SB) - MOVD $340, R0 - BR callbackasm1(SB) - MOVD $341, R0 - BR callbackasm1(SB) - MOVD $342, R0 - BR callbackasm1(SB) - MOVD $343, R0 - BR callbackasm1(SB) - MOVD $344, R0 - BR callbackasm1(SB) - MOVD $345, R0 - BR callbackasm1(SB) - MOVD $346, R0 - BR callbackasm1(SB) - MOVD $347, R0 - BR callbackasm1(SB) - MOVD $348, R0 - BR callbackasm1(SB) - MOVD $349, R0 - BR callbackasm1(SB) - MOVD $350, R0 - BR callbackasm1(SB) - MOVD $351, R0 - BR callbackasm1(SB) - MOVD $352, R0 - BR callbackasm1(SB) - MOVD $353, R0 - BR callbackasm1(SB) - MOVD $354, R0 - BR callbackasm1(SB) - MOVD $355, R0 - BR callbackasm1(SB) - MOVD $356, R0 - BR callbackasm1(SB) - MOVD $357, R0 - BR callbackasm1(SB) - MOVD $358, R0 - BR callbackasm1(SB) - MOVD $359, R0 - BR callbackasm1(SB) - MOVD $360, R0 - BR callbackasm1(SB) - MOVD $361, R0 - BR callbackasm1(SB) - MOVD $362, R0 - BR callbackasm1(SB) - MOVD $363, R0 - BR callbackasm1(SB) - MOVD $364, R0 - BR callbackasm1(SB) - MOVD $365, R0 - BR callbackasm1(SB) - MOVD $366, R0 - BR callbackasm1(SB) - MOVD $367, R0 - BR callbackasm1(SB) - MOVD $368, R0 - BR callbackasm1(SB) - MOVD $369, R0 - BR callbackasm1(SB) - MOVD $370, R0 - BR callbackasm1(SB) - MOVD $371, R0 - BR callbackasm1(SB) - MOVD $372, R0 - BR callbackasm1(SB) - MOVD $373, R0 - BR callbackasm1(SB) - MOVD $374, R0 - BR callbackasm1(SB) - MOVD $375, R0 - BR callbackasm1(SB) - MOVD $376, R0 - BR callbackasm1(SB) - MOVD $377, R0 - BR callbackasm1(SB) - MOVD $378, R0 - BR callbackasm1(SB) - MOVD $379, R0 - BR callbackasm1(SB) - MOVD $380, R0 - BR callbackasm1(SB) - MOVD $381, R0 - BR callbackasm1(SB) - MOVD $382, R0 - BR callbackasm1(SB) - MOVD $383, R0 - BR callbackasm1(SB) - MOVD $384, R0 - BR callbackasm1(SB) - MOVD $385, R0 - BR callbackasm1(SB) - MOVD $386, R0 - BR callbackasm1(SB) - MOVD $387, R0 - BR callbackasm1(SB) - MOVD $388, R0 - BR callbackasm1(SB) - MOVD $389, R0 - BR callbackasm1(SB) - MOVD $390, R0 - BR callbackasm1(SB) - MOVD $391, R0 - BR callbackasm1(SB) - MOVD $392, R0 - BR callbackasm1(SB) - MOVD $393, R0 - BR callbackasm1(SB) - MOVD $394, R0 - BR callbackasm1(SB) - MOVD $395, R0 - BR callbackasm1(SB) - MOVD $396, R0 - BR callbackasm1(SB) - MOVD $397, R0 - BR callbackasm1(SB) - MOVD $398, R0 - BR callbackasm1(SB) - MOVD $399, R0 - BR callbackasm1(SB) - MOVD $400, R0 - BR callbackasm1(SB) - MOVD $401, R0 - BR callbackasm1(SB) - MOVD $402, R0 - BR callbackasm1(SB) - MOVD $403, R0 - BR callbackasm1(SB) - MOVD $404, R0 - BR callbackasm1(SB) - MOVD $405, R0 - BR callbackasm1(SB) - MOVD $406, R0 - BR callbackasm1(SB) - MOVD $407, R0 - BR callbackasm1(SB) - MOVD $408, R0 - BR callbackasm1(SB) - MOVD $409, R0 - BR callbackasm1(SB) - MOVD $410, R0 - BR callbackasm1(SB) - MOVD $411, R0 - BR callbackasm1(SB) - MOVD $412, R0 - BR callbackasm1(SB) - MOVD $413, R0 - BR callbackasm1(SB) - MOVD $414, R0 - BR callbackasm1(SB) - MOVD $415, R0 - BR callbackasm1(SB) - MOVD $416, R0 - BR callbackasm1(SB) - MOVD $417, R0 - BR callbackasm1(SB) - MOVD $418, R0 - BR callbackasm1(SB) - MOVD $419, R0 - BR callbackasm1(SB) - MOVD $420, R0 - BR callbackasm1(SB) - MOVD $421, R0 - BR callbackasm1(SB) - MOVD $422, R0 - BR callbackasm1(SB) - MOVD $423, R0 - BR callbackasm1(SB) - MOVD $424, R0 - BR callbackasm1(SB) - MOVD $425, R0 - BR callbackasm1(SB) - MOVD $426, R0 - BR callbackasm1(SB) - MOVD $427, R0 - BR callbackasm1(SB) - MOVD $428, R0 - BR callbackasm1(SB) - MOVD $429, R0 - BR callbackasm1(SB) - MOVD $430, R0 - BR callbackasm1(SB) - MOVD $431, R0 - BR callbackasm1(SB) - MOVD $432, R0 - BR callbackasm1(SB) - MOVD $433, R0 - BR callbackasm1(SB) - MOVD $434, R0 - BR callbackasm1(SB) - MOVD $435, R0 - BR callbackasm1(SB) - MOVD $436, R0 - BR callbackasm1(SB) - MOVD $437, R0 - BR callbackasm1(SB) - MOVD $438, R0 - BR callbackasm1(SB) - MOVD $439, R0 - BR callbackasm1(SB) - MOVD $440, R0 - BR callbackasm1(SB) - MOVD $441, R0 - BR callbackasm1(SB) - MOVD $442, R0 - BR callbackasm1(SB) - MOVD $443, R0 - BR callbackasm1(SB) - MOVD $444, R0 - BR callbackasm1(SB) - MOVD $445, R0 - BR callbackasm1(SB) - MOVD $446, R0 - BR callbackasm1(SB) - MOVD $447, R0 - BR callbackasm1(SB) - MOVD $448, R0 - BR callbackasm1(SB) - MOVD $449, R0 - BR callbackasm1(SB) - MOVD $450, R0 - BR callbackasm1(SB) - MOVD $451, R0 - BR callbackasm1(SB) - MOVD $452, R0 - BR callbackasm1(SB) - MOVD $453, R0 - BR callbackasm1(SB) - MOVD $454, R0 - BR callbackasm1(SB) - MOVD $455, R0 - BR callbackasm1(SB) - MOVD $456, R0 - BR callbackasm1(SB) - MOVD $457, R0 - BR callbackasm1(SB) - MOVD $458, R0 - BR callbackasm1(SB) - MOVD $459, R0 - BR callbackasm1(SB) - MOVD $460, R0 - BR callbackasm1(SB) - MOVD $461, R0 - BR callbackasm1(SB) - MOVD $462, R0 - BR callbackasm1(SB) - MOVD $463, R0 - BR callbackasm1(SB) - MOVD $464, R0 - BR callbackasm1(SB) - MOVD $465, R0 - BR callbackasm1(SB) - MOVD $466, R0 - BR callbackasm1(SB) - MOVD $467, R0 - BR callbackasm1(SB) - MOVD $468, R0 - BR callbackasm1(SB) - MOVD $469, R0 - BR callbackasm1(SB) - MOVD $470, R0 - BR callbackasm1(SB) - MOVD $471, R0 - BR callbackasm1(SB) - MOVD $472, R0 - BR callbackasm1(SB) - MOVD $473, R0 - BR callbackasm1(SB) - MOVD $474, R0 - BR callbackasm1(SB) - MOVD $475, R0 - BR callbackasm1(SB) - MOVD $476, R0 - BR callbackasm1(SB) - MOVD $477, R0 - BR callbackasm1(SB) - MOVD $478, R0 - BR callbackasm1(SB) - MOVD $479, R0 - BR callbackasm1(SB) - MOVD $480, R0 - BR callbackasm1(SB) - MOVD $481, R0 - BR callbackasm1(SB) - MOVD $482, R0 - BR callbackasm1(SB) - MOVD $483, R0 - BR callbackasm1(SB) - MOVD $484, R0 - BR callbackasm1(SB) - MOVD $485, R0 - BR callbackasm1(SB) - MOVD $486, R0 - BR callbackasm1(SB) - MOVD $487, R0 - BR callbackasm1(SB) - MOVD $488, R0 - BR callbackasm1(SB) - MOVD $489, R0 - BR callbackasm1(SB) - MOVD $490, R0 - BR callbackasm1(SB) - MOVD $491, R0 - BR callbackasm1(SB) - MOVD $492, R0 - BR callbackasm1(SB) - MOVD $493, R0 - BR callbackasm1(SB) - MOVD $494, R0 - BR callbackasm1(SB) - MOVD $495, R0 - BR callbackasm1(SB) - MOVD $496, R0 - BR callbackasm1(SB) - MOVD $497, R0 - BR callbackasm1(SB) - MOVD $498, R0 - BR callbackasm1(SB) - MOVD $499, R0 - BR callbackasm1(SB) - MOVD $500, R0 - BR callbackasm1(SB) - MOVD $501, R0 - BR callbackasm1(SB) - MOVD $502, R0 - BR callbackasm1(SB) - MOVD $503, R0 - BR callbackasm1(SB) - MOVD $504, R0 - BR callbackasm1(SB) - MOVD $505, R0 - BR callbackasm1(SB) - MOVD $506, R0 - BR callbackasm1(SB) - MOVD $507, R0 - BR callbackasm1(SB) - MOVD $508, R0 - BR callbackasm1(SB) - MOVD $509, R0 - BR callbackasm1(SB) - MOVD $510, R0 - BR callbackasm1(SB) - MOVD $511, R0 - BR callbackasm1(SB) - MOVD $512, R0 - BR callbackasm1(SB) - MOVD $513, R0 - BR callbackasm1(SB) - MOVD $514, R0 - BR callbackasm1(SB) - MOVD $515, R0 - BR callbackasm1(SB) - MOVD $516, R0 - BR callbackasm1(SB) - MOVD $517, R0 - BR callbackasm1(SB) - MOVD $518, R0 - BR callbackasm1(SB) - MOVD $519, R0 - BR callbackasm1(SB) - MOVD $520, R0 - BR callbackasm1(SB) - MOVD $521, R0 - BR callbackasm1(SB) - MOVD $522, R0 - BR callbackasm1(SB) - MOVD $523, R0 - BR callbackasm1(SB) - MOVD $524, R0 - BR callbackasm1(SB) - MOVD $525, R0 - BR callbackasm1(SB) - MOVD $526, R0 - BR callbackasm1(SB) - MOVD $527, R0 - BR callbackasm1(SB) - MOVD $528, R0 - BR callbackasm1(SB) - MOVD $529, R0 - BR callbackasm1(SB) - MOVD $530, R0 - BR callbackasm1(SB) - MOVD $531, R0 - BR callbackasm1(SB) - MOVD $532, R0 - BR callbackasm1(SB) - MOVD $533, R0 - BR callbackasm1(SB) - MOVD $534, R0 - BR callbackasm1(SB) - MOVD $535, R0 - BR callbackasm1(SB) - MOVD $536, R0 - BR callbackasm1(SB) - MOVD $537, R0 - BR callbackasm1(SB) - MOVD $538, R0 - BR callbackasm1(SB) - MOVD $539, R0 - BR callbackasm1(SB) - MOVD $540, R0 - BR callbackasm1(SB) - MOVD $541, R0 - BR callbackasm1(SB) - MOVD $542, R0 - BR callbackasm1(SB) - MOVD $543, R0 - BR callbackasm1(SB) - MOVD $544, R0 - BR callbackasm1(SB) - MOVD $545, R0 - BR callbackasm1(SB) - MOVD $546, R0 - BR callbackasm1(SB) - MOVD $547, R0 - BR callbackasm1(SB) - MOVD $548, R0 - BR callbackasm1(SB) - MOVD $549, R0 - BR callbackasm1(SB) - MOVD $550, R0 - BR callbackasm1(SB) - MOVD $551, R0 - BR callbackasm1(SB) - MOVD $552, R0 - BR callbackasm1(SB) - MOVD $553, R0 - BR callbackasm1(SB) - MOVD $554, R0 - BR callbackasm1(SB) - MOVD $555, R0 - BR callbackasm1(SB) - MOVD $556, R0 - BR callbackasm1(SB) - MOVD $557, R0 - BR callbackasm1(SB) - MOVD $558, R0 - BR callbackasm1(SB) - MOVD $559, R0 - BR callbackasm1(SB) - MOVD $560, R0 - BR callbackasm1(SB) - MOVD $561, R0 - BR callbackasm1(SB) - MOVD $562, R0 - BR callbackasm1(SB) - MOVD $563, R0 - BR callbackasm1(SB) - MOVD $564, R0 - BR callbackasm1(SB) - MOVD $565, R0 - BR callbackasm1(SB) - MOVD $566, R0 - BR callbackasm1(SB) - MOVD $567, R0 - BR callbackasm1(SB) - MOVD $568, R0 - BR callbackasm1(SB) - MOVD $569, R0 - BR callbackasm1(SB) - MOVD $570, R0 - BR callbackasm1(SB) - MOVD $571, R0 - BR callbackasm1(SB) - MOVD $572, R0 - BR callbackasm1(SB) - MOVD $573, R0 - BR callbackasm1(SB) - MOVD $574, R0 - BR callbackasm1(SB) - MOVD $575, R0 - BR callbackasm1(SB) - MOVD $576, R0 - BR callbackasm1(SB) - MOVD $577, R0 - BR callbackasm1(SB) - MOVD $578, R0 - BR callbackasm1(SB) - MOVD $579, R0 - BR callbackasm1(SB) - MOVD $580, R0 - BR callbackasm1(SB) - MOVD $581, R0 - BR callbackasm1(SB) - MOVD $582, R0 - BR callbackasm1(SB) - MOVD $583, R0 - BR callbackasm1(SB) - MOVD $584, R0 - BR callbackasm1(SB) - MOVD $585, R0 - BR callbackasm1(SB) - MOVD $586, R0 - BR callbackasm1(SB) - MOVD $587, R0 - BR callbackasm1(SB) - MOVD $588, R0 - BR callbackasm1(SB) - MOVD $589, R0 - BR callbackasm1(SB) - MOVD $590, R0 - BR callbackasm1(SB) - MOVD $591, R0 - BR callbackasm1(SB) - MOVD $592, R0 - BR callbackasm1(SB) - MOVD $593, R0 - BR callbackasm1(SB) - MOVD $594, R0 - BR callbackasm1(SB) - MOVD $595, R0 - BR callbackasm1(SB) - MOVD $596, R0 - BR callbackasm1(SB) - MOVD $597, R0 - BR callbackasm1(SB) - MOVD $598, R0 - BR callbackasm1(SB) - MOVD $599, R0 - BR callbackasm1(SB) - MOVD $600, R0 - BR callbackasm1(SB) - MOVD $601, R0 - BR callbackasm1(SB) - MOVD $602, R0 - BR callbackasm1(SB) - MOVD $603, R0 - BR callbackasm1(SB) - MOVD $604, R0 - BR callbackasm1(SB) - MOVD $605, R0 - BR callbackasm1(SB) - MOVD $606, R0 - BR callbackasm1(SB) - MOVD $607, R0 - BR callbackasm1(SB) - MOVD $608, R0 - BR callbackasm1(SB) - MOVD $609, R0 - BR callbackasm1(SB) - MOVD $610, R0 - BR callbackasm1(SB) - MOVD $611, R0 - BR callbackasm1(SB) - MOVD $612, R0 - BR callbackasm1(SB) - MOVD $613, R0 - BR callbackasm1(SB) - MOVD $614, R0 - BR callbackasm1(SB) - MOVD $615, R0 - BR callbackasm1(SB) - MOVD $616, R0 - BR callbackasm1(SB) - MOVD $617, R0 - BR callbackasm1(SB) - MOVD $618, R0 - BR callbackasm1(SB) - MOVD $619, R0 - BR callbackasm1(SB) - MOVD $620, R0 - BR callbackasm1(SB) - MOVD $621, R0 - BR callbackasm1(SB) - MOVD $622, R0 - BR callbackasm1(SB) - MOVD $623, R0 - BR callbackasm1(SB) - MOVD $624, R0 - BR callbackasm1(SB) - MOVD $625, R0 - BR callbackasm1(SB) - MOVD $626, R0 - BR callbackasm1(SB) - MOVD $627, R0 - BR callbackasm1(SB) - MOVD $628, R0 - BR callbackasm1(SB) - MOVD $629, R0 - BR callbackasm1(SB) - MOVD $630, R0 - BR callbackasm1(SB) - MOVD $631, R0 - BR callbackasm1(SB) - MOVD $632, R0 - BR callbackasm1(SB) - MOVD $633, R0 - BR callbackasm1(SB) - MOVD $634, R0 - BR callbackasm1(SB) - MOVD $635, R0 - BR callbackasm1(SB) - MOVD $636, R0 - BR callbackasm1(SB) - MOVD $637, R0 - BR callbackasm1(SB) - MOVD $638, R0 - BR callbackasm1(SB) - MOVD $639, R0 - BR callbackasm1(SB) - MOVD $640, R0 - BR callbackasm1(SB) - MOVD $641, R0 - BR callbackasm1(SB) - MOVD $642, R0 - BR callbackasm1(SB) - MOVD $643, R0 - BR callbackasm1(SB) - MOVD $644, R0 - BR callbackasm1(SB) - MOVD $645, R0 - BR callbackasm1(SB) - MOVD $646, R0 - BR callbackasm1(SB) - MOVD $647, R0 - BR callbackasm1(SB) - MOVD $648, R0 - BR callbackasm1(SB) - MOVD $649, R0 - BR callbackasm1(SB) - MOVD $650, R0 - BR callbackasm1(SB) - MOVD $651, R0 - BR callbackasm1(SB) - MOVD $652, R0 - BR callbackasm1(SB) - MOVD $653, R0 - BR callbackasm1(SB) - MOVD $654, R0 - BR callbackasm1(SB) - MOVD $655, R0 - BR callbackasm1(SB) - MOVD $656, R0 - BR callbackasm1(SB) - MOVD $657, R0 - BR callbackasm1(SB) - MOVD $658, R0 - BR callbackasm1(SB) - MOVD $659, R0 - BR callbackasm1(SB) - MOVD $660, R0 - BR callbackasm1(SB) - MOVD $661, R0 - BR callbackasm1(SB) - MOVD $662, R0 - BR callbackasm1(SB) - MOVD $663, R0 - BR callbackasm1(SB) - MOVD $664, R0 - BR callbackasm1(SB) - MOVD $665, R0 - BR callbackasm1(SB) - MOVD $666, R0 - BR callbackasm1(SB) - MOVD $667, R0 - BR callbackasm1(SB) - MOVD $668, R0 - BR callbackasm1(SB) - MOVD $669, R0 - BR callbackasm1(SB) - MOVD $670, R0 - BR callbackasm1(SB) - MOVD $671, R0 - BR callbackasm1(SB) - MOVD $672, R0 - BR callbackasm1(SB) - MOVD $673, R0 - BR callbackasm1(SB) - MOVD $674, R0 - BR callbackasm1(SB) - MOVD $675, R0 - BR callbackasm1(SB) - MOVD $676, R0 - BR callbackasm1(SB) - MOVD $677, R0 - BR callbackasm1(SB) - MOVD $678, R0 - BR callbackasm1(SB) - MOVD $679, R0 - BR callbackasm1(SB) - MOVD $680, R0 - BR callbackasm1(SB) - MOVD $681, R0 - BR callbackasm1(SB) - MOVD $682, R0 - BR callbackasm1(SB) - MOVD $683, R0 - BR callbackasm1(SB) - MOVD $684, R0 - BR callbackasm1(SB) - MOVD $685, R0 - BR callbackasm1(SB) - MOVD $686, R0 - BR callbackasm1(SB) - MOVD $687, R0 - BR callbackasm1(SB) - MOVD $688, R0 - BR callbackasm1(SB) - MOVD $689, R0 - BR callbackasm1(SB) - MOVD $690, R0 - BR callbackasm1(SB) - MOVD $691, R0 - BR callbackasm1(SB) - MOVD $692, R0 - BR callbackasm1(SB) - MOVD $693, R0 - BR callbackasm1(SB) - MOVD $694, R0 - BR callbackasm1(SB) - MOVD $695, R0 - BR callbackasm1(SB) - MOVD $696, R0 - BR callbackasm1(SB) - MOVD $697, R0 - BR callbackasm1(SB) - MOVD $698, R0 - BR callbackasm1(SB) - MOVD $699, R0 - BR callbackasm1(SB) - MOVD $700, R0 - BR callbackasm1(SB) - MOVD $701, R0 - BR callbackasm1(SB) - MOVD $702, R0 - BR callbackasm1(SB) - MOVD $703, R0 - BR callbackasm1(SB) - MOVD $704, R0 - BR callbackasm1(SB) - MOVD $705, R0 - BR callbackasm1(SB) - MOVD $706, R0 - BR callbackasm1(SB) - MOVD $707, R0 - BR callbackasm1(SB) - MOVD $708, R0 - BR callbackasm1(SB) - MOVD $709, R0 - BR callbackasm1(SB) - MOVD $710, R0 - BR callbackasm1(SB) - MOVD $711, R0 - BR callbackasm1(SB) - MOVD $712, R0 - BR callbackasm1(SB) - MOVD $713, R0 - BR callbackasm1(SB) - MOVD $714, R0 - BR callbackasm1(SB) - MOVD $715, R0 - BR callbackasm1(SB) - MOVD $716, R0 - BR callbackasm1(SB) - MOVD $717, R0 - BR callbackasm1(SB) - MOVD $718, R0 - BR callbackasm1(SB) - MOVD $719, R0 - BR callbackasm1(SB) - MOVD $720, R0 - BR callbackasm1(SB) - MOVD $721, R0 - BR callbackasm1(SB) - MOVD $722, R0 - BR callbackasm1(SB) - MOVD $723, R0 - BR callbackasm1(SB) - MOVD $724, R0 - BR callbackasm1(SB) - MOVD $725, R0 - BR callbackasm1(SB) - MOVD $726, R0 - BR callbackasm1(SB) - MOVD $727, R0 - BR callbackasm1(SB) - MOVD $728, R0 - BR callbackasm1(SB) - MOVD $729, R0 - BR callbackasm1(SB) - MOVD $730, R0 - BR callbackasm1(SB) - MOVD $731, R0 - BR callbackasm1(SB) - MOVD $732, R0 - BR callbackasm1(SB) - MOVD $733, R0 - BR callbackasm1(SB) - MOVD $734, R0 - BR callbackasm1(SB) - MOVD $735, R0 - BR callbackasm1(SB) - MOVD $736, R0 - BR callbackasm1(SB) - MOVD $737, R0 - BR callbackasm1(SB) - MOVD $738, R0 - BR callbackasm1(SB) - MOVD $739, R0 - BR callbackasm1(SB) - MOVD $740, R0 - BR callbackasm1(SB) - MOVD $741, R0 - BR callbackasm1(SB) - MOVD $742, R0 - BR callbackasm1(SB) - MOVD $743, R0 - BR callbackasm1(SB) - MOVD $744, R0 - BR callbackasm1(SB) - MOVD $745, R0 - BR callbackasm1(SB) - MOVD $746, R0 - BR callbackasm1(SB) - MOVD $747, R0 - BR callbackasm1(SB) - MOVD $748, R0 - BR callbackasm1(SB) - MOVD $749, R0 - BR callbackasm1(SB) - MOVD $750, R0 - BR callbackasm1(SB) - MOVD $751, R0 - BR callbackasm1(SB) - MOVD $752, R0 - BR callbackasm1(SB) - MOVD $753, R0 - BR callbackasm1(SB) - MOVD $754, R0 - BR callbackasm1(SB) - MOVD $755, R0 - BR callbackasm1(SB) - MOVD $756, R0 - BR callbackasm1(SB) - MOVD $757, R0 - BR callbackasm1(SB) - MOVD $758, R0 - BR callbackasm1(SB) - MOVD $759, R0 - BR callbackasm1(SB) - MOVD $760, R0 - BR callbackasm1(SB) - MOVD $761, R0 - BR callbackasm1(SB) - MOVD $762, R0 - BR callbackasm1(SB) - MOVD $763, R0 - BR callbackasm1(SB) - MOVD $764, R0 - BR callbackasm1(SB) - MOVD $765, R0 - BR callbackasm1(SB) - MOVD $766, R0 - BR callbackasm1(SB) - MOVD $767, R0 - BR callbackasm1(SB) - MOVD $768, R0 - BR callbackasm1(SB) - MOVD $769, R0 - BR callbackasm1(SB) - MOVD $770, R0 - BR callbackasm1(SB) - MOVD $771, R0 - BR callbackasm1(SB) - MOVD $772, R0 - BR callbackasm1(SB) - MOVD $773, R0 - BR callbackasm1(SB) - MOVD $774, R0 - BR callbackasm1(SB) - MOVD $775, R0 - BR callbackasm1(SB) - MOVD $776, R0 - BR callbackasm1(SB) - MOVD $777, R0 - BR callbackasm1(SB) - MOVD $778, R0 - BR callbackasm1(SB) - MOVD $779, R0 - BR callbackasm1(SB) - MOVD $780, R0 - BR callbackasm1(SB) - MOVD $781, R0 - BR callbackasm1(SB) - MOVD $782, R0 - BR callbackasm1(SB) - MOVD $783, R0 - BR callbackasm1(SB) - MOVD $784, R0 - BR callbackasm1(SB) - MOVD $785, R0 - BR callbackasm1(SB) - MOVD $786, R0 - BR callbackasm1(SB) - MOVD $787, R0 - BR callbackasm1(SB) - MOVD $788, R0 - BR callbackasm1(SB) - MOVD $789, R0 - BR callbackasm1(SB) - MOVD $790, R0 - BR callbackasm1(SB) - MOVD $791, R0 - BR callbackasm1(SB) - MOVD $792, R0 - BR callbackasm1(SB) - MOVD $793, R0 - BR callbackasm1(SB) - MOVD $794, R0 - BR callbackasm1(SB) - MOVD $795, R0 - BR callbackasm1(SB) - MOVD $796, R0 - BR callbackasm1(SB) - MOVD $797, R0 - BR callbackasm1(SB) - MOVD $798, R0 - BR callbackasm1(SB) - MOVD $799, R0 - BR callbackasm1(SB) - MOVD $800, R0 - BR callbackasm1(SB) - MOVD $801, R0 - BR callbackasm1(SB) - MOVD $802, R0 - BR callbackasm1(SB) - MOVD $803, R0 - BR callbackasm1(SB) - MOVD $804, R0 - BR callbackasm1(SB) - MOVD $805, R0 - BR callbackasm1(SB) - MOVD $806, R0 - BR callbackasm1(SB) - MOVD $807, R0 - BR callbackasm1(SB) - MOVD $808, R0 - BR callbackasm1(SB) - MOVD $809, R0 - BR callbackasm1(SB) - MOVD $810, R0 - BR callbackasm1(SB) - MOVD $811, R0 - BR callbackasm1(SB) - MOVD $812, R0 - BR callbackasm1(SB) - MOVD $813, R0 - BR callbackasm1(SB) - MOVD $814, R0 - BR callbackasm1(SB) - MOVD $815, R0 - BR callbackasm1(SB) - MOVD $816, R0 - BR callbackasm1(SB) - MOVD $817, R0 - BR callbackasm1(SB) - MOVD $818, R0 - BR callbackasm1(SB) - MOVD $819, R0 - BR callbackasm1(SB) - MOVD $820, R0 - BR callbackasm1(SB) - MOVD $821, R0 - BR callbackasm1(SB) - MOVD $822, R0 - BR callbackasm1(SB) - MOVD $823, R0 - BR callbackasm1(SB) - MOVD $824, R0 - BR callbackasm1(SB) - MOVD $825, R0 - BR callbackasm1(SB) - MOVD $826, R0 - BR callbackasm1(SB) - MOVD $827, R0 - BR callbackasm1(SB) - MOVD $828, R0 - BR callbackasm1(SB) - MOVD $829, R0 - BR callbackasm1(SB) - MOVD $830, R0 - BR callbackasm1(SB) - MOVD $831, R0 - BR callbackasm1(SB) - MOVD $832, R0 - BR callbackasm1(SB) - MOVD $833, R0 - BR callbackasm1(SB) - MOVD $834, R0 - BR callbackasm1(SB) - MOVD $835, R0 - BR callbackasm1(SB) - MOVD $836, R0 - BR callbackasm1(SB) - MOVD $837, R0 - BR callbackasm1(SB) - MOVD $838, R0 - BR callbackasm1(SB) - MOVD $839, R0 - BR callbackasm1(SB) - MOVD $840, R0 - BR callbackasm1(SB) - MOVD $841, R0 - BR callbackasm1(SB) - MOVD $842, R0 - BR callbackasm1(SB) - MOVD $843, R0 - BR callbackasm1(SB) - MOVD $844, R0 - BR callbackasm1(SB) - MOVD $845, R0 - BR callbackasm1(SB) - MOVD $846, R0 - BR callbackasm1(SB) - MOVD $847, R0 - BR callbackasm1(SB) - MOVD $848, R0 - BR callbackasm1(SB) - MOVD $849, R0 - BR callbackasm1(SB) - MOVD $850, R0 - BR callbackasm1(SB) - MOVD $851, R0 - BR callbackasm1(SB) - MOVD $852, R0 - BR callbackasm1(SB) - MOVD $853, R0 - BR callbackasm1(SB) - MOVD $854, R0 - BR callbackasm1(SB) - MOVD $855, R0 - BR callbackasm1(SB) - MOVD $856, R0 - BR callbackasm1(SB) - MOVD $857, R0 - BR callbackasm1(SB) - MOVD $858, R0 - BR callbackasm1(SB) - MOVD $859, R0 - BR callbackasm1(SB) - MOVD $860, R0 - BR callbackasm1(SB) - MOVD $861, R0 - BR callbackasm1(SB) - MOVD $862, R0 - BR callbackasm1(SB) - MOVD $863, R0 - BR callbackasm1(SB) - MOVD $864, R0 - BR callbackasm1(SB) - MOVD $865, R0 - BR callbackasm1(SB) - MOVD $866, R0 - BR callbackasm1(SB) - MOVD $867, R0 - BR callbackasm1(SB) - MOVD $868, R0 - BR callbackasm1(SB) - MOVD $869, R0 - BR callbackasm1(SB) - MOVD $870, R0 - BR callbackasm1(SB) - MOVD $871, R0 - BR callbackasm1(SB) - MOVD $872, R0 - BR callbackasm1(SB) - MOVD $873, R0 - BR callbackasm1(SB) - MOVD $874, R0 - BR callbackasm1(SB) - MOVD $875, R0 - BR callbackasm1(SB) - MOVD $876, R0 - BR callbackasm1(SB) - MOVD $877, R0 - BR callbackasm1(SB) - MOVD $878, R0 - BR callbackasm1(SB) - MOVD $879, R0 - BR callbackasm1(SB) - MOVD $880, R0 - BR callbackasm1(SB) - MOVD $881, R0 - BR callbackasm1(SB) - MOVD $882, R0 - BR callbackasm1(SB) - MOVD $883, R0 - BR callbackasm1(SB) - MOVD $884, R0 - BR callbackasm1(SB) - MOVD $885, R0 - BR callbackasm1(SB) - MOVD $886, R0 - BR callbackasm1(SB) - MOVD $887, R0 - BR callbackasm1(SB) - MOVD $888, R0 - BR callbackasm1(SB) - MOVD $889, R0 - BR callbackasm1(SB) - MOVD $890, R0 - BR callbackasm1(SB) - MOVD $891, R0 - BR callbackasm1(SB) - MOVD $892, R0 - BR callbackasm1(SB) - MOVD $893, R0 - BR callbackasm1(SB) - MOVD $894, R0 - BR callbackasm1(SB) - MOVD $895, R0 - BR callbackasm1(SB) - MOVD $896, R0 - BR callbackasm1(SB) - MOVD $897, R0 - BR callbackasm1(SB) - MOVD $898, R0 - BR callbackasm1(SB) - MOVD $899, R0 - BR callbackasm1(SB) - MOVD $900, R0 - BR callbackasm1(SB) - MOVD $901, R0 - BR callbackasm1(SB) - MOVD $902, R0 - BR callbackasm1(SB) - MOVD $903, R0 - BR callbackasm1(SB) - MOVD $904, R0 - BR callbackasm1(SB) - MOVD $905, R0 - BR callbackasm1(SB) - MOVD $906, R0 - BR callbackasm1(SB) - MOVD $907, R0 - BR callbackasm1(SB) - MOVD $908, R0 - BR callbackasm1(SB) - MOVD $909, R0 - BR callbackasm1(SB) - MOVD $910, R0 - BR callbackasm1(SB) - MOVD $911, R0 - BR callbackasm1(SB) - MOVD $912, R0 - BR callbackasm1(SB) - MOVD $913, R0 - BR callbackasm1(SB) - MOVD $914, R0 - BR callbackasm1(SB) - MOVD $915, R0 - BR callbackasm1(SB) - MOVD $916, R0 - BR callbackasm1(SB) - MOVD $917, R0 - BR callbackasm1(SB) - MOVD $918, R0 - BR callbackasm1(SB) - MOVD $919, R0 - BR callbackasm1(SB) - MOVD $920, R0 - BR callbackasm1(SB) - MOVD $921, R0 - BR callbackasm1(SB) - MOVD $922, R0 - BR callbackasm1(SB) - MOVD $923, R0 - BR callbackasm1(SB) - MOVD $924, R0 - BR callbackasm1(SB) - MOVD $925, R0 - BR callbackasm1(SB) - MOVD $926, R0 - BR callbackasm1(SB) - MOVD $927, R0 - BR callbackasm1(SB) - MOVD $928, R0 - BR callbackasm1(SB) - MOVD $929, R0 - BR callbackasm1(SB) - MOVD $930, R0 - BR callbackasm1(SB) - MOVD $931, R0 - BR callbackasm1(SB) - MOVD $932, R0 - BR callbackasm1(SB) - MOVD $933, R0 - BR callbackasm1(SB) - MOVD $934, R0 - BR callbackasm1(SB) - MOVD $935, R0 - BR callbackasm1(SB) - MOVD $936, R0 - BR callbackasm1(SB) - MOVD $937, R0 - BR callbackasm1(SB) - MOVD $938, R0 - BR callbackasm1(SB) - MOVD $939, R0 - BR callbackasm1(SB) - MOVD $940, R0 - BR callbackasm1(SB) - MOVD $941, R0 - BR callbackasm1(SB) - MOVD $942, R0 - BR callbackasm1(SB) - MOVD $943, R0 - BR callbackasm1(SB) - MOVD $944, R0 - BR callbackasm1(SB) - MOVD $945, R0 - BR callbackasm1(SB) - MOVD $946, R0 - BR callbackasm1(SB) - MOVD $947, R0 - BR callbackasm1(SB) - MOVD $948, R0 - BR callbackasm1(SB) - MOVD $949, R0 - BR callbackasm1(SB) - MOVD $950, R0 - BR callbackasm1(SB) - MOVD $951, R0 - BR callbackasm1(SB) - MOVD $952, R0 - BR callbackasm1(SB) - MOVD $953, R0 - BR callbackasm1(SB) - MOVD $954, R0 - BR callbackasm1(SB) - MOVD $955, R0 - BR callbackasm1(SB) - MOVD $956, R0 - BR callbackasm1(SB) - MOVD $957, R0 - BR callbackasm1(SB) - MOVD $958, R0 - BR callbackasm1(SB) - MOVD $959, R0 - BR callbackasm1(SB) - MOVD $960, R0 - BR callbackasm1(SB) - MOVD $961, R0 - BR callbackasm1(SB) - MOVD $962, R0 - BR callbackasm1(SB) - MOVD $963, R0 - BR callbackasm1(SB) - MOVD $964, R0 - BR callbackasm1(SB) - MOVD $965, R0 - BR callbackasm1(SB) - MOVD $966, R0 - BR callbackasm1(SB) - MOVD $967, R0 - BR callbackasm1(SB) - MOVD $968, R0 - BR callbackasm1(SB) - MOVD $969, R0 - BR callbackasm1(SB) - MOVD $970, R0 - BR callbackasm1(SB) - MOVD $971, R0 - BR callbackasm1(SB) - MOVD $972, R0 - BR callbackasm1(SB) - MOVD $973, R0 - BR callbackasm1(SB) - MOVD $974, R0 - BR callbackasm1(SB) - MOVD $975, R0 - BR callbackasm1(SB) - MOVD $976, R0 - BR callbackasm1(SB) - MOVD $977, R0 - BR callbackasm1(SB) - MOVD $978, R0 - BR callbackasm1(SB) - MOVD $979, R0 - BR callbackasm1(SB) - MOVD $980, R0 - BR callbackasm1(SB) - MOVD $981, R0 - BR callbackasm1(SB) - MOVD $982, R0 - BR callbackasm1(SB) - MOVD $983, R0 - BR callbackasm1(SB) - MOVD $984, R0 - BR callbackasm1(SB) - MOVD $985, R0 - BR callbackasm1(SB) - MOVD $986, R0 - BR callbackasm1(SB) - MOVD $987, R0 - BR callbackasm1(SB) - MOVD $988, R0 - BR callbackasm1(SB) - MOVD $989, R0 - BR callbackasm1(SB) - MOVD $990, R0 - BR callbackasm1(SB) - MOVD $991, R0 - BR callbackasm1(SB) - MOVD $992, R0 - BR callbackasm1(SB) - MOVD $993, R0 - BR callbackasm1(SB) - MOVD $994, R0 - BR callbackasm1(SB) - MOVD $995, R0 - BR callbackasm1(SB) - MOVD $996, R0 - BR callbackasm1(SB) - MOVD $997, R0 - BR callbackasm1(SB) - MOVD $998, R0 - BR callbackasm1(SB) - MOVD $999, R0 - BR callbackasm1(SB) - MOVD $1000, R0 - BR callbackasm1(SB) - MOVD $1001, R0 - BR callbackasm1(SB) - MOVD $1002, R0 - BR callbackasm1(SB) - MOVD $1003, R0 - BR callbackasm1(SB) - MOVD $1004, R0 - BR callbackasm1(SB) - MOVD $1005, R0 - BR callbackasm1(SB) - MOVD $1006, R0 - BR callbackasm1(SB) - MOVD $1007, R0 - BR callbackasm1(SB) - MOVD $1008, R0 - BR callbackasm1(SB) - MOVD $1009, R0 - BR callbackasm1(SB) - MOVD $1010, R0 - BR callbackasm1(SB) - MOVD $1011, R0 - BR callbackasm1(SB) - MOVD $1012, R0 - BR callbackasm1(SB) - MOVD $1013, R0 - BR callbackasm1(SB) - MOVD $1014, R0 - BR callbackasm1(SB) - MOVD $1015, R0 - BR callbackasm1(SB) - MOVD $1016, R0 - BR callbackasm1(SB) - MOVD $1017, R0 - BR callbackasm1(SB) - MOVD $1018, R0 - BR callbackasm1(SB) - MOVD $1019, R0 - BR callbackasm1(SB) - MOVD $1020, R0 - BR callbackasm1(SB) - MOVD $1021, R0 - BR callbackasm1(SB) - MOVD $1022, R0 - BR callbackasm1(SB) - MOVD $1023, R0 - BR callbackasm1(SB) - MOVD $1024, R0 - BR callbackasm1(SB) - MOVD $1025, R0 - BR callbackasm1(SB) - MOVD $1026, R0 - BR callbackasm1(SB) - MOVD $1027, R0 - BR callbackasm1(SB) - MOVD $1028, R0 - BR callbackasm1(SB) - MOVD $1029, R0 - BR callbackasm1(SB) - MOVD $1030, R0 - BR callbackasm1(SB) - MOVD $1031, R0 - BR callbackasm1(SB) - MOVD $1032, R0 - BR callbackasm1(SB) - MOVD $1033, R0 - BR callbackasm1(SB) - MOVD $1034, R0 - BR callbackasm1(SB) - MOVD $1035, R0 - BR callbackasm1(SB) - MOVD $1036, R0 - BR callbackasm1(SB) - MOVD $1037, R0 - BR callbackasm1(SB) - MOVD $1038, R0 - BR callbackasm1(SB) - MOVD $1039, R0 - BR callbackasm1(SB) - MOVD $1040, R0 - BR callbackasm1(SB) - MOVD $1041, R0 - BR callbackasm1(SB) - MOVD $1042, R0 - BR callbackasm1(SB) - MOVD $1043, R0 - BR callbackasm1(SB) - MOVD $1044, R0 - BR callbackasm1(SB) - MOVD $1045, R0 - BR callbackasm1(SB) - MOVD $1046, R0 - BR callbackasm1(SB) - MOVD $1047, R0 - BR callbackasm1(SB) - MOVD $1048, R0 - BR callbackasm1(SB) - MOVD $1049, R0 - BR callbackasm1(SB) - MOVD $1050, R0 - BR callbackasm1(SB) - MOVD $1051, R0 - BR callbackasm1(SB) - MOVD $1052, R0 - BR callbackasm1(SB) - MOVD $1053, R0 - BR callbackasm1(SB) - MOVD $1054, R0 - BR callbackasm1(SB) - MOVD $1055, R0 - BR callbackasm1(SB) - MOVD $1056, R0 - BR callbackasm1(SB) - MOVD $1057, R0 - BR callbackasm1(SB) - MOVD $1058, R0 - BR callbackasm1(SB) - MOVD $1059, R0 - BR callbackasm1(SB) - MOVD $1060, R0 - BR callbackasm1(SB) - MOVD $1061, R0 - BR callbackasm1(SB) - MOVD $1062, R0 - BR callbackasm1(SB) - MOVD $1063, R0 - BR callbackasm1(SB) - MOVD $1064, R0 - BR callbackasm1(SB) - MOVD $1065, R0 - BR callbackasm1(SB) - MOVD $1066, R0 - BR callbackasm1(SB) - MOVD $1067, R0 - BR callbackasm1(SB) - MOVD $1068, R0 - BR callbackasm1(SB) - MOVD $1069, R0 - BR callbackasm1(SB) - MOVD $1070, R0 - BR callbackasm1(SB) - MOVD $1071, R0 - BR callbackasm1(SB) - MOVD $1072, R0 - BR callbackasm1(SB) - MOVD $1073, R0 - BR callbackasm1(SB) - MOVD $1074, R0 - BR callbackasm1(SB) - MOVD $1075, R0 - BR callbackasm1(SB) - MOVD $1076, R0 - BR callbackasm1(SB) - MOVD $1077, R0 - BR callbackasm1(SB) - MOVD $1078, R0 - BR callbackasm1(SB) - MOVD $1079, R0 - BR callbackasm1(SB) - MOVD $1080, R0 - BR callbackasm1(SB) - MOVD $1081, R0 - BR callbackasm1(SB) - MOVD $1082, R0 - BR callbackasm1(SB) - MOVD $1083, R0 - BR callbackasm1(SB) - MOVD $1084, R0 - BR callbackasm1(SB) - MOVD $1085, R0 - BR callbackasm1(SB) - MOVD $1086, R0 - BR callbackasm1(SB) - MOVD $1087, R0 - BR callbackasm1(SB) - MOVD $1088, R0 - BR callbackasm1(SB) - MOVD $1089, R0 - BR callbackasm1(SB) - MOVD $1090, R0 - BR callbackasm1(SB) - MOVD $1091, R0 - BR callbackasm1(SB) - MOVD $1092, R0 - BR callbackasm1(SB) - MOVD $1093, R0 - BR callbackasm1(SB) - MOVD $1094, R0 - BR callbackasm1(SB) - MOVD $1095, R0 - BR callbackasm1(SB) - MOVD $1096, R0 - BR callbackasm1(SB) - MOVD $1097, R0 - BR callbackasm1(SB) - MOVD $1098, R0 - BR callbackasm1(SB) - MOVD $1099, R0 - BR callbackasm1(SB) - MOVD $1100, R0 - BR callbackasm1(SB) - MOVD $1101, R0 - BR callbackasm1(SB) - MOVD $1102, R0 - BR callbackasm1(SB) - MOVD $1103, R0 - BR callbackasm1(SB) - MOVD $1104, R0 - BR callbackasm1(SB) - MOVD $1105, R0 - BR callbackasm1(SB) - MOVD $1106, R0 - BR callbackasm1(SB) - MOVD $1107, R0 - BR callbackasm1(SB) - MOVD $1108, R0 - BR callbackasm1(SB) - MOVD $1109, R0 - BR callbackasm1(SB) - MOVD $1110, R0 - BR callbackasm1(SB) - MOVD $1111, R0 - BR callbackasm1(SB) - MOVD $1112, R0 - BR callbackasm1(SB) - MOVD $1113, R0 - BR callbackasm1(SB) - MOVD $1114, R0 - BR callbackasm1(SB) - MOVD $1115, R0 - BR callbackasm1(SB) - MOVD $1116, R0 - BR callbackasm1(SB) - MOVD $1117, R0 - BR callbackasm1(SB) - MOVD $1118, R0 - BR callbackasm1(SB) - MOVD $1119, R0 - BR callbackasm1(SB) - MOVD $1120, R0 - BR callbackasm1(SB) - MOVD $1121, R0 - BR callbackasm1(SB) - MOVD $1122, R0 - BR callbackasm1(SB) - MOVD $1123, R0 - BR callbackasm1(SB) - MOVD $1124, R0 - BR callbackasm1(SB) - MOVD $1125, R0 - BR callbackasm1(SB) - MOVD $1126, R0 - BR callbackasm1(SB) - MOVD $1127, R0 - BR callbackasm1(SB) - MOVD $1128, R0 - BR callbackasm1(SB) - MOVD $1129, R0 - BR callbackasm1(SB) - MOVD $1130, R0 - BR callbackasm1(SB) - MOVD $1131, R0 - BR callbackasm1(SB) - MOVD $1132, R0 - BR callbackasm1(SB) - MOVD $1133, R0 - BR callbackasm1(SB) - MOVD $1134, R0 - BR callbackasm1(SB) - MOVD $1135, R0 - BR callbackasm1(SB) - MOVD $1136, R0 - BR callbackasm1(SB) - MOVD $1137, R0 - BR callbackasm1(SB) - MOVD $1138, R0 - BR callbackasm1(SB) - MOVD $1139, R0 - BR callbackasm1(SB) - MOVD $1140, R0 - BR callbackasm1(SB) - MOVD $1141, R0 - BR callbackasm1(SB) - MOVD $1142, R0 - BR callbackasm1(SB) - MOVD $1143, R0 - BR callbackasm1(SB) - MOVD $1144, R0 - BR callbackasm1(SB) - MOVD $1145, R0 - BR callbackasm1(SB) - MOVD $1146, R0 - BR callbackasm1(SB) - MOVD $1147, R0 - BR callbackasm1(SB) - MOVD $1148, R0 - BR callbackasm1(SB) - MOVD $1149, R0 - BR callbackasm1(SB) - MOVD $1150, R0 - BR callbackasm1(SB) - MOVD $1151, R0 - BR callbackasm1(SB) - MOVD $1152, R0 - BR callbackasm1(SB) - MOVD $1153, R0 - BR callbackasm1(SB) - MOVD $1154, R0 - BR callbackasm1(SB) - MOVD $1155, R0 - BR callbackasm1(SB) - MOVD $1156, R0 - BR callbackasm1(SB) - MOVD $1157, R0 - BR callbackasm1(SB) - MOVD $1158, R0 - BR callbackasm1(SB) - MOVD $1159, R0 - BR callbackasm1(SB) - MOVD $1160, R0 - BR callbackasm1(SB) - MOVD $1161, R0 - BR callbackasm1(SB) - MOVD $1162, R0 - BR callbackasm1(SB) - MOVD $1163, R0 - BR callbackasm1(SB) - MOVD $1164, R0 - BR callbackasm1(SB) - MOVD $1165, R0 - BR callbackasm1(SB) - MOVD $1166, R0 - BR callbackasm1(SB) - MOVD $1167, R0 - BR callbackasm1(SB) - MOVD $1168, R0 - BR callbackasm1(SB) - MOVD $1169, R0 - BR callbackasm1(SB) - MOVD $1170, R0 - BR callbackasm1(SB) - MOVD $1171, R0 - BR callbackasm1(SB) - MOVD $1172, R0 - BR callbackasm1(SB) - MOVD $1173, R0 - BR callbackasm1(SB) - MOVD $1174, R0 - BR callbackasm1(SB) - MOVD $1175, R0 - BR callbackasm1(SB) - MOVD $1176, R0 - BR callbackasm1(SB) - MOVD $1177, R0 - BR callbackasm1(SB) - MOVD $1178, R0 - BR callbackasm1(SB) - MOVD $1179, R0 - BR callbackasm1(SB) - MOVD $1180, R0 - BR callbackasm1(SB) - MOVD $1181, R0 - BR callbackasm1(SB) - MOVD $1182, R0 - BR callbackasm1(SB) - MOVD $1183, R0 - BR callbackasm1(SB) - MOVD $1184, R0 - BR callbackasm1(SB) - MOVD $1185, R0 - BR callbackasm1(SB) - MOVD $1186, R0 - BR callbackasm1(SB) - MOVD $1187, R0 - BR callbackasm1(SB) - MOVD $1188, R0 - BR callbackasm1(SB) - MOVD $1189, R0 - BR callbackasm1(SB) - MOVD $1190, R0 - BR callbackasm1(SB) - MOVD $1191, R0 - BR callbackasm1(SB) - MOVD $1192, R0 - BR callbackasm1(SB) - MOVD $1193, R0 - BR callbackasm1(SB) - MOVD $1194, R0 - BR callbackasm1(SB) - MOVD $1195, R0 - BR callbackasm1(SB) - MOVD $1196, R0 - BR callbackasm1(SB) - MOVD $1197, R0 - BR callbackasm1(SB) - MOVD $1198, R0 - BR callbackasm1(SB) - MOVD $1199, R0 - BR callbackasm1(SB) - MOVD $1200, R0 - BR callbackasm1(SB) - MOVD $1201, R0 - BR callbackasm1(SB) - MOVD $1202, R0 - BR callbackasm1(SB) - MOVD $1203, R0 - BR callbackasm1(SB) - MOVD $1204, R0 - BR callbackasm1(SB) - MOVD $1205, R0 - BR callbackasm1(SB) - MOVD $1206, R0 - BR callbackasm1(SB) - MOVD $1207, R0 - BR callbackasm1(SB) - MOVD $1208, R0 - BR callbackasm1(SB) - MOVD $1209, R0 - BR callbackasm1(SB) - MOVD $1210, R0 - BR callbackasm1(SB) - MOVD $1211, R0 - BR callbackasm1(SB) - MOVD $1212, R0 - BR callbackasm1(SB) - MOVD $1213, R0 - BR callbackasm1(SB) - MOVD $1214, R0 - BR callbackasm1(SB) - MOVD $1215, R0 - BR callbackasm1(SB) - MOVD $1216, R0 - BR callbackasm1(SB) - MOVD $1217, R0 - BR callbackasm1(SB) - MOVD $1218, R0 - BR callbackasm1(SB) - MOVD $1219, R0 - BR callbackasm1(SB) - MOVD $1220, R0 - BR callbackasm1(SB) - MOVD $1221, R0 - BR callbackasm1(SB) - MOVD $1222, R0 - BR callbackasm1(SB) - MOVD $1223, R0 - BR callbackasm1(SB) - MOVD $1224, R0 - BR callbackasm1(SB) - MOVD $1225, R0 - BR callbackasm1(SB) - MOVD $1226, R0 - BR callbackasm1(SB) - MOVD $1227, R0 - BR callbackasm1(SB) - MOVD $1228, R0 - BR callbackasm1(SB) - MOVD $1229, R0 - BR callbackasm1(SB) - MOVD $1230, R0 - BR callbackasm1(SB) - MOVD $1231, R0 - BR callbackasm1(SB) - MOVD $1232, R0 - BR callbackasm1(SB) - MOVD $1233, R0 - BR callbackasm1(SB) - MOVD $1234, R0 - BR callbackasm1(SB) - MOVD $1235, R0 - BR callbackasm1(SB) - MOVD $1236, R0 - BR callbackasm1(SB) - MOVD $1237, R0 - BR callbackasm1(SB) - MOVD $1238, R0 - BR callbackasm1(SB) - MOVD $1239, R0 - BR callbackasm1(SB) - MOVD $1240, R0 - BR callbackasm1(SB) - MOVD $1241, R0 - BR callbackasm1(SB) - MOVD $1242, R0 - BR callbackasm1(SB) - MOVD $1243, R0 - BR callbackasm1(SB) - MOVD $1244, R0 - BR callbackasm1(SB) - MOVD $1245, R0 - BR callbackasm1(SB) - MOVD $1246, R0 - BR callbackasm1(SB) - MOVD $1247, R0 - BR callbackasm1(SB) - MOVD $1248, R0 - BR callbackasm1(SB) - MOVD $1249, R0 - BR callbackasm1(SB) - MOVD $1250, R0 - BR callbackasm1(SB) - MOVD $1251, R0 - BR callbackasm1(SB) - MOVD $1252, R0 - BR callbackasm1(SB) - MOVD $1253, R0 - BR callbackasm1(SB) - MOVD $1254, R0 - BR callbackasm1(SB) - MOVD $1255, R0 - BR callbackasm1(SB) - MOVD $1256, R0 - BR callbackasm1(SB) - MOVD $1257, R0 - BR callbackasm1(SB) - MOVD $1258, R0 - BR callbackasm1(SB) - MOVD $1259, R0 - BR callbackasm1(SB) - MOVD $1260, R0 - BR callbackasm1(SB) - MOVD $1261, R0 - BR callbackasm1(SB) - MOVD $1262, R0 - BR callbackasm1(SB) - MOVD $1263, R0 - BR callbackasm1(SB) - MOVD $1264, R0 - BR callbackasm1(SB) - MOVD $1265, R0 - BR callbackasm1(SB) - MOVD $1266, R0 - BR callbackasm1(SB) - MOVD $1267, R0 - BR callbackasm1(SB) - MOVD $1268, R0 - BR callbackasm1(SB) - MOVD $1269, R0 - BR callbackasm1(SB) - MOVD $1270, R0 - BR callbackasm1(SB) - MOVD $1271, R0 - BR callbackasm1(SB) - MOVD $1272, R0 - BR callbackasm1(SB) - MOVD $1273, R0 - BR callbackasm1(SB) - MOVD $1274, R0 - BR callbackasm1(SB) - MOVD $1275, R0 - BR callbackasm1(SB) - MOVD $1276, R0 - BR callbackasm1(SB) - MOVD $1277, R0 - BR callbackasm1(SB) - MOVD $1278, R0 - BR callbackasm1(SB) - MOVD $1279, R0 - BR callbackasm1(SB) - MOVD $1280, R0 - BR callbackasm1(SB) - MOVD $1281, R0 - BR callbackasm1(SB) - MOVD $1282, R0 - BR callbackasm1(SB) - MOVD $1283, R0 - BR callbackasm1(SB) - MOVD $1284, R0 - BR callbackasm1(SB) - MOVD $1285, R0 - BR callbackasm1(SB) - MOVD $1286, R0 - BR callbackasm1(SB) - MOVD $1287, R0 - BR callbackasm1(SB) - MOVD $1288, R0 - BR callbackasm1(SB) - MOVD $1289, R0 - BR callbackasm1(SB) - MOVD $1290, R0 - BR callbackasm1(SB) - MOVD $1291, R0 - BR callbackasm1(SB) - MOVD $1292, R0 - BR callbackasm1(SB) - MOVD $1293, R0 - BR callbackasm1(SB) - MOVD $1294, R0 - BR callbackasm1(SB) - MOVD $1295, R0 - BR callbackasm1(SB) - MOVD $1296, R0 - BR callbackasm1(SB) - MOVD $1297, R0 - BR callbackasm1(SB) - MOVD $1298, R0 - BR callbackasm1(SB) - MOVD $1299, R0 - BR callbackasm1(SB) - MOVD $1300, R0 - BR callbackasm1(SB) - MOVD $1301, R0 - BR callbackasm1(SB) - MOVD $1302, R0 - BR callbackasm1(SB) - MOVD $1303, R0 - BR callbackasm1(SB) - MOVD $1304, R0 - BR callbackasm1(SB) - MOVD $1305, R0 - BR callbackasm1(SB) - MOVD $1306, R0 - BR callbackasm1(SB) - MOVD $1307, R0 - BR callbackasm1(SB) - MOVD $1308, R0 - BR callbackasm1(SB) - MOVD $1309, R0 - BR callbackasm1(SB) - MOVD $1310, R0 - BR callbackasm1(SB) - MOVD $1311, R0 - BR callbackasm1(SB) - MOVD $1312, R0 - BR callbackasm1(SB) - MOVD $1313, R0 - BR callbackasm1(SB) - MOVD $1314, R0 - BR callbackasm1(SB) - MOVD $1315, R0 - BR callbackasm1(SB) - MOVD $1316, R0 - BR callbackasm1(SB) - MOVD $1317, R0 - BR callbackasm1(SB) - MOVD $1318, R0 - BR callbackasm1(SB) - MOVD $1319, R0 - BR callbackasm1(SB) - MOVD $1320, R0 - BR callbackasm1(SB) - MOVD $1321, R0 - BR callbackasm1(SB) - MOVD $1322, R0 - BR callbackasm1(SB) - MOVD $1323, R0 - BR callbackasm1(SB) - MOVD $1324, R0 - BR callbackasm1(SB) - MOVD $1325, R0 - BR callbackasm1(SB) - MOVD $1326, R0 - BR callbackasm1(SB) - MOVD $1327, R0 - BR callbackasm1(SB) - MOVD $1328, R0 - BR callbackasm1(SB) - MOVD $1329, R0 - BR callbackasm1(SB) - MOVD $1330, R0 - BR callbackasm1(SB) - MOVD $1331, R0 - BR callbackasm1(SB) - MOVD $1332, R0 - BR callbackasm1(SB) - MOVD $1333, R0 - BR callbackasm1(SB) - MOVD $1334, R0 - BR callbackasm1(SB) - MOVD $1335, R0 - BR callbackasm1(SB) - MOVD $1336, R0 - BR callbackasm1(SB) - MOVD $1337, R0 - BR callbackasm1(SB) - MOVD $1338, R0 - BR callbackasm1(SB) - MOVD $1339, R0 - BR callbackasm1(SB) - MOVD $1340, R0 - BR callbackasm1(SB) - MOVD $1341, R0 - BR callbackasm1(SB) - MOVD $1342, R0 - BR callbackasm1(SB) - MOVD $1343, R0 - BR callbackasm1(SB) - MOVD $1344, R0 - BR callbackasm1(SB) - MOVD $1345, R0 - BR callbackasm1(SB) - MOVD $1346, R0 - BR callbackasm1(SB) - MOVD $1347, R0 - BR callbackasm1(SB) - MOVD $1348, R0 - BR callbackasm1(SB) - MOVD $1349, R0 - BR callbackasm1(SB) - MOVD $1350, R0 - BR callbackasm1(SB) - MOVD $1351, R0 - BR callbackasm1(SB) - MOVD $1352, R0 - BR callbackasm1(SB) - MOVD $1353, R0 - BR callbackasm1(SB) - MOVD $1354, R0 - BR callbackasm1(SB) - MOVD $1355, R0 - BR callbackasm1(SB) - MOVD $1356, R0 - BR callbackasm1(SB) - MOVD $1357, R0 - BR callbackasm1(SB) - MOVD $1358, R0 - BR callbackasm1(SB) - MOVD $1359, R0 - BR callbackasm1(SB) - MOVD $1360, R0 - BR callbackasm1(SB) - MOVD $1361, R0 - BR callbackasm1(SB) - MOVD $1362, R0 - BR callbackasm1(SB) - MOVD $1363, R0 - BR callbackasm1(SB) - MOVD $1364, R0 - BR callbackasm1(SB) - MOVD $1365, R0 - BR callbackasm1(SB) - MOVD $1366, R0 - BR callbackasm1(SB) - MOVD $1367, R0 - BR callbackasm1(SB) - MOVD $1368, R0 - BR callbackasm1(SB) - MOVD $1369, R0 - BR callbackasm1(SB) - MOVD $1370, R0 - BR callbackasm1(SB) - MOVD $1371, R0 - BR callbackasm1(SB) - MOVD $1372, R0 - BR callbackasm1(SB) - MOVD $1373, R0 - BR callbackasm1(SB) - MOVD $1374, R0 - BR callbackasm1(SB) - MOVD $1375, R0 - BR callbackasm1(SB) - MOVD $1376, R0 - BR callbackasm1(SB) - MOVD $1377, R0 - BR callbackasm1(SB) - MOVD $1378, R0 - BR callbackasm1(SB) - MOVD $1379, R0 - BR callbackasm1(SB) - MOVD $1380, R0 - BR callbackasm1(SB) - MOVD $1381, R0 - BR callbackasm1(SB) - MOVD $1382, R0 - BR callbackasm1(SB) - MOVD $1383, R0 - BR callbackasm1(SB) - MOVD $1384, R0 - BR callbackasm1(SB) - MOVD $1385, R0 - BR callbackasm1(SB) - MOVD $1386, R0 - BR callbackasm1(SB) - MOVD $1387, R0 - BR callbackasm1(SB) - MOVD $1388, R0 - BR callbackasm1(SB) - MOVD $1389, R0 - BR callbackasm1(SB) - MOVD $1390, R0 - BR callbackasm1(SB) - MOVD $1391, R0 - BR callbackasm1(SB) - MOVD $1392, R0 - BR callbackasm1(SB) - MOVD $1393, R0 - BR callbackasm1(SB) - MOVD $1394, R0 - BR callbackasm1(SB) - MOVD $1395, R0 - BR callbackasm1(SB) - MOVD $1396, R0 - BR callbackasm1(SB) - MOVD $1397, R0 - BR callbackasm1(SB) - MOVD $1398, R0 - BR callbackasm1(SB) - MOVD $1399, R0 - BR callbackasm1(SB) - MOVD $1400, R0 - BR callbackasm1(SB) - MOVD $1401, R0 - BR callbackasm1(SB) - MOVD $1402, R0 - BR callbackasm1(SB) - MOVD $1403, R0 - BR callbackasm1(SB) - MOVD $1404, R0 - BR callbackasm1(SB) - MOVD $1405, R0 - BR callbackasm1(SB) - MOVD $1406, R0 - BR callbackasm1(SB) - MOVD $1407, R0 - BR callbackasm1(SB) - MOVD $1408, R0 - BR callbackasm1(SB) - MOVD $1409, R0 - BR callbackasm1(SB) - MOVD $1410, R0 - BR callbackasm1(SB) - MOVD $1411, R0 - BR callbackasm1(SB) - MOVD $1412, R0 - BR callbackasm1(SB) - MOVD $1413, R0 - BR callbackasm1(SB) - MOVD $1414, R0 - BR callbackasm1(SB) - MOVD $1415, R0 - BR callbackasm1(SB) - MOVD $1416, R0 - BR callbackasm1(SB) - MOVD $1417, R0 - BR callbackasm1(SB) - MOVD $1418, R0 - BR callbackasm1(SB) - MOVD $1419, R0 - BR callbackasm1(SB) - MOVD $1420, R0 - BR callbackasm1(SB) - MOVD $1421, R0 - BR callbackasm1(SB) - MOVD $1422, R0 - BR callbackasm1(SB) - MOVD $1423, R0 - BR callbackasm1(SB) - MOVD $1424, R0 - BR callbackasm1(SB) - MOVD $1425, R0 - BR callbackasm1(SB) - MOVD $1426, R0 - BR callbackasm1(SB) - MOVD $1427, R0 - BR callbackasm1(SB) - MOVD $1428, R0 - BR callbackasm1(SB) - MOVD $1429, R0 - BR callbackasm1(SB) - MOVD $1430, R0 - BR callbackasm1(SB) - MOVD $1431, R0 - BR callbackasm1(SB) - MOVD $1432, R0 - BR callbackasm1(SB) - MOVD $1433, R0 - BR callbackasm1(SB) - MOVD $1434, R0 - BR callbackasm1(SB) - MOVD $1435, R0 - BR callbackasm1(SB) - MOVD $1436, R0 - BR callbackasm1(SB) - MOVD $1437, R0 - BR callbackasm1(SB) - MOVD $1438, R0 - BR callbackasm1(SB) - MOVD $1439, R0 - BR callbackasm1(SB) - MOVD $1440, R0 - BR callbackasm1(SB) - MOVD $1441, R0 - BR callbackasm1(SB) - MOVD $1442, R0 - BR callbackasm1(SB) - MOVD $1443, R0 - BR callbackasm1(SB) - MOVD $1444, R0 - BR callbackasm1(SB) - MOVD $1445, R0 - BR callbackasm1(SB) - MOVD $1446, R0 - BR callbackasm1(SB) - MOVD $1447, R0 - BR callbackasm1(SB) - MOVD $1448, R0 - BR callbackasm1(SB) - MOVD $1449, R0 - BR callbackasm1(SB) - MOVD $1450, R0 - BR callbackasm1(SB) - MOVD $1451, R0 - BR callbackasm1(SB) - MOVD $1452, R0 - BR callbackasm1(SB) - MOVD $1453, R0 - BR callbackasm1(SB) - MOVD $1454, R0 - BR callbackasm1(SB) - MOVD $1455, R0 - BR callbackasm1(SB) - MOVD $1456, R0 - BR callbackasm1(SB) - MOVD $1457, R0 - BR callbackasm1(SB) - MOVD $1458, R0 - BR callbackasm1(SB) - MOVD $1459, R0 - BR callbackasm1(SB) - MOVD $1460, R0 - BR callbackasm1(SB) - MOVD $1461, R0 - BR callbackasm1(SB) - MOVD $1462, R0 - BR callbackasm1(SB) - MOVD $1463, R0 - BR callbackasm1(SB) - MOVD $1464, R0 - BR callbackasm1(SB) - MOVD $1465, R0 - BR callbackasm1(SB) - MOVD $1466, R0 - BR callbackasm1(SB) - MOVD $1467, R0 - BR callbackasm1(SB) - MOVD $1468, R0 - BR callbackasm1(SB) - MOVD $1469, R0 - BR callbackasm1(SB) - MOVD $1470, R0 - BR callbackasm1(SB) - MOVD $1471, R0 - BR callbackasm1(SB) - MOVD $1472, R0 - BR callbackasm1(SB) - MOVD $1473, R0 - BR callbackasm1(SB) - MOVD $1474, R0 - BR callbackasm1(SB) - MOVD $1475, R0 - BR callbackasm1(SB) - MOVD $1476, R0 - BR callbackasm1(SB) - MOVD $1477, R0 - BR callbackasm1(SB) - MOVD $1478, R0 - BR callbackasm1(SB) - MOVD $1479, R0 - BR callbackasm1(SB) - MOVD $1480, R0 - BR callbackasm1(SB) - MOVD $1481, R0 - BR callbackasm1(SB) - MOVD $1482, R0 - BR callbackasm1(SB) - MOVD $1483, R0 - BR callbackasm1(SB) - MOVD $1484, R0 - BR callbackasm1(SB) - MOVD $1485, R0 - BR callbackasm1(SB) - MOVD $1486, R0 - BR callbackasm1(SB) - MOVD $1487, R0 - BR callbackasm1(SB) - MOVD $1488, R0 - BR callbackasm1(SB) - MOVD $1489, R0 - BR callbackasm1(SB) - MOVD $1490, R0 - BR callbackasm1(SB) - MOVD $1491, R0 - BR callbackasm1(SB) - MOVD $1492, R0 - BR callbackasm1(SB) - MOVD $1493, R0 - BR callbackasm1(SB) - MOVD $1494, R0 - BR callbackasm1(SB) - MOVD $1495, R0 - BR callbackasm1(SB) - MOVD $1496, R0 - BR callbackasm1(SB) - MOVD $1497, R0 - BR callbackasm1(SB) - MOVD $1498, R0 - BR callbackasm1(SB) - MOVD $1499, R0 - BR callbackasm1(SB) - MOVD $1500, R0 - BR callbackasm1(SB) - MOVD $1501, R0 - BR callbackasm1(SB) - MOVD $1502, R0 - BR callbackasm1(SB) - MOVD $1503, R0 - BR callbackasm1(SB) - MOVD $1504, R0 - BR callbackasm1(SB) - MOVD $1505, R0 - BR callbackasm1(SB) - MOVD $1506, R0 - BR callbackasm1(SB) - MOVD $1507, R0 - BR callbackasm1(SB) - MOVD $1508, R0 - BR callbackasm1(SB) - MOVD $1509, R0 - BR callbackasm1(SB) - MOVD $1510, R0 - BR callbackasm1(SB) - MOVD $1511, R0 - BR callbackasm1(SB) - MOVD $1512, R0 - BR callbackasm1(SB) - MOVD $1513, R0 - BR callbackasm1(SB) - MOVD $1514, R0 - BR callbackasm1(SB) - MOVD $1515, R0 - BR callbackasm1(SB) - MOVD $1516, R0 - BR callbackasm1(SB) - MOVD $1517, R0 - BR callbackasm1(SB) - MOVD $1518, R0 - BR callbackasm1(SB) - MOVD $1519, R0 - BR callbackasm1(SB) - MOVD $1520, R0 - BR callbackasm1(SB) - MOVD $1521, R0 - BR callbackasm1(SB) - MOVD $1522, R0 - BR callbackasm1(SB) - MOVD $1523, R0 - BR callbackasm1(SB) - MOVD $1524, R0 - BR callbackasm1(SB) - MOVD $1525, R0 - BR callbackasm1(SB) - MOVD $1526, R0 - BR callbackasm1(SB) - MOVD $1527, R0 - BR callbackasm1(SB) - MOVD $1528, R0 - BR callbackasm1(SB) - MOVD $1529, R0 - BR callbackasm1(SB) - MOVD $1530, R0 - BR callbackasm1(SB) - MOVD $1531, R0 - BR callbackasm1(SB) - MOVD $1532, R0 - BR callbackasm1(SB) - MOVD $1533, R0 - BR callbackasm1(SB) - MOVD $1534, R0 - BR callbackasm1(SB) - MOVD $1535, R0 - BR callbackasm1(SB) - MOVD $1536, R0 - BR callbackasm1(SB) - MOVD $1537, R0 - BR callbackasm1(SB) - MOVD $1538, R0 - BR callbackasm1(SB) - MOVD $1539, R0 - BR callbackasm1(SB) - MOVD $1540, R0 - BR callbackasm1(SB) - MOVD $1541, R0 - BR callbackasm1(SB) - MOVD $1542, R0 - BR callbackasm1(SB) - MOVD $1543, R0 - BR callbackasm1(SB) - MOVD $1544, R0 - BR callbackasm1(SB) - MOVD $1545, R0 - BR callbackasm1(SB) - MOVD $1546, R0 - BR callbackasm1(SB) - MOVD $1547, R0 - BR callbackasm1(SB) - MOVD $1548, R0 - BR callbackasm1(SB) - MOVD $1549, R0 - BR callbackasm1(SB) - MOVD $1550, R0 - BR callbackasm1(SB) - MOVD $1551, R0 - BR callbackasm1(SB) - MOVD $1552, R0 - BR callbackasm1(SB) - MOVD $1553, R0 - BR callbackasm1(SB) - MOVD $1554, R0 - BR callbackasm1(SB) - MOVD $1555, R0 - BR callbackasm1(SB) - MOVD $1556, R0 - BR callbackasm1(SB) - MOVD $1557, R0 - BR callbackasm1(SB) - MOVD $1558, R0 - BR callbackasm1(SB) - MOVD $1559, R0 - BR callbackasm1(SB) - MOVD $1560, R0 - BR callbackasm1(SB) - MOVD $1561, R0 - BR callbackasm1(SB) - MOVD $1562, R0 - BR callbackasm1(SB) - MOVD $1563, R0 - BR callbackasm1(SB) - MOVD $1564, R0 - BR callbackasm1(SB) - MOVD $1565, R0 - BR callbackasm1(SB) - MOVD $1566, R0 - BR callbackasm1(SB) - MOVD $1567, R0 - BR callbackasm1(SB) - MOVD $1568, R0 - BR callbackasm1(SB) - MOVD $1569, R0 - BR callbackasm1(SB) - MOVD $1570, R0 - BR callbackasm1(SB) - MOVD $1571, R0 - BR callbackasm1(SB) - MOVD $1572, R0 - BR callbackasm1(SB) - MOVD $1573, R0 - BR callbackasm1(SB) - MOVD $1574, R0 - BR callbackasm1(SB) - MOVD $1575, R0 - BR callbackasm1(SB) - MOVD $1576, R0 - BR callbackasm1(SB) - MOVD $1577, R0 - BR callbackasm1(SB) - MOVD $1578, R0 - BR callbackasm1(SB) - MOVD $1579, R0 - BR callbackasm1(SB) - MOVD $1580, R0 - BR callbackasm1(SB) - MOVD $1581, R0 - BR callbackasm1(SB) - MOVD $1582, R0 - BR callbackasm1(SB) - MOVD $1583, R0 - BR callbackasm1(SB) - MOVD $1584, R0 - BR callbackasm1(SB) - MOVD $1585, R0 - BR callbackasm1(SB) - MOVD $1586, R0 - BR callbackasm1(SB) - MOVD $1587, R0 - BR callbackasm1(SB) - MOVD $1588, R0 - BR callbackasm1(SB) - MOVD $1589, R0 - BR callbackasm1(SB) - MOVD $1590, R0 - BR callbackasm1(SB) - MOVD $1591, R0 - BR callbackasm1(SB) - MOVD $1592, R0 - BR callbackasm1(SB) - MOVD $1593, R0 - BR callbackasm1(SB) - MOVD $1594, R0 - BR callbackasm1(SB) - MOVD $1595, R0 - BR callbackasm1(SB) - MOVD $1596, R0 - BR callbackasm1(SB) - MOVD $1597, R0 - BR callbackasm1(SB) - MOVD $1598, R0 - BR callbackasm1(SB) - MOVD $1599, R0 - BR callbackasm1(SB) - MOVD $1600, R0 - BR callbackasm1(SB) - MOVD $1601, R0 - BR callbackasm1(SB) - MOVD $1602, R0 - BR callbackasm1(SB) - MOVD $1603, R0 - BR callbackasm1(SB) - MOVD $1604, R0 - BR callbackasm1(SB) - MOVD $1605, R0 - BR callbackasm1(SB) - MOVD $1606, R0 - BR callbackasm1(SB) - MOVD $1607, R0 - BR callbackasm1(SB) - MOVD $1608, R0 - BR callbackasm1(SB) - MOVD $1609, R0 - BR callbackasm1(SB) - MOVD $1610, R0 - BR callbackasm1(SB) - MOVD $1611, R0 - BR callbackasm1(SB) - MOVD $1612, R0 - BR callbackasm1(SB) - MOVD $1613, R0 - BR callbackasm1(SB) - MOVD $1614, R0 - BR callbackasm1(SB) - MOVD $1615, R0 - BR callbackasm1(SB) - MOVD $1616, R0 - BR callbackasm1(SB) - MOVD $1617, R0 - BR callbackasm1(SB) - MOVD $1618, R0 - BR callbackasm1(SB) - MOVD $1619, R0 - BR callbackasm1(SB) - MOVD $1620, R0 - BR callbackasm1(SB) - MOVD $1621, R0 - BR callbackasm1(SB) - MOVD $1622, R0 - BR callbackasm1(SB) - MOVD $1623, R0 - BR callbackasm1(SB) - MOVD $1624, R0 - BR callbackasm1(SB) - MOVD $1625, R0 - BR callbackasm1(SB) - MOVD $1626, R0 - BR callbackasm1(SB) - MOVD $1627, R0 - BR callbackasm1(SB) - MOVD $1628, R0 - BR callbackasm1(SB) - MOVD $1629, R0 - BR callbackasm1(SB) - MOVD $1630, R0 - BR callbackasm1(SB) - MOVD $1631, R0 - BR callbackasm1(SB) - MOVD $1632, R0 - BR callbackasm1(SB) - MOVD $1633, R0 - BR callbackasm1(SB) - MOVD $1634, R0 - BR callbackasm1(SB) - MOVD $1635, R0 - BR callbackasm1(SB) - MOVD $1636, R0 - BR callbackasm1(SB) - MOVD $1637, R0 - BR callbackasm1(SB) - MOVD $1638, R0 - BR callbackasm1(SB) - MOVD $1639, R0 - BR callbackasm1(SB) - MOVD $1640, R0 - BR callbackasm1(SB) - MOVD $1641, R0 - BR callbackasm1(SB) - MOVD $1642, R0 - BR callbackasm1(SB) - MOVD $1643, R0 - BR callbackasm1(SB) - MOVD $1644, R0 - BR callbackasm1(SB) - MOVD $1645, R0 - BR callbackasm1(SB) - MOVD $1646, R0 - BR callbackasm1(SB) - MOVD $1647, R0 - BR callbackasm1(SB) - MOVD $1648, R0 - BR callbackasm1(SB) - MOVD $1649, R0 - BR callbackasm1(SB) - MOVD $1650, R0 - BR callbackasm1(SB) - MOVD $1651, R0 - BR callbackasm1(SB) - MOVD $1652, R0 - BR callbackasm1(SB) - MOVD $1653, R0 - BR callbackasm1(SB) - MOVD $1654, R0 - BR callbackasm1(SB) - MOVD $1655, R0 - BR callbackasm1(SB) - MOVD $1656, R0 - BR callbackasm1(SB) - MOVD $1657, R0 - BR callbackasm1(SB) - MOVD $1658, R0 - BR callbackasm1(SB) - MOVD $1659, R0 - BR callbackasm1(SB) - MOVD $1660, R0 - BR callbackasm1(SB) - MOVD $1661, R0 - BR callbackasm1(SB) - MOVD $1662, R0 - BR callbackasm1(SB) - MOVD $1663, R0 - BR callbackasm1(SB) - MOVD $1664, R0 - BR callbackasm1(SB) - MOVD $1665, R0 - BR callbackasm1(SB) - MOVD $1666, R0 - BR callbackasm1(SB) - MOVD $1667, R0 - BR callbackasm1(SB) - MOVD $1668, R0 - BR callbackasm1(SB) - MOVD $1669, R0 - BR callbackasm1(SB) - MOVD $1670, R0 - BR callbackasm1(SB) - MOVD $1671, R0 - BR callbackasm1(SB) - MOVD $1672, R0 - BR callbackasm1(SB) - MOVD $1673, R0 - BR callbackasm1(SB) - MOVD $1674, R0 - BR callbackasm1(SB) - MOVD $1675, R0 - BR callbackasm1(SB) - MOVD $1676, R0 - BR callbackasm1(SB) - MOVD $1677, R0 - BR callbackasm1(SB) - MOVD $1678, R0 - BR callbackasm1(SB) - MOVD $1679, R0 - BR callbackasm1(SB) - MOVD $1680, R0 - BR callbackasm1(SB) - MOVD $1681, R0 - BR callbackasm1(SB) - MOVD $1682, R0 - BR callbackasm1(SB) - MOVD $1683, R0 - BR callbackasm1(SB) - MOVD $1684, R0 - BR callbackasm1(SB) - MOVD $1685, R0 - BR callbackasm1(SB) - MOVD $1686, R0 - BR callbackasm1(SB) - MOVD $1687, R0 - BR callbackasm1(SB) - MOVD $1688, R0 - BR callbackasm1(SB) - MOVD $1689, R0 - BR callbackasm1(SB) - MOVD $1690, R0 - BR callbackasm1(SB) - MOVD $1691, R0 - BR callbackasm1(SB) - MOVD $1692, R0 - BR callbackasm1(SB) - MOVD $1693, R0 - BR callbackasm1(SB) - MOVD $1694, R0 - BR callbackasm1(SB) - MOVD $1695, R0 - BR callbackasm1(SB) - MOVD $1696, R0 - BR callbackasm1(SB) - MOVD $1697, R0 - BR callbackasm1(SB) - MOVD $1698, R0 - BR callbackasm1(SB) - MOVD $1699, R0 - BR callbackasm1(SB) - MOVD $1700, R0 - BR callbackasm1(SB) - MOVD $1701, R0 - BR callbackasm1(SB) - MOVD $1702, R0 - BR callbackasm1(SB) - MOVD $1703, R0 - BR callbackasm1(SB) - MOVD $1704, R0 - BR callbackasm1(SB) - MOVD $1705, R0 - BR callbackasm1(SB) - MOVD $1706, R0 - BR callbackasm1(SB) - MOVD $1707, R0 - BR callbackasm1(SB) - MOVD $1708, R0 - BR callbackasm1(SB) - MOVD $1709, R0 - BR callbackasm1(SB) - MOVD $1710, R0 - BR callbackasm1(SB) - MOVD $1711, R0 - BR callbackasm1(SB) - MOVD $1712, R0 - BR callbackasm1(SB) - MOVD $1713, R0 - BR callbackasm1(SB) - MOVD $1714, R0 - BR callbackasm1(SB) - MOVD $1715, R0 - BR callbackasm1(SB) - MOVD $1716, R0 - BR callbackasm1(SB) - MOVD $1717, R0 - BR callbackasm1(SB) - MOVD $1718, R0 - BR callbackasm1(SB) - MOVD $1719, R0 - BR callbackasm1(SB) - MOVD $1720, R0 - BR callbackasm1(SB) - MOVD $1721, R0 - BR callbackasm1(SB) - MOVD $1722, R0 - BR callbackasm1(SB) - MOVD $1723, R0 - BR callbackasm1(SB) - MOVD $1724, R0 - BR callbackasm1(SB) - MOVD $1725, R0 - BR callbackasm1(SB) - MOVD $1726, R0 - BR callbackasm1(SB) - MOVD $1727, R0 - BR callbackasm1(SB) - MOVD $1728, R0 - BR callbackasm1(SB) - MOVD $1729, R0 - BR callbackasm1(SB) - MOVD $1730, R0 - BR callbackasm1(SB) - MOVD $1731, R0 - BR callbackasm1(SB) - MOVD $1732, R0 - BR callbackasm1(SB) - MOVD $1733, R0 - BR callbackasm1(SB) - MOVD $1734, R0 - BR callbackasm1(SB) - MOVD $1735, R0 - BR callbackasm1(SB) - MOVD $1736, R0 - BR callbackasm1(SB) - MOVD $1737, R0 - BR callbackasm1(SB) - MOVD $1738, R0 - BR callbackasm1(SB) - MOVD $1739, R0 - BR callbackasm1(SB) - MOVD $1740, R0 - BR callbackasm1(SB) - MOVD $1741, R0 - BR callbackasm1(SB) - MOVD $1742, R0 - BR callbackasm1(SB) - MOVD $1743, R0 - BR callbackasm1(SB) - MOVD $1744, R0 - BR callbackasm1(SB) - MOVD $1745, R0 - BR callbackasm1(SB) - MOVD $1746, R0 - BR callbackasm1(SB) - MOVD $1747, R0 - BR callbackasm1(SB) - MOVD $1748, R0 - BR callbackasm1(SB) - MOVD $1749, R0 - BR callbackasm1(SB) - MOVD $1750, R0 - BR callbackasm1(SB) - MOVD $1751, R0 - BR callbackasm1(SB) - MOVD $1752, R0 - BR callbackasm1(SB) - MOVD $1753, R0 - BR callbackasm1(SB) - MOVD $1754, R0 - BR callbackasm1(SB) - MOVD $1755, R0 - BR callbackasm1(SB) - MOVD $1756, R0 - BR callbackasm1(SB) - MOVD $1757, R0 - BR callbackasm1(SB) - MOVD $1758, R0 - BR callbackasm1(SB) - MOVD $1759, R0 - BR callbackasm1(SB) - MOVD $1760, R0 - BR callbackasm1(SB) - MOVD $1761, R0 - BR callbackasm1(SB) - MOVD $1762, R0 - BR callbackasm1(SB) - MOVD $1763, R0 - BR callbackasm1(SB) - MOVD $1764, R0 - BR callbackasm1(SB) - MOVD $1765, R0 - BR callbackasm1(SB) - MOVD $1766, R0 - BR callbackasm1(SB) - MOVD $1767, R0 - BR callbackasm1(SB) - MOVD $1768, R0 - BR callbackasm1(SB) - MOVD $1769, R0 - BR callbackasm1(SB) - MOVD $1770, R0 - BR callbackasm1(SB) - MOVD $1771, R0 - BR callbackasm1(SB) - MOVD $1772, R0 - BR callbackasm1(SB) - MOVD $1773, R0 - BR callbackasm1(SB) - MOVD $1774, R0 - BR callbackasm1(SB) - MOVD $1775, R0 - BR callbackasm1(SB) - MOVD $1776, R0 - BR callbackasm1(SB) - MOVD $1777, R0 - BR callbackasm1(SB) - MOVD $1778, R0 - BR callbackasm1(SB) - MOVD $1779, R0 - BR callbackasm1(SB) - MOVD $1780, R0 - BR callbackasm1(SB) - MOVD $1781, R0 - BR callbackasm1(SB) - MOVD $1782, R0 - BR callbackasm1(SB) - MOVD $1783, R0 - BR callbackasm1(SB) - MOVD $1784, R0 - BR callbackasm1(SB) - MOVD $1785, R0 - BR callbackasm1(SB) - MOVD $1786, R0 - BR callbackasm1(SB) - MOVD $1787, R0 - BR callbackasm1(SB) - MOVD $1788, R0 - BR callbackasm1(SB) - MOVD $1789, R0 - BR callbackasm1(SB) - MOVD $1790, R0 - BR callbackasm1(SB) - MOVD $1791, R0 - BR callbackasm1(SB) - MOVD $1792, R0 - BR callbackasm1(SB) - MOVD $1793, R0 - BR callbackasm1(SB) - MOVD $1794, R0 - BR callbackasm1(SB) - MOVD $1795, R0 - BR callbackasm1(SB) - MOVD $1796, R0 - BR callbackasm1(SB) - MOVD $1797, R0 - BR callbackasm1(SB) - MOVD $1798, R0 - BR callbackasm1(SB) - MOVD $1799, R0 - BR callbackasm1(SB) - MOVD $1800, R0 - BR callbackasm1(SB) - MOVD $1801, R0 - BR callbackasm1(SB) - MOVD $1802, R0 - BR callbackasm1(SB) - MOVD $1803, R0 - BR callbackasm1(SB) - MOVD $1804, R0 - BR callbackasm1(SB) - MOVD $1805, R0 - BR callbackasm1(SB) - MOVD $1806, R0 - BR callbackasm1(SB) - MOVD $1807, R0 - BR callbackasm1(SB) - MOVD $1808, R0 - BR callbackasm1(SB) - MOVD $1809, R0 - BR callbackasm1(SB) - MOVD $1810, R0 - BR callbackasm1(SB) - MOVD $1811, R0 - BR callbackasm1(SB) - MOVD $1812, R0 - BR callbackasm1(SB) - MOVD $1813, R0 - BR callbackasm1(SB) - MOVD $1814, R0 - BR callbackasm1(SB) - MOVD $1815, R0 - BR callbackasm1(SB) - MOVD $1816, R0 - BR callbackasm1(SB) - MOVD $1817, R0 - BR callbackasm1(SB) - MOVD $1818, R0 - BR callbackasm1(SB) - MOVD $1819, R0 - BR callbackasm1(SB) - MOVD $1820, R0 - BR callbackasm1(SB) - MOVD $1821, R0 - BR callbackasm1(SB) - MOVD $1822, R0 - BR callbackasm1(SB) - MOVD $1823, R0 - BR callbackasm1(SB) - MOVD $1824, R0 - BR callbackasm1(SB) - MOVD $1825, R0 - BR callbackasm1(SB) - MOVD $1826, R0 - BR callbackasm1(SB) - MOVD $1827, R0 - BR callbackasm1(SB) - MOVD $1828, R0 - BR callbackasm1(SB) - MOVD $1829, R0 - BR callbackasm1(SB) - MOVD $1830, R0 - BR callbackasm1(SB) - MOVD $1831, R0 - BR callbackasm1(SB) - MOVD $1832, R0 - BR callbackasm1(SB) - MOVD $1833, R0 - BR callbackasm1(SB) - MOVD $1834, R0 - BR callbackasm1(SB) - MOVD $1835, R0 - BR callbackasm1(SB) - MOVD $1836, R0 - BR callbackasm1(SB) - MOVD $1837, R0 - BR callbackasm1(SB) - MOVD $1838, R0 - BR callbackasm1(SB) - MOVD $1839, R0 - BR callbackasm1(SB) - MOVD $1840, R0 - BR callbackasm1(SB) - MOVD $1841, R0 - BR callbackasm1(SB) - MOVD $1842, R0 - BR callbackasm1(SB) - MOVD $1843, R0 - BR callbackasm1(SB) - MOVD $1844, R0 - BR callbackasm1(SB) - MOVD $1845, R0 - BR callbackasm1(SB) - MOVD $1846, R0 - BR callbackasm1(SB) - MOVD $1847, R0 - BR callbackasm1(SB) - MOVD $1848, R0 - BR callbackasm1(SB) - MOVD $1849, R0 - BR callbackasm1(SB) - MOVD $1850, R0 - BR callbackasm1(SB) - MOVD $1851, R0 - BR callbackasm1(SB) - MOVD $1852, R0 - BR callbackasm1(SB) - MOVD $1853, R0 - BR callbackasm1(SB) - MOVD $1854, R0 - BR callbackasm1(SB) - MOVD $1855, R0 - BR callbackasm1(SB) - MOVD $1856, R0 - BR callbackasm1(SB) - MOVD $1857, R0 - BR callbackasm1(SB) - MOVD $1858, R0 - BR callbackasm1(SB) - MOVD $1859, R0 - BR callbackasm1(SB) - MOVD $1860, R0 - BR callbackasm1(SB) - MOVD $1861, R0 - BR callbackasm1(SB) - MOVD $1862, R0 - BR callbackasm1(SB) - MOVD $1863, R0 - BR callbackasm1(SB) - MOVD $1864, R0 - BR callbackasm1(SB) - MOVD $1865, R0 - BR callbackasm1(SB) - MOVD $1866, R0 - BR callbackasm1(SB) - MOVD $1867, R0 - BR callbackasm1(SB) - MOVD $1868, R0 - BR callbackasm1(SB) - MOVD $1869, R0 - BR callbackasm1(SB) - MOVD $1870, R0 - BR callbackasm1(SB) - MOVD $1871, R0 - BR callbackasm1(SB) - MOVD $1872, R0 - BR callbackasm1(SB) - MOVD $1873, R0 - BR callbackasm1(SB) - MOVD $1874, R0 - BR callbackasm1(SB) - MOVD $1875, R0 - BR callbackasm1(SB) - MOVD $1876, R0 - BR callbackasm1(SB) - MOVD $1877, R0 - BR callbackasm1(SB) - MOVD $1878, R0 - BR callbackasm1(SB) - MOVD $1879, R0 - BR callbackasm1(SB) - MOVD $1880, R0 - BR callbackasm1(SB) - MOVD $1881, R0 - BR callbackasm1(SB) - MOVD $1882, R0 - BR callbackasm1(SB) - MOVD $1883, R0 - BR callbackasm1(SB) - MOVD $1884, R0 - BR callbackasm1(SB) - MOVD $1885, R0 - BR callbackasm1(SB) - MOVD $1886, R0 - BR callbackasm1(SB) - MOVD $1887, R0 - BR callbackasm1(SB) - MOVD $1888, R0 - BR callbackasm1(SB) - MOVD $1889, R0 - BR callbackasm1(SB) - MOVD $1890, R0 - BR callbackasm1(SB) - MOVD $1891, R0 - BR callbackasm1(SB) - MOVD $1892, R0 - BR callbackasm1(SB) - MOVD $1893, R0 - BR callbackasm1(SB) - MOVD $1894, R0 - BR callbackasm1(SB) - MOVD $1895, R0 - BR callbackasm1(SB) - MOVD $1896, R0 - BR callbackasm1(SB) - MOVD $1897, R0 - BR callbackasm1(SB) - MOVD $1898, R0 - BR callbackasm1(SB) - MOVD $1899, R0 - BR callbackasm1(SB) - MOVD $1900, R0 - BR callbackasm1(SB) - MOVD $1901, R0 - BR callbackasm1(SB) - MOVD $1902, R0 - BR callbackasm1(SB) - MOVD $1903, R0 - BR callbackasm1(SB) - MOVD $1904, R0 - BR callbackasm1(SB) - MOVD $1905, R0 - BR callbackasm1(SB) - MOVD $1906, R0 - BR callbackasm1(SB) - MOVD $1907, R0 - BR callbackasm1(SB) - MOVD $1908, R0 - BR callbackasm1(SB) - MOVD $1909, R0 - BR callbackasm1(SB) - MOVD $1910, R0 - BR callbackasm1(SB) - MOVD $1911, R0 - BR callbackasm1(SB) - MOVD $1912, R0 - BR callbackasm1(SB) - MOVD $1913, R0 - BR callbackasm1(SB) - MOVD $1914, R0 - BR callbackasm1(SB) - MOVD $1915, R0 - BR callbackasm1(SB) - MOVD $1916, R0 - BR callbackasm1(SB) - MOVD $1917, R0 - BR callbackasm1(SB) - MOVD $1918, R0 - BR callbackasm1(SB) - MOVD $1919, R0 - BR callbackasm1(SB) - MOVD $1920, R0 - BR callbackasm1(SB) - MOVD $1921, R0 - BR callbackasm1(SB) - MOVD $1922, R0 - BR callbackasm1(SB) - MOVD $1923, R0 - BR callbackasm1(SB) - MOVD $1924, R0 - BR callbackasm1(SB) - MOVD $1925, R0 - BR callbackasm1(SB) - MOVD $1926, R0 - BR callbackasm1(SB) - MOVD $1927, R0 - BR callbackasm1(SB) - MOVD $1928, R0 - BR callbackasm1(SB) - MOVD $1929, R0 - BR callbackasm1(SB) - MOVD $1930, R0 - BR callbackasm1(SB) - MOVD $1931, R0 - BR callbackasm1(SB) - MOVD $1932, R0 - BR callbackasm1(SB) - MOVD $1933, R0 - BR callbackasm1(SB) - MOVD $1934, R0 - BR callbackasm1(SB) - MOVD $1935, R0 - BR callbackasm1(SB) - MOVD $1936, R0 - BR callbackasm1(SB) - MOVD $1937, R0 - BR callbackasm1(SB) - MOVD $1938, R0 - BR callbackasm1(SB) - MOVD $1939, R0 - BR callbackasm1(SB) - MOVD $1940, R0 - BR callbackasm1(SB) - MOVD $1941, R0 - BR callbackasm1(SB) - MOVD $1942, R0 - BR callbackasm1(SB) - MOVD $1943, R0 - BR callbackasm1(SB) - MOVD $1944, R0 - BR callbackasm1(SB) - MOVD $1945, R0 - BR callbackasm1(SB) - MOVD $1946, R0 - BR callbackasm1(SB) - MOVD $1947, R0 - BR callbackasm1(SB) - MOVD $1948, R0 - BR callbackasm1(SB) - MOVD $1949, R0 - BR callbackasm1(SB) - MOVD $1950, R0 - BR callbackasm1(SB) - MOVD $1951, R0 - BR callbackasm1(SB) - MOVD $1952, R0 - BR callbackasm1(SB) - MOVD $1953, R0 - BR callbackasm1(SB) - MOVD $1954, R0 - BR callbackasm1(SB) - MOVD $1955, R0 - BR callbackasm1(SB) - MOVD $1956, R0 - BR callbackasm1(SB) - MOVD $1957, R0 - BR callbackasm1(SB) - MOVD $1958, R0 - BR callbackasm1(SB) - MOVD $1959, R0 - BR callbackasm1(SB) - MOVD $1960, R0 - BR callbackasm1(SB) - MOVD $1961, R0 - BR callbackasm1(SB) - MOVD $1962, R0 - BR callbackasm1(SB) - MOVD $1963, R0 - BR callbackasm1(SB) - MOVD $1964, R0 - BR callbackasm1(SB) - MOVD $1965, R0 - BR callbackasm1(SB) - MOVD $1966, R0 - BR callbackasm1(SB) - MOVD $1967, R0 - BR callbackasm1(SB) - MOVD $1968, R0 - BR callbackasm1(SB) - MOVD $1969, R0 - BR callbackasm1(SB) - MOVD $1970, R0 - BR callbackasm1(SB) - MOVD $1971, R0 - BR callbackasm1(SB) - MOVD $1972, R0 - BR callbackasm1(SB) - MOVD $1973, R0 - BR callbackasm1(SB) - MOVD $1974, R0 - BR callbackasm1(SB) - MOVD $1975, R0 - BR callbackasm1(SB) - MOVD $1976, R0 - BR callbackasm1(SB) - MOVD $1977, R0 - BR callbackasm1(SB) - MOVD $1978, R0 - BR callbackasm1(SB) - MOVD $1979, R0 - BR callbackasm1(SB) - MOVD $1980, R0 - BR callbackasm1(SB) - MOVD $1981, R0 - BR callbackasm1(SB) - MOVD $1982, R0 - BR callbackasm1(SB) - MOVD $1983, R0 - BR callbackasm1(SB) - MOVD $1984, R0 - BR callbackasm1(SB) - MOVD $1985, R0 - BR callbackasm1(SB) - MOVD $1986, R0 - BR callbackasm1(SB) - MOVD $1987, R0 - BR callbackasm1(SB) - MOVD $1988, R0 - BR callbackasm1(SB) - MOVD $1989, R0 - BR callbackasm1(SB) - MOVD $1990, R0 - BR callbackasm1(SB) - MOVD $1991, R0 - BR callbackasm1(SB) - MOVD $1992, R0 - BR callbackasm1(SB) - MOVD $1993, R0 - BR callbackasm1(SB) - MOVD $1994, R0 - BR callbackasm1(SB) - MOVD $1995, R0 - BR callbackasm1(SB) - MOVD $1996, R0 - BR callbackasm1(SB) - MOVD $1997, R0 - BR callbackasm1(SB) - MOVD $1998, R0 - BR callbackasm1(SB) - MOVD $1999, R0 - BR callbackasm1(SB) diff --git a/vendor/github.com/facebookgo/grace/gracenet/net.go b/vendor/github.com/facebookgo/grace/gracenet/net.go deleted file mode 100644 index a980954a9d9..00000000000 --- a/vendor/github.com/facebookgo/grace/gracenet/net.go +++ /dev/null @@ -1,252 +0,0 @@ -// Package gracenet provides a family of Listen functions that either open a -// fresh connection or provide an inherited connection from when the process -// was started. The behave like their counterparts in the net package, but -// transparently provide support for graceful restarts without dropping -// connections. This is provided in a systemd socket activation compatible form -// to allow using socket activation. -// -// BUG: Doesn't handle closing of listeners. -package gracenet - -import ( - "fmt" - "net" - "os" - "os/exec" - "strconv" - "strings" - "sync" -) - -const ( - // Used to indicate a graceful restart in the new process. - envCountKey = "LISTEN_FDS" - envCountKeyPrefix = envCountKey + "=" -) - -// In order to keep the working directory the same as when we started we record -// it at startup. -var originalWD, _ = os.Getwd() - -// Net provides the family of Listen functions and maintains the associated -// state. Typically you will have only once instance of Net per application. -type Net struct { - inherited []net.Listener - active []net.Listener - mutex sync.Mutex - inheritOnce sync.Once - - // used in tests to override the default behavior of starting from fd 3. - fdStart int -} - -func (n *Net) inherit() error { - var retErr error - n.inheritOnce.Do(func() { - n.mutex.Lock() - defer n.mutex.Unlock() - countStr := os.Getenv(envCountKey) - if countStr == "" { - return - } - count, err := strconv.Atoi(countStr) - if err != nil { - retErr = fmt.Errorf("found invalid count value: %s=%s", envCountKey, countStr) - return - } - - // In tests this may be overridden. - fdStart := n.fdStart - if fdStart == 0 { - // In normal operations if we are inheriting, the listeners will begin at - // fd 3. - fdStart = 3 - } - - for i := fdStart; i < fdStart+count; i++ { - file := os.NewFile(uintptr(i), "listener") - l, err := net.FileListener(file) - if err != nil { - file.Close() - retErr = fmt.Errorf("error inheriting socket fd %d: %s", i, err) - return - } - if err := file.Close(); err != nil { - retErr = fmt.Errorf("error closing inherited socket fd %d: %s", i, err) - return - } - n.inherited = append(n.inherited, l) - } - }) - return retErr -} - -// Listen announces on the local network address laddr. The network net must be -// a stream-oriented network: "tcp", "tcp4", "tcp6", "unix" or "unixpacket". It -// returns an inherited net.Listener for the matching network and address, or -// creates a new one using net.Listen. -func (n *Net) Listen(nett, laddr string) (net.Listener, error) { - switch nett { - default: - return nil, net.UnknownNetworkError(nett) - case "tcp", "tcp4", "tcp6": - addr, err := net.ResolveTCPAddr(nett, laddr) - if err != nil { - return nil, err - } - return n.ListenTCP(nett, addr) - case "unix", "unixpacket", "invalid_unix_net_for_test": - addr, err := net.ResolveUnixAddr(nett, laddr) - if err != nil { - return nil, err - } - return n.ListenUnix(nett, addr) - } -} - -// ListenTCP announces on the local network address laddr. The network net must -// be: "tcp", "tcp4" or "tcp6". It returns an inherited net.Listener for the -// matching network and address, or creates a new one using net.ListenTCP. -func (n *Net) ListenTCP(nett string, laddr *net.TCPAddr) (*net.TCPListener, error) { - if err := n.inherit(); err != nil { - return nil, err - } - - n.mutex.Lock() - defer n.mutex.Unlock() - - // look for an inherited listener - for i, l := range n.inherited { - if l == nil { // we nil used inherited listeners - continue - } - if isSameAddr(l.Addr(), laddr) { - n.inherited[i] = nil - n.active = append(n.active, l) - return l.(*net.TCPListener), nil - } - } - - // make a fresh listener - l, err := net.ListenTCP(nett, laddr) - if err != nil { - return nil, err - } - n.active = append(n.active, l) - return l, nil -} - -// ListenUnix announces on the local network address laddr. The network net -// must be a: "unix" or "unixpacket". It returns an inherited net.Listener for -// the matching network and address, or creates a new one using net.ListenUnix. -func (n *Net) ListenUnix(nett string, laddr *net.UnixAddr) (*net.UnixListener, error) { - if err := n.inherit(); err != nil { - return nil, err - } - - n.mutex.Lock() - defer n.mutex.Unlock() - - // look for an inherited listener - for i, l := range n.inherited { - if l == nil { // we nil used inherited listeners - continue - } - if isSameAddr(l.Addr(), laddr) { - n.inherited[i] = nil - n.active = append(n.active, l) - return l.(*net.UnixListener), nil - } - } - - // make a fresh listener - l, err := net.ListenUnix(nett, laddr) - if err != nil { - return nil, err - } - n.active = append(n.active, l) - return l, nil -} - -// activeListeners returns a snapshot copy of the active listeners. -func (n *Net) activeListeners() ([]net.Listener, error) { - n.mutex.Lock() - defer n.mutex.Unlock() - ls := make([]net.Listener, len(n.active)) - copy(ls, n.active) - return ls, nil -} - -func isSameAddr(a1, a2 net.Addr) bool { - if a1.Network() != a2.Network() { - return false - } - a1s := a1.String() - a2s := a2.String() - if a1s == a2s { - return true - } - - // This allows for ipv6 vs ipv4 local addresses to compare as equal. This - // scenario is common when listening on localhost. - const ipv6prefix = "[::]" - a1s = strings.TrimPrefix(a1s, ipv6prefix) - a2s = strings.TrimPrefix(a2s, ipv6prefix) - const ipv4prefix = "0.0.0.0" - a1s = strings.TrimPrefix(a1s, ipv4prefix) - a2s = strings.TrimPrefix(a2s, ipv4prefix) - return a1s == a2s -} - -// StartProcess starts a new process passing it the active listeners. It -// doesn't fork, but starts a new process using the same environment and -// arguments as when it was originally started. This allows for a newly -// deployed binary to be started. It returns the pid of the newly started -// process when successful. -func (n *Net) StartProcess() (int, error) { - listeners, err := n.activeListeners() - if err != nil { - return 0, err - } - - // Extract the fds from the listeners. - files := make([]*os.File, len(listeners)) - for i, l := range listeners { - files[i], err = l.(filer).File() - if err != nil { - return 0, err - } - defer files[i].Close() - } - - // Use the original binary location. This works with symlinks such that if - // the file it points to has been changed we will use the updated symlink. - argv0, err := exec.LookPath(os.Args[0]) - if err != nil { - return 0, err - } - - // Pass on the environment and replace the old count key with the new one. - var env []string - for _, v := range os.Environ() { - if !strings.HasPrefix(v, envCountKeyPrefix) { - env = append(env, v) - } - } - env = append(env, fmt.Sprintf("%s%d", envCountKeyPrefix, len(listeners))) - - allFiles := append([]*os.File{os.Stdin, os.Stdout, os.Stderr}, files...) - process, err := os.StartProcess(argv0, os.Args, &os.ProcAttr{ - Dir: originalWD, - Env: env, - Files: allFiles, - }) - if err != nil { - return 0, err - } - return process.Pid, nil -} - -type filer interface { - File() (*os.File, error) -} diff --git a/vendor/github.com/fortytw2/leaktest/.travis.yml b/vendor/github.com/fortytw2/leaktest/.travis.yml deleted file mode 100644 index 5a791be17b1..00000000000 --- a/vendor/github.com/fortytw2/leaktest/.travis.yml +++ /dev/null @@ -1,16 +0,0 @@ -language: go -go: - - 1.8 - - 1.9 - - "1.10" - - "1.11" - - tip - -script: - - go test -v -race -parallel 5 -coverprofile=coverage.txt -covermode=atomic ./ - - go test github.com/fortytw2/leaktest -run ^TestEmptyLeak$ - -before_install: - - pip install --user codecov -after_success: - - codecov diff --git a/vendor/github.com/fortytw2/leaktest/LICENSE b/vendor/github.com/fortytw2/leaktest/LICENSE deleted file mode 100644 index 74487567632..00000000000 --- a/vendor/github.com/fortytw2/leaktest/LICENSE +++ /dev/null @@ -1,27 +0,0 @@ -Copyright (c) 2012 The Go Authors. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - * Redistributions of source code must retain the above copyright -notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above -copyright notice, this list of conditions and the following disclaimer -in the documentation and/or other materials provided with the -distribution. - * Neither the name of Google Inc. nor the names of its -contributors may be used to endorse or promote products derived from -this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/fortytw2/leaktest/README.md b/vendor/github.com/fortytw2/leaktest/README.md deleted file mode 100644 index 82822bf0a52..00000000000 --- a/vendor/github.com/fortytw2/leaktest/README.md +++ /dev/null @@ -1,64 +0,0 @@ -## Leaktest [![Build Status](https://travis-ci.org/fortytw2/leaktest.svg?branch=master)](https://travis-ci.org/fortytw2/leaktest) [![codecov](https://codecov.io/gh/fortytw2/leaktest/branch/master/graph/badge.svg)](https://codecov.io/gh/fortytw2/leaktest) [![Sourcegraph](https://sourcegraph.com/github.com/fortytw2/leaktest/-/badge.svg)](https://sourcegraph.com/github.com/fortytw2/leaktest?badge) [![Documentation](https://godoc.org/github.com/fortytw2/gpt?status.svg)](http://godoc.org/github.com/fortytw2/leaktest) - -Refactored, tested variant of the goroutine leak detector found in both -`net/http` tests and the `cockroachdb` source tree. - -Takes a snapshot of running goroutines at the start of a test, and at the end - -compares the two and _voila_. Ignores runtime/sys goroutines. Doesn't play nice -with `t.Parallel()` right now, but there are plans to do so. - -### Installation - -Go 1.7+ - -``` -go get -u github.com/fortytw2/leaktest -``` - -Go 1.5/1.6 need to use the tag `v1.0.0`, as newer versions depend on -`context.Context`. - -### Example - -These tests fail, because they leak a goroutine - -```go -// Default "Check" will poll for 5 seconds to check that all -// goroutines are cleaned up -func TestPool(t *testing.T) { - defer leaktest.Check(t)() - - go func() { - for { - time.Sleep(time.Second) - } - }() -} - -// Helper function to timeout after X duration -func TestPoolTimeout(t *testing.T) { - defer leaktest.CheckTimeout(t, time.Second)() - - go func() { - for { - time.Sleep(time.Second) - } - }() -} - -// Use Go 1.7+ context.Context for cancellation -func TestPoolContext(t *testing.T) { - ctx, _ := context.WithTimeout(context.Background(), time.Second) - defer leaktest.CheckContext(ctx, t)() - - go func() { - for { - time.Sleep(time.Second) - } - }() -} -``` - -## LICENSE - -Same BSD-style as Go, see LICENSE diff --git a/vendor/github.com/fortytw2/leaktest/leaktest.go b/vendor/github.com/fortytw2/leaktest/leaktest.go deleted file mode 100644 index 219e9307db3..00000000000 --- a/vendor/github.com/fortytw2/leaktest/leaktest.go +++ /dev/null @@ -1,153 +0,0 @@ -// Copyright 2013 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 leaktest provides tools to detect leaked goroutines in tests. -// To use it, call "defer leaktest.Check(t)()" at the beginning of each -// test that may use goroutines. -// copied out of the cockroachdb source tree with slight modifications to be -// more re-useable -package leaktest - -import ( - "context" - "fmt" - "runtime" - "sort" - "strconv" - "strings" - "time" -) - -type goroutine struct { - id uint64 - stack string -} - -type goroutineByID []*goroutine - -func (g goroutineByID) Len() int { return len(g) } -func (g goroutineByID) Less(i, j int) bool { return g[i].id < g[j].id } -func (g goroutineByID) Swap(i, j int) { g[i], g[j] = g[j], g[i] } - -func interestingGoroutine(g string) (*goroutine, error) { - sl := strings.SplitN(g, "\n", 2) - if len(sl) != 2 { - return nil, fmt.Errorf("error parsing stack: %q", g) - } - stack := strings.TrimSpace(sl[1]) - if strings.HasPrefix(stack, "testing.RunTests") { - return nil, nil - } - - if stack == "" || - // Ignore HTTP keep alives - strings.Contains(stack, ").readLoop(") || - strings.Contains(stack, ").writeLoop(") || - // Below are the stacks ignored by the upstream leaktest code. - strings.Contains(stack, "testing.Main(") || - strings.Contains(stack, "testing.(*T).Run(") || - strings.Contains(stack, "runtime.goexit") || - strings.Contains(stack, "created by runtime.gc") || - strings.Contains(stack, "interestingGoroutines") || - strings.Contains(stack, "runtime.MHeap_Scavenger") || - strings.Contains(stack, "signal.signal_recv") || - strings.Contains(stack, "sigterm.handler") || - strings.Contains(stack, "runtime_mcall") || - strings.Contains(stack, "goroutine in C code") { - return nil, nil - } - - // Parse the goroutine's ID from the header line. - h := strings.SplitN(sl[0], " ", 3) - if len(h) < 3 { - return nil, fmt.Errorf("error parsing stack header: %q", sl[0]) - } - id, err := strconv.ParseUint(h[1], 10, 64) - if err != nil { - return nil, fmt.Errorf("error parsing goroutine id: %s", err) - } - - return &goroutine{id: id, stack: strings.TrimSpace(g)}, nil -} - -// interestingGoroutines returns all goroutines we care about for the purpose -// of leak checking. It excludes testing or runtime ones. -func interestingGoroutines(t ErrorReporter) []*goroutine { - buf := make([]byte, 2<<20) - buf = buf[:runtime.Stack(buf, true)] - var gs []*goroutine - for _, g := range strings.Split(string(buf), "\n\n") { - gr, err := interestingGoroutine(g) - if err != nil { - t.Errorf("leaktest: %s", err) - continue - } else if gr == nil { - continue - } - gs = append(gs, gr) - } - sort.Sort(goroutineByID(gs)) - return gs -} - -// ErrorReporter is a tiny subset of a testing.TB to make testing not such a -// massive pain -type ErrorReporter interface { - Errorf(format string, args ...interface{}) -} - -// Check snapshots the currently-running goroutines and returns a -// function to be run at the end of tests to see whether any -// goroutines leaked, waiting up to 5 seconds in error conditions -func Check(t ErrorReporter) func() { - return CheckTimeout(t, 5*time.Second) -} - -// CheckTimeout is the same as Check, but with a configurable timeout -func CheckTimeout(t ErrorReporter, dur time.Duration) func() { - ctx, cancel := context.WithCancel(context.Background()) - fn := CheckContext(ctx, t) - return func() { - timer := time.AfterFunc(dur, cancel) - fn() - // Remember to clean up the timer and context - timer.Stop() - cancel() - } -} - -// CheckContext is the same as Check, but uses a context.Context for -// cancellation and timeout control -func CheckContext(ctx context.Context, t ErrorReporter) func() { - orig := map[uint64]bool{} - for _, g := range interestingGoroutines(t) { - orig[g.id] = true - } - return func() { - var leaked []string - for { - select { - case <-ctx.Done(): - t.Errorf("leaktest: timed out checking goroutines") - default: - leaked = make([]string, 0) - for _, g := range interestingGoroutines(t) { - if !orig[g.id] { - leaked = append(leaked, g.stack) - } - } - if len(leaked) == 0 { - return - } - // don't spin needlessly - time.Sleep(time.Millisecond * 50) - continue - } - break - } - for _, g := range leaked { - t.Errorf("leaktest: leaked goroutine: %v", g) - } - } -} diff --git a/vendor/github.com/fsnotify/fsnotify/.editorconfig b/vendor/github.com/fsnotify/fsnotify/.editorconfig deleted file mode 100644 index fad895851e5..00000000000 --- a/vendor/github.com/fsnotify/fsnotify/.editorconfig +++ /dev/null @@ -1,12 +0,0 @@ -root = true - -[*.go] -indent_style = tab -indent_size = 4 -insert_final_newline = true - -[*.{yml,yaml}] -indent_style = space -indent_size = 2 -insert_final_newline = true -trim_trailing_whitespace = true diff --git a/vendor/github.com/fsnotify/fsnotify/.gitattributes b/vendor/github.com/fsnotify/fsnotify/.gitattributes deleted file mode 100644 index 32f1001be0a..00000000000 --- a/vendor/github.com/fsnotify/fsnotify/.gitattributes +++ /dev/null @@ -1 +0,0 @@ -go.sum linguist-generated diff --git a/vendor/github.com/fsnotify/fsnotify/.gitignore b/vendor/github.com/fsnotify/fsnotify/.gitignore deleted file mode 100644 index 4cd0cbaf432..00000000000 --- a/vendor/github.com/fsnotify/fsnotify/.gitignore +++ /dev/null @@ -1,6 +0,0 @@ -# Setup a Global .gitignore for OS and editor generated files: -# https://help.github.com/articles/ignoring-files -# git config --global core.excludesfile ~/.gitignore_global - -.vagrant -*.sublime-project diff --git a/vendor/github.com/fsnotify/fsnotify/.travis.yml b/vendor/github.com/fsnotify/fsnotify/.travis.yml deleted file mode 100644 index a9c30165cdd..00000000000 --- a/vendor/github.com/fsnotify/fsnotify/.travis.yml +++ /dev/null @@ -1,36 +0,0 @@ -sudo: false -language: go - -go: - - "stable" - - "1.11.x" - - "1.10.x" - - "1.9.x" - -matrix: - include: - - go: "stable" - env: GOLINT=true - allow_failures: - - go: tip - fast_finish: true - - -before_install: - - if [ ! -z "${GOLINT}" ]; then go get -u golang.org/x/lint/golint; fi - -script: - - go test --race ./... - -after_script: - - test -z "$(gofmt -s -l -w . | tee /dev/stderr)" - - if [ ! -z "${GOLINT}" ]; then echo running golint; golint --set_exit_status ./...; else echo skipping golint; fi - - go vet ./... - -os: - - linux - - osx - - windows - -notifications: - email: false diff --git a/vendor/github.com/fsnotify/fsnotify/AUTHORS b/vendor/github.com/fsnotify/fsnotify/AUTHORS deleted file mode 100644 index 5ab5d41c547..00000000000 --- a/vendor/github.com/fsnotify/fsnotify/AUTHORS +++ /dev/null @@ -1,52 +0,0 @@ -# Names should be added to this file as -# Name or Organization -# The email address is not required for organizations. - -# You can update this list using the following command: -# -# $ git shortlog -se | awk '{print $2 " " $3 " " $4}' - -# Please keep the list sorted. - -Aaron L -Adrien Bustany -Amit Krishnan -Anmol Sethi -Bjørn Erik Pedersen -Bruno Bigras -Caleb Spare -Case Nelson -Chris Howey -Christoffer Buchholz -Daniel Wagner-Hall -Dave Cheney -Evan Phoenix -Francisco Souza -Hari haran -John C Barstow -Kelvin Fo -Ken-ichirou MATSUZAWA -Matt Layher -Nathan Youngman -Nickolai Zeldovich -Patrick -Paul Hammond -Pawel Knap -Pieter Droogendijk -Pursuit92 -Riku Voipio -Rob Figueiredo -Rodrigo Chiossi -Slawek Ligus -Soge Zhang -Tiffany Jernigan -Tilak Sharma -Tom Payne -Travis Cline -Tudor Golubenco -Vahe Khachikyan -Yukang -bronze1man -debrando -henrikedwards -铁哥 diff --git a/vendor/github.com/fsnotify/fsnotify/CHANGELOG.md b/vendor/github.com/fsnotify/fsnotify/CHANGELOG.md deleted file mode 100644 index be4d7ea2c14..00000000000 --- a/vendor/github.com/fsnotify/fsnotify/CHANGELOG.md +++ /dev/null @@ -1,317 +0,0 @@ -# Changelog - -## v1.4.7 / 2018-01-09 - -* BSD/macOS: Fix possible deadlock on closing the watcher on kqueue (thanks @nhooyr and @glycerine) -* Tests: Fix missing verb on format string (thanks @rchiossi) -* Linux: Fix deadlock in Remove (thanks @aarondl) -* Linux: Watch.Add improvements (avoid race, fix consistency, reduce garbage) (thanks @twpayne) -* Docs: Moved FAQ into the README (thanks @vahe) -* Linux: Properly handle inotify's IN_Q_OVERFLOW event (thanks @zeldovich) -* Docs: replace references to OS X with macOS - -## v1.4.2 / 2016-10-10 - -* Linux: use InotifyInit1 with IN_CLOEXEC to stop leaking a file descriptor to a child process when using fork/exec [#178](https://github.com/fsnotify/fsnotify/pull/178) (thanks @pattyshack) - -## v1.4.1 / 2016-10-04 - -* Fix flaky inotify stress test on Linux [#177](https://github.com/fsnotify/fsnotify/pull/177) (thanks @pattyshack) - -## v1.4.0 / 2016-10-01 - -* add a String() method to Event.Op [#165](https://github.com/fsnotify/fsnotify/pull/165) (thanks @oozie) - -## v1.3.1 / 2016-06-28 - -* Windows: fix for double backslash when watching the root of a drive [#151](https://github.com/fsnotify/fsnotify/issues/151) (thanks @brunoqc) - -## v1.3.0 / 2016-04-19 - -* Support linux/arm64 by [patching](https://go-review.googlesource.com/#/c/21971/) x/sys/unix and switching to to it from syscall (thanks @suihkulokki) [#135](https://github.com/fsnotify/fsnotify/pull/135) - -## v1.2.10 / 2016-03-02 - -* Fix golint errors in windows.go [#121](https://github.com/fsnotify/fsnotify/pull/121) (thanks @tiffanyfj) - -## v1.2.9 / 2016-01-13 - -kqueue: Fix logic for CREATE after REMOVE [#111](https://github.com/fsnotify/fsnotify/pull/111) (thanks @bep) - -## v1.2.8 / 2015-12-17 - -* kqueue: fix race condition in Close [#105](https://github.com/fsnotify/fsnotify/pull/105) (thanks @djui for reporting the issue and @ppknap for writing a failing test) -* inotify: fix race in test -* enable race detection for continuous integration (Linux, Mac, Windows) - -## v1.2.5 / 2015-10-17 - -* inotify: use epoll_create1 for arm64 support (requires Linux 2.6.27 or later) [#100](https://github.com/fsnotify/fsnotify/pull/100) (thanks @suihkulokki) -* inotify: fix path leaks [#73](https://github.com/fsnotify/fsnotify/pull/73) (thanks @chamaken) -* kqueue: watch for rename events on subdirectories [#83](https://github.com/fsnotify/fsnotify/pull/83) (thanks @guotie) -* kqueue: avoid infinite loops from symlinks cycles [#101](https://github.com/fsnotify/fsnotify/pull/101) (thanks @illicitonion) - -## v1.2.1 / 2015-10-14 - -* kqueue: don't watch named pipes [#98](https://github.com/fsnotify/fsnotify/pull/98) (thanks @evanphx) - -## v1.2.0 / 2015-02-08 - -* inotify: use epoll to wake up readEvents [#66](https://github.com/fsnotify/fsnotify/pull/66) (thanks @PieterD) -* inotify: closing watcher should now always shut down goroutine [#63](https://github.com/fsnotify/fsnotify/pull/63) (thanks @PieterD) -* kqueue: close kqueue after removing watches, fixes [#59](https://github.com/fsnotify/fsnotify/issues/59) - -## v1.1.1 / 2015-02-05 - -* inotify: Retry read on EINTR [#61](https://github.com/fsnotify/fsnotify/issues/61) (thanks @PieterD) - -## v1.1.0 / 2014-12-12 - -* kqueue: rework internals [#43](https://github.com/fsnotify/fsnotify/pull/43) - * add low-level functions - * only need to store flags on directories - * less mutexes [#13](https://github.com/fsnotify/fsnotify/issues/13) - * done can be an unbuffered channel - * remove calls to os.NewSyscallError -* More efficient string concatenation for Event.String() [#52](https://github.com/fsnotify/fsnotify/pull/52) (thanks @mdlayher) -* kqueue: fix regression in rework causing subdirectories to be watched [#48](https://github.com/fsnotify/fsnotify/issues/48) -* kqueue: cleanup internal watch before sending remove event [#51](https://github.com/fsnotify/fsnotify/issues/51) - -## v1.0.4 / 2014-09-07 - -* kqueue: add dragonfly to the build tags. -* Rename source code files, rearrange code so exported APIs are at the top. -* Add done channel to example code. [#37](https://github.com/fsnotify/fsnotify/pull/37) (thanks @chenyukang) - -## v1.0.3 / 2014-08-19 - -* [Fix] Windows MOVED_TO now translates to Create like on BSD and Linux. [#36](https://github.com/fsnotify/fsnotify/issues/36) - -## v1.0.2 / 2014-08-17 - -* [Fix] Missing create events on macOS. [#14](https://github.com/fsnotify/fsnotify/issues/14) (thanks @zhsso) -* [Fix] Make ./path and path equivalent. (thanks @zhsso) - -## v1.0.0 / 2014-08-15 - -* [API] Remove AddWatch on Windows, use Add. -* Improve documentation for exported identifiers. [#30](https://github.com/fsnotify/fsnotify/issues/30) -* Minor updates based on feedback from golint. - -## dev / 2014-07-09 - -* Moved to [github.com/fsnotify/fsnotify](https://github.com/fsnotify/fsnotify). -* Use os.NewSyscallError instead of returning errno (thanks @hariharan-uno) - -## dev / 2014-07-04 - -* kqueue: fix incorrect mutex used in Close() -* Update example to demonstrate usage of Op. - -## dev / 2014-06-28 - -* [API] Don't set the Write Op for attribute notifications [#4](https://github.com/fsnotify/fsnotify/issues/4) -* Fix for String() method on Event (thanks Alex Brainman) -* Don't build on Plan 9 or Solaris (thanks @4ad) - -## dev / 2014-06-21 - -* Events channel of type Event rather than *Event. -* [internal] use syscall constants directly for inotify and kqueue. -* [internal] kqueue: rename events to kevents and fileEvent to event. - -## dev / 2014-06-19 - -* Go 1.3+ required on Windows (uses syscall.ERROR_MORE_DATA internally). -* [internal] remove cookie from Event struct (unused). -* [internal] Event struct has the same definition across every OS. -* [internal] remove internal watch and removeWatch methods. - -## dev / 2014-06-12 - -* [API] Renamed Watch() to Add() and RemoveWatch() to Remove(). -* [API] Pluralized channel names: Events and Errors. -* [API] Renamed FileEvent struct to Event. -* [API] Op constants replace methods like IsCreate(). - -## dev / 2014-06-12 - -* Fix data race on kevent buffer (thanks @tilaks) [#98](https://github.com/howeyc/fsnotify/pull/98) - -## dev / 2014-05-23 - -* [API] Remove current implementation of WatchFlags. - * current implementation doesn't take advantage of OS for efficiency - * provides little benefit over filtering events as they are received, but has extra bookkeeping and mutexes - * no tests for the current implementation - * not fully implemented on Windows [#93](https://github.com/howeyc/fsnotify/issues/93#issuecomment-39285195) - -## v0.9.3 / 2014-12-31 - -* kqueue: cleanup internal watch before sending remove event [#51](https://github.com/fsnotify/fsnotify/issues/51) - -## v0.9.2 / 2014-08-17 - -* [Backport] Fix missing create events on macOS. [#14](https://github.com/fsnotify/fsnotify/issues/14) (thanks @zhsso) - -## v0.9.1 / 2014-06-12 - -* Fix data race on kevent buffer (thanks @tilaks) [#98](https://github.com/howeyc/fsnotify/pull/98) - -## v0.9.0 / 2014-01-17 - -* IsAttrib() for events that only concern a file's metadata [#79][] (thanks @abustany) -* [Fix] kqueue: fix deadlock [#77][] (thanks @cespare) -* [NOTICE] Development has moved to `code.google.com/p/go.exp/fsnotify` in preparation for inclusion in the Go standard library. - -## v0.8.12 / 2013-11-13 - -* [API] Remove FD_SET and friends from Linux adapter - -## v0.8.11 / 2013-11-02 - -* [Doc] Add Changelog [#72][] (thanks @nathany) -* [Doc] Spotlight and double modify events on macOS [#62][] (reported by @paulhammond) - -## v0.8.10 / 2013-10-19 - -* [Fix] kqueue: remove file watches when parent directory is removed [#71][] (reported by @mdwhatcott) -* [Fix] kqueue: race between Close and readEvents [#70][] (reported by @bernerdschaefer) -* [Doc] specify OS-specific limits in README (thanks @debrando) - -## v0.8.9 / 2013-09-08 - -* [Doc] Contributing (thanks @nathany) -* [Doc] update package path in example code [#63][] (thanks @paulhammond) -* [Doc] GoCI badge in README (Linux only) [#60][] -* [Doc] Cross-platform testing with Vagrant [#59][] (thanks @nathany) - -## v0.8.8 / 2013-06-17 - -* [Fix] Windows: handle `ERROR_MORE_DATA` on Windows [#49][] (thanks @jbowtie) - -## v0.8.7 / 2013-06-03 - -* [API] Make syscall flags internal -* [Fix] inotify: ignore event changes -* [Fix] race in symlink test [#45][] (reported by @srid) -* [Fix] tests on Windows -* lower case error messages - -## v0.8.6 / 2013-05-23 - -* kqueue: Use EVT_ONLY flag on Darwin -* [Doc] Update README with full example - -## v0.8.5 / 2013-05-09 - -* [Fix] inotify: allow monitoring of "broken" symlinks (thanks @tsg) - -## v0.8.4 / 2013-04-07 - -* [Fix] kqueue: watch all file events [#40][] (thanks @ChrisBuchholz) - -## v0.8.3 / 2013-03-13 - -* [Fix] inoitfy/kqueue memory leak [#36][] (reported by @nbkolchin) -* [Fix] kqueue: use fsnFlags for watching a directory [#33][] (reported by @nbkolchin) - -## v0.8.2 / 2013-02-07 - -* [Doc] add Authors -* [Fix] fix data races for map access [#29][] (thanks @fsouza) - -## v0.8.1 / 2013-01-09 - -* [Fix] Windows path separators -* [Doc] BSD License - -## v0.8.0 / 2012-11-09 - -* kqueue: directory watching improvements (thanks @vmirage) -* inotify: add `IN_MOVED_TO` [#25][] (requested by @cpisto) -* [Fix] kqueue: deleting watched directory [#24][] (reported by @jakerr) - -## v0.7.4 / 2012-10-09 - -* [Fix] inotify: fixes from https://codereview.appspot.com/5418045/ (ugorji) -* [Fix] kqueue: preserve watch flags when watching for delete [#21][] (reported by @robfig) -* [Fix] kqueue: watch the directory even if it isn't a new watch (thanks @robfig) -* [Fix] kqueue: modify after recreation of file - -## v0.7.3 / 2012-09-27 - -* [Fix] kqueue: watch with an existing folder inside the watched folder (thanks @vmirage) -* [Fix] kqueue: no longer get duplicate CREATE events - -## v0.7.2 / 2012-09-01 - -* kqueue: events for created directories - -## v0.7.1 / 2012-07-14 - -* [Fix] for renaming files - -## v0.7.0 / 2012-07-02 - -* [Feature] FSNotify flags -* [Fix] inotify: Added file name back to event path - -## v0.6.0 / 2012-06-06 - -* kqueue: watch files after directory created (thanks @tmc) - -## v0.5.1 / 2012-05-22 - -* [Fix] inotify: remove all watches before Close() - -## v0.5.0 / 2012-05-03 - -* [API] kqueue: return errors during watch instead of sending over channel -* kqueue: match symlink behavior on Linux -* inotify: add `DELETE_SELF` (requested by @taralx) -* [Fix] kqueue: handle EINTR (reported by @robfig) -* [Doc] Godoc example [#1][] (thanks @davecheney) - -## v0.4.0 / 2012-03-30 - -* Go 1 released: build with go tool -* [Feature] Windows support using winfsnotify -* Windows does not have attribute change notifications -* Roll attribute notifications into IsModify - -## v0.3.0 / 2012-02-19 - -* kqueue: add files when watch directory - -## v0.2.0 / 2011-12-30 - -* update to latest Go weekly code - -## v0.1.0 / 2011-10-19 - -* kqueue: add watch on file creation to match inotify -* kqueue: create file event -* inotify: ignore `IN_IGNORED` events -* event String() -* linux: common FileEvent functions -* initial commit - -[#79]: https://github.com/howeyc/fsnotify/pull/79 -[#77]: https://github.com/howeyc/fsnotify/pull/77 -[#72]: https://github.com/howeyc/fsnotify/issues/72 -[#71]: https://github.com/howeyc/fsnotify/issues/71 -[#70]: https://github.com/howeyc/fsnotify/issues/70 -[#63]: https://github.com/howeyc/fsnotify/issues/63 -[#62]: https://github.com/howeyc/fsnotify/issues/62 -[#60]: https://github.com/howeyc/fsnotify/issues/60 -[#59]: https://github.com/howeyc/fsnotify/issues/59 -[#49]: https://github.com/howeyc/fsnotify/issues/49 -[#45]: https://github.com/howeyc/fsnotify/issues/45 -[#40]: https://github.com/howeyc/fsnotify/issues/40 -[#36]: https://github.com/howeyc/fsnotify/issues/36 -[#33]: https://github.com/howeyc/fsnotify/issues/33 -[#29]: https://github.com/howeyc/fsnotify/issues/29 -[#25]: https://github.com/howeyc/fsnotify/issues/25 -[#24]: https://github.com/howeyc/fsnotify/issues/24 -[#21]: https://github.com/howeyc/fsnotify/issues/21 diff --git a/vendor/github.com/fsnotify/fsnotify/CONTRIBUTING.md b/vendor/github.com/fsnotify/fsnotify/CONTRIBUTING.md deleted file mode 100644 index 828a60b24ba..00000000000 --- a/vendor/github.com/fsnotify/fsnotify/CONTRIBUTING.md +++ /dev/null @@ -1,77 +0,0 @@ -# Contributing - -## Issues - -* Request features and report bugs using the [GitHub Issue Tracker](https://github.com/fsnotify/fsnotify/issues). -* Please indicate the platform you are using fsnotify on. -* A code example to reproduce the problem is appreciated. - -## Pull Requests - -### Contributor License Agreement - -fsnotify is derived from code in the [golang.org/x/exp](https://godoc.org/golang.org/x/exp) package and it may be included [in the standard library](https://github.com/fsnotify/fsnotify/issues/1) in the future. Therefore fsnotify carries the same [LICENSE](https://github.com/fsnotify/fsnotify/blob/master/LICENSE) as Go. Contributors retain their copyright, so you need to fill out a short form before we can accept your contribution: [Google Individual Contributor License Agreement](https://developers.google.com/open-source/cla/individual). - -Please indicate that you have signed the CLA in your pull request. - -### How fsnotify is Developed - -* Development is done on feature branches. -* Tests are run on BSD, Linux, macOS and Windows. -* Pull requests are reviewed and [applied to master][am] using [hub][]. - * Maintainers may modify or squash commits rather than asking contributors to. -* To issue a new release, the maintainers will: - * Update the CHANGELOG - * Tag a version, which will become available through gopkg.in. - -### How to Fork - -For smooth sailing, always use the original import path. Installing with `go get` makes this easy. - -1. Install from GitHub (`go get -u github.com/fsnotify/fsnotify`) -2. Create your feature branch (`git checkout -b my-new-feature`) -3. Ensure everything works and the tests pass (see below) -4. Commit your changes (`git commit -am 'Add some feature'`) - -Contribute upstream: - -1. Fork fsnotify on GitHub -2. Add your remote (`git remote add fork git@github.com:mycompany/repo.git`) -3. Push to the branch (`git push fork my-new-feature`) -4. Create a new Pull Request on GitHub - -This workflow is [thoroughly explained by Katrina Owen](https://splice.com/blog/contributing-open-source-git-repositories-go/). - -### Testing - -fsnotify uses build tags to compile different code on Linux, BSD, macOS, and Windows. - -Before doing a pull request, please do your best to test your changes on multiple platforms, and list which platforms you were able/unable to test on. - -To aid in cross-platform testing there is a Vagrantfile for Linux and BSD. - -* Install [Vagrant](http://www.vagrantup.com/) and [VirtualBox](https://www.virtualbox.org/) -* Setup [Vagrant Gopher](https://github.com/nathany/vagrant-gopher) in your `src` folder. -* Run `vagrant up` from the project folder. You can also setup just one box with `vagrant up linux` or `vagrant up bsd` (note: the BSD box doesn't support Windows hosts at this time, and NFS may prompt for your host OS password) -* Once setup, you can run the test suite on a given OS with a single command `vagrant ssh linux -c 'cd fsnotify/fsnotify; go test'`. -* When you're done, you will want to halt or destroy the Vagrant boxes. - -Notice: fsnotify file system events won't trigger in shared folders. The tests get around this limitation by using the /tmp directory. - -Right now there is no equivalent solution for Windows and macOS, but there are Windows VMs [freely available from Microsoft](http://www.modern.ie/en-us/virtualization-tools#downloads). - -### Maintainers - -Help maintaining fsnotify is welcome. To be a maintainer: - -* Submit a pull request and sign the CLA as above. -* You must be able to run the test suite on Mac, Windows, Linux and BSD. - -To keep master clean, the fsnotify project uses the "apply mail" workflow outlined in Nathaniel Talbott's post ["Merge pull request" Considered Harmful][am]. This requires installing [hub][]. - -All code changes should be internal pull requests. - -Releases are tagged using [Semantic Versioning](http://semver.org/). - -[hub]: https://github.com/github/hub -[am]: http://blog.spreedly.com/2014/06/24/merge-pull-request-considered-harmful/#.VGa5yZPF_Zs diff --git a/vendor/github.com/fsnotify/fsnotify/LICENSE b/vendor/github.com/fsnotify/fsnotify/LICENSE deleted file mode 100644 index e180c8fb059..00000000000 --- a/vendor/github.com/fsnotify/fsnotify/LICENSE +++ /dev/null @@ -1,28 +0,0 @@ -Copyright (c) 2012 The Go Authors. All rights reserved. -Copyright (c) 2012-2019 fsnotify Authors. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - * Redistributions of source code must retain the above copyright -notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above -copyright notice, this list of conditions and the following disclaimer -in the documentation and/or other materials provided with the -distribution. - * Neither the name of Google Inc. nor the names of its -contributors may be used to endorse or promote products derived from -this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/fsnotify/fsnotify/README.md b/vendor/github.com/fsnotify/fsnotify/README.md deleted file mode 100644 index b2629e5229c..00000000000 --- a/vendor/github.com/fsnotify/fsnotify/README.md +++ /dev/null @@ -1,130 +0,0 @@ -# File system notifications for Go - -[![GoDoc](https://godoc.org/github.com/fsnotify/fsnotify?status.svg)](https://godoc.org/github.com/fsnotify/fsnotify) [![Go Report Card](https://goreportcard.com/badge/github.com/fsnotify/fsnotify)](https://goreportcard.com/report/github.com/fsnotify/fsnotify) - -fsnotify utilizes [golang.org/x/sys](https://godoc.org/golang.org/x/sys) rather than `syscall` from the standard library. Ensure you have the latest version installed by running: - -```console -go get -u golang.org/x/sys/... -``` - -Cross platform: Windows, Linux, BSD and macOS. - -| Adapter | OS | Status | -| --------------------- | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | -| inotify | Linux 2.6.27 or later, Android\* | Supported [![Build Status](https://travis-ci.org/fsnotify/fsnotify.svg?branch=master)](https://travis-ci.org/fsnotify/fsnotify) | -| kqueue | BSD, macOS, iOS\* | Supported [![Build Status](https://travis-ci.org/fsnotify/fsnotify.svg?branch=master)](https://travis-ci.org/fsnotify/fsnotify) | -| ReadDirectoryChangesW | Windows | Supported [![Build Status](https://travis-ci.org/fsnotify/fsnotify.svg?branch=master)](https://travis-ci.org/fsnotify/fsnotify) | -| FSEvents | macOS | [Planned](https://github.com/fsnotify/fsnotify/issues/11) | -| FEN | Solaris 11 | [In Progress](https://github.com/fsnotify/fsnotify/issues/12) | -| fanotify | Linux 2.6.37+ | [Planned](https://github.com/fsnotify/fsnotify/issues/114) | -| USN Journals | Windows | [Maybe](https://github.com/fsnotify/fsnotify/issues/53) | -| Polling | *All* | [Maybe](https://github.com/fsnotify/fsnotify/issues/9) | - -\* Android and iOS are untested. - -Please see [the documentation](https://godoc.org/github.com/fsnotify/fsnotify) and consult the [FAQ](#faq) for usage information. - -## API stability - -fsnotify is a fork of [howeyc/fsnotify](https://godoc.org/github.com/howeyc/fsnotify) with a new API as of v1.0. The API is based on [this design document](http://goo.gl/MrYxyA). - -All [releases](https://github.com/fsnotify/fsnotify/releases) are tagged based on [Semantic Versioning](http://semver.org/). Further API changes are [planned](https://github.com/fsnotify/fsnotify/milestones), and will be tagged with a new major revision number. - -Go 1.6 supports dependencies located in the `vendor/` folder. Unless you are creating a library, it is recommended that you copy fsnotify into `vendor/github.com/fsnotify/fsnotify` within your project, and likewise for `golang.org/x/sys`. - -## Usage - -```go -package main - -import ( - "log" - - "github.com/fsnotify/fsnotify" -) - -func main() { - watcher, err := fsnotify.NewWatcher() - if err != nil { - log.Fatal(err) - } - defer watcher.Close() - - done := make(chan bool) - go func() { - for { - select { - case event, ok := <-watcher.Events: - if !ok { - return - } - log.Println("event:", event) - if event.Op&fsnotify.Write == fsnotify.Write { - log.Println("modified file:", event.Name) - } - case err, ok := <-watcher.Errors: - if !ok { - return - } - log.Println("error:", err) - } - } - }() - - err = watcher.Add("/tmp/foo") - if err != nil { - log.Fatal(err) - } - <-done -} -``` - -## Contributing - -Please refer to [CONTRIBUTING][] before opening an issue or pull request. - -## Example - -See [example_test.go](https://github.com/fsnotify/fsnotify/blob/master/example_test.go). - -## FAQ - -**When a file is moved to another directory is it still being watched?** - -No (it shouldn't be, unless you are watching where it was moved to). - -**When I watch a directory, are all subdirectories watched as well?** - -No, you must add watches for any directory you want to watch (a recursive watcher is on the roadmap [#18][]). - -**Do I have to watch the Error and Event channels in a separate goroutine?** - -As of now, yes. Looking into making this single-thread friendly (see [howeyc #7][#7]) - -**Why am I receiving multiple events for the same file on OS X?** - -Spotlight indexing on OS X can result in multiple events (see [howeyc #62][#62]). A temporary workaround is to add your folder(s) to the *Spotlight Privacy settings* until we have a native FSEvents implementation (see [#11][]). - -**How many files can be watched at once?** - -There are OS-specific limits as to how many watches can be created: -* Linux: /proc/sys/fs/inotify/max_user_watches contains the limit, reaching this limit results in a "no space left on device" error. -* BSD / OSX: sysctl variables "kern.maxfiles" and "kern.maxfilesperproc", reaching these limits results in a "too many open files" error. - -**Why don't notifications work with NFS filesystems or filesystem in userspace (FUSE)?** - -fsnotify requires support from underlying OS to work. The current NFS protocol does not provide network level support for file notifications. - -[#62]: https://github.com/howeyc/fsnotify/issues/62 -[#18]: https://github.com/fsnotify/fsnotify/issues/18 -[#11]: https://github.com/fsnotify/fsnotify/issues/11 -[#7]: https://github.com/howeyc/fsnotify/issues/7 - -[contributing]: https://github.com/fsnotify/fsnotify/blob/master/CONTRIBUTING.md - -## Related Projects - -* [notify](https://github.com/rjeczalik/notify) -* [fsevents](https://github.com/fsnotify/fsevents) - diff --git a/vendor/github.com/fsnotify/fsnotify/fen.go b/vendor/github.com/fsnotify/fsnotify/fen.go deleted file mode 100644 index ced39cb881e..00000000000 --- a/vendor/github.com/fsnotify/fsnotify/fen.go +++ /dev/null @@ -1,37 +0,0 @@ -// Copyright 2010 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. - -// +build solaris - -package fsnotify - -import ( - "errors" -) - -// Watcher watches a set of files, delivering events to a channel. -type Watcher struct { - Events chan Event - Errors chan error -} - -// NewWatcher establishes a new watcher with the underlying OS and begins waiting for events. -func NewWatcher() (*Watcher, error) { - return nil, errors.New("FEN based watcher not yet supported for fsnotify\n") -} - -// Close removes all watches and closes the events channel. -func (w *Watcher) Close() error { - return nil -} - -// Add starts watching the named file or directory (non-recursively). -func (w *Watcher) Add(name string) error { - return nil -} - -// Remove stops watching the the named file or directory (non-recursively). -func (w *Watcher) Remove(name string) error { - return nil -} diff --git a/vendor/github.com/fsnotify/fsnotify/fsnotify.go b/vendor/github.com/fsnotify/fsnotify/fsnotify.go deleted file mode 100644 index 89cab046d12..00000000000 --- a/vendor/github.com/fsnotify/fsnotify/fsnotify.go +++ /dev/null @@ -1,68 +0,0 @@ -// Copyright 2012 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. - -// +build !plan9 - -// Package fsnotify provides a platform-independent interface for file system notifications. -package fsnotify - -import ( - "bytes" - "errors" - "fmt" -) - -// Event represents a single file system notification. -type Event struct { - Name string // Relative path to the file or directory. - Op Op // File operation that triggered the event. -} - -// Op describes a set of file operations. -type Op uint32 - -// These are the generalized file operations that can trigger a notification. -const ( - Create Op = 1 << iota - Write - Remove - Rename - Chmod -) - -func (op Op) String() string { - // Use a buffer for efficient string concatenation - var buffer bytes.Buffer - - if op&Create == Create { - buffer.WriteString("|CREATE") - } - if op&Remove == Remove { - buffer.WriteString("|REMOVE") - } - if op&Write == Write { - buffer.WriteString("|WRITE") - } - if op&Rename == Rename { - buffer.WriteString("|RENAME") - } - if op&Chmod == Chmod { - buffer.WriteString("|CHMOD") - } - if buffer.Len() == 0 { - return "" - } - return buffer.String()[1:] // Strip leading pipe -} - -// String returns a string representation of the event in the form -// "file: REMOVE|WRITE|..." -func (e Event) String() string { - return fmt.Sprintf("%q: %s", e.Name, e.Op.String()) -} - -// Common errors that can be reported by a watcher -var ( - ErrEventOverflow = errors.New("fsnotify queue overflow") -) diff --git a/vendor/github.com/fsnotify/fsnotify/inotify.go b/vendor/github.com/fsnotify/fsnotify/inotify.go deleted file mode 100644 index d9fd1b88a05..00000000000 --- a/vendor/github.com/fsnotify/fsnotify/inotify.go +++ /dev/null @@ -1,337 +0,0 @@ -// Copyright 2010 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. - -// +build linux - -package fsnotify - -import ( - "errors" - "fmt" - "io" - "os" - "path/filepath" - "strings" - "sync" - "unsafe" - - "golang.org/x/sys/unix" -) - -// Watcher watches a set of files, delivering events to a channel. -type Watcher struct { - Events chan Event - Errors chan error - mu sync.Mutex // Map access - fd int - poller *fdPoller - watches map[string]*watch // Map of inotify watches (key: path) - paths map[int]string // Map of watched paths (key: watch descriptor) - done chan struct{} // Channel for sending a "quit message" to the reader goroutine - doneResp chan struct{} // Channel to respond to Close -} - -// NewWatcher establishes a new watcher with the underlying OS and begins waiting for events. -func NewWatcher() (*Watcher, error) { - // Create inotify fd - fd, errno := unix.InotifyInit1(unix.IN_CLOEXEC) - if fd == -1 { - return nil, errno - } - // Create epoll - poller, err := newFdPoller(fd) - if err != nil { - unix.Close(fd) - return nil, err - } - w := &Watcher{ - fd: fd, - poller: poller, - watches: make(map[string]*watch), - paths: make(map[int]string), - Events: make(chan Event), - Errors: make(chan error), - done: make(chan struct{}), - doneResp: make(chan struct{}), - } - - go w.readEvents() - return w, nil -} - -func (w *Watcher) isClosed() bool { - select { - case <-w.done: - return true - default: - return false - } -} - -// Close removes all watches and closes the events channel. -func (w *Watcher) Close() error { - if w.isClosed() { - return nil - } - - // Send 'close' signal to goroutine, and set the Watcher to closed. - close(w.done) - - // Wake up goroutine - w.poller.wake() - - // Wait for goroutine to close - <-w.doneResp - - return nil -} - -// Add starts watching the named file or directory (non-recursively). -func (w *Watcher) Add(name string) error { - name = filepath.Clean(name) - if w.isClosed() { - return errors.New("inotify instance already closed") - } - - const agnosticEvents = unix.IN_MOVED_TO | unix.IN_MOVED_FROM | - unix.IN_CREATE | unix.IN_ATTRIB | unix.IN_MODIFY | - unix.IN_MOVE_SELF | unix.IN_DELETE | unix.IN_DELETE_SELF - - var flags uint32 = agnosticEvents - - w.mu.Lock() - defer w.mu.Unlock() - watchEntry := w.watches[name] - if watchEntry != nil { - flags |= watchEntry.flags | unix.IN_MASK_ADD - } - wd, errno := unix.InotifyAddWatch(w.fd, name, flags) - if wd == -1 { - return errno - } - - if watchEntry == nil { - w.watches[name] = &watch{wd: uint32(wd), flags: flags} - w.paths[wd] = name - } else { - watchEntry.wd = uint32(wd) - watchEntry.flags = flags - } - - return nil -} - -// Remove stops watching the named file or directory (non-recursively). -func (w *Watcher) Remove(name string) error { - name = filepath.Clean(name) - - // Fetch the watch. - w.mu.Lock() - defer w.mu.Unlock() - watch, ok := w.watches[name] - - // Remove it from inotify. - if !ok { - return fmt.Errorf("can't remove non-existent inotify watch for: %s", name) - } - - // We successfully removed the watch if InotifyRmWatch doesn't return an - // error, we need to clean up our internal state to ensure it matches - // inotify's kernel state. - delete(w.paths, int(watch.wd)) - delete(w.watches, name) - - // inotify_rm_watch will return EINVAL if the file has been deleted; - // the inotify will already have been removed. - // watches and pathes are deleted in ignoreLinux() implicitly and asynchronously - // by calling inotify_rm_watch() below. e.g. readEvents() goroutine receives IN_IGNORE - // so that EINVAL means that the wd is being rm_watch()ed or its file removed - // by another thread and we have not received IN_IGNORE event. - success, errno := unix.InotifyRmWatch(w.fd, watch.wd) - if success == -1 { - // TODO: Perhaps it's not helpful to return an error here in every case. - // the only two possible errors are: - // EBADF, which happens when w.fd is not a valid file descriptor of any kind. - // EINVAL, which is when fd is not an inotify descriptor or wd is not a valid watch descriptor. - // Watch descriptors are invalidated when they are removed explicitly or implicitly; - // explicitly by inotify_rm_watch, implicitly when the file they are watching is deleted. - return errno - } - - return nil -} - -type watch struct { - wd uint32 // Watch descriptor (as returned by the inotify_add_watch() syscall) - flags uint32 // inotify flags of this watch (see inotify(7) for the list of valid flags) -} - -// readEvents reads from the inotify file descriptor, converts the -// received events into Event objects and sends them via the Events channel -func (w *Watcher) readEvents() { - var ( - buf [unix.SizeofInotifyEvent * 4096]byte // Buffer for a maximum of 4096 raw events - n int // Number of bytes read with read() - errno error // Syscall errno - ok bool // For poller.wait - ) - - defer close(w.doneResp) - defer close(w.Errors) - defer close(w.Events) - defer unix.Close(w.fd) - defer w.poller.close() - - for { - // See if we have been closed. - if w.isClosed() { - return - } - - ok, errno = w.poller.wait() - if errno != nil { - select { - case w.Errors <- errno: - case <-w.done: - return - } - continue - } - - if !ok { - continue - } - - n, errno = unix.Read(w.fd, buf[:]) - // If a signal interrupted execution, see if we've been asked to close, and try again. - // http://man7.org/linux/man-pages/man7/signal.7.html : - // "Before Linux 3.8, reads from an inotify(7) file descriptor were not restartable" - if errno == unix.EINTR { - continue - } - - // unix.Read might have been woken up by Close. If so, we're done. - if w.isClosed() { - return - } - - if n < unix.SizeofInotifyEvent { - var err error - if n == 0 { - // If EOF is received. This should really never happen. - err = io.EOF - } else if n < 0 { - // If an error occurred while reading. - err = errno - } else { - // Read was too short. - err = errors.New("notify: short read in readEvents()") - } - select { - case w.Errors <- err: - case <-w.done: - return - } - continue - } - - var offset uint32 - // We don't know how many events we just read into the buffer - // While the offset points to at least one whole event... - for offset <= uint32(n-unix.SizeofInotifyEvent) { - // Point "raw" to the event in the buffer - raw := (*unix.InotifyEvent)(unsafe.Pointer(&buf[offset])) - - mask := uint32(raw.Mask) - nameLen := uint32(raw.Len) - - if mask&unix.IN_Q_OVERFLOW != 0 { - select { - case w.Errors <- ErrEventOverflow: - case <-w.done: - return - } - } - - // If the event happened to the watched directory or the watched file, the kernel - // doesn't append the filename to the event, but we would like to always fill the - // the "Name" field with a valid filename. We retrieve the path of the watch from - // the "paths" map. - w.mu.Lock() - name, ok := w.paths[int(raw.Wd)] - // IN_DELETE_SELF occurs when the file/directory being watched is removed. - // This is a sign to clean up the maps, otherwise we are no longer in sync - // with the inotify kernel state which has already deleted the watch - // automatically. - if ok && mask&unix.IN_DELETE_SELF == unix.IN_DELETE_SELF { - delete(w.paths, int(raw.Wd)) - delete(w.watches, name) - } - w.mu.Unlock() - - if nameLen > 0 { - // Point "bytes" at the first byte of the filename - bytes := (*[unix.PathMax]byte)(unsafe.Pointer(&buf[offset+unix.SizeofInotifyEvent])) - // The filename is padded with NULL bytes. TrimRight() gets rid of those. - name += "/" + strings.TrimRight(string(bytes[0:nameLen]), "\000") - } - - event := newEvent(name, mask) - - // Send the events that are not ignored on the events channel - if !event.ignoreLinux(mask) { - select { - case w.Events <- event: - case <-w.done: - return - } - } - - // Move to the next event in the buffer - offset += unix.SizeofInotifyEvent + nameLen - } - } -} - -// Certain types of events can be "ignored" and not sent over the Events -// channel. Such as events marked ignore by the kernel, or MODIFY events -// against files that do not exist. -func (e *Event) ignoreLinux(mask uint32) bool { - // Ignore anything the inotify API says to ignore - if mask&unix.IN_IGNORED == unix.IN_IGNORED { - return true - } - - // If the event is not a DELETE or RENAME, the file must exist. - // Otherwise the event is ignored. - // *Note*: this was put in place because it was seen that a MODIFY - // event was sent after the DELETE. This ignores that MODIFY and - // assumes a DELETE will come or has come if the file doesn't exist. - if !(e.Op&Remove == Remove || e.Op&Rename == Rename) { - _, statErr := os.Lstat(e.Name) - return os.IsNotExist(statErr) - } - return false -} - -// newEvent returns an platform-independent Event based on an inotify mask. -func newEvent(name string, mask uint32) Event { - e := Event{Name: name} - if mask&unix.IN_CREATE == unix.IN_CREATE || mask&unix.IN_MOVED_TO == unix.IN_MOVED_TO { - e.Op |= Create - } - if mask&unix.IN_DELETE_SELF == unix.IN_DELETE_SELF || mask&unix.IN_DELETE == unix.IN_DELETE { - e.Op |= Remove - } - if mask&unix.IN_MODIFY == unix.IN_MODIFY { - e.Op |= Write - } - if mask&unix.IN_MOVE_SELF == unix.IN_MOVE_SELF || mask&unix.IN_MOVED_FROM == unix.IN_MOVED_FROM { - e.Op |= Rename - } - if mask&unix.IN_ATTRIB == unix.IN_ATTRIB { - e.Op |= Chmod - } - return e -} diff --git a/vendor/github.com/fsnotify/fsnotify/inotify_poller.go b/vendor/github.com/fsnotify/fsnotify/inotify_poller.go deleted file mode 100644 index b33f2b4d4b7..00000000000 --- a/vendor/github.com/fsnotify/fsnotify/inotify_poller.go +++ /dev/null @@ -1,187 +0,0 @@ -// Copyright 2015 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. - -// +build linux - -package fsnotify - -import ( - "errors" - - "golang.org/x/sys/unix" -) - -type fdPoller struct { - fd int // File descriptor (as returned by the inotify_init() syscall) - epfd int // Epoll file descriptor - pipe [2]int // Pipe for waking up -} - -func emptyPoller(fd int) *fdPoller { - poller := new(fdPoller) - poller.fd = fd - poller.epfd = -1 - poller.pipe[0] = -1 - poller.pipe[1] = -1 - return poller -} - -// Create a new inotify poller. -// This creates an inotify handler, and an epoll handler. -func newFdPoller(fd int) (*fdPoller, error) { - var errno error - poller := emptyPoller(fd) - defer func() { - if errno != nil { - poller.close() - } - }() - poller.fd = fd - - // Create epoll fd - poller.epfd, errno = unix.EpollCreate1(unix.EPOLL_CLOEXEC) - if poller.epfd == -1 { - return nil, errno - } - // Create pipe; pipe[0] is the read end, pipe[1] the write end. - errno = unix.Pipe2(poller.pipe[:], unix.O_NONBLOCK|unix.O_CLOEXEC) - if errno != nil { - return nil, errno - } - - // Register inotify fd with epoll - event := unix.EpollEvent{ - Fd: int32(poller.fd), - Events: unix.EPOLLIN, - } - errno = unix.EpollCtl(poller.epfd, unix.EPOLL_CTL_ADD, poller.fd, &event) - if errno != nil { - return nil, errno - } - - // Register pipe fd with epoll - event = unix.EpollEvent{ - Fd: int32(poller.pipe[0]), - Events: unix.EPOLLIN, - } - errno = unix.EpollCtl(poller.epfd, unix.EPOLL_CTL_ADD, poller.pipe[0], &event) - if errno != nil { - return nil, errno - } - - return poller, nil -} - -// Wait using epoll. -// Returns true if something is ready to be read, -// false if there is not. -func (poller *fdPoller) wait() (bool, error) { - // 3 possible events per fd, and 2 fds, makes a maximum of 6 events. - // I don't know whether epoll_wait returns the number of events returned, - // or the total number of events ready. - // I decided to catch both by making the buffer one larger than the maximum. - events := make([]unix.EpollEvent, 7) - for { - n, errno := unix.EpollWait(poller.epfd, events, -1) - if n == -1 { - if errno == unix.EINTR { - continue - } - return false, errno - } - if n == 0 { - // If there are no events, try again. - continue - } - if n > 6 { - // This should never happen. More events were returned than should be possible. - return false, errors.New("epoll_wait returned more events than I know what to do with") - } - ready := events[:n] - epollhup := false - epollerr := false - epollin := false - for _, event := range ready { - if event.Fd == int32(poller.fd) { - if event.Events&unix.EPOLLHUP != 0 { - // This should not happen, but if it does, treat it as a wakeup. - epollhup = true - } - if event.Events&unix.EPOLLERR != 0 { - // If an error is waiting on the file descriptor, we should pretend - // something is ready to read, and let unix.Read pick up the error. - epollerr = true - } - if event.Events&unix.EPOLLIN != 0 { - // There is data to read. - epollin = true - } - } - if event.Fd == int32(poller.pipe[0]) { - if event.Events&unix.EPOLLHUP != 0 { - // Write pipe descriptor was closed, by us. This means we're closing down the - // watcher, and we should wake up. - } - if event.Events&unix.EPOLLERR != 0 { - // If an error is waiting on the pipe file descriptor. - // This is an absolute mystery, and should never ever happen. - return false, errors.New("Error on the pipe descriptor.") - } - if event.Events&unix.EPOLLIN != 0 { - // This is a regular wakeup, so we have to clear the buffer. - err := poller.clearWake() - if err != nil { - return false, err - } - } - } - } - - if epollhup || epollerr || epollin { - return true, nil - } - return false, nil - } -} - -// Close the write end of the poller. -func (poller *fdPoller) wake() error { - buf := make([]byte, 1) - n, errno := unix.Write(poller.pipe[1], buf) - if n == -1 { - if errno == unix.EAGAIN { - // Buffer is full, poller will wake. - return nil - } - return errno - } - return nil -} - -func (poller *fdPoller) clearWake() error { - // You have to be woken up a LOT in order to get to 100! - buf := make([]byte, 100) - n, errno := unix.Read(poller.pipe[0], buf) - if n == -1 { - if errno == unix.EAGAIN { - // Buffer is empty, someone else cleared our wake. - return nil - } - return errno - } - return nil -} - -// Close all poller file descriptors, but not the one passed to it. -func (poller *fdPoller) close() { - if poller.pipe[1] != -1 { - unix.Close(poller.pipe[1]) - } - if poller.pipe[0] != -1 { - unix.Close(poller.pipe[0]) - } - if poller.epfd != -1 { - unix.Close(poller.epfd) - } -} diff --git a/vendor/github.com/fsnotify/fsnotify/kqueue.go b/vendor/github.com/fsnotify/fsnotify/kqueue.go deleted file mode 100644 index 86e76a3d676..00000000000 --- a/vendor/github.com/fsnotify/fsnotify/kqueue.go +++ /dev/null @@ -1,521 +0,0 @@ -// Copyright 2010 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. - -// +build freebsd openbsd netbsd dragonfly darwin - -package fsnotify - -import ( - "errors" - "fmt" - "io/ioutil" - "os" - "path/filepath" - "sync" - "time" - - "golang.org/x/sys/unix" -) - -// Watcher watches a set of files, delivering events to a channel. -type Watcher struct { - Events chan Event - Errors chan error - done chan struct{} // Channel for sending a "quit message" to the reader goroutine - - kq int // File descriptor (as returned by the kqueue() syscall). - - mu sync.Mutex // Protects access to watcher data - watches map[string]int // Map of watched file descriptors (key: path). - externalWatches map[string]bool // Map of watches added by user of the library. - dirFlags map[string]uint32 // Map of watched directories to fflags used in kqueue. - paths map[int]pathInfo // Map file descriptors to path names for processing kqueue events. - fileExists map[string]bool // Keep track of if we know this file exists (to stop duplicate create events). - isClosed bool // Set to true when Close() is first called -} - -type pathInfo struct { - name string - isDir bool -} - -// NewWatcher establishes a new watcher with the underlying OS and begins waiting for events. -func NewWatcher() (*Watcher, error) { - kq, err := kqueue() - if err != nil { - return nil, err - } - - w := &Watcher{ - kq: kq, - watches: make(map[string]int), - dirFlags: make(map[string]uint32), - paths: make(map[int]pathInfo), - fileExists: make(map[string]bool), - externalWatches: make(map[string]bool), - Events: make(chan Event), - Errors: make(chan error), - done: make(chan struct{}), - } - - go w.readEvents() - return w, nil -} - -// Close removes all watches and closes the events channel. -func (w *Watcher) Close() error { - w.mu.Lock() - if w.isClosed { - w.mu.Unlock() - return nil - } - w.isClosed = true - - // copy paths to remove while locked - var pathsToRemove = make([]string, 0, len(w.watches)) - for name := range w.watches { - pathsToRemove = append(pathsToRemove, name) - } - w.mu.Unlock() - // unlock before calling Remove, which also locks - - for _, name := range pathsToRemove { - w.Remove(name) - } - - // send a "quit" message to the reader goroutine - close(w.done) - - return nil -} - -// Add starts watching the named file or directory (non-recursively). -func (w *Watcher) Add(name string) error { - w.mu.Lock() - w.externalWatches[name] = true - w.mu.Unlock() - _, err := w.addWatch(name, noteAllEvents) - return err -} - -// Remove stops watching the the named file or directory (non-recursively). -func (w *Watcher) Remove(name string) error { - name = filepath.Clean(name) - w.mu.Lock() - watchfd, ok := w.watches[name] - w.mu.Unlock() - if !ok { - return fmt.Errorf("can't remove non-existent kevent watch for: %s", name) - } - - const registerRemove = unix.EV_DELETE - if err := register(w.kq, []int{watchfd}, registerRemove, 0); err != nil { - return err - } - - unix.Close(watchfd) - - w.mu.Lock() - isDir := w.paths[watchfd].isDir - delete(w.watches, name) - delete(w.paths, watchfd) - delete(w.dirFlags, name) - w.mu.Unlock() - - // Find all watched paths that are in this directory that are not external. - if isDir { - var pathsToRemove []string - w.mu.Lock() - for _, path := range w.paths { - wdir, _ := filepath.Split(path.name) - if filepath.Clean(wdir) == name { - if !w.externalWatches[path.name] { - pathsToRemove = append(pathsToRemove, path.name) - } - } - } - w.mu.Unlock() - for _, name := range pathsToRemove { - // Since these are internal, not much sense in propagating error - // to the user, as that will just confuse them with an error about - // a path they did not explicitly watch themselves. - w.Remove(name) - } - } - - return nil -} - -// Watch all events (except NOTE_EXTEND, NOTE_LINK, NOTE_REVOKE) -const noteAllEvents = unix.NOTE_DELETE | unix.NOTE_WRITE | unix.NOTE_ATTRIB | unix.NOTE_RENAME - -// keventWaitTime to block on each read from kevent -var keventWaitTime = durationToTimespec(100 * time.Millisecond) - -// addWatch adds name to the watched file set. -// The flags are interpreted as described in kevent(2). -// Returns the real path to the file which was added, if any, which may be different from the one passed in the case of symlinks. -func (w *Watcher) addWatch(name string, flags uint32) (string, error) { - var isDir bool - // Make ./name and name equivalent - name = filepath.Clean(name) - - w.mu.Lock() - if w.isClosed { - w.mu.Unlock() - return "", errors.New("kevent instance already closed") - } - watchfd, alreadyWatching := w.watches[name] - // We already have a watch, but we can still override flags. - if alreadyWatching { - isDir = w.paths[watchfd].isDir - } - w.mu.Unlock() - - if !alreadyWatching { - fi, err := os.Lstat(name) - if err != nil { - return "", err - } - - // Don't watch sockets. - if fi.Mode()&os.ModeSocket == os.ModeSocket { - return "", nil - } - - // Don't watch named pipes. - if fi.Mode()&os.ModeNamedPipe == os.ModeNamedPipe { - return "", nil - } - - // Follow Symlinks - // Unfortunately, Linux can add bogus symlinks to watch list without - // issue, and Windows can't do symlinks period (AFAIK). To maintain - // consistency, we will act like everything is fine. There will simply - // be no file events for broken symlinks. - // Hence the returns of nil on errors. - if fi.Mode()&os.ModeSymlink == os.ModeSymlink { - name, err = filepath.EvalSymlinks(name) - if err != nil { - return "", nil - } - - w.mu.Lock() - _, alreadyWatching = w.watches[name] - w.mu.Unlock() - - if alreadyWatching { - return name, nil - } - - fi, err = os.Lstat(name) - if err != nil { - return "", nil - } - } - - watchfd, err = unix.Open(name, openMode, 0700) - if watchfd == -1 { - return "", err - } - - isDir = fi.IsDir() - } - - const registerAdd = unix.EV_ADD | unix.EV_CLEAR | unix.EV_ENABLE - if err := register(w.kq, []int{watchfd}, registerAdd, flags); err != nil { - unix.Close(watchfd) - return "", err - } - - if !alreadyWatching { - w.mu.Lock() - w.watches[name] = watchfd - w.paths[watchfd] = pathInfo{name: name, isDir: isDir} - w.mu.Unlock() - } - - if isDir { - // Watch the directory if it has not been watched before, - // or if it was watched before, but perhaps only a NOTE_DELETE (watchDirectoryFiles) - w.mu.Lock() - - watchDir := (flags&unix.NOTE_WRITE) == unix.NOTE_WRITE && - (!alreadyWatching || (w.dirFlags[name]&unix.NOTE_WRITE) != unix.NOTE_WRITE) - // Store flags so this watch can be updated later - w.dirFlags[name] = flags - w.mu.Unlock() - - if watchDir { - if err := w.watchDirectoryFiles(name); err != nil { - return "", err - } - } - } - return name, nil -} - -// readEvents reads from kqueue and converts the received kevents into -// Event values that it sends down the Events channel. -func (w *Watcher) readEvents() { - eventBuffer := make([]unix.Kevent_t, 10) - -loop: - for { - // See if there is a message on the "done" channel - select { - case <-w.done: - break loop - default: - } - - // Get new events - kevents, err := read(w.kq, eventBuffer, &keventWaitTime) - // EINTR is okay, the syscall was interrupted before timeout expired. - if err != nil && err != unix.EINTR { - select { - case w.Errors <- err: - case <-w.done: - break loop - } - continue - } - - // Flush the events we received to the Events channel - for len(kevents) > 0 { - kevent := &kevents[0] - watchfd := int(kevent.Ident) - mask := uint32(kevent.Fflags) - w.mu.Lock() - path := w.paths[watchfd] - w.mu.Unlock() - event := newEvent(path.name, mask) - - if path.isDir && !(event.Op&Remove == Remove) { - // Double check to make sure the directory exists. This can happen when - // we do a rm -fr on a recursively watched folders and we receive a - // modification event first but the folder has been deleted and later - // receive the delete event - if _, err := os.Lstat(event.Name); os.IsNotExist(err) { - // mark is as delete event - event.Op |= Remove - } - } - - if event.Op&Rename == Rename || event.Op&Remove == Remove { - w.Remove(event.Name) - w.mu.Lock() - delete(w.fileExists, event.Name) - w.mu.Unlock() - } - - if path.isDir && event.Op&Write == Write && !(event.Op&Remove == Remove) { - w.sendDirectoryChangeEvents(event.Name) - } else { - // Send the event on the Events channel. - select { - case w.Events <- event: - case <-w.done: - break loop - } - } - - if event.Op&Remove == Remove { - // Look for a file that may have overwritten this. - // For example, mv f1 f2 will delete f2, then create f2. - if path.isDir { - fileDir := filepath.Clean(event.Name) - w.mu.Lock() - _, found := w.watches[fileDir] - w.mu.Unlock() - if found { - // make sure the directory exists before we watch for changes. When we - // do a recursive watch and perform rm -fr, the parent directory might - // have gone missing, ignore the missing directory and let the - // upcoming delete event remove the watch from the parent directory. - if _, err := os.Lstat(fileDir); err == nil { - w.sendDirectoryChangeEvents(fileDir) - } - } - } else { - filePath := filepath.Clean(event.Name) - if fileInfo, err := os.Lstat(filePath); err == nil { - w.sendFileCreatedEventIfNew(filePath, fileInfo) - } - } - } - - // Move to next event - kevents = kevents[1:] - } - } - - // cleanup - err := unix.Close(w.kq) - if err != nil { - // only way the previous loop breaks is if w.done was closed so we need to async send to w.Errors. - select { - case w.Errors <- err: - default: - } - } - close(w.Events) - close(w.Errors) -} - -// newEvent returns an platform-independent Event based on kqueue Fflags. -func newEvent(name string, mask uint32) Event { - e := Event{Name: name} - if mask&unix.NOTE_DELETE == unix.NOTE_DELETE { - e.Op |= Remove - } - if mask&unix.NOTE_WRITE == unix.NOTE_WRITE { - e.Op |= Write - } - if mask&unix.NOTE_RENAME == unix.NOTE_RENAME { - e.Op |= Rename - } - if mask&unix.NOTE_ATTRIB == unix.NOTE_ATTRIB { - e.Op |= Chmod - } - return e -} - -func newCreateEvent(name string) Event { - return Event{Name: name, Op: Create} -} - -// watchDirectoryFiles to mimic inotify when adding a watch on a directory -func (w *Watcher) watchDirectoryFiles(dirPath string) error { - // Get all files - files, err := ioutil.ReadDir(dirPath) - if err != nil { - return err - } - - for _, fileInfo := range files { - filePath := filepath.Join(dirPath, fileInfo.Name()) - filePath, err = w.internalWatch(filePath, fileInfo) - if err != nil { - return err - } - - w.mu.Lock() - w.fileExists[filePath] = true - w.mu.Unlock() - } - - return nil -} - -// sendDirectoryEvents searches the directory for newly created files -// and sends them over the event channel. This functionality is to have -// the BSD version of fsnotify match Linux inotify which provides a -// create event for files created in a watched directory. -func (w *Watcher) sendDirectoryChangeEvents(dirPath string) { - // Get all files - files, err := ioutil.ReadDir(dirPath) - if err != nil { - select { - case w.Errors <- err: - case <-w.done: - return - } - } - - // Search for new files - for _, fileInfo := range files { - filePath := filepath.Join(dirPath, fileInfo.Name()) - err := w.sendFileCreatedEventIfNew(filePath, fileInfo) - - if err != nil { - return - } - } -} - -// sendFileCreatedEvent sends a create event if the file isn't already being tracked. -func (w *Watcher) sendFileCreatedEventIfNew(filePath string, fileInfo os.FileInfo) (err error) { - w.mu.Lock() - _, doesExist := w.fileExists[filePath] - w.mu.Unlock() - if !doesExist { - // Send create event - select { - case w.Events <- newCreateEvent(filePath): - case <-w.done: - return - } - } - - // like watchDirectoryFiles (but without doing another ReadDir) - filePath, err = w.internalWatch(filePath, fileInfo) - if err != nil { - return err - } - - w.mu.Lock() - w.fileExists[filePath] = true - w.mu.Unlock() - - return nil -} - -func (w *Watcher) internalWatch(name string, fileInfo os.FileInfo) (string, error) { - if fileInfo.IsDir() { - // mimic Linux providing delete events for subdirectories - // but preserve the flags used if currently watching subdirectory - w.mu.Lock() - flags := w.dirFlags[name] - w.mu.Unlock() - - flags |= unix.NOTE_DELETE | unix.NOTE_RENAME - return w.addWatch(name, flags) - } - - // watch file to mimic Linux inotify - return w.addWatch(name, noteAllEvents) -} - -// kqueue creates a new kernel event queue and returns a descriptor. -func kqueue() (kq int, err error) { - kq, err = unix.Kqueue() - if kq == -1 { - return kq, err - } - return kq, nil -} - -// register events with the queue -func register(kq int, fds []int, flags int, fflags uint32) error { - changes := make([]unix.Kevent_t, len(fds)) - - for i, fd := range fds { - // SetKevent converts int to the platform-specific types: - unix.SetKevent(&changes[i], fd, unix.EVFILT_VNODE, flags) - changes[i].Fflags = fflags - } - - // register the events - success, err := unix.Kevent(kq, changes, nil, nil) - if success == -1 { - return err - } - return nil -} - -// read retrieves pending events, or waits until an event occurs. -// A timeout of nil blocks indefinitely, while 0 polls the queue. -func read(kq int, events []unix.Kevent_t, timeout *unix.Timespec) ([]unix.Kevent_t, error) { - n, err := unix.Kevent(kq, nil, events, timeout) - if err != nil { - return nil, err - } - return events[0:n], nil -} - -// durationToTimespec prepares a timeout value -func durationToTimespec(d time.Duration) unix.Timespec { - return unix.NsecToTimespec(d.Nanoseconds()) -} diff --git a/vendor/github.com/fsnotify/fsnotify/open_mode_bsd.go b/vendor/github.com/fsnotify/fsnotify/open_mode_bsd.go deleted file mode 100644 index 2306c4620bf..00000000000 --- a/vendor/github.com/fsnotify/fsnotify/open_mode_bsd.go +++ /dev/null @@ -1,11 +0,0 @@ -// Copyright 2013 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. - -// +build freebsd openbsd netbsd dragonfly - -package fsnotify - -import "golang.org/x/sys/unix" - -const openMode = unix.O_NONBLOCK | unix.O_RDONLY | unix.O_CLOEXEC diff --git a/vendor/github.com/fsnotify/fsnotify/open_mode_darwin.go b/vendor/github.com/fsnotify/fsnotify/open_mode_darwin.go deleted file mode 100644 index 870c4d6d184..00000000000 --- a/vendor/github.com/fsnotify/fsnotify/open_mode_darwin.go +++ /dev/null @@ -1,12 +0,0 @@ -// Copyright 2013 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. - -// +build darwin - -package fsnotify - -import "golang.org/x/sys/unix" - -// note: this constant is not defined on BSD -const openMode = unix.O_EVTONLY | unix.O_CLOEXEC diff --git a/vendor/github.com/fsnotify/fsnotify/windows.go b/vendor/github.com/fsnotify/fsnotify/windows.go deleted file mode 100644 index 09436f31d82..00000000000 --- a/vendor/github.com/fsnotify/fsnotify/windows.go +++ /dev/null @@ -1,561 +0,0 @@ -// Copyright 2011 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. - -// +build windows - -package fsnotify - -import ( - "errors" - "fmt" - "os" - "path/filepath" - "runtime" - "sync" - "syscall" - "unsafe" -) - -// Watcher watches a set of files, delivering events to a channel. -type Watcher struct { - Events chan Event - Errors chan error - isClosed bool // Set to true when Close() is first called - mu sync.Mutex // Map access - port syscall.Handle // Handle to completion port - watches watchMap // Map of watches (key: i-number) - input chan *input // Inputs to the reader are sent on this channel - quit chan chan<- error -} - -// NewWatcher establishes a new watcher with the underlying OS and begins waiting for events. -func NewWatcher() (*Watcher, error) { - port, e := syscall.CreateIoCompletionPort(syscall.InvalidHandle, 0, 0, 0) - if e != nil { - return nil, os.NewSyscallError("CreateIoCompletionPort", e) - } - w := &Watcher{ - port: port, - watches: make(watchMap), - input: make(chan *input, 1), - Events: make(chan Event, 50), - Errors: make(chan error), - quit: make(chan chan<- error, 1), - } - go w.readEvents() - return w, nil -} - -// Close removes all watches and closes the events channel. -func (w *Watcher) Close() error { - if w.isClosed { - return nil - } - w.isClosed = true - - // Send "quit" message to the reader goroutine - ch := make(chan error) - w.quit <- ch - if err := w.wakeupReader(); err != nil { - return err - } - return <-ch -} - -// Add starts watching the named file or directory (non-recursively). -func (w *Watcher) Add(name string) error { - if w.isClosed { - return errors.New("watcher already closed") - } - in := &input{ - op: opAddWatch, - path: filepath.Clean(name), - flags: sysFSALLEVENTS, - reply: make(chan error), - } - w.input <- in - if err := w.wakeupReader(); err != nil { - return err - } - return <-in.reply -} - -// Remove stops watching the the named file or directory (non-recursively). -func (w *Watcher) Remove(name string) error { - in := &input{ - op: opRemoveWatch, - path: filepath.Clean(name), - reply: make(chan error), - } - w.input <- in - if err := w.wakeupReader(); err != nil { - return err - } - return <-in.reply -} - -const ( - // Options for AddWatch - sysFSONESHOT = 0x80000000 - sysFSONLYDIR = 0x1000000 - - // Events - sysFSACCESS = 0x1 - sysFSALLEVENTS = 0xfff - sysFSATTRIB = 0x4 - sysFSCLOSE = 0x18 - sysFSCREATE = 0x100 - sysFSDELETE = 0x200 - sysFSDELETESELF = 0x400 - sysFSMODIFY = 0x2 - sysFSMOVE = 0xc0 - sysFSMOVEDFROM = 0x40 - sysFSMOVEDTO = 0x80 - sysFSMOVESELF = 0x800 - - // Special events - sysFSIGNORED = 0x8000 - sysFSQOVERFLOW = 0x4000 -) - -func newEvent(name string, mask uint32) Event { - e := Event{Name: name} - if mask&sysFSCREATE == sysFSCREATE || mask&sysFSMOVEDTO == sysFSMOVEDTO { - e.Op |= Create - } - if mask&sysFSDELETE == sysFSDELETE || mask&sysFSDELETESELF == sysFSDELETESELF { - e.Op |= Remove - } - if mask&sysFSMODIFY == sysFSMODIFY { - e.Op |= Write - } - if mask&sysFSMOVE == sysFSMOVE || mask&sysFSMOVESELF == sysFSMOVESELF || mask&sysFSMOVEDFROM == sysFSMOVEDFROM { - e.Op |= Rename - } - if mask&sysFSATTRIB == sysFSATTRIB { - e.Op |= Chmod - } - return e -} - -const ( - opAddWatch = iota - opRemoveWatch -) - -const ( - provisional uint64 = 1 << (32 + iota) -) - -type input struct { - op int - path string - flags uint32 - reply chan error -} - -type inode struct { - handle syscall.Handle - volume uint32 - index uint64 -} - -type watch struct { - ov syscall.Overlapped - ino *inode // i-number - path string // Directory path - mask uint64 // Directory itself is being watched with these notify flags - names map[string]uint64 // Map of names being watched and their notify flags - rename string // Remembers the old name while renaming a file - buf [4096]byte -} - -type indexMap map[uint64]*watch -type watchMap map[uint32]indexMap - -func (w *Watcher) wakeupReader() error { - e := syscall.PostQueuedCompletionStatus(w.port, 0, 0, nil) - if e != nil { - return os.NewSyscallError("PostQueuedCompletionStatus", e) - } - return nil -} - -func getDir(pathname string) (dir string, err error) { - attr, e := syscall.GetFileAttributes(syscall.StringToUTF16Ptr(pathname)) - if e != nil { - return "", os.NewSyscallError("GetFileAttributes", e) - } - if attr&syscall.FILE_ATTRIBUTE_DIRECTORY != 0 { - dir = pathname - } else { - dir, _ = filepath.Split(pathname) - dir = filepath.Clean(dir) - } - return -} - -func getIno(path string) (ino *inode, err error) { - h, e := syscall.CreateFile(syscall.StringToUTF16Ptr(path), - syscall.FILE_LIST_DIRECTORY, - syscall.FILE_SHARE_READ|syscall.FILE_SHARE_WRITE|syscall.FILE_SHARE_DELETE, - nil, syscall.OPEN_EXISTING, - syscall.FILE_FLAG_BACKUP_SEMANTICS|syscall.FILE_FLAG_OVERLAPPED, 0) - if e != nil { - return nil, os.NewSyscallError("CreateFile", e) - } - var fi syscall.ByHandleFileInformation - if e = syscall.GetFileInformationByHandle(h, &fi); e != nil { - syscall.CloseHandle(h) - return nil, os.NewSyscallError("GetFileInformationByHandle", e) - } - ino = &inode{ - handle: h, - volume: fi.VolumeSerialNumber, - index: uint64(fi.FileIndexHigh)<<32 | uint64(fi.FileIndexLow), - } - return ino, nil -} - -// Must run within the I/O thread. -func (m watchMap) get(ino *inode) *watch { - if i := m[ino.volume]; i != nil { - return i[ino.index] - } - return nil -} - -// Must run within the I/O thread. -func (m watchMap) set(ino *inode, watch *watch) { - i := m[ino.volume] - if i == nil { - i = make(indexMap) - m[ino.volume] = i - } - i[ino.index] = watch -} - -// Must run within the I/O thread. -func (w *Watcher) addWatch(pathname string, flags uint64) error { - dir, err := getDir(pathname) - if err != nil { - return err - } - if flags&sysFSONLYDIR != 0 && pathname != dir { - return nil - } - ino, err := getIno(dir) - if err != nil { - return err - } - w.mu.Lock() - watchEntry := w.watches.get(ino) - w.mu.Unlock() - if watchEntry == nil { - if _, e := syscall.CreateIoCompletionPort(ino.handle, w.port, 0, 0); e != nil { - syscall.CloseHandle(ino.handle) - return os.NewSyscallError("CreateIoCompletionPort", e) - } - watchEntry = &watch{ - ino: ino, - path: dir, - names: make(map[string]uint64), - } - w.mu.Lock() - w.watches.set(ino, watchEntry) - w.mu.Unlock() - flags |= provisional - } else { - syscall.CloseHandle(ino.handle) - } - if pathname == dir { - watchEntry.mask |= flags - } else { - watchEntry.names[filepath.Base(pathname)] |= flags - } - if err = w.startRead(watchEntry); err != nil { - return err - } - if pathname == dir { - watchEntry.mask &= ^provisional - } else { - watchEntry.names[filepath.Base(pathname)] &= ^provisional - } - return nil -} - -// Must run within the I/O thread. -func (w *Watcher) remWatch(pathname string) error { - dir, err := getDir(pathname) - if err != nil { - return err - } - ino, err := getIno(dir) - if err != nil { - return err - } - w.mu.Lock() - watch := w.watches.get(ino) - w.mu.Unlock() - if watch == nil { - return fmt.Errorf("can't remove non-existent watch for: %s", pathname) - } - if pathname == dir { - w.sendEvent(watch.path, watch.mask&sysFSIGNORED) - watch.mask = 0 - } else { - name := filepath.Base(pathname) - w.sendEvent(filepath.Join(watch.path, name), watch.names[name]&sysFSIGNORED) - delete(watch.names, name) - } - return w.startRead(watch) -} - -// Must run within the I/O thread. -func (w *Watcher) deleteWatch(watch *watch) { - for name, mask := range watch.names { - if mask&provisional == 0 { - w.sendEvent(filepath.Join(watch.path, name), mask&sysFSIGNORED) - } - delete(watch.names, name) - } - if watch.mask != 0 { - if watch.mask&provisional == 0 { - w.sendEvent(watch.path, watch.mask&sysFSIGNORED) - } - watch.mask = 0 - } -} - -// Must run within the I/O thread. -func (w *Watcher) startRead(watch *watch) error { - if e := syscall.CancelIo(watch.ino.handle); e != nil { - w.Errors <- os.NewSyscallError("CancelIo", e) - w.deleteWatch(watch) - } - mask := toWindowsFlags(watch.mask) - for _, m := range watch.names { - mask |= toWindowsFlags(m) - } - if mask == 0 { - if e := syscall.CloseHandle(watch.ino.handle); e != nil { - w.Errors <- os.NewSyscallError("CloseHandle", e) - } - w.mu.Lock() - delete(w.watches[watch.ino.volume], watch.ino.index) - w.mu.Unlock() - return nil - } - e := syscall.ReadDirectoryChanges(watch.ino.handle, &watch.buf[0], - uint32(unsafe.Sizeof(watch.buf)), false, mask, nil, &watch.ov, 0) - if e != nil { - err := os.NewSyscallError("ReadDirectoryChanges", e) - if e == syscall.ERROR_ACCESS_DENIED && watch.mask&provisional == 0 { - // Watched directory was probably removed - if w.sendEvent(watch.path, watch.mask&sysFSDELETESELF) { - if watch.mask&sysFSONESHOT != 0 { - watch.mask = 0 - } - } - err = nil - } - w.deleteWatch(watch) - w.startRead(watch) - return err - } - return nil -} - -// readEvents reads from the I/O completion port, converts the -// received events into Event objects and sends them via the Events channel. -// Entry point to the I/O thread. -func (w *Watcher) readEvents() { - var ( - n, key uint32 - ov *syscall.Overlapped - ) - runtime.LockOSThread() - - for { - e := syscall.GetQueuedCompletionStatus(w.port, &n, &key, &ov, syscall.INFINITE) - watch := (*watch)(unsafe.Pointer(ov)) - - if watch == nil { - select { - case ch := <-w.quit: - w.mu.Lock() - var indexes []indexMap - for _, index := range w.watches { - indexes = append(indexes, index) - } - w.mu.Unlock() - for _, index := range indexes { - for _, watch := range index { - w.deleteWatch(watch) - w.startRead(watch) - } - } - var err error - if e := syscall.CloseHandle(w.port); e != nil { - err = os.NewSyscallError("CloseHandle", e) - } - close(w.Events) - close(w.Errors) - ch <- err - return - case in := <-w.input: - switch in.op { - case opAddWatch: - in.reply <- w.addWatch(in.path, uint64(in.flags)) - case opRemoveWatch: - in.reply <- w.remWatch(in.path) - } - default: - } - continue - } - - switch e { - case syscall.ERROR_MORE_DATA: - if watch == nil { - w.Errors <- errors.New("ERROR_MORE_DATA has unexpectedly null lpOverlapped buffer") - } else { - // The i/o succeeded but the buffer is full. - // In theory we should be building up a full packet. - // In practice we can get away with just carrying on. - n = uint32(unsafe.Sizeof(watch.buf)) - } - case syscall.ERROR_ACCESS_DENIED: - // Watched directory was probably removed - w.sendEvent(watch.path, watch.mask&sysFSDELETESELF) - w.deleteWatch(watch) - w.startRead(watch) - continue - case syscall.ERROR_OPERATION_ABORTED: - // CancelIo was called on this handle - continue - default: - w.Errors <- os.NewSyscallError("GetQueuedCompletionPort", e) - continue - case nil: - } - - var offset uint32 - for { - if n == 0 { - w.Events <- newEvent("", sysFSQOVERFLOW) - w.Errors <- errors.New("short read in readEvents()") - break - } - - // Point "raw" to the event in the buffer - raw := (*syscall.FileNotifyInformation)(unsafe.Pointer(&watch.buf[offset])) - buf := (*[syscall.MAX_PATH]uint16)(unsafe.Pointer(&raw.FileName)) - name := syscall.UTF16ToString(buf[:raw.FileNameLength/2]) - fullname := filepath.Join(watch.path, name) - - var mask uint64 - switch raw.Action { - case syscall.FILE_ACTION_REMOVED: - mask = sysFSDELETESELF - case syscall.FILE_ACTION_MODIFIED: - mask = sysFSMODIFY - case syscall.FILE_ACTION_RENAMED_OLD_NAME: - watch.rename = name - case syscall.FILE_ACTION_RENAMED_NEW_NAME: - if watch.names[watch.rename] != 0 { - watch.names[name] |= watch.names[watch.rename] - delete(watch.names, watch.rename) - mask = sysFSMOVESELF - } - } - - sendNameEvent := func() { - if w.sendEvent(fullname, watch.names[name]&mask) { - if watch.names[name]&sysFSONESHOT != 0 { - delete(watch.names, name) - } - } - } - if raw.Action != syscall.FILE_ACTION_RENAMED_NEW_NAME { - sendNameEvent() - } - if raw.Action == syscall.FILE_ACTION_REMOVED { - w.sendEvent(fullname, watch.names[name]&sysFSIGNORED) - delete(watch.names, name) - } - if w.sendEvent(fullname, watch.mask&toFSnotifyFlags(raw.Action)) { - if watch.mask&sysFSONESHOT != 0 { - watch.mask = 0 - } - } - if raw.Action == syscall.FILE_ACTION_RENAMED_NEW_NAME { - fullname = filepath.Join(watch.path, watch.rename) - sendNameEvent() - } - - // Move to the next event in the buffer - if raw.NextEntryOffset == 0 { - break - } - offset += raw.NextEntryOffset - - // Error! - if offset >= n { - w.Errors <- errors.New("Windows system assumed buffer larger than it is, events have likely been missed.") - break - } - } - - if err := w.startRead(watch); err != nil { - w.Errors <- err - } - } -} - -func (w *Watcher) sendEvent(name string, mask uint64) bool { - if mask == 0 { - return false - } - event := newEvent(name, uint32(mask)) - select { - case ch := <-w.quit: - w.quit <- ch - case w.Events <- event: - } - return true -} - -func toWindowsFlags(mask uint64) uint32 { - var m uint32 - if mask&sysFSACCESS != 0 { - m |= syscall.FILE_NOTIFY_CHANGE_LAST_ACCESS - } - if mask&sysFSMODIFY != 0 { - m |= syscall.FILE_NOTIFY_CHANGE_LAST_WRITE - } - if mask&sysFSATTRIB != 0 { - m |= syscall.FILE_NOTIFY_CHANGE_ATTRIBUTES - } - if mask&(sysFSMOVE|sysFSCREATE|sysFSDELETE) != 0 { - m |= syscall.FILE_NOTIFY_CHANGE_FILE_NAME | syscall.FILE_NOTIFY_CHANGE_DIR_NAME - } - return m -} - -func toFSnotifyFlags(action uint32) uint64 { - switch action { - case syscall.FILE_ACTION_ADDED: - return sysFSCREATE - case syscall.FILE_ACTION_REMOVED: - return sysFSDELETE - case syscall.FILE_ACTION_MODIFIED: - return sysFSMODIFY - case syscall.FILE_ACTION_RENAMED_OLD_NAME: - return sysFSMOVEDFROM - case syscall.FILE_ACTION_RENAMED_NEW_NAME: - return sysFSMOVEDTO - } - return 0 -} diff --git a/vendor/github.com/getsentry/sentry-go/.codecov.yml b/vendor/github.com/getsentry/sentry-go/.codecov.yml deleted file mode 100644 index 0c0e695f275..00000000000 --- a/vendor/github.com/getsentry/sentry-go/.codecov.yml +++ /dev/null @@ -1,19 +0,0 @@ -codecov: - # across - notify: - # Do not notify until at least this number of reports have been uploaded - # from the CI pipeline. We normally have more than that number, but 6 - # should be enough to get a first notification. - after_n_builds: 6 -coverage: - status: - project: - default: - # Do not fail the commit status if the coverage was reduced up to this value - threshold: 0.5% - patch: - default: - informational: true -ignore: - - "log_fallback.go" - - "internal/testutils" diff --git a/vendor/github.com/getsentry/sentry-go/.craft.yml b/vendor/github.com/getsentry/sentry-go/.craft.yml deleted file mode 100644 index 0081e1243a2..00000000000 --- a/vendor/github.com/getsentry/sentry-go/.craft.yml +++ /dev/null @@ -1,46 +0,0 @@ -minVersion: 2.14.0 -changelog: - policy: auto -versioning: - policy: auto -artifactProvider: - name: none -targets: - - name: github - tagPrefix: v - - name: github - tagPrefix: otel/v - tagOnly: true - - name: github - tagPrefix: echo/v - tagOnly: true - - name: github - tagPrefix: fasthttp/v - tagOnly: true - - name: github - tagPrefix: fiber/v - tagOnly: true - - name: github - tagPrefix: gin/v - tagOnly: true - - name: github - tagPrefix: iris/v - tagOnly: true - - name: github - tagPrefix: negroni/v - tagOnly: true - - name: github - tagPrefix: logrus/v - tagOnly: true - - name: github - tagPrefix: slog/v - tagOnly: true - - name: github - tagPrefix: zerolog/v - tagOnly: true - - name: github - tagPrefix: zap/v - tagOnly: true - - name: registry - sdks: - github:getsentry/sentry-go: diff --git a/vendor/github.com/getsentry/sentry-go/.gitattributes b/vendor/github.com/getsentry/sentry-go/.gitattributes deleted file mode 100644 index bccfeeab047..00000000000 --- a/vendor/github.com/getsentry/sentry-go/.gitattributes +++ /dev/null @@ -1,5 +0,0 @@ -# Tell Git to use LF for line endings on all platforms. -# Required to have correct test data on Windows. -# https://github.com/mvdan/github-actions-golang#caveats -# https://github.com/actions/checkout/issues/135#issuecomment-613361104 -* text eol=lf diff --git a/vendor/github.com/getsentry/sentry-go/.gitignore b/vendor/github.com/getsentry/sentry-go/.gitignore deleted file mode 100644 index 036570ab428..00000000000 --- a/vendor/github.com/getsentry/sentry-go/.gitignore +++ /dev/null @@ -1,17 +0,0 @@ -# Code coverage artifacts -coverage.txt -coverage.out -coverage.html -.coverage/ - -# Just my personal way of tracking stuff — Kamil -FIXME.md -TODO.md -!NOTES.md - -# IDE system files -.idea -.vscode - -# Local Claude Code settings that should not be committed -.claude/settings.local.json diff --git a/vendor/github.com/getsentry/sentry-go/.golangci.yml b/vendor/github.com/getsentry/sentry-go/.golangci.yml deleted file mode 100644 index e487535b8e4..00000000000 --- a/vendor/github.com/getsentry/sentry-go/.golangci.yml +++ /dev/null @@ -1,62 +0,0 @@ -version: "2" -linters: - default: none - enable: - - bodyclose - - dogsled - - dupl - - errcheck - - gochecknoinits - - goconst - - gocritic - - gocyclo - - godot - - gosec - - govet - - ineffassign - - misspell - - nakedret - - prealloc - - revive - - staticcheck - - unconvert - - unparam - - unused - - whitespace - exclusions: - generated: lax - presets: - - comments - - common-false-positives - - legacy - - std-error-handling - rules: - - linters: - - goconst - - prealloc - path: _test\.go - - linters: - - gosec - path: _test\.go - text: 'G306:' - - linters: - - unused - path: errors_test\.go - - linters: - - bodyclose - - errcheck - path: http/example_test\.go - paths: - - third_party$ - - builtin$ - - examples$ -formatters: - enable: - - gofmt - - goimports - exclusions: - generated: lax - paths: - - third_party$ - - builtin$ - - examples$ diff --git a/vendor/github.com/getsentry/sentry-go/CHANGELOG.md b/vendor/github.com/getsentry/sentry-go/CHANGELOG.md deleted file mode 100644 index af49d79b76c..00000000000 --- a/vendor/github.com/getsentry/sentry-go/CHANGELOG.md +++ /dev/null @@ -1,1407 +0,0 @@ -# Changelog - -## 0.43.0 - -### Breaking Changes 🛠 - -- Add support for go 1.26 by @giortzisg in [#1193](https://github.com/getsentry/sentry-go/pull/1193) - - bump minimum supported go version to 1.24 -- change type signature of attributes for Logs and Metrics. by @giortzisg in [#1205](https://github.com/getsentry/sentry-go/pull/1205) - - users are not supposed to modify Attributes directly on the Log/Metric itself, but this is still is a breaking change on the type. -- Send uint64 overflowing attributes as numbers. by @giortzisg in [#1198](https://github.com/getsentry/sentry-go/pull/1198) - - The SDK was converting overflowing uint64 attributes to strings for slog and logrus integrations. To eliminate double types for these attributes, the SDK now sends the overflowing attribute as is, and lets the server handle the overflow appropriately. - - It is expected that overflowing unsigned integers would now get dropped, instead of converted to strings. - -### New Features ✨ - -- Add zap logging integration by @giortzisg in [#1184](https://github.com/getsentry/sentry-go/pull/1184) -- Log specific message for RequestEntityTooLarge by @giortzisg in [#1185](https://github.com/getsentry/sentry-go/pull/1185) - -### Bug Fixes 🐛 - -- Improve otel span map cleanup performance by @giortzisg in [#1200](https://github.com/getsentry/sentry-go/pull/1200) -- Ensure correct signal delivery on multi-client setups by @giortzisg in [#1190](https://github.com/getsentry/sentry-go/pull/1190) - -### Internal Changes 🔧 - -#### Deps - -- Bump golang.org/x/crypto to 0.48.0 by @giortzisg in [#1196](https://github.com/getsentry/sentry-go/pull/1196) -- Use go1.24.0 by @giortzisg in [#1195](https://github.com/getsentry/sentry-go/pull/1195) -- Bump github.com/gofiber/fiber/v2 from 2.52.9 to 2.52.11 in /fiber by @dependabot in [#1191](https://github.com/getsentry/sentry-go/pull/1191) -- Bump getsentry/craft from 2.19.0 to 2.20.1 by @dependabot in [#1187](https://github.com/getsentry/sentry-go/pull/1187) - -#### Other - -- Add omitzero and remove custom serialization by @giortzisg in [#1197](https://github.com/getsentry/sentry-go/pull/1197) -- Rename Telemetry Processor components by @giortzisg in [#1186](https://github.com/getsentry/sentry-go/pull/1186) - -## 0.42.0 - -### Breaking Changes 🛠 - -- refactor Telemetry Processor to use TelemetryItem instead of ItemConvertible by @giortzisg in [#1180](https://github.com/getsentry/sentry-go/pull/1180) - - remove ToEnvelopeItem from single log items - - rename TelemetryBuffer to Telemetry Processor to adhere to spec - - remove unsed ToEnvelopeItem(dsn) from Event. - -### New Features ✨ - -- Add metric support by @aldy505 in [#1151](https://github.com/getsentry/sentry-go/pull/1151) - - support for three metric methods (counter, gauge, distribution) - - custom metric units - - unexport batchlogger - -### Internal Changes 🔧 - -#### Release - -- Fix changelog-preview permissions by @BYK in [#1181](https://github.com/getsentry/sentry-go/pull/1181) -- Switch from action-prepare-release to Craft by @BYK in [#1167](https://github.com/getsentry/sentry-go/pull/1167) - -#### Other - -- (repo) Add Claude Code settings with basic permissions by @philipphofmann in [#1175](https://github.com/getsentry/sentry-go/pull/1175) -- Update release and changelog-preview workflows by @giortzisg in [#1177](https://github.com/getsentry/sentry-go/pull/1177) -- Bump echo to 4.10.1 by @giortzisg in [#1174](https://github.com/getsentry/sentry-go/pull/1174) - -## 0.41.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.41.0. - -### Features - -- Add HTTP client integration for distributed tracing via `sentryhttpclient` package ([#876](https://github.com/getsentry/sentry-go/pull/876)) - - Provides an `http.RoundTripper` implementation that automatically creates spans for outgoing HTTP requests - - Supports trace propagation targets configuration via `WithTracePropagationTargets` option - - Example usage: - ```go - import sentryhttpclient "github.com/getsentry/sentry-go/httpclient" - - roundTripper := sentryhttpclient.NewSentryRoundTripper(nil) - client := &http.Client{ - Transport: roundTripper, - } - ``` -- Add `ClientOptions.PropagateTraceparent` option to control W3C `traceparent` header propagation in outgoing HTTP requests ([#1161](https://github.com/getsentry/sentry-go/pull/1161)) -- Add `SpanID` field to structured logs ([#1169](https://github.com/getsentry/sentry-go/pull/1169)) - -## 0.40.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.40.0. - -### Bug Fixes - -- Disable `DisableTelemetryBuffer` flag and noop Telemetry Buffer, to prevent a panic at runtime ([#1149](https://github.com/getsentry/sentry-go/pull/1149)). - -## 0.39.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.39.0. - -### Features - -- Drop events from the telemetry buffer when rate-limited or transport is full, allowing the buffer queue to empty itself under load ([#1138](https://github.com/getsentry/sentry-go/pull/1138)). - -### Bug Fixes - -- Fix scheduler's `hasWork()` method to check if buffers are ready to flush. The previous implementation was causing CPU spikes ([#1143](https://github.com/getsentry/sentry-go/pull/1143)). - -## 0.38.0 - -### Breaking Changes - -### Features - -- Introduce a new async envelope transport and telemetry buffer to prioritize and batch events ([#1094](https://github.com/getsentry/sentry-go/pull/1094), [#1093](https://github.com/getsentry/sentry-go/pull/1093), [#1107](https://github.com/getsentry/sentry-go/pull/1107)). - - Advantages: - - Prioritized, per-category buffers (errors, transactions, logs, check-ins) reduce starvation and improve resilience under load - - Batching for high-volume logs (up to 100 items or 5s) cuts network overhead - - Bounded memory with eviction policies - - Improved flush behavior with context-aware flushing -- Add `ClientOptions.DisableTelemetryBuffer` to opt out and fall back to the legacy transport layer (`HTTPTransport` / `HTTPSyncTransport`). - - ```go - err := sentry.Init(sentry.ClientOptions{ - Dsn: "__DSN__", - DisableTelemetryBuffer: true, // fallback to legacy transport - }) - ``` - -### Notes - -- If a custom `Transport` is provided, the SDK automatically disables the telemetry buffer and uses the legacy transport for compatibility. - -## 0.37.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.37.0. - -### Breaking Changes - -- Behavioral change for the `TraceIgnoreStatusCodes` option. The option now defaults to ignoring 404 status codes ([#1122](https://github.com/getsentry/sentry-go/pull/1122)). - -### Features - -- Add `sentry.origin` attribute to structured logs to identify log origin for `slog` and `logrus` integrations (`auto.log.slog`, `auto.log.logrus`) ([#1121](https://github.com/getsentry/sentry-go/pull/1121)). - -### Bug Fixes - -- Fix `slog` event handler to use the initial context, ensuring events use the correct hub/span when the emission context lacks one ([#1133](https://github.com/getsentry/sentry-go/pull/1133)). -- Improve exception chain processing by checking pointer values when tracking visited errors, avoiding instability for certain wrapped errors ([#1132](https://github.com/getsentry/sentry-go/pull/1132)). - -### Misc - -- Bump `golang.org/x/net` to v0.38.0 ([#1126](https://github.com/getsentry/sentry-go/pull/1126)). - -## 0.36.2 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.36.2. - -### Bug Fixes - -- Fix context propagation for logs to ensure logger instances correctly inherit span and hub information from their creation context ([#1118](https://github.com/getsentry/sentry-go/pull/1118)) - - Logs now properly propagate trace context from the logger's original context, even when emitted in a different context - - The logger will first check the emission context, then fall back to its creation context, and finally to the current hub - -## 0.36.1 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.36.1. - -### Bug Fixes - -- Prevent panic when converting error chains containing non-comparable error types by using a safe fallback for visited detection in exception conversion ([#1113](https://github.com/getsentry/sentry-go/pull/1113)) - -## 0.36.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.36.0. - -### Breaking Changes - -- Behavioral change for the `MaxBreadcrumbs` client option. Removed the hard limit of 100 breadcrumbs, allowing users to set a larger limit and also changed the default limit from 30 to 100 ([#1106](https://github.com/getsentry/sentry-go/pull/1106))) - -- The changes to error handling ([#1075](https://github.com/getsentry/sentry-go/pull/1075)) will affect issue grouping. It is expected that any wrapped and complex errors will be grouped under a new issue group. - -### Features - -- Add support for improved issue grouping with enhanced error chain handling ([#1075](https://github.com/getsentry/sentry-go/pull/1075)) - - The SDK now provides better handling of complex error scenarios, particularly when dealing with multiple related errors or error chains. This feature automatically detects and properly structures errors created with Go's `errors.Join()` function and other multi-error patterns. - - ```go - // Multiple errors are now properly grouped and displayed in Sentry - err1 := errors.New("err1") - err2 := errors.New("err2") - combinedErr := errors.Join(err1, err2) - - // When captured, these will be shown as related exceptions in Sentry - sentry.CaptureException(combinedErr) - ``` - -- Add `TraceIgnoreStatusCodes` option to allow filtering of HTTP transactions based on status codes ([#1089](https://github.com/getsentry/sentry-go/pull/1089)) - - Configure which HTTP status codes should not be traced by providing single codes or ranges - - Example: `TraceIgnoreStatusCodes: [][]int{{404}, {500, 599}}` ignores 404 and server errors 500-599 - -### Bug Fixes - -- Fix logs being incorrectly filtered by `BeforeSend` callback ([#1109](https://github.com/getsentry/sentry-go/pull/1109)) - - Logs now bypass the `processEvent` method and are sent directly to the transport - - This ensures logs are only filtered by `BeforeSendLog`, not by the error/message `BeforeSend` callback - -### Misc - -- Add support for Go 1.25 and drop support for Go 1.22 ([#1103](https://github.com/getsentry/sentry-go/pull/1103)) - -## 0.35.3 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.35.3. - -### Bug Fixes - -- Add missing rate limit categories ([#1082](https://github.com/getsentry/sentry-go/pull/1082)) - -## 0.35.2 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.35.2. - -### Bug Fixes - -- Fix OpenTelemetry spans being created as transactions instead of child spans ([#1073](https://github.com/getsentry/sentry-go/pull/1073)) - -### Misc - -- Add `MockTransport` to test clients for improved testing ([#1071](https://github.com/getsentry/sentry-go/pull/1071)) - -## 0.35.1 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.35.1. - -### Bug Fixes - -- Fix race conditions when accessing the scope during logging operations ([#1050](https://github.com/getsentry/sentry-go/pull/1050)) -- Fix nil pointer dereference with malformed URLs when tracing is enabled in `fasthttp` and `fiber` integrations ([#1055](https://github.com/getsentry/sentry-go/pull/1055)) - -### Misc - -- Bump `github.com/gofiber/fiber/v2` from 2.52.5 to 2.52.9 in `/fiber` ([#1067](https://github.com/getsentry/sentry-go/pull/1067)) - -## 0.35.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.35.0. - -### Breaking Changes - -- Changes to the logging API ([#1046](https://github.com/getsentry/sentry-go/pull/1046)) - -The logging API now supports a fluent interface for structured logging with attributes: - -```go -// usage before -logger := sentry.NewLogger(ctx) -// attributes weren't being set permanently -logger.SetAttributes( - attribute.String("version", "1.0.0"), -) -logger.Infof(ctx, "Message with parameters %d and %d", 1, 2) - -// new behavior -ctx := context.Background() -logger := sentry.NewLogger(ctx) - -// Set permanent attributes on the logger -logger.SetAttributes( - attribute.String("version", "1.0.0"), -) - -// Chain attributes on individual log entries -logger.Info(). - String("key.string", "value"). - Int("key.int", 42). - Bool("key.bool", true). - Emitf("Message with parameters %d and %d", 1, 2) -``` - -### Bug Fixes - -- Correctly serialize `FailureIssueThreshold` and `RecoveryThreshold` onto check-in payloads ([#1060](https://github.com/getsentry/sentry-go/pull/1060)) - -## 0.34.1 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.34.1. - -### Bug Fixes - -- Allow flush to be used multiple times without issues, particularly for the batch logger ([#1051](https://github.com/getsentry/sentry-go/pull/1051)) -- Fix race condition in `Scope.GetSpan()` method by adding proper mutex locking ([#1044](https://github.com/getsentry/sentry-go/pull/1044)) -- Guard transport on `Close()` to prevent panic when called multiple times ([#1044](https://github.com/getsentry/sentry-go/pull/1044)) - -## 0.34.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.34.0. - -### Breaking Changes - -- Logrus structured logging support replaces the `sentrylogrus.Hook` signature from a `*Hook` to an interface. - -```go -var hook *sentrylogrus.Hook -hook = sentrylogrus.New( - // ... your setup -) - -// should change the definition to -var hook sentrylogrus.Hook -hook = sentrylogrus.New( - // ... your setup -) -``` - -### Features - -- Structured logging support for [slog](https://pkg.go.dev/log/slog). ([#1033](https://github.com/getsentry/sentry-go/pull/1033)) - -```go -ctx := context.Background() -handler := sentryslog.Option{ - EventLevel: []slog.Level{slog.LevelError, sentryslog.LevelFatal}, // Only Error and Fatal as events - LogLevel: []slog.Level{slog.LevelWarn, slog.LevelInfo}, // Only Warn and Info as logs -}.NewSentryHandler(ctx) -logger := slog.New(handler) -logger.Info("hello")) -``` - -- Structured logging support for [logrus](https://github.com/sirupsen/logrus). ([#1036](https://github.com/getsentry/sentry-go/pull/1036)) -```go -logHook, _ := sentrylogrus.NewLogHook( - []logrus.Level{logrus.InfoLevel, logrus.WarnLevel}, - sentry.ClientOptions{ - Dsn: "your-dsn", - EnableLogs: true, // Required for log entries - }) -defer logHook.Flush(5 * time.Secod) -logrus.RegisterExitHandler(func() { - logHook.Flush(5 * time.Second) -}) - -logger := logrus.New() -logger.AddHook(logHook) -logger.Infof("hello") -``` - -- Add support for flushing events with context using `FlushWithContext()`. ([#935](https://github.com/getsentry/sentry-go/pull/935)) - -```go -ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) -defer cancel() - -if !sentry.FlushWithContext(ctx) { - // Handle timeout or cancellation -} -``` - -- Add support for custom fingerprints in slog integration. ([#1039](https://github.com/getsentry/sentry-go/pull/1039)) - -### Deprecations - -- Slog structured logging support replaces `Level` option with `EventLevel` and `LogLevel` options, for specifying fine-grained levels for capturing events and logs. - -```go -handler := sentryslog.Option{ - EventLevel: []slog.Level{slog.LevelWarn, slog.LevelError, sentryslog.LevelFatal}, - LogLevel: []slog.Level{slog.LevelDebug, slog.LevelInfo, slog.LevelWarn, slog.LevelError, sentryslog.LevelFatal}, -}.NewSentryHandler(ctx) -``` - -- Logrus structured logging support replaces `New` and `NewFromClient` functions to `NewEventHook`, `NewEventHookFromClient`, to match the newly added `NewLogHook` functions, and specify the hook type being created each time. - -```go -logHook, err := sentrylogrus.NewLogHook( - []logrus.Level{logrus.InfoLevel}, - sentry.ClientOptions{}) -eventHook, err := sentrylogrus.NewEventHook([]logrus.Level{ - logrus.ErrorLevel, - logrus.FatalLevel, - logrus.PanicLevel, -}, sentry.ClientOptions{}) -``` - -### Bug Fixes - -- Fix issue where `ContinueTrace()` would panic when `sentry-trace` header does not exist. ([#1026](https://github.com/getsentry/sentry-go/pull/1026)) -- Fix incorrect log level signature in structured logging. ([#1034](https://github.com/getsentry/sentry-go/pull/1034)) -- Remove `sentry.origin` attribute from Sentry logger to prevent confusion in spans. ([#1038](https://github.com/getsentry/sentry-go/pull/1038)) -- Don't gate user information behind `SendDefaultPII` flag for logs. ([#1032](https://github.com/getsentry/sentry-go/pull/1032)) - -### Misc - -- Add more sensitive HTTP headers to the default list of headers that are scrubbed by default. ([#1008](https://github.com/getsentry/sentry-go/pull/1008)) - -## 0.33.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.33.0. - - -### Breaking Changes - -- Rename the internal `Logger` to `DebugLogger`. This feature was only used when you set `Debug: True` in your `sentry.Init()` call. If you haven't used the Logger directly, no changes are necessary. ([#1012](https://github.com/getsentry/sentry-go/issues/1012)) - -### Features - -- Add support for [Structured Logging](https://docs.sentry.io/product/explore/logs/). ([#1010](https://github.com/getsentry/sentry-go/issues/1010)) - - ```go - logger := sentry.NewLogger(ctx) - logger.Info(ctx, "Hello, Logs!") - ``` - - You can learn more about Sentry Logs on our [docs](https://docs.sentry.io/product/explore/logs/) and the [examples](https://github.com/getsentry/sentry-go/blob/master/_examples/logs/main.go). - -- Add new attributes APIs, which are currently only exposed on logs. ([#1007](https://github.com/getsentry/sentry-go/issues/1007)) - -### Bug Fixes - -- Do not push a new scope on `StartSpan`. ([#1013](https://github.com/getsentry/sentry-go/issues/1013)) -- Fix an issue where the propagated smapling decision wasn't used. ([#995](https://github.com/getsentry/sentry-go/issues/995)) -- [Otel] Prefer `httpRoute` over `httpTarget` for span descriptions. ([#1002](https://github.com/getsentry/sentry-go/issues/1002)) - -### Misc - -- Update `github.com/stretchr/testify` to v1.8.4. ([#988](https://github.com/getsentry/sentry-go/issues/988)) - -## 0.32.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.32.0. - -### Breaking Changes - -- Bump the minimum Go version to 1.22. The supported versions are 1.22, 1.23 and 1.24. ([#967](https://github.com/getsentry/sentry-go/issues/967)) -- Setting any values on `span.Extra` has no effect anymore. Use `SetData(name string, value interface{})` instead. ([#864](https://github.com/getsentry/sentry-go/pull/864)) - -### Features - -- Add a `MockTransport` and `MockScope`. ([#972](https://github.com/getsentry/sentry-go/pull/972)) - -### Bug Fixes - -- Fix writing `*http.Request` in the Logrus JSONFormatter. ([#955](https://github.com/getsentry/sentry-go/issues/955)) - -### Misc - -- Transaction `data` attributes are now seralized as trace context data attributes, allowing you to query these attributes in the [Trace Explorer](https://docs.sentry.io/product/explore/traces/). - -## 0.31.1 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.31.1. - -### Bug Fixes - -- Correct wrong module name for `sentry-go/logrus` ([#950](https://github.com/getsentry/sentry-go/pull/950)) - -## 0.31.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.31.0. - -### Breaking Changes - -- Remove support for metrics. Read more about the end of the Metrics beta [here](https://sentry.zendesk.com/hc/en-us/articles/26369339769883-Metrics-Beta-Ended-on-October-7th). ([#914](https://github.com/getsentry/sentry-go/pull/914)) - -- Remove support for profiling. ([#915](https://github.com/getsentry/sentry-go/pull/915)) - -- Remove `Segment` field from the `User` struct. This field is no longer used in the Sentry product. ([#928](https://github.com/getsentry/sentry-go/pull/928)) - -- Every integration is now a separate module, reducing the binary size and number of dependencies. Once you update `sentry-go` to latest version, you'll need to `go get` the integration you want to use. For example, if you want to use the `echo` integration, you'll need to run `go get github.com/getsentry/sentry-go/echo` ([#919](github.com/getsentry/sentry-go/pull/919)). - -### Features - -Add the ability to override `hub` in `context` for integrations that use custom context. ([#931](https://github.com/getsentry/sentry-go/pull/931)) - -- Add `HubProvider` Hook for `sentrylogrus`, enabling dynamic Sentry hub allocation for each log entry or goroutine. ([#936](https://github.com/getsentry/sentry-go/pull/936)) - -This change enhances compatibility with Sentry's recommendation of using separate hubs per goroutine. To ensure a separate Sentry hub for each goroutine, configure the `HubProvider` like this: - -```go -hook, err := sentrylogrus.New(nil, sentry.ClientOptions{}) -if err != nil { - log.Fatalf("Failed to initialize Sentry hook: %v", err) -} - -// Set a custom HubProvider to generate a new hub for each goroutine or log entry -hook.SetHubProvider(func() *sentry.Hub { - client, _ := sentry.NewClient(sentry.ClientOptions{}) - return sentry.NewHub(client, sentry.NewScope()) -}) - -logrus.AddHook(hook) -``` - -### Bug Fixes - -- Add support for closing worker goroutines started by the `HTTPTranport` to prevent goroutine leaks. ([#894](https://github.com/getsentry/sentry-go/pull/894)) - -```go -client, _ := sentry.NewClient() -defer client.Close() -``` - -Worker can be also closed by calling `Close()` method on the `HTTPTransport` instance. `Close` should be called after `Flush` and before terminating the program otherwise some events may be lost. - -```go -transport := sentry.NewHTTPTransport() -defer transport.Close() -``` - -### Misc - -- Bump [gin-gonic/gin](https://github.com/gin-gonic/gin) to v1.9.1. ([#946](https://github.com/getsentry/sentry-go/pull/946)) - -## 0.30.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.30.0. - -### Features - -- Add `sentryzerolog` integration ([#857](https://github.com/getsentry/sentry-go/pull/857)) -- Add `sentryslog` integration ([#865](https://github.com/getsentry/sentry-go/pull/865)) -- Always set Mechanism Type to generic ([#896](https://github.com/getsentry/sentry-go/pull/897)) - -### Bug Fixes - -- Prevent panic in `fasthttp` and `fiber` integration in case a malformed URL has to be parsed ([#912](https://github.com/getsentry/sentry-go/pull/912)) - -### Misc - -Drop support for Go 1.18, 1.19 and 1.20. The currently supported Go versions are the last 3 stable releases: 1.23, 1.22 and 1.21. - -## 0.29.1 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.29.1. - -### Bug Fixes - -- Correlate errors to the current trace ([#886](https://github.com/getsentry/sentry-go/pull/886)) -- Set the trace context when the transaction finishes ([#888](https://github.com/getsentry/sentry-go/pull/888)) - -### Misc - -- Update the `sentrynegroni` integration to use the latest (v3.1.1) version of Negroni ([#885](https://github.com/getsentry/sentry-go/pull/885)) - -## 0.29.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.29.0. - -### Breaking Changes - -- Remove the `sentrymartini` integration ([#861](https://github.com/getsentry/sentry-go/pull/861)) -- The `WrapResponseWriter` has been moved from the `sentryhttp` package to the `internal/httputils` package. If you've imported it previosuly, you'll need to copy the implementation in your project. ([#871](https://github.com/getsentry/sentry-go/pull/871)) - -### Features - -- Add new convenience methods to continue a trace and propagate tracing headers for error-only use cases. ([#862](https://github.com/getsentry/sentry-go/pull/862)) - - If you are not using one of our integrations, you can manually continue an incoming trace by using `sentry.ContinueTrace()` by providing the `sentry-trace` and `baggage` header received from a downstream SDK. - - ```go - hub := sentry.CurrentHub() - sentry.ContinueTrace(hub, r.Header.Get(sentry.SentryTraceHeader), r.Header.Get(sentry.SentryBaggageHeader)), - ``` - - You can use `hub.GetTraceparent()` and `hub.GetBaggage()` to fetch the necessary header values for outgoing HTTP requests. - - ```go - hub := sentry.GetHubFromContext(ctx) - req, _ := http.NewRequest("GET", "http://localhost:3000", nil) - req.Header.Add(sentry.SentryTraceHeader, hub.GetTraceparent()) - req.Header.Add(sentry.SentryBaggageHeader, hub.GetBaggage()) - ``` - -### Bug Fixes - -- Initialize `HTTPTransport.limit` if `nil` ([#844](https://github.com/getsentry/sentry-go/pull/844)) -- Fix `sentry.StartTransaction()` returning a transaction with an outdated context on existing transactions ([#854](https://github.com/getsentry/sentry-go/pull/854)) -- Treat `Proxy-Authorization` as a sensitive header ([#859](https://github.com/getsentry/sentry-go/pull/859)) -- Add support for the `http.Hijacker` interface to the `sentrynegroni` package ([#871](https://github.com/getsentry/sentry-go/pull/871)) -- Go version >= 1.23: Use value from `http.Request.Pattern` for HTTP transaction names when using `sentryhttp` & `sentrynegroni` ([#875](https://github.com/getsentry/sentry-go/pull/875)) -- Go version >= 1.21: Fix closure functions name grouping ([#877](https://github.com/getsentry/sentry-go/pull/877)) - -### Misc - -- Collect `span` origins ([#849](https://github.com/getsentry/sentry-go/pull/849)) - -## 0.28.1 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.28.1. - -### Bug Fixes - -- Implement `http.ResponseWriter` to hook into various parts of the response process ([#837](https://github.com/getsentry/sentry-go/pull/837)) - -## 0.28.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.28.0. - -### Features - -- Add a `Fiber` performance tracing & error reporting integration ([#795](https://github.com/getsentry/sentry-go/pull/795)) -- Add performance tracing to the `Echo` integration ([#722](https://github.com/getsentry/sentry-go/pull/722)) -- Add performance tracing to the `FastHTTP` integration ([#732](https://github.com/getsentry/sentry-go/pull/723)) -- Add performance tracing to the `Iris` integration ([#809](https://github.com/getsentry/sentry-go/pull/809)) -- Add performance tracing to the `Negroni` integration ([#808](https://github.com/getsentry/sentry-go/pull/808)) -- Add `FailureIssueThreshold` & `RecoveryThreshold` to `MonitorConfig` ([#775](https://github.com/getsentry/sentry-go/pull/775)) -- Use `errors.Unwrap()` to create exception groups ([#792](https://github.com/getsentry/sentry-go/pull/792)) -- Add support for matching on strings for `ClientOptions.IgnoreErrors` & `ClientOptions.IgnoreTransactions` ([#819](https://github.com/getsentry/sentry-go/pull/819)) -- Add `http.request.method` attribute for performance span data ([#786](https://github.com/getsentry/sentry-go/pull/786)) -- Accept `interface{}` for span data values ([#784](https://github.com/getsentry/sentry-go/pull/784)) - -### Bug Fixes - -- Fix missing stack trace for parsing error in `logrusentry` ([#689](https://github.com/getsentry/sentry-go/pull/689)) - -## 0.27.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.27.0. - -### Breaking Changes - -- `Exception.ThreadId` is now typed as `uint64`. It was wrongly typed as `string` before. ([#770](https://github.com/getsentry/sentry-go/pull/770)) - -### Misc - -- Export `Event.Attachments` ([#771](https://github.com/getsentry/sentry-go/pull/771)) - -## 0.26.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.26.0. - -### Breaking Changes - -As previously announced, this release removes some methods from the SDK. - -- `sentry.TransactionName()` use `sentry.WithTransactionName()` instead. -- `sentry.OpName()` use `sentry.WithOpName()` instead. -- `sentry.TransctionSource()` use `sentry.WithTransactionSource()` instead. -- `sentry.SpanSampled()` use `sentry.WithSpanSampled()` instead. - -### Features - -- Add `WithDescription` span option ([#751](https://github.com/getsentry/sentry-go/pull/751)) - - ```go - span := sentry.StartSpan(ctx, "http.client", WithDescription("GET /api/users")) - ``` -- Add support for package name parsing in Go 1.20 and higher ([#730](https://github.com/getsentry/sentry-go/pull/730)) - -### Bug Fixes - -- Apply `ClientOptions.SampleRate` only to errors & messages ([#754](https://github.com/getsentry/sentry-go/pull/754)) -- Check if git is available before executing any git commands ([#737](https://github.com/getsentry/sentry-go/pull/737)) - -## 0.25.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.25.0. - -### Breaking Changes - -As previously announced, this release removes two global constants from the SDK. - -- `sentry.Version` was removed. Use `sentry.SDKVersion` instead ([#727](https://github.com/getsentry/sentry-go/pull/727)) -- `sentry.SDKIdentifier` was removed. Use `Client.GetSDKIdentifier()` instead ([#727](https://github.com/getsentry/sentry-go/pull/727)) - -### Features - -- Add `ClientOptions.IgnoreTransactions`, which allows you to ignore specific transactions based on their name ([#717](https://github.com/getsentry/sentry-go/pull/717)) -- Add `ClientOptions.Tags`, which allows you to set global tags that are applied to all events. You can also define tags by setting `SENTRY_TAGS_` environment variables ([#718](https://github.com/getsentry/sentry-go/pull/718)) - -### Bug fixes - -- Fix an issue in the profiler that would cause an infinite loop if the duration of a transaction is longer than 30 seconds ([#724](https://github.com/getsentry/sentry-go/issues/724)) - -### Misc - -- `dsn.RequestHeaders()` is not to be removed, though it is still considered deprecated and should only be used when using a custom transport that sends events to the `/store` endpoint ([#720](https://github.com/getsentry/sentry-go/pull/720)) - -## 0.24.1 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.24.1. - -### Bug fixes - -- Prevent a panic in `sentryotel.flushSpanProcessor()` ([(#711)](https://github.com/getsentry/sentry-go/pull/711)) -- Prevent a panic when setting the SDK identifier ([#715](https://github.com/getsentry/sentry-go/pull/715)) - -## 0.24.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.24.0. - -### Deprecations - -- `sentry.Version` to be removed in 0.25.0. Use `sentry.SDKVersion` instead. -- `sentry.SDKIdentifier` to be removed in 0.25.0. Use `Client.GetSDKIdentifier()` instead. -- `dsn.RequestHeaders()` to be removed after 0.25.0, but no earlier than December 1, 2023. Requests to the `/envelope` endpoint are authenticated using the DSN in the envelope header. - -### Features - -- Run a single instance of the profiler instead of multiple ones for each Go routine ([#655](https://github.com/getsentry/sentry-go/pull/655)) -- Use the route path as the transaction names when using the Gin integration ([#675](https://github.com/getsentry/sentry-go/pull/675)) -- Set the SDK name accordingly when a framework integration is used ([#694](https://github.com/getsentry/sentry-go/pull/694)) -- Read release information (VCS revision) from `debug.ReadBuildInfo` ([#704](https://github.com/getsentry/sentry-go/pull/704)) - -### Bug fixes - -- [otel] Fix incorrect usage of `attributes.Value.AsString` ([#684](https://github.com/getsentry/sentry-go/pull/684)) -- Fix trace function name parsing in profiler on go1.21+ ([#695](https://github.com/getsentry/sentry-go/pull/695)) - -### Misc - -- Test against Go 1.21 ([#695](https://github.com/getsentry/sentry-go/pull/695)) -- Make tests more robust ([#698](https://github.com/getsentry/sentry-go/pull/698), [#699](https://github.com/getsentry/sentry-go/pull/699), [#700](https://github.com/getsentry/sentry-go/pull/700), [#702](https://github.com/getsentry/sentry-go/pull/702)) - -## 0.23.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.23.0. - -### Features - -- Initial support for [Cron Monitoring](https://docs.sentry.io/product/crons/) ([#661](https://github.com/getsentry/sentry-go/pull/661)) - - This is how the basic usage of the feature looks like: - - ```go - // 🟡 Notify Sentry your job is running: - checkinId := sentry.CaptureCheckIn( - &sentry.CheckIn{ - MonitorSlug: "", - Status: sentry.CheckInStatusInProgress, - }, - nil, - ) - - // Execute your scheduled task here... - - // 🟢 Notify Sentry your job has completed successfully: - sentry.CaptureCheckIn( - &sentry.CheckIn{ - ID: *checkinId, - MonitorSlug: "", - Status: sentry.CheckInStatusOK, - }, - nil, - ) - ``` - - A full example of using Crons Monitoring is available [here](https://github.com/getsentry/sentry-go/blob/dde4d360660838f3c2e0ced8205bc8f7a8d312d9/_examples/crons/main.go). - - More documentation on configuring and using Crons [can be found here](https://docs.sentry.io/platforms/go/crons/). - -- Add support for [Event Attachments](https://docs.sentry.io/platforms/go/enriching-events/attachments/) ([#670](https://github.com/getsentry/sentry-go/pull/670)) - - It's now possible to add file/binary payloads to Sentry events: - - ```go - sentry.ConfigureScope(func(scope *sentry.Scope) { - scope.AddAttachment(&Attachment{ - Filename: "report.html", - ContentType: "text/html", - Payload: []byte("

Look, HTML

"), - }) - }) - ``` - - The attachment will then be accessible on the Issue Details page. - -- Add sampling decision to trace envelope header ([#666](https://github.com/getsentry/sentry-go/pull/666)) -- Expose SpanFromContext function ([#672](https://github.com/getsentry/sentry-go/pull/672)) - -### Bug fixes - -- Make `Span.Finish` a no-op when the span is already finished ([#660](https://github.com/getsentry/sentry-go/pull/660)) - -## 0.22.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.22.0. - -This release contains initial [profiling](https://docs.sentry.io/product/profiling/) support, as well as a few bug fixes and improvements. - -### Features - -- Initial (alpha) support for [profiling](https://docs.sentry.io/product/profiling/) ([#626](https://github.com/getsentry/sentry-go/pull/626)) - - Profiling is disabled by default. To enable it, configure both `TracesSampleRate` and `ProfilesSampleRate` when initializing the SDK: - - ```go - err := sentry.Init(sentry.ClientOptions{ - Dsn: "__DSN__", - EnableTracing: true, - TracesSampleRate: 1.0, - // The sampling rate for profiling is relative to TracesSampleRate. In this case, we'll capture profiles for 100% of transactions. - ProfilesSampleRate: 1.0, - }) - ``` - - More documentation on profiling and current limitations [can be found here](https://docs.sentry.io/platforms/go/profiling/). - -- Add transactions/tracing support go the Gin integration ([#644](https://github.com/getsentry/sentry-go/pull/644)) - -### Bug fixes - -- Always set a valid source on transactions ([#637](https://github.com/getsentry/sentry-go/pull/637)) -- Clone scope.Context in more places to avoid panics on concurrent reads and writes ([#638](https://github.com/getsentry/sentry-go/pull/638)) - - Fixes [#570](https://github.com/getsentry/sentry-go/issues/570) -- Fix frames recognized as not being in-app still showing as in-app ([#647](https://github.com/getsentry/sentry-go/pull/647)) - -## 0.21.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.21.0. - -Note: this release includes one **breaking change** and some **deprecations**, which are listed below. - -### Breaking Changes - -**This change does not apply if you use [https://sentry.io](https://sentry.io)** - -- Remove support for the `/store` endpoint ([#631](https://github.com/getsentry/sentry-go/pull/631)) - - This change requires a self-hosted version of Sentry 20.6.0 or higher. If you are using a version of [self-hosted Sentry](https://develop.sentry.dev/self-hosted/) (aka *on-premise*) older than 20.6.0, then you will need to [upgrade](https://develop.sentry.dev/self-hosted/releases/) your instance. - -### Features - -- Rename four span option functions ([#611](https://github.com/getsentry/sentry-go/pull/611), [#624](https://github.com/getsentry/sentry-go/pull/624)) - - `TransctionSource` -> `WithTransactionSource` - - `SpanSampled` -> `WithSpanSampled` - - `OpName` -> `WithOpName` - - `TransactionName` -> `WithTransactionName` - - Old functions `TransctionSource`, `SpanSampled`, `OpName`, and `TransactionName` are still available but are now **deprecated** and will be removed in a future release. -- Make `client.EventFromMessage` and `client.EventFromException` methods public ([#607](https://github.com/getsentry/sentry-go/pull/607)) -- Add `client.SetException` method ([#607](https://github.com/getsentry/sentry-go/pull/607)) - - This allows to set or add errors to an existing `Event`. - -### Bug Fixes - -- Protect from panics while doing concurrent reads/writes to Span data fields ([#609](https://github.com/getsentry/sentry-go/pull/609)) -- [otel] Improve detection of Sentry-related spans ([#632](https://github.com/getsentry/sentry-go/pull/632), [#636](https://github.com/getsentry/sentry-go/pull/636)) - - Fixes cases when HTTP spans containing requests to Sentry were captured by Sentry ([#627](https://github.com/getsentry/sentry-go/issues/627)) - -### Misc - -- Drop testing in (legacy) GOPATH mode ([#618](https://github.com/getsentry/sentry-go/pull/618)) -- Remove outdated documentation from https://pkg.go.dev/github.com/getsentry/sentry-go ([#623](https://github.com/getsentry/sentry-go/pull/623)) - -## 0.20.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.20.0. - -Note: this release has some **breaking changes**, which are listed below. - -### Breaking Changes - -- Remove the following methods: `Scope.SetTransaction()`, `Scope.Transaction()` ([#605](https://github.com/getsentry/sentry-go/pull/605)) - - Span.Name should be used instead to access the transaction's name. - - For example, the following [`TracesSampler`](https://docs.sentry.io/platforms/go/configuration/sampling/#setting-a-sampling-function) function should be now written as follows: - - **Before:** - ```go - TracesSampler: func(ctx sentry.SamplingContext) float64 { - hub := sentry.GetHubFromContext(ctx.Span.Context()) - if hub.Scope().Transaction() == "GET /health" { - return 0 - } - return 1 - }, - ``` - - **After:** - ```go - TracesSampler: func(ctx sentry.SamplingContext) float64 { - if ctx.Span.Name == "GET /health" { - return 0 - } - return 1 - }, - ``` - -### Features - -- Add `Span.SetContext()` method ([#599](https://github.com/getsentry/sentry-go/pull/599/)) - - It is recommended to use it instead of `hub.Scope().SetContext` when setting or updating context on transactions. -- Add `DebugMeta` interface to `Event` and extend `Frame` structure with more fields ([#606](https://github.com/getsentry/sentry-go/pull/606)) - - More about DebugMeta interface [here](https://develop.sentry.dev/sdk/event-payloads/debugmeta/). - -### Bug Fixes - -- [otel] Fix missing OpenTelemetry context on some events ([#599](https://github.com/getsentry/sentry-go/pull/599), [#605](https://github.com/getsentry/sentry-go/pull/605)) - - Fixes ([#596](https://github.com/getsentry/sentry-go/issues/596)). -- [otel] Better handling for HTTP span attributes ([#610](https://github.com/getsentry/sentry-go/pull/610)) - -### Misc - -- Bump minimum versions: `github.com/kataras/iris/v12` to 12.2.0, `github.com/labstack/echo/v4` to v4.10.0 ([#595](https://github.com/getsentry/sentry-go/pull/595)) - - Resolves [GO-2022-1144 / CVE-2022-41717](https://deps.dev/advisory/osv/GO-2022-1144), [GO-2023-1495 / CVE-2022-41721](https://deps.dev/advisory/osv/GO-2023-1495), [GO-2022-1059 / CVE-2022-32149](https://deps.dev/advisory/osv/GO-2022-1059). -- Bump `google.golang.org/protobuf` minimum required version to 1.29.1 ([#604](https://github.com/getsentry/sentry-go/pull/604)) - - This fixes a potential denial of service issue ([CVE-2023-24535](https://github.com/advisories/GHSA-hw7c-3rfg-p46j)). -- Exclude the `otel` module when building in GOPATH mode ([#615](https://github.com/getsentry/sentry-go/pull/615)) - -## 0.19.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.19.0. - -### Features - -- Add support for exception mechanism metadata ([#564](https://github.com/getsentry/sentry-go/pull/564/)) - - More about exception mechanisms [here](https://develop.sentry.dev/sdk/event-payloads/exception/#exception-mechanism). - -### Bug Fixes -- [otel] Use the correct "trace" context when sending a Sentry error ([#580](https://github.com/getsentry/sentry-go/pull/580/)) - - -### Misc -- Drop support for Go 1.17, add support for Go 1.20 ([#563](https://github.com/getsentry/sentry-go/pull/563/)) - - According to our policy, we're officially supporting the last three minor releases of Go. -- Switch repository license to MIT ([#583](https://github.com/getsentry/sentry-go/pull/583/)) - - More about Sentry licensing [here](https://open.sentry.io/licensing/). -- Bump `golang.org/x/text` minimum required version to 0.3.8 ([#586](https://github.com/getsentry/sentry-go/pull/586)) - - This fixes [CVE-2022-32149](https://github.com/advisories/GHSA-69ch-w2m2-3vjp) vulnerability. - -## 0.18.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.18.0. -This release contains initial support for [OpenTelemetry](https://opentelemetry.io/) and various other bug fixes and improvements. - -**Note**: This is the last release supporting Go 1.17. - -### Features - -- Initial support for [OpenTelemetry](https://opentelemetry.io/). - You can now send all your OpenTelemetry spans to Sentry. - - Install the `otel` module - - ```bash - go get github.com/getsentry/sentry-go \ - github.com/getsentry/sentry-go/otel - ``` - - Configure the Sentry and OpenTelemetry SDKs - - ```go - import ( - "go.opentelemetry.io/otel" - sdktrace "go.opentelemetry.io/otel/sdk/trace" - "github.com/getsentry/sentry-go" - "github.com/getsentry/sentry-go/otel" - // ... - ) - - // Initlaize the Sentry SDK - sentry.Init(sentry.ClientOptions{ - Dsn: "__DSN__", - EnableTracing: true, - TracesSampleRate: 1.0, - }) - - // Set up the Sentry span processor - tp := sdktrace.NewTracerProvider( - sdktrace.WithSpanProcessor(sentryotel.NewSentrySpanProcessor()), - // ... - ) - otel.SetTracerProvider(tp) - - // Set up the Sentry propagator - otel.SetTextMapPropagator(sentryotel.NewSentryPropagator()) - ``` - - You can read more about using OpenTelemetry with Sentry in our [docs](https://docs.sentry.io/platforms/go/performance/instrumentation/opentelemetry/). - -### Bug Fixes - -- Do not freeze the Dynamic Sampling Context when no Sentry values are present in the baggage header ([#532](https://github.com/getsentry/sentry-go/pull/532)) -- Create a frozen Dynamic Sampling Context when calling `span.ToBaggage()` ([#566](https://github.com/getsentry/sentry-go/pull/566)) -- Fix baggage parsing and encoding in vendored otel package ([#568](https://github.com/getsentry/sentry-go/pull/568)) - -### Misc - -- Add `Span.SetDynamicSamplingContext()` ([#539](https://github.com/getsentry/sentry-go/pull/539/)) -- Add various getters for `Dsn` ([#540](https://github.com/getsentry/sentry-go/pull/540)) -- Add `SpanOption::SpanSampled` ([#546](https://github.com/getsentry/sentry-go/pull/546)) -- Add `Span.SetData()` ([#542](https://github.com/getsentry/sentry-go/pull/542)) -- Add `Span.IsTransaction()` ([#543](https://github.com/getsentry/sentry-go/pull/543)) -- Add `Span.GetTransaction()` method ([#558](https://github.com/getsentry/sentry-go/pull/558)) - -## 0.17.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.17.0. -This release contains a new `BeforeSendTransaction` hook option and corrects two regressions introduced in `0.16.0`. - -### Features - -- Add `BeforeSendTransaction` hook to `ClientOptions` ([#517](https://github.com/getsentry/sentry-go/pull/517)) - - Here's [an example](https://github.com/getsentry/sentry-go/blob/master/_examples/http/main.go#L56-L66) of how BeforeSendTransaction can be used to modify or drop transaction events. - -### Bug Fixes - -- Do not crash in Span.Finish() when the Client is empty [#520](https://github.com/getsentry/sentry-go/pull/520) - - Fixes [#518](https://github.com/getsentry/sentry-go/issues/518) -- Attach non-PII/non-sensitive request headers to events when `ClientOptions.SendDefaultPii` is set to `false` ([#524](https://github.com/getsentry/sentry-go/pull/524)) - - Fixes [#523](https://github.com/getsentry/sentry-go/issues/523) - -### Misc - -- Clarify how to handle logrus.Fatalf events ([#501](https://github.com/getsentry/sentry-go/pull/501/)) -- Rename the `examples` directory to `_examples` ([#521](https://github.com/getsentry/sentry-go/pull/521)) - - This removes an indirect dependency to `github.com/golang-jwt/jwt` - -## 0.16.0 - -The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.16.0. -Due to ongoing work towards a stable API for `v1.0.0`, we sadly had to include **two breaking changes** in this release. - -### Breaking Changes - -- Add `EnableTracing`, a boolean option flag to enable performance monitoring (`false` by default). - - If you're using `TracesSampleRate` or `TracesSampler`, this option is **required** to enable performance monitoring. - - ```go - sentry.Init(sentry.ClientOptions{ - EnableTracing: true, - TracesSampleRate: 1.0, - }) - ``` -- Unify TracesSampler [#498](https://github.com/getsentry/sentry-go/pull/498) - - `TracesSampler` was changed to a callback that must return a `float64` between `0.0` and `1.0`. - - For example, you can apply a sample rate of `1.0` (100%) to all `/api` transactions, and a sample rate of `0.5` (50%) to all other transactions. - You can read more about this in our [SDK docs](https://docs.sentry.io/platforms/go/configuration/filtering/#using-sampling-to-filter-transaction-events). - - ```go - sentry.Init(sentry.ClientOptions{ - TracesSampler: sentry.TracesSampler(func(ctx sentry.SamplingContext) float64 { - hub := sentry.GetHubFromContext(ctx.Span.Context()) - name := hub.Scope().Transaction() - - if strings.HasPrefix(name, "GET /api") { - return 1.0 - } - - return 0.5 - }), - } - ``` - -### Features - -- Send errors logged with [Logrus](https://github.com/sirupsen/logrus) to Sentry. - - Have a look at our [logrus examples](https://github.com/getsentry/sentry-go/blob/master/_examples/logrus/main.go) on how to use the integration. -- Add support for Dynamic Sampling [#491](https://github.com/getsentry/sentry-go/pull/491) - - You can read more about Dynamic Sampling in our [product docs](https://docs.sentry.io/product/data-management-settings/dynamic-sampling/). -- Add detailed logging about the reason transactions are being dropped. - - You can enable SDK logging via `sentry.ClientOptions.Debug: true`. - -### Bug Fixes - -- Do not clone the hub when calling `StartTransaction` [#505](https://github.com/getsentry/sentry-go/pull/505) - - Fixes [#502](https://github.com/getsentry/sentry-go/issues/502) - -## 0.15.0 - -- fix: Scope values should not override Event values (#446) -- feat: Make maximum amount of spans configurable (#460) -- feat: Add a method to start a transaction (#482) -- feat: Extend User interface by adding Data, Name and Segment (#483) -- feat: Add ClientOptions.SendDefaultPII (#485) - -## 0.14.0 - -- feat: Add function to continue from trace string (#434) -- feat: Add `max-depth` options (#428) -- *[breaking]* ref: Use a `Context` type mapping to a `map[string]interface{}` for all event contexts (#444) -- *[breaking]* ref: Replace deprecated `ioutil` pkg with `os` & `io` (#454) -- ref: Optimize `stacktrace.go` from size and speed (#467) -- ci: Test against `go1.19` and `go1.18`, drop `go1.16` and `go1.15` support (#432, #477) -- deps: Dependency update to fix CVEs (#462, #464, #477) - -_NOTE:_ This version drops support for Go 1.16 and Go 1.15. The currently supported Go versions are the last 3 stable releases: 1.19, 1.18 and 1.17. - -## v0.13.0 - -- ref: Change DSN ProjectID to be a string (#420) -- fix: When extracting PCs from stack frames, try the `PC` field (#393) -- build: Bump gin-gonic/gin from v1.4.0 to v1.7.7 (#412) -- build: Bump Go version in go.mod (#410) -- ci: Bump golangci-lint version in GH workflow (#419) -- ci: Update GraphQL config with appropriate permissions (#417) -- ci: ci: Add craft release automation (#422) - -## v0.12.0 - -- feat: Automatic Release detection (#363, #369, #386, #400) -- fix: Do not change Hub.lastEventID for transactions (#379) -- fix: Do not clear LastEventID when events are dropped (#382) -- Updates to documentation (#366, #385) - -_NOTE:_ -This version drops support for Go 1.14, however no changes have been made that would make the SDK not work with Go 1.14. The currently supported Go versions are the last 3 stable releases: 1.15, 1.16 and 1.17. -There are two behavior changes related to `LastEventID`, both of which were intended to align the behavior of the Sentry Go SDK with other Sentry SDKs. -The new [automatic release detection feature](https://github.com/getsentry/sentry-go/issues/335) makes it easier to use Sentry and separate events per release without requiring extra work from users. We intend to improve this functionality in a future release by utilizing information that will be available in runtime starting with Go 1.18. The tracking issue is [#401](https://github.com/getsentry/sentry-go/issues/401). - -## v0.11.0 - -- feat(transports): Category-based Rate Limiting ([#354](https://github.com/getsentry/sentry-go/pull/354)) -- feat(transports): Report User-Agent identifying SDK ([#357](https://github.com/getsentry/sentry-go/pull/357)) -- fix(scope): Include event processors in clone ([#349](https://github.com/getsentry/sentry-go/pull/349)) -- Improvements to `go doc` documentation ([#344](https://github.com/getsentry/sentry-go/pull/344), [#350](https://github.com/getsentry/sentry-go/pull/350), [#351](https://github.com/getsentry/sentry-go/pull/351)) -- Miscellaneous changes to our testing infrastructure with GitHub Actions - ([57123a40](https://github.com/getsentry/sentry-go/commit/57123a409be55f61b1d5a6da93c176c55a399ad0), [#128](https://github.com/getsentry/sentry-go/pull/128), [#338](https://github.com/getsentry/sentry-go/pull/338), [#345](https://github.com/getsentry/sentry-go/pull/345), [#346](https://github.com/getsentry/sentry-go/pull/346), [#352](https://github.com/getsentry/sentry-go/pull/352), [#353](https://github.com/getsentry/sentry-go/pull/353), [#355](https://github.com/getsentry/sentry-go/pull/355)) - -_NOTE:_ -This version drops support for Go 1.13. The currently supported Go versions are the last 3 stable releases: 1.14, 1.15 and 1.16. -Users of the tracing functionality (`StartSpan`, etc) should upgrade to this version to benefit from separate rate limits for errors and transactions. -There are no breaking changes and upgrading should be a smooth experience for all users. - -## v0.10.0 - -- feat: Debug connection reuse (#323) -- fix: Send root span data as `Event.Extra` (#329) -- fix: Do not double sample transactions (#328) -- fix: Do not override trace context of transactions (#327) -- fix: Drain and close API response bodies (#322) -- ci: Run tests against Go tip (#319) -- ci: Move away from Travis in favor of GitHub Actions (#314) (#321) - -## v0.9.0 - -- feat: Initial tracing and performance monitoring support (#285) -- doc: Revamp sentryhttp documentation (#304) -- fix: Hub.PopScope never empties the scope stack (#300) -- ref: Report Event.Timestamp in local time (#299) -- ref: Report Breadcrumb.Timestamp in local time (#299) - -_NOTE:_ -This version introduces support for [Sentry's Performance Monitoring](https://docs.sentry.io/platforms/go/performance/). -The new tracing capabilities are beta, and we plan to expand them on future versions. Feedback is welcome, please open new issues on GitHub. -The `sentryhttp` package got better API docs, an [updated usage example](https://github.com/getsentry/sentry-go/tree/master/_examples/http) and support for creating automatic transactions as part of Performance Monitoring. - -## v0.8.0 - -- build: Bump required version of Iris (#296) -- fix: avoid unnecessary allocation in Client.processEvent (#293) -- doc: Remove deprecation of sentryhttp.HandleFunc (#284) -- ref: Update sentryhttp example (#283) -- doc: Improve documentation of sentryhttp package (#282) -- doc: Clarify SampleRate documentation (#279) -- fix: Remove RawStacktrace (#278) -- docs: Add example of custom HTTP transport -- ci: Test against go1.15, drop go1.12 support (#271) - -_NOTE:_ -This version comes with a few updates. Some examples and documentation have been -improved. We've bumped the supported version of the Iris framework to avoid -LGPL-licensed modules in the module dependency graph. -The `Exception.RawStacktrace` and `Thread.RawStacktrace` fields have been -removed to conform to Sentry's ingestion protocol, only `Exception.Stacktrace` -and `Thread.Stacktrace` should appear in user code. - -## v0.7.0 - -- feat: Include original error when event cannot be encoded as JSON (#258) -- feat: Use Hub from request context when available (#217, #259) -- feat: Extract stack frames from golang.org/x/xerrors (#262) -- feat: Make Environment Integration preserve existing context data (#261) -- feat: Recover and RecoverWithContext with arbitrary types (#268) -- feat: Report bad usage of CaptureMessage and CaptureEvent (#269) -- feat: Send debug logging to stderr by default (#266) -- feat: Several improvements to documentation (#223, #245, #250, #265) -- feat: Example of Recover followed by panic (#241, #247) -- feat: Add Transactions and Spans (to support OpenTelemetry Sentry Exporter) (#235, #243, #254) -- fix: Set either Frame.Filename or Frame.AbsPath (#233) -- fix: Clone requestBody to new Scope (#244) -- fix: Synchronize access and mutation of Hub.lastEventID (#264) -- fix: Avoid repeated syscalls in prepareEvent (#256) -- fix: Do not allocate new RNG for every event (#256) -- fix: Remove stale replace directive in go.mod (#255) -- fix(http): Deprecate HandleFunc, remove duplication (#260) - -_NOTE:_ -This version comes packed with several fixes and improvements and no breaking -changes. -Notably, there is a change in how the SDK reports file names in stack traces -that should resolve any ambiguity when looking at stack traces and using the -Suspect Commits feature. -We recommend all users to upgrade. - -## v0.6.1 - -- fix: Use NewEvent to init Event struct (#220) - -_NOTE:_ -A change introduced in v0.6.0 with the intent of avoiding allocations made a -pattern used in official examples break in certain circumstances (attempting -to write to a nil map). -This release reverts the change such that maps in the Event struct are always -allocated. - -## v0.6.0 - -- feat: Read module dependencies from runtime/debug (#199) -- feat: Support chained errors using Unwrap (#206) -- feat: Report chain of errors when available (#185) -- **[breaking]** fix: Accept http.RoundTripper to customize transport (#205) - Before the SDK accepted a concrete value of type `*http.Transport` in - `ClientOptions`, now it accepts any value implementing the `http.RoundTripper` - interface. Note that `*http.Transport` implements `http.RoundTripper`, so most - code bases will continue to work unchanged. - Users of custom transport gain the ability to pass in other implementations of - `http.RoundTripper` and may be able to simplify their code bases. -- fix: Do not panic when scope event processor drops event (#192) -- **[breaking]** fix: Use time.Time for timestamps (#191) - Users of sentry-go typically do not need to manipulate timestamps manually. - For those who do, the field type changed from `int64` to `time.Time`, which - should be more convenient to use. The recommended way to get the current time - is `time.Now().UTC()`. -- fix: Report usage error including stack trace (#189) -- feat: Add Exception.ThreadID field (#183) -- ci: Test against Go 1.14, drop 1.11 (#170) -- feat: Limit reading bytes from request bodies (#168) -- **[breaking]** fix: Rename fasthttp integration package sentryhttp => sentryfasthttp - The current recommendation is to use a named import, in which case existing - code should not require any change: - ```go - package main - - import ( - "fmt" - - "github.com/getsentry/sentry-go" - sentryfasthttp "github.com/getsentry/sentry-go/fasthttp" - "github.com/valyala/fasthttp" - ) - ``` - -_NOTE:_ -This version includes some new features and a few breaking changes, none of -which should pose troubles with upgrading. Most code bases should be able to -upgrade without any changes. - -## v0.5.1 - -- fix: Ignore err.Cause() when it is nil (#160) - -## v0.5.0 - -- fix: Synchronize access to HTTPTransport.disabledUntil (#158) -- docs: Update Flush documentation (#153) -- fix: HTTPTransport.Flush panic and data race (#140) - -_NOTE:_ -This version changes the implementation of the default transport, modifying the -behavior of `sentry.Flush`. The previous behavior was to wait until there were -no buffered events; new concurrent events kept `Flush` from returning. The new -behavior is to wait until the last event prior to the call to `Flush` has been -sent or the timeout; new concurrent events have no effect. The new behavior is -inline with the [Unified API -Guidelines](https://docs.sentry.io/development/sdk-dev/unified-api/). - -We have updated the documentation and examples to clarify that `Flush` is meant -to be called typically only once before program termination, to wait for -in-flight events to be sent to Sentry. Calling `Flush` after every event is not -recommended, as it introduces unnecessary latency to the surrounding function. -Please verify the usage of `sentry.Flush` in your code base. - -## v0.4.0 - -- fix(stacktrace): Correctly report package names (#127) -- fix(stacktrace): Do not rely on AbsPath of files (#123) -- build: Require github.com/ugorji/go@v1.1.7 (#110) -- fix: Correctly store last event id (#99) -- fix: Include request body in event payload (#94) -- build: Reset go.mod version to 1.11 (#109) -- fix: Eliminate data race in modules integration (#105) -- feat: Add support for path prefixes in the DSN (#102) -- feat: Add HTTPClient option (#86) -- feat: Extract correct type and value from top-most error (#85) -- feat: Check for broken pipe errors in Gin integration (#82) -- fix: Client.CaptureMessage accept nil EventModifier (#72) - -## v0.3.1 - -- feat: Send extra information exposed by the Go runtime (#76) -- fix: Handle new lines in module integration (#65) -- fix: Make sure that cache is locked when updating for contextifyFramesIntegration -- ref: Update Iris integration and example to version 12 -- misc: Remove indirect dependencies in order to move them to separate go.mod files - -## v0.3.0 - -- feat: Retry event marshaling without contextual data if the first pass fails -- fix: Include `url.Parse` error in `DsnParseError` -- fix: Make more `Scope` methods safe for concurrency -- fix: Synchronize concurrent access to `Hub.client` -- ref: Remove mutex from `Scope` exported API -- ref: Remove mutex from `Hub` exported API -- ref: Compile regexps for `filterFrames` only once -- ref: Change `SampleRate` type to `float64` -- doc: `Scope.Clear` not safe for concurrent use -- ci: Test sentry-go with `go1.13`, drop `go1.10` - -_NOTE:_ -This version removes some of the internal APIs that landed publicly (namely `Hub/Scope` mutex structs) and may require (but shouldn't) some changes to your code. -It's not done through major version update, as we are still in `0.x` stage. - -## v0.2.1 - -- fix: Run `Contextify` integration on `Threads` as well - -## v0.2.0 - -- feat: Add `SetTransaction()` method on the `Scope` -- feat: `fasthttp` framework support with `sentryfasthttp` package -- fix: Add `RWMutex` locks to internal `Hub` and `Scope` changes - -## v0.1.3 - -- feat: Move frames context reading into `contextifyFramesIntegration` (#28) - -_NOTE:_ -In case of any performance issues due to source contexts IO, you can let us know and turn off the integration in the meantime with: - -```go -sentry.Init(sentry.ClientOptions{ - Integrations: func(integrations []sentry.Integration) []sentry.Integration { - var filteredIntegrations []sentry.Integration - for _, integration := range integrations { - if integration.Name() == "ContextifyFrames" { - continue - } - filteredIntegrations = append(filteredIntegrations, integration) - } - return filteredIntegrations - }, -}) -``` - -## v0.1.2 - -- feat: Better source code location resolution and more useful inapp frames (#26) -- feat: Use `noopTransport` when no `Dsn` provided (#27) -- ref: Allow empty `Dsn` instead of returning an error (#22) -- fix: Use `NewScope` instead of literal struct inside a `scope.Clear` call (#24) -- fix: Add to `WaitGroup` before the request is put inside a buffer (#25) - -## v0.1.1 - -- fix: Check for initialized `Client` in `AddBreadcrumbs` (#20) -- build: Bump version when releasing with Craft (#19) - -## v0.1.0 - -- First stable release! \o/ - -## v0.0.1-beta.5 - -- feat: **[breaking]** Add `NewHTTPTransport` and `NewHTTPSyncTransport` which accepts all transport options -- feat: New `HTTPSyncTransport` that blocks after each call -- feat: New `Echo` integration -- ref: **[breaking]** Remove `BufferSize` option from `ClientOptions` and move it to `HTTPTransport` instead -- ref: Export default `HTTPTransport` -- ref: Export `net/http` integration handler -- ref: Set `Request` instantly in the package handlers, not in `recoverWithSentry` so it can be accessed later on -- ci: Add craft config - -## v0.0.1-beta.4 - -- feat: `IgnoreErrors` client option and corresponding integration -- ref: Reworked `net/http` integration, wrote better example and complete readme -- ref: Reworked `Gin` integration, wrote better example and complete readme -- ref: Reworked `Iris` integration, wrote better example and complete readme -- ref: Reworked `Negroni` integration, wrote better example and complete readme -- ref: Reworked `Martini` integration, wrote better example and complete readme -- ref: Remove `Handle()` from frameworks handlers and return it directly from New - -## v0.0.1-beta.3 - -- feat: `Iris` framework support with `sentryiris` package -- feat: `Gin` framework support with `sentrygin` package -- feat: `Martini` framework support with `sentrymartini` package -- feat: `Negroni` framework support with `sentrynegroni` package -- feat: Add `Hub.Clone()` for easier frameworks integration -- feat: Return `EventID` from `Recovery` methods -- feat: Add `NewScope` and `NewEvent` functions and use them in the whole codebase -- feat: Add `AddEventProcessor` to the `Client` -- fix: Operate on requests body copy instead of the original -- ref: Try to read source files from the root directory, based on the filename as well, to make it work on AWS Lambda -- ref: Remove `gocertifi` dependence and document how to provide your own certificates -- ref: **[breaking]** Remove `Decorate` and `DecorateFunc` methods in favor of `sentryhttp` package -- ref: **[breaking]** Allow for integrations to live on the client, by passing client instance in `SetupOnce` method -- ref: **[breaking]** Remove `GetIntegration` from the `Hub` -- ref: **[breaking]** Remove `GlobalEventProcessors` getter from the public API - -## v0.0.1-beta.2 - -- feat: Add `AttachStacktrace` client option to include stacktrace for messages -- feat: Add `BufferSize` client option to configure transport buffer size -- feat: Add `SetRequest` method on a `Scope` to control `Request` context data -- feat: Add `FromHTTPRequest` for `Request` type for easier extraction -- ref: Extract `Request` information more accurately -- fix: Attach `ServerName`, `Release`, `Dist`, `Environment` options to the event -- fix: Don't log events dropped due to full transport buffer as sent -- fix: Don't panic and create an appropriate event when called `CaptureException` or `Recover` with `nil` value - -## v0.0.1-beta - -- Initial release diff --git a/vendor/github.com/getsentry/sentry-go/CONTRIBUTING.md b/vendor/github.com/getsentry/sentry-go/CONTRIBUTING.md deleted file mode 100644 index 9808f1862b5..00000000000 --- a/vendor/github.com/getsentry/sentry-go/CONTRIBUTING.md +++ /dev/null @@ -1,98 +0,0 @@ -# Contributing to sentry-go - -Hey, thank you if you're reading this, we welcome your contribution! - -## Sending a Pull Request - -Please help us save time when reviewing your PR by following this simple -process: - -1. Is your PR a simple typo fix? Read no further, **click that green "Create - pull request" button**! - -2. For more complex PRs that involve behavior changes or new APIs, please - consider [opening an **issue**][new-issue] describing the problem you're - trying to solve if there's not one already. - - A PR is often one specific solution to a problem and sometimes talking about - the problem unfolds new possible solutions. Remember we will be responsible - for maintaining the changes later. - -3. Fixing a bug and changing a behavior? Please add automated tests to prevent - future regression. - -4. Practice writing good commit messages. We have [commit - guidelines][commit-guide]. - -5. We have [guidelines for PR submitters][pr-guide]. A short summary: - - - Good PR descriptions are very helpful and most of the time they include - **why** something is done and why done in this particular way. Also list - other possible solutions that were considered and discarded. - - Be your own first reviewer. Make sure your code compiles and passes the - existing tests. - -[new-issue]: https://github.com/getsentry/sentry-go/issues/new/choose -[commit-guide]: https://develop.sentry.dev/code-review/#commit-guidelines -[pr-guide]: https://develop.sentry.dev/code-review/#guidelines-for-submitters - -Please also read through our [SDK Development docs](https://develop.sentry.dev/sdk/). -It contains information about SDK features, expected payloads and best practices for -contributing to Sentry SDKs. - -## Community - -The public-facing channels for support and development of Sentry SDKs can be found on [Discord](https://discord.gg/Ww9hbqr). - -## Testing - -```console -$ go test -``` - -### Watch mode - -Use: https://github.com/cespare/reflex - -```console -$ reflex -g '*.go' -d "none" -- sh -c 'printf "\n"; go test' -``` - -### With data race detection - -```console -$ go test -race -``` - -### Coverage - -```console -$ go test -race -coverprofile=coverage.txt -covermode=atomic && go tool cover -html coverage.txt -``` - -## Linting - -Lint with [`golangci-lint`](https://github.com/golangci/golangci-lint): - -```console -$ golangci-lint run -``` - -## Release - -1. Update `CHANGELOG.md` with new version in `vX.X.X` format title and list of changes. - - The command below can be used to get a list of changes since the last tag, with the format used in `CHANGELOG.md`: - - ```console - $ git log --no-merges --format=%s $(git describe --abbrev=0).. | sed 's/^/- /' - ``` - -2. Commit with `misc: vX.X.X changelog` commit message and push to `master`. - -3. Let [`craft`](https://github.com/getsentry/craft) do the rest: - - ```console - $ craft prepare X.X.X - $ craft publish X.X.X - ``` diff --git a/vendor/github.com/getsentry/sentry-go/LICENSE b/vendor/github.com/getsentry/sentry-go/LICENSE deleted file mode 100644 index b1b358e418b..00000000000 --- a/vendor/github.com/getsentry/sentry-go/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2019 Functional Software, Inc. dba Sentry - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/vendor/github.com/getsentry/sentry-go/MIGRATION.md b/vendor/github.com/getsentry/sentry-go/MIGRATION.md deleted file mode 100644 index 2c30d6288a6..00000000000 --- a/vendor/github.com/getsentry/sentry-go/MIGRATION.md +++ /dev/null @@ -1,3 +0,0 @@ -# `raven-go` to `sentry-go` Migration Guide - -A [`raven-go` to `sentry-go` migration guide](https://docs.sentry.io/platforms/go/migration/) is available at the official Sentry documentation site. diff --git a/vendor/github.com/getsentry/sentry-go/Makefile b/vendor/github.com/getsentry/sentry-go/Makefile deleted file mode 100644 index d5aaa298903..00000000000 --- a/vendor/github.com/getsentry/sentry-go/Makefile +++ /dev/null @@ -1,93 +0,0 @@ -.DEFAULT_GOAL := help - -MKFILE_PATH := $(abspath $(lastword $(MAKEFILE_LIST))) -MKFILE_DIR := $(dir $(MKFILE_PATH)) -ALL_GO_MOD_DIRS := $(shell find . -type f -name 'go.mod' -exec dirname {} \; | sort) -GO = go -TIMEOUT = 300 - -# Parse Makefile and display the help -help: ## Show help - @grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' -.PHONY: help - -build: ## Build everything - for dir in $(ALL_GO_MOD_DIRS); do \ - cd "$${dir}"; \ - echo ">>> Running 'go build' for module: $${dir}"; \ - go build ./...; \ - done; -.PHONY: build - -### Tests (inspired by https://github.com/open-telemetry/opentelemetry-go/blob/main/Makefile) -TEST_TARGETS := test-short test-verbose test-race -test-race: ARGS=-race -test-short: ARGS=-short -test-verbose: ARGS=-v -race -$(TEST_TARGETS): test -test: $(ALL_GO_MOD_DIRS:%=test/%) ## Run tests -test/%: DIR=$* -test/%: - @echo ">>> Running tests for module: $(DIR)" - @# We use '-count=1' to disable test caching. - (cd $(DIR) && $(GO) test -count=1 -timeout $(TIMEOUT)s $(ARGS) ./...) -.PHONY: $(TEST_TARGETS) test - -# Coverage -COVERAGE_MODE = atomic -COVERAGE_PROFILE = coverage.out -COVERAGE_REPORT_DIR = .coverage -COVERAGE_REPORT_DIR_ABS = "$(MKFILE_DIR)/$(COVERAGE_REPORT_DIR)" -$(COVERAGE_REPORT_DIR): - mkdir -p $(COVERAGE_REPORT_DIR) -clean-report-dir: $(COVERAGE_REPORT_DIR) - test $(COVERAGE_REPORT_DIR) && rm -f $(COVERAGE_REPORT_DIR)/* -test-coverage: $(COVERAGE_REPORT_DIR) clean-report-dir ## Test with coverage enabled - set -e ; \ - for dir in $(ALL_GO_MOD_DIRS); do \ - echo ">>> Running tests with coverage for module: $${dir}"; \ - DIR_ABS=$$(python -c 'import os, sys; print(os.path.realpath(sys.argv[1]))' $${dir}) ; \ - REPORT_NAME=$$(basename $${DIR_ABS}); \ - (cd "$${dir}" && \ - $(GO) test -count=1 -timeout $(TIMEOUT)s -coverpkg=./... -covermode=$(COVERAGE_MODE) -coverprofile="$(COVERAGE_PROFILE)" ./... && \ - cp $(COVERAGE_PROFILE) "$(COVERAGE_REPORT_DIR_ABS)/$${REPORT_NAME}_$(COVERAGE_PROFILE)" && \ - $(GO) tool cover -html=$(COVERAGE_PROFILE) -o coverage.html); \ - done; -.PHONY: test-coverage clean-report-dir -test-race-coverage: $(COVERAGE_REPORT_DIR) clean-report-dir ## Run tests with race detection and coverage - set -e ; \ - for dir in $(ALL_GO_MOD_DIRS); do \ - echo ">>> Running tests with race detection and coverage for module: $${dir}"; \ - DIR_ABS=$$(python -c 'import os, sys; print(os.path.realpath(sys.argv[1]))' $${dir}) ; \ - REPORT_NAME=$$(basename $${DIR_ABS}); \ - (cd "$${dir}" && \ - $(GO) test -count=1 -timeout $(TIMEOUT)s -race -coverpkg=./... -covermode=$(COVERAGE_MODE) -coverprofile="$(COVERAGE_PROFILE)" ./... && \ - cp $(COVERAGE_PROFILE) "$(COVERAGE_REPORT_DIR_ABS)/$${REPORT_NAME}_$(COVERAGE_PROFILE)" && \ - $(GO) tool cover -html=$(COVERAGE_PROFILE) -o coverage.html); \ - done; -.PHONY: test-race-coverage -mod-tidy: ## Check go.mod tidiness - set -e ; \ - for dir in $(ALL_GO_MOD_DIRS); do \ - echo ">>> Running 'go mod tidy' for module: $${dir}"; \ - (cd "$${dir}" && GOTOOLCHAIN=local go mod tidy -go=1.24.0 -compat=1.24.0); \ - done; \ - git diff --exit-code; -.PHONY: mod-tidy - -vet: ## Run "go vet" - set -e ; \ - for dir in $(ALL_GO_MOD_DIRS); do \ - echo ">>> Running 'go vet' for module: $${dir}"; \ - (cd "$${dir}" && go vet ./...); \ - done; -.PHONY: vet - - -lint: ## Lint (using "golangci-lint") - golangci-lint run -.PHONY: lint - -fmt: ## Format all Go files - gofmt -l -w -s . -.PHONY: fmt diff --git a/vendor/github.com/getsentry/sentry-go/README.md b/vendor/github.com/getsentry/sentry-go/README.md deleted file mode 100644 index 1941fa06465..00000000000 --- a/vendor/github.com/getsentry/sentry-go/README.md +++ /dev/null @@ -1,107 +0,0 @@ -

- - - - - Sentry - - -

- -# Official Sentry SDK for Go - -[![Build Status](https://github.com/getsentry/sentry-go/actions/workflows/test.yml/badge.svg)](https://github.com/getsentry/sentry-go/actions/workflows/test.yml) -[![Go Report Card](https://goreportcard.com/badge/github.com/getsentry/sentry-go)](https://goreportcard.com/report/github.com/getsentry/sentry-go) -[![Discord](https://img.shields.io/discord/621778831602221064)](https://discord.gg/Ww9hbqr) -[![X Follow](https://img.shields.io/twitter/follow/sentry?label=sentry&style=social)](https://x.com/intent/follow?screen_name=sentry) -[![go.dev](https://img.shields.io/badge/go.dev-pkg-007d9c.svg?style=flat)](https://pkg.go.dev/github.com/getsentry/sentry-go) - -`sentry-go` provides a Sentry client implementation for the Go programming -language. This is the next generation of the Go SDK for [Sentry](https://sentry.io/), -intended to replace the `raven-go` package. - -> Looking for the old `raven-go` SDK documentation? See the Legacy client section [here](https://docs.sentry.io/clients/go/). -> If you want to start using `sentry-go` instead, check out the [migration guide](https://docs.sentry.io/platforms/go/migration/). - -## Requirements - -The only requirement is a Go compiler. - -We verify this package against the 3 most recent releases of Go. Those are the -supported versions. The exact versions are defined in -[`GitHub workflow`](.github/workflows/test.yml). - -In addition, we run tests against the current master branch of the Go toolchain, -though support for this configuration is best-effort. - -## Installation - -`sentry-go` can be installed like any other Go library through `go get`: - -```console -$ go get github.com/getsentry/sentry-go@latest -``` - -Check out the [list of released versions](https://github.com/getsentry/sentry-go/releases). - -## Configuration - -To use `sentry-go`, you’ll need to import the `sentry-go` package and initialize -it with your DSN and other [options](https://pkg.go.dev/github.com/getsentry/sentry-go#ClientOptions). - -If not specified in the SDK initialization, the -[DSN](https://docs.sentry.io/product/sentry-basics/dsn-explainer/), -[Release](https://docs.sentry.io/product/releases/) and -[Environment](https://docs.sentry.io/product/sentry-basics/environments/) -are read from the environment variables `SENTRY_DSN`, `SENTRY_RELEASE` and -`SENTRY_ENVIRONMENT`, respectively. - -More on this in the [Configuration section of the official Sentry Go SDK documentation](https://docs.sentry.io/platforms/go/configuration/). - -## Usage - -The SDK supports reporting errors and tracking application performance. - -To get started, have a look at one of our [examples](_examples/): -- [Basic error instrumentation](_examples/basic/main.go) -- [Error and tracing for HTTP servers](_examples/http/main.go) - -We also provide a [complete API reference](https://pkg.go.dev/github.com/getsentry/sentry-go). - -For more detailed information about how to get the most out of `sentry-go`, -check out the official documentation: - -- [Sentry Go SDK documentation](https://docs.sentry.io/platforms/go/) -- Guides: - - [net/http](https://docs.sentry.io/platforms/go/guides/http/) - - [echo](https://docs.sentry.io/platforms/go/guides/echo/) - - [fasthttp](https://docs.sentry.io/platforms/go/guides/fasthttp/) - - [fiber](https://docs.sentry.io/platforms/go/guides/fiber/) - - [gin](https://docs.sentry.io/platforms/go/guides/gin/) - - [iris](https://docs.sentry.io/platforms/go/guides/iris/) - - [logrus](https://docs.sentry.io/platforms/go/guides/logrus/) - - [negroni](https://docs.sentry.io/platforms/go/guides/negroni/) - - [slog](https://docs.sentry.io/platforms/go/guides/slog/) - - [zerolog](https://docs.sentry.io/platforms/go/guides/zerolog/) - -## Resources - -- [Bug Tracker](https://github.com/getsentry/sentry-go/issues) -- [GitHub Project](https://github.com/getsentry/sentry-go) -- [![go.dev](https://img.shields.io/badge/go.dev-pkg-007d9c.svg?style=flat)](https://pkg.go.dev/github.com/getsentry/sentry-go) -- [![Documentation](https://img.shields.io/badge/documentation-sentry.io-green.svg)](https://docs.sentry.io/platforms/go/) -- [![Discussions](https://img.shields.io/github/discussions/getsentry/sentry-go.svg)](https://github.com/getsentry/sentry-go/discussions) -- [![Discord](https://img.shields.io/discord/621778831602221064)](https://discord.gg/Ww9hbqr) -- [![Stack Overflow](https://img.shields.io/badge/stack%20overflow-sentry-green.svg)](http://stackoverflow.com/questions/tagged/sentry) -- [![Twitter Follow](https://img.shields.io/twitter/follow/getsentry?label=getsentry&style=social)](https://twitter.com/intent/follow?screen_name=getsentry) - -## License - -Licensed under -[The MIT License](https://opensource.org/licenses/mit/), see -[`LICENSE`](LICENSE). - -## Community - -Join Sentry's [`#go` channel on Discord](https://discord.gg/Ww9hbqr) to get -involved and help us improve the SDK! diff --git a/vendor/github.com/getsentry/sentry-go/attribute/builder.go b/vendor/github.com/getsentry/sentry-go/attribute/builder.go deleted file mode 100644 index d2bd9a2639e..00000000000 --- a/vendor/github.com/getsentry/sentry-go/attribute/builder.go +++ /dev/null @@ -1,36 +0,0 @@ -package attribute - -type Builder struct { - Key string - Value Value -} - -// String returns a Builder for a string value. -func String(key, value string) Builder { - return Builder{key, StringValue(value)} -} - -// Int64 returns a Builder for an int64. -func Int64(key string, value int64) Builder { - return Builder{key, Int64Value(value)} -} - -// Int returns a Builder for an int64. -func Int(key string, value int) Builder { - return Builder{key, IntValue(value)} -} - -// Float64 returns a Builder for a float64. -func Float64(key string, v float64) Builder { - return Builder{key, Float64Value(v)} -} - -// Bool returns a Builder for a boolean. -func Bool(key string, v bool) Builder { - return Builder{key, BoolValue(v)} -} - -// Valid checks for valid key and type. -func (b *Builder) Valid() bool { - return len(b.Key) > 0 && b.Value.Type() != INVALID -} diff --git a/vendor/github.com/getsentry/sentry-go/attribute/rawhelpers.go b/vendor/github.com/getsentry/sentry-go/attribute/rawhelpers.go deleted file mode 100644 index 8ba7a88995f..00000000000 --- a/vendor/github.com/getsentry/sentry-go/attribute/rawhelpers.go +++ /dev/null @@ -1,49 +0,0 @@ -// Copied from https://github.com/open-telemetry/opentelemetry-go/blob/cc43e01c27892252aac9a8f20da28cdde957a289/attribute/rawhelpers.go -// Copyright The OpenTelemetry Authors -// -// 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 attribute - -import ( - "math" -) - -func boolToRaw(b bool) uint64 { // b is not a control flag. - if b { - return 1 - } - return 0 -} - -func rawToBool(r uint64) bool { - return r != 0 -} - -func int64ToRaw(i int64) uint64 { - // Assumes original was a valid int64 (overflow not checked). - return uint64(i) // nolint: gosec -} - -func rawToInt64(r uint64) int64 { - // Assumes original was a valid int64 (overflow not checked). - return int64(r) // nolint: gosec -} - -func float64ToRaw(f float64) uint64 { - return math.Float64bits(f) -} - -func rawToFloat64(r uint64) float64 { - return math.Float64frombits(r) -} diff --git a/vendor/github.com/getsentry/sentry-go/attribute/value.go b/vendor/github.com/getsentry/sentry-go/attribute/value.go deleted file mode 100644 index 49431e03afa..00000000000 --- a/vendor/github.com/getsentry/sentry-go/attribute/value.go +++ /dev/null @@ -1,207 +0,0 @@ -// Adapted from https://github.com/open-telemetry/opentelemetry-go/blob/cc43e01c27892252aac9a8f20da28cdde957a289/attribute/value.go -// -// Copyright The OpenTelemetry Authors -// -// 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 attribute - -import ( - "encoding/json" - "fmt" - "strconv" -) - -// Type describes the type of the data Value holds. -type Type int // redefines builtin Type. - -// Value represents the value part in key-value pairs. -type Value struct { - vtype Type - numeric uint64 - stringly string -} - -const ( - // INVALID is used for a Value with no value set. - INVALID Type = iota - // BOOL is a boolean Type Value. - BOOL - // INT64 is a 64-bit signed integral Type Value. - INT64 - // FLOAT64 is a 64-bit floating point Type Value. - FLOAT64 - // STRING is a string Type Value. - STRING - // UINT64 is a 64-bit unsigned integral Type Value. - // - // This type is intentionally not exposed through the Builder API. - UINT64 -) - -// BoolValue creates a BOOL Value. -func BoolValue(v bool) Value { - return Value{ - vtype: BOOL, - numeric: boolToRaw(v), - } -} - -// IntValue creates an INT64 Value. -func IntValue(v int) Value { - return Int64Value(int64(v)) -} - -// Int64Value creates an INT64 Value. -func Int64Value(v int64) Value { - return Value{ - vtype: INT64, - numeric: int64ToRaw(v), - } -} - -// Float64Value creates a FLOAT64 Value. -func Float64Value(v float64) Value { - return Value{ - vtype: FLOAT64, - numeric: float64ToRaw(v), - } -} - -// StringValue creates a STRING Value. -func StringValue(v string) Value { - return Value{ - vtype: STRING, - stringly: v, - } -} - -// Uint64Value creates a UINT64 Value. -// -// This constructor is intentionally not exposed through the Builder API. -func Uint64Value(v uint64) Value { - return Value{ - vtype: UINT64, - numeric: v, - } -} - -// Type returns a type of the Value. -func (v Value) Type() Type { - return v.vtype -} - -// AsBool returns the bool value. Make sure that the Value's type is -// BOOL. -func (v Value) AsBool() bool { - return rawToBool(v.numeric) -} - -// AsInt64 returns the int64 value. Make sure that the Value's type is -// INT64. -func (v Value) AsInt64() int64 { - return rawToInt64(v.numeric) -} - -// AsFloat64 returns the float64 value. Make sure that the Value's -// type is FLOAT64. -func (v Value) AsFloat64() float64 { - return rawToFloat64(v.numeric) -} - -// AsString returns the string value. Make sure that the Value's type -// is STRING. -func (v Value) AsString() string { - return v.stringly -} - -// AsUint64 returns the uint64 value. Make sure that the Value's type is -// UINT64. -func (v Value) AsUint64() uint64 { - return v.numeric -} - -type unknownValueType struct{} - -// AsInterface returns Value's data as interface{}. -func (v Value) AsInterface() interface{} { - switch v.Type() { - case BOOL: - return v.AsBool() - case INT64: - return v.AsInt64() - case FLOAT64: - return v.AsFloat64() - case STRING: - return v.stringly - case UINT64: - return v.numeric - } - return unknownValueType{} -} - -// String returns a string representation of Value's data. -func (v Value) String() string { - switch v.Type() { - case BOOL: - return strconv.FormatBool(v.AsBool()) - case INT64: - return strconv.FormatInt(v.AsInt64(), 10) - case FLOAT64: - return fmt.Sprint(v.AsFloat64()) - case STRING: - return v.stringly - case UINT64: - return strconv.FormatUint(v.numeric, 10) - default: - return "unknown" - } -} - -// MarshalJSON returns the JSON encoding of the Value. -func (v Value) MarshalJSON() ([]byte, error) { - var jsonVal struct { - Value any `json:"value"` - Type string `json:"type"` - } - jsonVal.Type = mapTypesToStr[v.Type()] - jsonVal.Value = v.AsInterface() - return json.Marshal(jsonVal) -} - -func (t Type) String() string { - switch t { - case BOOL: - return "bool" - case INT64: - return "int64" - case FLOAT64: - return "float64" - case STRING: - return "string" - case UINT64: - return "uint64" - } - return "invalid" -} - -// mapTypesToStr is a map from attribute.Type to the primitive types the server understands. -// https://develop.sentry.dev/sdk/foundations/data-model/attributes/#primitive-types -var mapTypesToStr = map[Type]string{ - INVALID: "", - BOOL: "boolean", - INT64: "integer", - FLOAT64: "double", - STRING: "string", - UINT64: "integer", // wire format: same "integer" type -} diff --git a/vendor/github.com/getsentry/sentry-go/batch_processor.go b/vendor/github.com/getsentry/sentry-go/batch_processor.go deleted file mode 100644 index 9fcc452bc48..00000000000 --- a/vendor/github.com/getsentry/sentry-go/batch_processor.go +++ /dev/null @@ -1,136 +0,0 @@ -package sentry - -import ( - "context" - "sync" - "time" -) - -const ( - batchSize = 100 - defaultBatchTimeout = 5 * time.Second -) - -type batchProcessor[T any] struct { - sendBatch func([]T) - itemCh chan T - flushCh chan chan struct{} - cancel context.CancelFunc - wg sync.WaitGroup - startOnce sync.Once - shutdownOnce sync.Once - batchTimeout time.Duration -} - -func newBatchProcessor[T any](sendBatch func([]T)) *batchProcessor[T] { - return &batchProcessor[T]{ - itemCh: make(chan T, batchSize), - flushCh: make(chan chan struct{}), - sendBatch: sendBatch, - batchTimeout: defaultBatchTimeout, - } -} - -// WithBatchTimeout sets a custom batch timeout for the processor. -// This is useful for testing or when different timing behavior is needed. -func (p *batchProcessor[T]) WithBatchTimeout(timeout time.Duration) *batchProcessor[T] { - p.batchTimeout = timeout - return p -} - -func (p *batchProcessor[T]) Send(item T) bool { - select { - case p.itemCh <- item: - return true - default: - return false - } -} - -func (p *batchProcessor[T]) Start() { - p.startOnce.Do(func() { - ctx, cancel := context.WithCancel(context.Background()) - p.cancel = cancel - p.wg.Add(1) - go p.run(ctx) - }) -} - -func (p *batchProcessor[T]) Flush(timeout <-chan struct{}) { - done := make(chan struct{}) - select { - case p.flushCh <- done: - select { - case <-done: - case <-timeout: - } - case <-timeout: - } -} - -func (p *batchProcessor[T]) Shutdown() { - p.shutdownOnce.Do(func() { - if p.cancel != nil { - p.cancel() - p.wg.Wait() - } - }) -} - -func (p *batchProcessor[T]) run(ctx context.Context) { - defer p.wg.Done() - var items []T - timer := time.NewTimer(0) - timer.Stop() - defer timer.Stop() - - for { - select { - case item := <-p.itemCh: - if len(items) == 0 { - timer.Reset(p.batchTimeout) - } - items = append(items, item) - if len(items) >= batchSize { - p.sendBatch(items) - items = nil - } - case <-timer.C: - if len(items) > 0 { - p.sendBatch(items) - items = nil - } - case done := <-p.flushCh: - flushDrain: - for { - select { - case item := <-p.itemCh: - items = append(items, item) - default: - break flushDrain - } - } - - if len(items) > 0 { - p.sendBatch(items) - items = nil - } - close(done) - case <-ctx.Done(): - drain: - for { - select { - case item := <-p.itemCh: - items = append(items, item) - default: - break drain - } - } - - if len(items) > 0 { - p.sendBatch(items) - } - return - } - } -} diff --git a/vendor/github.com/getsentry/sentry-go/check_in.go b/vendor/github.com/getsentry/sentry-go/check_in.go deleted file mode 100644 index de6d0adb682..00000000000 --- a/vendor/github.com/getsentry/sentry-go/check_in.go +++ /dev/null @@ -1,121 +0,0 @@ -package sentry - -import "time" - -type CheckInStatus string - -const ( - CheckInStatusInProgress CheckInStatus = "in_progress" - CheckInStatusOK CheckInStatus = "ok" - CheckInStatusError CheckInStatus = "error" -) - -type checkInScheduleType string - -const ( - checkInScheduleTypeCrontab checkInScheduleType = "crontab" - checkInScheduleTypeInterval checkInScheduleType = "interval" -) - -type MonitorSchedule interface { - // scheduleType is a private method that must be implemented for monitor schedule - // implementation. It should never be called. This method is made for having - // specific private implementation of MonitorSchedule interface. - scheduleType() checkInScheduleType -} - -type crontabSchedule struct { - Type string `json:"type"` - Value string `json:"value"` -} - -func (c crontabSchedule) scheduleType() checkInScheduleType { - return checkInScheduleTypeCrontab -} - -// CrontabSchedule defines the MonitorSchedule with a cron format. -// Example: "8 * * * *". -func CrontabSchedule(scheduleString string) MonitorSchedule { - return crontabSchedule{ - Type: string(checkInScheduleTypeCrontab), - Value: scheduleString, - } -} - -type intervalSchedule struct { - Type string `json:"type"` - Value int64 `json:"value"` - Unit string `json:"unit"` -} - -func (i intervalSchedule) scheduleType() checkInScheduleType { - return checkInScheduleTypeInterval -} - -type MonitorScheduleUnit string - -const ( - MonitorScheduleUnitMinute MonitorScheduleUnit = "minute" - MonitorScheduleUnitHour MonitorScheduleUnit = "hour" - MonitorScheduleUnitDay MonitorScheduleUnit = "day" - MonitorScheduleUnitWeek MonitorScheduleUnit = "week" - MonitorScheduleUnitMonth MonitorScheduleUnit = "month" - MonitorScheduleUnitYear MonitorScheduleUnit = "year" -) - -// IntervalSchedule defines the MonitorSchedule with an interval format. -// -// Example: -// -// IntervalSchedule(1, sentry.MonitorScheduleUnitDay) -func IntervalSchedule(value int64, unit MonitorScheduleUnit) MonitorSchedule { - return intervalSchedule{ - Type: string(checkInScheduleTypeInterval), - Value: value, - Unit: string(unit), - } -} - -type MonitorConfig struct { //nolint: maligned // prefer readability over optimal memory layout - Schedule MonitorSchedule `json:"schedule,omitempty"` - // The allowed margin of minutes after the expected check-in time that - // the monitor will not be considered missed for. - CheckInMargin int64 `json:"checkin_margin,omitempty"` - // The allowed duration in minutes that the monitor may be `in_progress` - // for before being considered failed due to timeout. - MaxRuntime int64 `json:"max_runtime,omitempty"` - // A tz database string representing the timezone which the monitor's execution schedule is in. - // See: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones - Timezone string `json:"timezone,omitempty"` - // The number of consecutive failed check-ins it takes before an issue is created. - FailureIssueThreshold int64 `json:"failure_issue_threshold,omitempty"` - // The number of consecutive OK check-ins it takes before an issue is resolved. - RecoveryThreshold int64 `json:"recovery_threshold,omitempty"` -} - -type CheckIn struct { //nolint: maligned // prefer readability over optimal memory layout - // Check-In ID (unique and client generated) - ID EventID `json:"check_in_id"` - // The distinct slug of the monitor. - MonitorSlug string `json:"monitor_slug"` - // The status of the check-in. - Status CheckInStatus `json:"status"` - // The duration of the check-in. Will only take effect if the status is ok or error. - Duration time.Duration `json:"duration,omitempty"` -} - -// serializedCheckIn is used by checkInMarshalJSON method on Event struct. -// See https://develop.sentry.dev/sdk/check-ins/ -type serializedCheckIn struct { //nolint: maligned - // Check-In ID (unique and client generated). - CheckInID string `json:"check_in_id"` - // The distinct slug of the monitor. - MonitorSlug string `json:"monitor_slug"` - // The status of the check-in. - Status CheckInStatus `json:"status"` - // The duration of the check-in in seconds. Will only take effect if the status is ok or error. - Duration float64 `json:"duration,omitempty"` - Release string `json:"release,omitempty"` - Environment string `json:"environment,omitempty"` - MonitorConfig *MonitorConfig `json:"monitor_config,omitempty"` -} diff --git a/vendor/github.com/getsentry/sentry-go/client.go b/vendor/github.com/getsentry/sentry-go/client.go deleted file mode 100644 index fd6cba163fc..00000000000 --- a/vendor/github.com/getsentry/sentry-go/client.go +++ /dev/null @@ -1,948 +0,0 @@ -package sentry - -import ( - "context" - "crypto/x509" - "fmt" - "io" - "math/rand" - "net/http" - "os" - "sort" - "strings" - "sync" - "time" - - "github.com/getsentry/sentry-go/internal/debug" - "github.com/getsentry/sentry-go/internal/debuglog" - httpInternal "github.com/getsentry/sentry-go/internal/http" - "github.com/getsentry/sentry-go/internal/protocol" - "github.com/getsentry/sentry-go/internal/ratelimit" - "github.com/getsentry/sentry-go/internal/telemetry" -) - -// The identifier of the SDK. -const sdkIdentifier = "sentry.go" - -const ( - // maxErrorDepth is the maximum number of errors reported in a chain of errors. - // This protects the SDK from an arbitrarily long chain of wrapped errors. - // - // An additional consideration is that arguably reporting a long chain of errors - // is of little use when debugging production errors with Sentry. The Sentry UI - // is not optimized for long chains either. The top-level error together with a - // stack trace is often the most useful information. - maxErrorDepth = 100 - - // defaultMaxSpans limits the default number of recorded spans per transaction. The limit is - // meant to bound memory usage and prevent too large transaction events that - // would be rejected by Sentry. - defaultMaxSpans = 1000 - - // defaultMaxBreadcrumbs is the default maximum number of breadcrumbs added to - // an event. Can be overwritten with the MaxBreadcrumbs option. - defaultMaxBreadcrumbs = 100 -) - -// hostname is the host name reported by the kernel. It is precomputed once to -// avoid syscalls when capturing events. -// -// The error is ignored because retrieving the host name is best-effort. If the -// error is non-nil, there is nothing to do other than retrying. We choose not -// to retry for now. -var hostname, _ = os.Hostname() - -// lockedRand is a random number generator safe for concurrent use. Its API is -// intentionally limited and it is not meant as a full replacement for a -// rand.Rand. -type lockedRand struct { - mu sync.Mutex - r *rand.Rand -} - -// Float64 returns a pseudo-random number in [0.0,1.0). -func (r *lockedRand) Float64() float64 { - r.mu.Lock() - defer r.mu.Unlock() - return r.r.Float64() -} - -// rng is the internal random number generator. -// -// We do not use the global functions from math/rand because, while they are -// safe for concurrent use, any package in a build could change the seed and -// affect the generated numbers, for instance making them deterministic. On the -// other hand, the source returned from rand.NewSource is not safe for -// concurrent use, so we need to couple its use with a sync.Mutex. -var rng = &lockedRand{ - // #nosec G404 -- We are fine using transparent, non-secure value here. - r: rand.New(rand.NewSource(time.Now().UnixNano())), -} - -// usageError is used to report to Sentry an SDK usage error. -// -// It is not exported because it is never returned by any function or method in -// the exported API. -type usageError struct { - error -} - -// DebugLogger is an instance of log.Logger that is used to provide debug information about running Sentry Client -// can be enabled by either using debuglog.SetOutput directly or with Debug client option. -var DebugLogger = debuglog.GetLogger() - -// EventProcessor is a function that processes an event. -// Event processors are used to change an event before it is sent to Sentry. -type EventProcessor func(event *Event, hint *EventHint) *Event - -// EventModifier is the interface that wraps the ApplyToEvent method. -// -// ApplyToEvent changes an event based on external data and/or -// an event hint. -type EventModifier interface { - ApplyToEvent(event *Event, hint *EventHint, client *Client) *Event -} - -var globalEventProcessors []EventProcessor - -// AddGlobalEventProcessor adds processor to the global list of event -// processors. Global event processors apply to all events. -// -// AddGlobalEventProcessor is deprecated. Most users will prefer to initialize -// the SDK with Init and provide a ClientOptions.BeforeSend function or use -// Scope.AddEventProcessor instead. -func AddGlobalEventProcessor(processor EventProcessor) { - globalEventProcessors = append(globalEventProcessors, processor) -} - -// Integration allows for registering a functions that modify or discard captured events. -type Integration interface { - Name() string - SetupOnce(client *Client) -} - -// ClientOptions that configures a SDK Client. -type ClientOptions struct { - // The DSN to use. If the DSN is not set, the client is effectively - // disabled. - Dsn string - // In debug mode, the debug information is printed to stdout to help you - // understand what sentry is doing. - Debug bool - // Configures whether SDK should generate and attach stacktraces to pure - // capture message calls. - AttachStacktrace bool - // The sample rate for event submission in the range [0.0, 1.0]. By default, - // all events are sent. Thus, as a historical special case, the sample rate - // 0.0 is treated as if it was 1.0. To drop all events, set the DSN to the - // empty string. - SampleRate float64 - // Enable performance tracing. - EnableTracing bool - // The sample rate for sampling traces in the range [0.0, 1.0]. - TracesSampleRate float64 - // Used to customize the sampling of traces, overrides TracesSampleRate. - TracesSampler TracesSampler - // Control with URLs trace propagation should be enabled. Does not support regex patterns. - TracePropagationTargets []string - // PropagateTraceparent is used to control whether the W3C Trace Context HTTP traceparent header - // is propagated on outgoing http requests. - PropagateTraceparent bool - // List of regexp strings that will be used to match against event's message - // and if applicable, caught errors type and value. - // If the match is found, then a whole event will be dropped. - IgnoreErrors []string - // List of regexp strings that will be used to match against a transaction's - // name. If a match is found, then the transaction will be dropped. - IgnoreTransactions []string - // If this flag is enabled, certain personally identifiable information (PII) is added by active integrations. - // By default, no such data is sent. - SendDefaultPII bool - // BeforeSend is called before error events are sent to Sentry. - // You can use it to mutate the event or return nil to discard it. - BeforeSend func(event *Event, hint *EventHint) *Event - // BeforeSendLong is called before log events are sent to Sentry. - // You can use it to mutate the log event or return nil to discard it. - BeforeSendLog func(event *Log) *Log - // BeforeSendTransaction is called before transaction events are sent to Sentry. - // Use it to mutate the transaction or return nil to discard the transaction. - BeforeSendTransaction func(event *Event, hint *EventHint) *Event - // Before breadcrumb add callback. - BeforeBreadcrumb func(breadcrumb *Breadcrumb, hint *BreadcrumbHint) *Breadcrumb - // BeforeSendMetric is called before metric events are sent to Sentry. - // You can use it to mutate the metric or return nil to discard it. - BeforeSendMetric func(metric *Metric) *Metric - // Integrations to be installed on the current Client, receives default - // integrations. - Integrations func([]Integration) []Integration - // io.Writer implementation that should be used with the Debug mode. - DebugWriter io.Writer - // The transport to use. Defaults to HTTPTransport. - Transport Transport - // The server name to be reported. - ServerName string - // The release to be sent with events. - // - // Some Sentry features are built around releases, and, thus, reporting - // events with a non-empty release improves the product experience. See - // https://docs.sentry.io/product/releases/. - // - // If Release is not set, the SDK will try to derive a default value - // from environment variables or the Git repository in the working - // directory. - // - // If you distribute a compiled binary, it is recommended to set the - // Release value explicitly at build time. As an example, you can use: - // - // go build -ldflags='-X main.release=VALUE' - // - // That will set the value of a predeclared variable 'release' in the - // 'main' package to 'VALUE'. Then, use that variable when initializing - // the SDK: - // - // sentry.Init(ClientOptions{Release: release}) - // - // See https://golang.org/cmd/go/ and https://golang.org/cmd/link/ for - // the official documentation of -ldflags and -X, respectively. - Release string - // The dist to be sent with events. - Dist string - // The environment to be sent with events. - Environment string - // Maximum number of breadcrumbs - // when MaxBreadcrumbs is negative then ignore breadcrumbs. - MaxBreadcrumbs int - // Maximum number of spans. - // - // See https://develop.sentry.dev/sdk/envelopes/#size-limits for size limits - // applied during event ingestion. Events that exceed these limits might get dropped. - MaxSpans int - // An optional pointer to http.Client that will be used with a default - // HTTPTransport. Using your own client will make HTTPTransport, HTTPProxy, - // HTTPSProxy and CaCerts options ignored. - HTTPClient *http.Client - // An optional pointer to http.Transport that will be used with a default - // HTTPTransport. Using your own transport will make HTTPProxy, HTTPSProxy - // and CaCerts options ignored. - HTTPTransport http.RoundTripper - // An optional HTTP proxy to use. - // This will default to the HTTP_PROXY environment variable. - HTTPProxy string - // An optional HTTPS proxy to use. - // This will default to the HTTPS_PROXY environment variable. - // HTTPS_PROXY takes precedence over HTTP_PROXY for https requests. - HTTPSProxy string - // An optional set of SSL certificates to use. - CaCerts *x509.CertPool - // MaxErrorDepth is the maximum number of errors reported in a chain of errors. - // This protects the SDK from an arbitrarily long chain of wrapped errors. - // - // An additional consideration is that arguably reporting a long chain of errors - // is of little use when debugging production errors with Sentry. The Sentry UI - // is not optimized for long chains either. The top-level error together with a - // stack trace is often the most useful information. - MaxErrorDepth int - // Default event tags. These are overridden by tags set on a scope. - Tags map[string]string - // EnableLogs controls when logs should be emitted. - EnableLogs bool - // DisableMetrics controls when metrics should be emitted. - DisableMetrics bool - // TraceIgnoreStatusCodes is a list of HTTP status codes that should not be traced. - // Each element can be either: - // - A single-element slice [code] for a specific status code - // - A two-element slice [min, max] for a range of status codes (inclusive) - // When an HTTP request results in a status code that matches any of these codes or ranges, - // the transaction will not be sent to Sentry. - // - // Examples: - // [][]int{{404}} // ignore only status code 404 - // [][]int{{400, 405}} // ignore status codes 400-405 - // [][]int{{404}, {500}} // ignore status codes 404 and 500 - // [][]int{{404}, {400, 405}, {500, 599}} // ignore 404, range 400-405, and range 500-599 - // - // By default, this ignores 404 status codes. - // - // IMPORTANT: to not ignore any status codes, the option should be an empty slice and not nil. The nil option is - // used for defaulting to 404 ignores. - TraceIgnoreStatusCodes [][]int - // DisableTelemetryBuffer disables the telemetry buffer layer for prioritizing events and uses the old transport layer. - DisableTelemetryBuffer bool -} - -// Client is the underlying processor that is used by the main API and Hub -// instances. It must be created with NewClient. -type Client struct { - mu sync.RWMutex - options ClientOptions - dsn *Dsn - eventProcessors []EventProcessor - integrations []Integration - sdkIdentifier string - sdkVersion string - // Transport is read-only. Replacing the transport of an existing client is - // not supported, create a new client instead. - Transport Transport - batchLogger *logBatchProcessor - batchMeter *metricBatchProcessor - telemetryProcessor *telemetry.Processor -} - -// NewClient creates and returns an instance of Client configured using -// ClientOptions. -// -// Most users will not create clients directly. Instead, initialize the SDK with -// Init and use the package-level functions (for simple programs that run on a -// single goroutine) or hub methods (for concurrent programs, for example web -// servers). -func NewClient(options ClientOptions) (*Client, error) { - // The default error event sample rate for all SDKs is 1.0 (send all). - // - // In Go, the zero value (default) for float64 is 0.0, which means that - // constructing a client with NewClient(ClientOptions{}), or, equivalently, - // initializing the SDK with Init(ClientOptions{}) without an explicit - // SampleRate would drop all events. - // - // To retain the desired default behavior, we exceptionally flip SampleRate - // from 0.0 to 1.0 here. Setting the sample rate to 0.0 is not very useful - // anyway, and the same end result can be achieved in many other ways like - // not initializing the SDK, setting the DSN to the empty string or using an - // event processor that always returns nil. - // - // An alternative API could be such that default options don't need to be - // the same as Go's zero values, for example using the Functional Options - // pattern. That would either require a breaking change if we want to reuse - // the obvious NewClient name, or a new function as an alternative - // constructor. - if options.SampleRate == 0.0 { - options.SampleRate = 1.0 - } - - if options.Debug { - debugWriter := options.DebugWriter - if debugWriter == nil { - debugWriter = os.Stderr - } - debuglog.SetOutput(debugWriter) - } - - if options.Dsn == "" { - options.Dsn = os.Getenv("SENTRY_DSN") - } - - if options.Release == "" { - options.Release = defaultRelease() - } - - if options.Environment == "" { - options.Environment = os.Getenv("SENTRY_ENVIRONMENT") - } - - if options.MaxErrorDepth == 0 { - options.MaxErrorDepth = maxErrorDepth - } - - if options.MaxSpans == 0 { - options.MaxSpans = defaultMaxSpans - } - - if options.TraceIgnoreStatusCodes == nil { - options.TraceIgnoreStatusCodes = [][]int{{404}} - } - - // SENTRYGODEBUG is a comma-separated list of key=value pairs (similar - // to GODEBUG). It is not a supported feature: recognized debug options - // may change any time. - // - // The intended public is SDK developers. It is orthogonal to - // options.Debug, which is also available for SDK users. - dbg := strings.Split(os.Getenv("SENTRYGODEBUG"), ",") - sort.Strings(dbg) - // dbgOpt returns true when the given debug option is enabled, for - // example SENTRYGODEBUG=someopt=1. - dbgOpt := func(opt string) bool { - s := opt + "=1" - return dbg[sort.SearchStrings(dbg, s)%len(dbg)] == s - } - if dbgOpt("httpdump") || dbgOpt("httptrace") { - options.HTTPTransport = &debug.Transport{ - RoundTripper: http.DefaultTransport, - Output: os.Stderr, - Dump: dbgOpt("httpdump"), - Trace: dbgOpt("httptrace"), - } - } - - var dsn *Dsn - if options.Dsn != "" { - var err error - dsn, err = NewDsn(options.Dsn) - if err != nil { - return nil, err - } - } - - client := Client{ - options: options, - dsn: dsn, - sdkIdentifier: sdkIdentifier, - sdkVersion: SDKVersion, - } - - client.setupTransport() - - // noop Telemetry Buffers and Processor fow now - // if !options.DisableTelemetryBuffer { - // client.setupTelemetryProcessor() - // } else - if options.EnableLogs { - client.batchLogger = newLogBatchProcessor(&client) - client.batchLogger.Start() - } - - if !options.DisableMetrics { - client.batchMeter = newMetricBatchProcessor(&client) - client.batchMeter.Start() - } - - client.setupIntegrations() - - return &client, nil -} - -func (client *Client) setupTransport() { - opts := client.options - transport := opts.Transport - - if transport == nil { - if opts.Dsn == "" { - transport = new(noopTransport) - } else { - transport = NewHTTPTransport() - } - } - - transport.Configure(opts) - client.Transport = transport -} - -func (client *Client) setupTelemetryProcessor() { // nolint: unused - if client.options.DisableTelemetryBuffer { - return - } - - if client.dsn == nil { - debuglog.Println("Telemetry buffer disabled: no DSN configured") - return - } - - // We currently disallow using custom Transport with the new Telemetry Processor, due to the difference in transport signatures. - // The option should be enabled when the new Transport interface signature changes. - if client.options.Transport != nil { - debuglog.Println("Cannot enable Telemetry Processor/Buffers with custom Transport: fallback to old transport") - if client.options.EnableLogs { - client.batchLogger = newLogBatchProcessor(client) - client.batchLogger.Start() - } - if !client.options.DisableMetrics { - client.batchMeter = newMetricBatchProcessor(client) - client.batchMeter.Start() - } - return - } - - transport := httpInternal.NewAsyncTransport(httpInternal.TransportOptions{ - Dsn: client.options.Dsn, - HTTPClient: client.options.HTTPClient, - HTTPTransport: client.options.HTTPTransport, - HTTPProxy: client.options.HTTPProxy, - HTTPSProxy: client.options.HTTPSProxy, - CaCerts: client.options.CaCerts, - }) - client.Transport = &internalAsyncTransportAdapter{transport: transport} - - buffers := map[ratelimit.Category]telemetry.Buffer[protocol.TelemetryItem]{ - ratelimit.CategoryError: telemetry.NewRingBuffer[protocol.TelemetryItem](ratelimit.CategoryError, 100, telemetry.OverflowPolicyDropOldest, 1, 0), - ratelimit.CategoryTransaction: telemetry.NewRingBuffer[protocol.TelemetryItem](ratelimit.CategoryTransaction, 1000, telemetry.OverflowPolicyDropOldest, 1, 0), - ratelimit.CategoryLog: telemetry.NewRingBuffer[protocol.TelemetryItem](ratelimit.CategoryLog, 10*100, telemetry.OverflowPolicyDropOldest, 100, 5*time.Second), - ratelimit.CategoryMonitor: telemetry.NewRingBuffer[protocol.TelemetryItem](ratelimit.CategoryMonitor, 100, telemetry.OverflowPolicyDropOldest, 1, 0), - ratelimit.CategoryTraceMetric: telemetry.NewRingBuffer[protocol.TelemetryItem](ratelimit.CategoryTraceMetric, 10*100, telemetry.OverflowPolicyDropOldest, 100, 5*time.Second), - } - - sdkInfo := &protocol.SdkInfo{ - Name: client.sdkIdentifier, - Version: client.sdkVersion, - } - - client.telemetryProcessor = telemetry.NewProcessor(buffers, transport, &client.dsn.Dsn, sdkInfo) -} - -func (client *Client) setupIntegrations() { - integrations := []Integration{ - new(contextifyFramesIntegration), - new(environmentIntegration), - new(modulesIntegration), - new(ignoreErrorsIntegration), - new(ignoreTransactionsIntegration), - new(globalTagsIntegration), - } - - if client.options.Integrations != nil { - integrations = client.options.Integrations(integrations) - } - - for _, integration := range integrations { - if client.integrationAlreadyInstalled(integration.Name()) { - debuglog.Printf("Integration %s is already installed\n", integration.Name()) - continue - } - client.integrations = append(client.integrations, integration) - integration.SetupOnce(client) - debuglog.Printf("Integration installed: %s\n", integration.Name()) - } - - sort.Slice(client.integrations, func(i, j int) bool { - return client.integrations[i].Name() < client.integrations[j].Name() - }) -} - -// AddEventProcessor adds an event processor to the client. It must not be -// called from concurrent goroutines. Most users will prefer to use -// ClientOptions.BeforeSend or Scope.AddEventProcessor instead. -// -// Note that typical programs have only a single client created by Init and the -// client is shared among multiple hubs, one per goroutine, such that adding an -// event processor to the client affects all hubs that share the client. -func (client *Client) AddEventProcessor(processor EventProcessor) { - client.eventProcessors = append(client.eventProcessors, processor) -} - -// Options return ClientOptions for the current Client. -func (client *Client) Options() ClientOptions { - // Note: internally, consider using `client.options` instead of `client.Options()` to avoid copying the object each time. - return client.options -} - -// CaptureMessage captures an arbitrary message. -func (client *Client) CaptureMessage(message string, hint *EventHint, scope EventModifier) *EventID { - event := client.EventFromMessage(message, LevelInfo) - return client.CaptureEvent(event, hint, scope) -} - -// CaptureException captures an error. -func (client *Client) CaptureException(exception error, hint *EventHint, scope EventModifier) *EventID { - event := client.EventFromException(exception, LevelError) - return client.CaptureEvent(event, hint, scope) -} - -// CaptureCheckIn captures a check in. -func (client *Client) CaptureCheckIn(checkIn *CheckIn, monitorConfig *MonitorConfig, scope EventModifier) *EventID { - event := client.EventFromCheckIn(checkIn, monitorConfig) - if event != nil && event.CheckIn != nil { - client.CaptureEvent(event, nil, scope) - return &event.CheckIn.ID - } - return nil -} - -// CaptureEvent captures an event on the currently active client if any. -// -// The event must already be assembled. Typically, code would instead use -// the utility methods like CaptureException. The return value is the -// event ID. In case Sentry is disabled or event was dropped, the return value will be nil. -func (client *Client) CaptureEvent(event *Event, hint *EventHint, scope EventModifier) *EventID { - return client.processEvent(event, hint, scope) -} - -func (client *Client) captureLog(log *Log, _ *Scope) bool { - if log == nil { - return false - } - - if client.options.BeforeSendLog != nil { - log = client.options.BeforeSendLog(log) - if log == nil { - debuglog.Println("Log dropped due to BeforeSendLog callback.") - return false - } - } - - if client.telemetryProcessor != nil { - if !client.telemetryProcessor.Add(log) { - debuglog.Print("Dropping log: telemetry buffer full or category missing") - return false - } - } else if client.batchLogger != nil { - if !client.batchLogger.Send(log) { - debuglog.Printf("Dropping log [%s]: buffer full", log.Level) - return false - } - } - - return true -} - -func (client *Client) captureMetric(metric *Metric, _ *Scope) bool { - if metric == nil { - return false - } - - if client.options.BeforeSendMetric != nil { - metric = client.options.BeforeSendMetric(metric) - if metric == nil { - debuglog.Println("Metric dropped due to BeforeSendMetric callback.") - return false - } - } - - if client.telemetryProcessor != nil { - if !client.telemetryProcessor.Add(metric) { - debuglog.Printf("Dropping metric: telemetry buffer full or category missing") - return false - } - } else if client.batchMeter != nil { - if !client.batchMeter.Send(metric) { - debuglog.Printf("Dropping metric %q: buffer full", metric.Name) - return false - } - } - - return true -} - -// Recover captures a panic. -// Returns EventID if successfully, or nil if there's no error to recover from. -func (client *Client) Recover(err interface{}, hint *EventHint, scope EventModifier) *EventID { - if err == nil { - err = recover() - } - - // Normally we would not pass a nil Context, but RecoverWithContext doesn't - // use the Context for communicating deadline nor cancelation. All it does - // is store the Context in the EventHint and there nil means the Context is - // not available. - // nolint: staticcheck - return client.RecoverWithContext(nil, err, hint, scope) -} - -// RecoverWithContext captures a panic and passes relevant context object. -// Returns EventID if successfully, or nil if there's no error to recover from. -func (client *Client) RecoverWithContext( - ctx context.Context, - err interface{}, - hint *EventHint, - scope EventModifier, -) *EventID { - if err == nil { - err = recover() - } - if err == nil { - return nil - } - - if ctx != nil { - if hint == nil { - hint = &EventHint{} - } - if hint.Context == nil { - hint.Context = ctx - } - } - - var event *Event - switch err := err.(type) { - case error: - event = client.EventFromException(err, LevelFatal) - case string: - event = client.EventFromMessage(err, LevelFatal) - default: - event = client.EventFromMessage(fmt.Sprintf("%#v", err), LevelFatal) - } - return client.CaptureEvent(event, hint, scope) -} - -// Flush waits until the underlying Transport sends any buffered events to the -// Sentry server, blocking for at most the given timeout. It returns false if -// the timeout was reached. In that case, some events may not have been sent. -// -// Flush should be called before terminating the program to avoid -// unintentionally dropping events. -// -// Do not call Flush indiscriminately after every call to CaptureEvent, -// CaptureException or CaptureMessage. Instead, to have the SDK send events over -// the network synchronously, configure it to use the HTTPSyncTransport in the -// call to Init. -func (client *Client) Flush(timeout time.Duration) bool { - if client.batchLogger != nil || client.batchMeter != nil || client.telemetryProcessor != nil { - ctx, cancel := context.WithTimeout(context.Background(), timeout) - defer cancel() - return client.FlushWithContext(ctx) - } - return client.Transport.Flush(timeout) -} - -// FlushWithContext waits until the underlying Transport sends any buffered events -// to the Sentry server, blocking for at most the duration specified by the context. -// It returns false if the context is canceled before the events are sent. In such a case, -// some events may not be delivered. -// -// FlushWithContext should be called before terminating the program to ensure no -// events are unintentionally dropped. -// -// Avoid calling FlushWithContext indiscriminately after each call to CaptureEvent, -// CaptureException, or CaptureMessage. To send events synchronously over the network, -// configure the SDK to use HTTPSyncTransport during initialization with Init. - -func (client *Client) FlushWithContext(ctx context.Context) bool { - if client.batchLogger != nil { - client.batchLogger.Flush(ctx.Done()) - } - if client.batchMeter != nil { - client.batchMeter.Flush(ctx.Done()) - } - if client.telemetryProcessor != nil { - return client.telemetryProcessor.FlushWithContext(ctx) - } - return client.Transport.FlushWithContext(ctx) -} - -// Close clean up underlying Transport resources. -// -// Close should be called after Flush and before terminating the program -// otherwise some events may be lost. -func (client *Client) Close() { - if client.telemetryProcessor != nil { - client.telemetryProcessor.Close(5 * time.Second) - } - if client.batchLogger != nil { - client.batchLogger.Shutdown() - } - if client.batchMeter != nil { - client.batchMeter.Shutdown() - } - client.Transport.Close() -} - -// EventFromMessage creates an event from the given message string. -func (client *Client) EventFromMessage(message string, level Level) *Event { - if message == "" { - err := usageError{fmt.Errorf("%s called with empty message", callerFunctionName())} - return client.EventFromException(err, level) - } - event := NewEvent() - event.Level = level - event.Message = message - - if client.options.AttachStacktrace { - event.Threads = []Thread{{ - Stacktrace: NewStacktrace(), - Crashed: false, - Current: true, - }} - } - - return event -} - -// EventFromException creates a new Sentry event from the given `error` instance. -func (client *Client) EventFromException(exception error, level Level) *Event { - event := NewEvent() - event.Level = level - - err := exception - if err == nil { - err = usageError{fmt.Errorf("%s called with nil error", callerFunctionName())} - } - - event.SetException(err, client.options.MaxErrorDepth) - - return event -} - -// EventFromCheckIn creates a new Sentry event from the given `check_in` instance. -func (client *Client) EventFromCheckIn(checkIn *CheckIn, monitorConfig *MonitorConfig) *Event { - if checkIn == nil { - return nil - } - - event := NewEvent() - event.Type = checkInType - - var checkInID EventID - if checkIn.ID == "" { - checkInID = EventID(uuid()) - } else { - checkInID = checkIn.ID - } - - event.CheckIn = &CheckIn{ - ID: checkInID, - MonitorSlug: checkIn.MonitorSlug, - Status: checkIn.Status, - Duration: checkIn.Duration, - } - event.MonitorConfig = monitorConfig - - return event -} - -func (client *Client) SetSDKIdentifier(identifier string) { - client.mu.Lock() - defer client.mu.Unlock() - - client.sdkIdentifier = identifier -} - -func (client *Client) GetSDKIdentifier() string { - client.mu.RLock() - defer client.mu.RUnlock() - - return client.sdkIdentifier -} - -func (client *Client) processEvent(event *Event, hint *EventHint, scope EventModifier) *EventID { - if event == nil { - err := usageError{fmt.Errorf("%s called with nil event", callerFunctionName())} - return client.CaptureException(err, hint, scope) - } - - // Transactions are sampled by options.TracesSampleRate or - // options.TracesSampler when they are started. Other events - // (errors, messages) are sampled here. Does not apply to check-ins. - if event.Type != transactionType && event.Type != checkInType && !sample(client.options.SampleRate) { - debuglog.Println("Event dropped due to SampleRate hit.") - return nil - } - - if event = client.prepareEvent(event, hint, scope); event == nil { - return nil - } - - // Apply beforeSend* processors - if hint == nil { - hint = &EventHint{} - } - switch event.Type { - case transactionType: - if client.options.BeforeSendTransaction != nil { - if event = client.options.BeforeSendTransaction(event, hint); event == nil { - debuglog.Println("Transaction dropped due to BeforeSendTransaction callback.") - return nil - } - } - case checkInType: // not a default case, since we shouldn't apply BeforeSend on check-in events - default: - if client.options.BeforeSend != nil { - if event = client.options.BeforeSend(event, hint); event == nil { - debuglog.Println("Event dropped due to BeforeSend callback.") - return nil - } - } - } - - if client.telemetryProcessor != nil { - if !client.telemetryProcessor.Add(event) { - debuglog.Println("Event dropped: telemetry buffer full or unavailable") - } - } else { - client.Transport.SendEvent(event) - } - - return &event.EventID -} - -func (client *Client) prepareEvent(event *Event, hint *EventHint, scope EventModifier) *Event { - if event.EventID == "" { - // TODO set EventID when the event is created, same as in other SDKs. It's necessary for profileTransaction.ID. - event.EventID = EventID(uuid()) - } - - if event.Timestamp.IsZero() { - event.Timestamp = time.Now() - } - - if event.Level == "" { - event.Level = LevelInfo - } - - if event.ServerName == "" { - event.ServerName = client.options.ServerName - - if event.ServerName == "" { - event.ServerName = hostname - } - } - - if event.Release == "" { - event.Release = client.options.Release - } - - if event.Dist == "" { - event.Dist = client.options.Dist - } - - if event.Environment == "" { - event.Environment = client.options.Environment - } - - event.Platform = "go" - event.Sdk = SdkInfo{ - Name: client.GetSDKIdentifier(), - Version: SDKVersion, - Integrations: client.listIntegrations(), - Packages: []SdkPackage{{ - Name: "sentry-go", - Version: SDKVersion, - }}, - } - - if scope != nil { - event = scope.ApplyToEvent(event, hint, client) - if event == nil { - return nil - } - } - - for _, processor := range client.eventProcessors { - id := event.EventID - event = processor(event, hint) - if event == nil { - debuglog.Printf("Event dropped by one of the Client EventProcessors: %s\n", id) - return nil - } - } - - for _, processor := range globalEventProcessors { - id := event.EventID - event = processor(event, hint) - if event == nil { - debuglog.Printf("Event dropped by one of the Global EventProcessors: %s\n", id) - return nil - } - } - - return event -} - -func (client *Client) listIntegrations() []string { - integrations := make([]string, len(client.integrations)) - for i, integration := range client.integrations { - integrations[i] = integration.Name() - } - return integrations -} - -func (client *Client) integrationAlreadyInstalled(name string) bool { - for _, integration := range client.integrations { - if integration.Name() == name { - return true - } - } - return false -} - -// sample returns true with the given probability, which must be in the range -// [0.0, 1.0]. -func sample(probability float64) bool { - return rng.Float64() < probability -} diff --git a/vendor/github.com/getsentry/sentry-go/doc.go b/vendor/github.com/getsentry/sentry-go/doc.go deleted file mode 100644 index 973020ae815..00000000000 --- a/vendor/github.com/getsentry/sentry-go/doc.go +++ /dev/null @@ -1,6 +0,0 @@ -/* -Package repository: https://github.com/getsentry/sentry-go/ - -For more information about Sentry and SDK features, please have a look at the official documentation site: https://docs.sentry.io/platforms/go/ -*/ -package sentry diff --git a/vendor/github.com/getsentry/sentry-go/dsn.go b/vendor/github.com/getsentry/sentry-go/dsn.go deleted file mode 100644 index 64b6f055d8e..00000000000 --- a/vendor/github.com/getsentry/sentry-go/dsn.go +++ /dev/null @@ -1,37 +0,0 @@ -package sentry - -import ( - "github.com/getsentry/sentry-go/internal/protocol" -) - -// Re-export protocol types to maintain public API compatibility - -// Dsn is used as the remote address source to client transport. -type Dsn struct { - protocol.Dsn -} - -// DsnParseError represents an error that occurs if a Sentry -// DSN cannot be parsed. -type DsnParseError = protocol.DsnParseError - -// NewDsn creates a Dsn by parsing rawURL. Most users will never call this -// function directly. It is provided for use in custom Transport -// implementations. -func NewDsn(rawURL string) (*Dsn, error) { - protocolDsn, err := protocol.NewDsn(rawURL) - if err != nil { - return nil, err - } - return &Dsn{Dsn: *protocolDsn}, nil -} - -// RequestHeaders returns all the necessary headers that have to be used in the transport when sending events -// to the /store endpoint. -// -// Deprecated: This method shall only be used if you want to implement your own transport that sends events to -// the /store endpoint. If you're using the transport provided by the SDK, all necessary headers to authenticate -// against the /envelope endpoint are added automatically. -func (dsn Dsn) RequestHeaders() map[string]string { - return dsn.Dsn.RequestHeaders(SDKVersion) -} diff --git a/vendor/github.com/getsentry/sentry-go/dynamic_sampling_context.go b/vendor/github.com/getsentry/sentry-go/dynamic_sampling_context.go deleted file mode 100644 index 5ae38748e13..00000000000 --- a/vendor/github.com/getsentry/sentry-go/dynamic_sampling_context.go +++ /dev/null @@ -1,154 +0,0 @@ -package sentry - -import ( - "strconv" - "strings" - - "github.com/getsentry/sentry-go/internal/otel/baggage" -) - -const ( - sentryPrefix = "sentry-" -) - -// DynamicSamplingContext holds information about the current event that can be used to make dynamic sampling decisions. -type DynamicSamplingContext struct { - Entries map[string]string - Frozen bool -} - -func DynamicSamplingContextFromHeader(header []byte) (DynamicSamplingContext, error) { - bag, err := baggage.Parse(string(header)) - if err != nil { - return DynamicSamplingContext{}, err - } - - entries := map[string]string{} - for _, member := range bag.Members() { - // We only store baggage members if their key starts with "sentry-". - if k, v := member.Key(), member.Value(); strings.HasPrefix(k, sentryPrefix) { - entries[strings.TrimPrefix(k, sentryPrefix)] = v - } - } - - return DynamicSamplingContext{ - Entries: entries, - // If there's at least one Sentry value, we consider the DSC frozen - Frozen: len(entries) > 0, - }, nil -} - -func DynamicSamplingContextFromTransaction(span *Span) DynamicSamplingContext { - hub := hubFromContext(span.Context()) - scope := hub.Scope() - client := hub.Client() - - if client == nil || scope == nil { - return DynamicSamplingContext{ - Entries: map[string]string{}, - Frozen: false, - } - } - - entries := make(map[string]string) - - if traceID := span.TraceID.String(); traceID != "" { - entries["trace_id"] = traceID - } - if sampleRate := span.sampleRate; sampleRate != 0 { - entries["sample_rate"] = strconv.FormatFloat(sampleRate, 'f', -1, 64) - } - - if dsn := client.dsn; dsn != nil { - if publicKey := dsn.GetPublicKey(); publicKey != "" { - entries["public_key"] = publicKey - } - } - if release := client.options.Release; release != "" { - entries["release"] = release - } - if environment := client.options.Environment; environment != "" { - entries["environment"] = environment - } - - // Only include the transaction name if it's of good quality (not empty and not SourceURL) - if span.Source != "" && span.Source != SourceURL { - if span.IsTransaction() { - entries["transaction"] = span.Name - } - } - - entries["sampled"] = strconv.FormatBool(span.Sampled.Bool()) - - return DynamicSamplingContext{Entries: entries, Frozen: true} -} - -func (d DynamicSamplingContext) HasEntries() bool { - return len(d.Entries) > 0 -} - -func (d DynamicSamplingContext) IsFrozen() bool { - return d.Frozen -} - -func (d DynamicSamplingContext) String() string { - members := []baggage.Member{} - for k, entry := range d.Entries { - member, err := baggage.NewMember(sentryPrefix+k, entry) - if err != nil { - continue - } - members = append(members, member) - } - - if len(members) == 0 { - return "" - } - - baggage, err := baggage.New(members...) - if err != nil { - return "" - } - - return baggage.String() -} - -// Constructs a new DynamicSamplingContext using a scope and client. Accessing -// fields on the scope are not thread safe, and this function should only be -// called within scope methods. -func DynamicSamplingContextFromScope(scope *Scope, client *Client) DynamicSamplingContext { - entries := map[string]string{} - - if client == nil || scope == nil { - return DynamicSamplingContext{ - Entries: entries, - Frozen: false, - } - } - - propagationContext := scope.propagationContext - - if traceID := propagationContext.TraceID.String(); traceID != "" { - entries["trace_id"] = traceID - } - if sampleRate := client.options.TracesSampleRate; sampleRate != 0 { - entries["sample_rate"] = strconv.FormatFloat(sampleRate, 'f', -1, 64) - } - - if dsn := client.dsn; dsn != nil { - if publicKey := dsn.GetPublicKey(); publicKey != "" { - entries["public_key"] = publicKey - } - } - if release := client.options.Release; release != "" { - entries["release"] = release - } - if environment := client.options.Environment; environment != "" { - entries["environment"] = environment - } - - return DynamicSamplingContext{ - Entries: entries, - Frozen: true, - } -} diff --git a/vendor/github.com/getsentry/sentry-go/exception.go b/vendor/github.com/getsentry/sentry-go/exception.go deleted file mode 100644 index f7ef4a00e4e..00000000000 --- a/vendor/github.com/getsentry/sentry-go/exception.go +++ /dev/null @@ -1,129 +0,0 @@ -package sentry - -import ( - "fmt" - "reflect" - "slices" -) - -const ( - MechanismTypeGeneric string = "generic" - MechanismTypeChained string = "chained" - MechanismTypeUnwrap string = "unwrap" - MechanismSourceCause string = "cause" -) - -type visited struct { - ptrs map[uintptr]struct{} - msgs map[string]struct{} -} - -func (v *visited) seenError(err error) bool { - t := reflect.ValueOf(err) - if t.Kind() == reflect.Ptr && !t.IsNil() { - ptr := t.Pointer() - if _, ok := v.ptrs[ptr]; ok { - return true - } - v.ptrs[ptr] = struct{}{} - return false - } - - key := t.String() + err.Error() - if _, ok := v.msgs[key]; ok { - return true - } - v.msgs[key] = struct{}{} - return false -} - -func convertErrorToExceptions(err error, maxErrorDepth int) []Exception { - var exceptions []Exception - vis := &visited{ - ptrs: make(map[uintptr]struct{}), - msgs: make(map[string]struct{}), - } - convertErrorDFS(err, &exceptions, nil, "", vis, maxErrorDepth, 0) - - // mechanism type is used for debugging purposes, but since we can't really distinguish the origin of who invoked - // captureException, we set it to nil if the error is not chained. - if len(exceptions) == 1 { - exceptions[0].Mechanism = nil - } - - slices.Reverse(exceptions) - - // Add a trace of the current stack to the top level(outermost) error in a chain if - // it doesn't have a stack trace yet. - // We only add to the most recent error to avoid duplication and because the - // current stack is most likely unrelated to errors deeper in the chain. - if len(exceptions) > 0 && exceptions[len(exceptions)-1].Stacktrace == nil { - exceptions[len(exceptions)-1].Stacktrace = NewStacktrace() - } - - return exceptions -} - -func convertErrorDFS(err error, exceptions *[]Exception, parentID *int, source string, visited *visited, maxErrorDepth int, currentDepth int) { - if err == nil { - return - } - - if visited.seenError(err) { - return - } - - _, isExceptionGroup := err.(interface{ Unwrap() []error }) - - exception := Exception{ - Value: err.Error(), - Type: reflect.TypeOf(err).String(), - Stacktrace: ExtractStacktrace(err), - } - - currentID := len(*exceptions) - - var mechanismType string - - if parentID == nil { - mechanismType = MechanismTypeGeneric - source = "" - } else { - mechanismType = MechanismTypeChained - } - - exception.Mechanism = &Mechanism{ - Type: mechanismType, - ExceptionID: currentID, - ParentID: parentID, - Source: source, - IsExceptionGroup: isExceptionGroup, - } - - *exceptions = append(*exceptions, exception) - - if maxErrorDepth >= 0 && currentDepth >= maxErrorDepth { - return - } - - switch v := err.(type) { - case interface{ Unwrap() []error }: - unwrapped := v.Unwrap() - for i := range unwrapped { - if unwrapped[i] != nil { - childSource := fmt.Sprintf("errors[%d]", i) - convertErrorDFS(unwrapped[i], exceptions, ¤tID, childSource, visited, maxErrorDepth, currentDepth+1) - } - } - case interface{ Unwrap() error }: - unwrapped := v.Unwrap() - if unwrapped != nil { - convertErrorDFS(unwrapped, exceptions, ¤tID, MechanismTypeUnwrap, visited, maxErrorDepth, currentDepth+1) - } - case interface{ Cause() error }: - cause := v.Cause() - if cause != nil { - convertErrorDFS(cause, exceptions, ¤tID, MechanismSourceCause, visited, maxErrorDepth, currentDepth+1) - } - } -} diff --git a/vendor/github.com/getsentry/sentry-go/hub.go b/vendor/github.com/getsentry/sentry-go/hub.go deleted file mode 100644 index 9bc87261178..00000000000 --- a/vendor/github.com/getsentry/sentry-go/hub.go +++ /dev/null @@ -1,448 +0,0 @@ -package sentry - -import ( - "context" - "fmt" - "sync" - "time" - - "github.com/getsentry/sentry-go/internal/debuglog" -) - -type contextKey int - -// Keys used to store values in a Context. Use with Context.Value to access -// values stored by the SDK. -const ( - // HubContextKey is the key used to store the current Hub. - HubContextKey = contextKey(1) - // RequestContextKey is the key used to store the current http.Request. - RequestContextKey = contextKey(2) -) - -// currentHub is the initial Hub with no Client bound and an empty Scope. -var currentHub = NewHub(nil, NewScope()) - -// Hub is the central object that manages scopes and clients. -// -// This can be used to capture events and manage the scope. -// The default hub that is available automatically. -// -// In most situations developers do not need to interface the hub. Instead -// toplevel convenience functions are exposed that will automatically dispatch -// to global (CurrentHub) hub. In some situations this might not be -// possible in which case it might become necessary to manually work with the -// hub. This is for instance the case when working with async code. -type Hub struct { - mu sync.RWMutex - stack *stack - lastEventID EventID -} - -type layer struct { - // mu protects concurrent reads and writes to client. - mu sync.RWMutex - client *Client - // scope is read-only, not protected by mu. - scope *Scope -} - -// Client returns the layer's client. Safe for concurrent use. -func (l *layer) Client() *Client { - l.mu.RLock() - defer l.mu.RUnlock() - return l.client -} - -// SetClient sets the layer's client. Safe for concurrent use. -func (l *layer) SetClient(c *Client) { - l.mu.Lock() - defer l.mu.Unlock() - l.client = c -} - -type stack []*layer - -// NewHub returns an instance of a Hub with provided Client and Scope bound. -func NewHub(client *Client, scope *Scope) *Hub { - hub := Hub{ - stack: &stack{{ - client: client, - scope: scope, - }}, - } - return &hub -} - -// CurrentHub returns an instance of previously initialized Hub stored in the global namespace. -func CurrentHub() *Hub { - return currentHub -} - -// LastEventID returns the ID of the last event (error or message) captured -// through the hub and sent to the underlying transport. -// -// Transactions and events dropped by sampling or event processors do not change -// the last event ID. -// -// LastEventID is a convenience method to cover use cases in which errors are -// captured indirectly and the ID is needed. For example, it can be used as part -// of an HTTP middleware to log the ID of the last error, if any. -// -// For more flexibility, consider instead using the ClientOptions.BeforeSend -// function or event processors. -func (hub *Hub) LastEventID() EventID { - hub.mu.RLock() - defer hub.mu.RUnlock() - - return hub.lastEventID -} - -// stackTop returns the top layer of the hub stack. Valid hubs always have at -// least one layer, therefore stackTop always return a non-nil pointer. -func (hub *Hub) stackTop() *layer { - hub.mu.RLock() - defer hub.mu.RUnlock() - - stack := hub.stack - stackLen := len(*stack) - top := (*stack)[stackLen-1] - return top -} - -// Clone returns a copy of the current Hub with top-most scope and client copied over. -func (hub *Hub) Clone() *Hub { - top := hub.stackTop() - scope := top.scope - if scope != nil { - scope = scope.Clone() - } - return NewHub(top.Client(), scope) -} - -// Scope returns top-level Scope of the current Hub or nil if no Scope is bound. -func (hub *Hub) Scope() *Scope { - top := hub.stackTop() - return top.scope -} - -// Client returns top-level Client of the current Hub or nil if no Client is bound. -func (hub *Hub) Client() *Client { - top := hub.stackTop() - return top.Client() -} - -// PushScope pushes a new scope for the current Hub and reuses previously bound Client. -func (hub *Hub) PushScope() *Scope { - top := hub.stackTop() - - var scope *Scope - if top.scope != nil { - scope = top.scope.Clone() - } else { - scope = NewScope() - } - - hub.mu.Lock() - defer hub.mu.Unlock() - - *hub.stack = append(*hub.stack, &layer{ - client: top.Client(), - scope: scope, - }) - - return scope -} - -// PopScope drops the most recent scope. -// -// Calls to PopScope must be coordinated with PushScope. For most cases, using -// WithScope should be more convenient. -// -// Calls to PopScope that do not match previous calls to PushScope are silently -// ignored. -func (hub *Hub) PopScope() { - hub.mu.Lock() - defer hub.mu.Unlock() - - stack := *hub.stack - stackLen := len(stack) - if stackLen > 1 { - // Never pop the last item off the stack, the stack should always have - // at least one item. - *hub.stack = stack[0 : stackLen-1] - } -} - -// BindClient binds a new Client for the current Hub. -func (hub *Hub) BindClient(client *Client) { - top := hub.stackTop() - top.SetClient(client) -} - -// WithScope runs f in an isolated temporary scope. -// -// It is useful when extra data should be sent with a single capture call, for -// instance a different level or tags. -// -// The scope passed to f starts as a clone of the current scope and can be -// freely modified without affecting the current scope. -// -// It is a shorthand for PushScope followed by PopScope. -func (hub *Hub) WithScope(f func(scope *Scope)) { - scope := hub.PushScope() - defer hub.PopScope() - f(scope) -} - -// ConfigureScope runs f in the current scope. -// -// It is useful to set data that applies to all events that share the current -// scope. -// -// Modifying the scope affects all references to the current scope. -// -// See also WithScope for making isolated temporary changes. -func (hub *Hub) ConfigureScope(f func(scope *Scope)) { - scope := hub.Scope() - f(scope) -} - -// CaptureEvent calls the method of a same name on currently bound Client instance -// passing it a top-level Scope. -// Returns EventID if successfully, or nil if there's no Scope or Client available. -func (hub *Hub) CaptureEvent(event *Event) *EventID { - client, scope := hub.Client(), hub.Scope() - if client == nil || scope == nil { - return nil - } - eventID := client.CaptureEvent(event, nil, scope) - - if event.Type != transactionType && eventID != nil { - hub.mu.Lock() - hub.lastEventID = *eventID - hub.mu.Unlock() - } - return eventID -} - -// CaptureMessage calls the method of a same name on currently bound Client instance -// passing it a top-level Scope. -// Returns EventID if successfully, or nil if there's no Scope or Client available. -func (hub *Hub) CaptureMessage(message string) *EventID { - client, scope := hub.Client(), hub.Scope() - if client == nil || scope == nil { - return nil - } - eventID := client.CaptureMessage(message, nil, scope) - - if eventID != nil { - hub.mu.Lock() - hub.lastEventID = *eventID - hub.mu.Unlock() - } - return eventID -} - -// CaptureException calls the method of a same name on currently bound Client instance -// passing it a top-level Scope. -// Returns EventID if successfully, or nil if there's no Scope or Client available. -func (hub *Hub) CaptureException(exception error) *EventID { - client, scope := hub.Client(), hub.Scope() - if client == nil || scope == nil { - return nil - } - eventID := client.CaptureException(exception, &EventHint{OriginalException: exception}, scope) - - if eventID != nil { - hub.mu.Lock() - hub.lastEventID = *eventID - hub.mu.Unlock() - } - return eventID -} - -// CaptureCheckIn calls the method of the same name on currently bound Client instance -// passing it a top-level Scope. -// Returns CheckInID if the check-in was captured successfully, or nil otherwise. -func (hub *Hub) CaptureCheckIn(checkIn *CheckIn, monitorConfig *MonitorConfig) *EventID { - client, scope := hub.Client(), hub.Scope() - if client == nil { - return nil - } - - return client.CaptureCheckIn(checkIn, monitorConfig, scope) -} - -// AddBreadcrumb records a new breadcrumb. -// -// The total number of breadcrumbs that can be recorded are limited by the -// configuration on the client. -func (hub *Hub) AddBreadcrumb(breadcrumb *Breadcrumb, hint *BreadcrumbHint) { - client := hub.Client() - - // If there's no client, just store it on the scope straight away - if client == nil { - hub.Scope().AddBreadcrumb(breadcrumb, defaultMaxBreadcrumbs) - return - } - - limit := client.options.MaxBreadcrumbs - switch { - case limit < 0: - return - case limit == 0: - limit = defaultMaxBreadcrumbs - } - - if client.options.BeforeBreadcrumb != nil { - if hint == nil { - hint = &BreadcrumbHint{} - } - if breadcrumb = client.options.BeforeBreadcrumb(breadcrumb, hint); breadcrumb == nil { - debuglog.Println("breadcrumb dropped due to BeforeBreadcrumb callback.") - return - } - } - - hub.Scope().AddBreadcrumb(breadcrumb, limit) -} - -// Recover calls the method of a same name on currently bound Client instance -// passing it a top-level Scope. -// Returns EventID if successfully, or nil if there's no Scope or Client available. -func (hub *Hub) Recover(err interface{}) *EventID { - if err == nil { - err = recover() - } - client, scope := hub.Client(), hub.Scope() - if client == nil || scope == nil { - return nil - } - return client.Recover(err, &EventHint{RecoveredException: err}, scope) -} - -// RecoverWithContext calls the method of a same name on currently bound Client instance -// passing it a top-level Scope. -// Returns EventID if successfully, or nil if there's no Scope or Client available. -func (hub *Hub) RecoverWithContext(ctx context.Context, err interface{}) *EventID { - if err == nil { - err = recover() - } - client, scope := hub.Client(), hub.Scope() - if client == nil || scope == nil { - return nil - } - return client.RecoverWithContext(ctx, err, &EventHint{RecoveredException: err}, scope) -} - -// Flush waits until the underlying Transport sends any buffered events to the -// Sentry server, blocking for at most the given timeout. It returns false if -// the timeout was reached. In that case, some events may not have been sent. -// -// Flush should be called before terminating the program to avoid -// unintentionally dropping events. -// -// Do not call Flush indiscriminately after every call to CaptureEvent, -// CaptureException or CaptureMessage. Instead, to have the SDK send events over -// the network synchronously, configure it to use the HTTPSyncTransport in the -// call to Init. -func (hub *Hub) Flush(timeout time.Duration) bool { - client := hub.Client() - - if client == nil { - return false - } - - return client.Flush(timeout) -} - -// FlushWithContext waits until the underlying Transport sends any buffered events -// to the Sentry server, blocking for at most the duration specified by the context. -// It returns false if the context is canceled before the events are sent. In such a case, -// some events may not be delivered. -// -// FlushWithContext should be called before terminating the program to ensure no -// events are unintentionally dropped. -// -// Avoid calling FlushWithContext indiscriminately after each call to CaptureEvent, -// CaptureException, or CaptureMessage. To send events synchronously over the network, -// configure the SDK to use HTTPSyncTransport during initialization with Init. - -func (hub *Hub) FlushWithContext(ctx context.Context) bool { - client := hub.Client() - - if client == nil { - return false - } - - return client.FlushWithContext(ctx) -} - -// GetTraceparent returns the current Sentry traceparent string, to be used as a HTTP header value -// or HTML meta tag value. -// This function is context aware, as in it either returns the traceparent based -// on the current span, or the scope's propagation context. -func (hub *Hub) GetTraceparent() string { - scope := hub.Scope() - - if scope.span != nil { - return scope.span.ToSentryTrace() - } - - return fmt.Sprintf("%s-%s", scope.propagationContext.TraceID, scope.propagationContext.SpanID) -} - -// GetTraceparentW3C returns the current traceparent string in W3C format. -// This is intended for propagation to downstream services that expect the W3C header. -func (hub *Hub) GetTraceparentW3C() string { - scope := hub.Scope() - if scope.span != nil { - return scope.span.ToTraceparent() - } - - return fmt.Sprintf("00-%s-%s-00", scope.propagationContext.TraceID, scope.propagationContext.SpanID) -} - -// GetBaggage returns the current Sentry baggage string, to be used as a HTTP header value -// or HTML meta tag value. -// This function is context aware, as in it either returns the baggage based -// on the current span or the scope's propagation context. -func (hub *Hub) GetBaggage() string { - scope := hub.Scope() - - if scope.span != nil { - return scope.span.ToBaggage() - } - - return scope.propagationContext.DynamicSamplingContext.String() -} - -// HasHubOnContext checks whether Hub instance is bound to a given Context struct. -func HasHubOnContext(ctx context.Context) bool { - _, ok := ctx.Value(HubContextKey).(*Hub) - return ok -} - -// GetHubFromContext tries to retrieve Hub instance from the given Context struct -// or return nil if one is not found. -func GetHubFromContext(ctx context.Context) *Hub { - if hub, ok := ctx.Value(HubContextKey).(*Hub); ok { - return hub - } - return nil -} - -// hubFromContext returns either a hub stored in the context or the current hub. -// The return value is guaranteed to be non-nil, unlike GetHubFromContext. -func hubFromContext(ctx context.Context) *Hub { - if hub, ok := ctx.Value(HubContextKey).(*Hub); ok { - return hub - } - return currentHub -} - -// SetHubOnContext stores given Hub instance on the Context struct and returns a new Context. -func SetHubOnContext(ctx context.Context, hub *Hub) context.Context { - return context.WithValue(ctx, HubContextKey, hub) -} diff --git a/vendor/github.com/getsentry/sentry-go/integrations.go b/vendor/github.com/getsentry/sentry-go/integrations.go deleted file mode 100644 index 60cc73d5756..00000000000 --- a/vendor/github.com/getsentry/sentry-go/integrations.go +++ /dev/null @@ -1,393 +0,0 @@ -package sentry - -import ( - "fmt" - "os" - "regexp" - "runtime" - "runtime/debug" - "strings" - "sync" - - "github.com/getsentry/sentry-go/internal/debuglog" -) - -// ================================ -// Modules Integration -// ================================ - -type modulesIntegration struct { - once sync.Once - modules map[string]string -} - -func (mi *modulesIntegration) Name() string { - return "Modules" -} - -func (mi *modulesIntegration) SetupOnce(client *Client) { - client.AddEventProcessor(mi.processor) -} - -func (mi *modulesIntegration) processor(event *Event, _ *EventHint) *Event { - if len(event.Modules) == 0 { - mi.once.Do(func() { - info, ok := debug.ReadBuildInfo() - if !ok { - debuglog.Print("The Modules integration is not available in binaries built without module support.") - return - } - mi.modules = extractModules(info) - }) - } - event.Modules = mi.modules - return event -} - -func extractModules(info *debug.BuildInfo) map[string]string { - modules := map[string]string{ - info.Main.Path: info.Main.Version, - } - for _, dep := range info.Deps { - ver := dep.Version - if dep.Replace != nil { - ver += fmt.Sprintf(" => %s %s", dep.Replace.Path, dep.Replace.Version) - } - modules[dep.Path] = strings.TrimSuffix(ver, " ") - } - return modules -} - -// ================================ -// Environment Integration -// ================================ - -type environmentIntegration struct{} - -func (ei *environmentIntegration) Name() string { - return "Environment" -} - -func (ei *environmentIntegration) SetupOnce(client *Client) { - client.AddEventProcessor(ei.processor) -} - -func (ei *environmentIntegration) processor(event *Event, _ *EventHint) *Event { - // Initialize maps as necessary. - contextNames := []string{"device", "os", "runtime"} - if event.Contexts == nil { - event.Contexts = make(map[string]Context, len(contextNames)) - } - for _, name := range contextNames { - if event.Contexts[name] == nil { - event.Contexts[name] = make(Context) - } - } - - // Set contextual information preserving existing data. For each context, if - // the existing value is not of type map[string]interface{}, then no - // additional information is added. - if deviceContext, ok := event.Contexts["device"]; ok { - if _, ok := deviceContext["arch"]; !ok { - deviceContext["arch"] = runtime.GOARCH - } - if _, ok := deviceContext["num_cpu"]; !ok { - deviceContext["num_cpu"] = runtime.NumCPU() - } - } - if osContext, ok := event.Contexts["os"]; ok { - if _, ok := osContext["name"]; !ok { - osContext["name"] = runtime.GOOS - } - } - if runtimeContext, ok := event.Contexts["runtime"]; ok { - if _, ok := runtimeContext["name"]; !ok { - runtimeContext["name"] = "go" - } - if _, ok := runtimeContext["version"]; !ok { - runtimeContext["version"] = runtime.Version() - } - if _, ok := runtimeContext["go_numroutines"]; !ok { - runtimeContext["go_numroutines"] = runtime.NumGoroutine() - } - if _, ok := runtimeContext["go_maxprocs"]; !ok { - runtimeContext["go_maxprocs"] = runtime.GOMAXPROCS(0) - } - if _, ok := runtimeContext["go_numcgocalls"]; !ok { - runtimeContext["go_numcgocalls"] = runtime.NumCgoCall() - } - } - return event -} - -// ================================ -// Ignore Errors Integration -// ================================ - -type ignoreErrorsIntegration struct { - ignoreErrors []*regexp.Regexp -} - -func (iei *ignoreErrorsIntegration) Name() string { - return "IgnoreErrors" -} - -func (iei *ignoreErrorsIntegration) SetupOnce(client *Client) { - iei.ignoreErrors = transformStringsIntoRegexps(client.options.IgnoreErrors) - client.AddEventProcessor(iei.processor) -} - -func (iei *ignoreErrorsIntegration) processor(event *Event, _ *EventHint) *Event { - suspects := getIgnoreErrorsSuspects(event) - - for _, suspect := range suspects { - for _, pattern := range iei.ignoreErrors { - if pattern.Match([]byte(suspect)) || strings.Contains(suspect, pattern.String()) { - debuglog.Printf("Event dropped due to being matched by `IgnoreErrors` option."+ - "| Value matched: %s | Filter used: %s", suspect, pattern) - return nil - } - } - } - - return event -} - -func transformStringsIntoRegexps(strings []string) []*regexp.Regexp { - var exprs []*regexp.Regexp - - for _, s := range strings { - r, err := regexp.Compile(s) - if err == nil { - exprs = append(exprs, r) - } - } - - return exprs -} - -func getIgnoreErrorsSuspects(event *Event) []string { - suspects := []string{} - - if event.Message != "" { - suspects = append(suspects, event.Message) - } - - for _, ex := range event.Exception { - suspects = append(suspects, ex.Type, ex.Value) - } - - return suspects -} - -// ================================ -// Ignore Transactions Integration -// ================================ - -type ignoreTransactionsIntegration struct { - ignoreTransactions []*regexp.Regexp -} - -func (iei *ignoreTransactionsIntegration) Name() string { - return "IgnoreTransactions" -} - -func (iei *ignoreTransactionsIntegration) SetupOnce(client *Client) { - iei.ignoreTransactions = transformStringsIntoRegexps(client.options.IgnoreTransactions) - client.AddEventProcessor(iei.processor) -} - -func (iei *ignoreTransactionsIntegration) processor(event *Event, _ *EventHint) *Event { - suspect := event.Transaction - if suspect == "" { - return event - } - - for _, pattern := range iei.ignoreTransactions { - if pattern.Match([]byte(suspect)) || strings.Contains(suspect, pattern.String()) { - debuglog.Printf("Transaction dropped due to being matched by `IgnoreTransactions` option."+ - "| Value matched: %s | Filter used: %s", suspect, pattern) - return nil - } - } - - return event -} - -// ================================ -// Contextify Frames Integration -// ================================ - -type contextifyFramesIntegration struct { - sr sourceReader - contextLines int - cachedLocations sync.Map -} - -func (cfi *contextifyFramesIntegration) Name() string { - return "ContextifyFrames" -} - -func (cfi *contextifyFramesIntegration) SetupOnce(client *Client) { - cfi.sr = newSourceReader() - cfi.contextLines = 5 - - client.AddEventProcessor(cfi.processor) -} - -func (cfi *contextifyFramesIntegration) processor(event *Event, _ *EventHint) *Event { - // Range over all exceptions - for _, ex := range event.Exception { - // If it has no stacktrace, just bail out - if ex.Stacktrace == nil { - continue - } - - // If it does, it should have frames, so try to contextify them - ex.Stacktrace.Frames = cfi.contextify(ex.Stacktrace.Frames) - } - - // Range over all threads - for _, th := range event.Threads { - // If it has no stacktrace, just bail out - if th.Stacktrace == nil { - continue - } - - // If it does, it should have frames, so try to contextify them - th.Stacktrace.Frames = cfi.contextify(th.Stacktrace.Frames) - } - - return event -} - -func (cfi *contextifyFramesIntegration) contextify(frames []Frame) []Frame { - contextifiedFrames := make([]Frame, 0, len(frames)) - - for _, frame := range frames { - if !frame.InApp { - contextifiedFrames = append(contextifiedFrames, frame) - continue - } - - var path string - - if cachedPath, ok := cfi.cachedLocations.Load(frame.AbsPath); ok { - if p, ok := cachedPath.(string); ok { - path = p - } - } else { - // Optimize for happy path here - if fileExists(frame.AbsPath) { - path = frame.AbsPath - } else { - path = cfi.findNearbySourceCodeLocation(frame.AbsPath) - } - } - - if path == "" { - contextifiedFrames = append(contextifiedFrames, frame) - continue - } - - lines, contextLine := cfi.sr.readContextLines(path, frame.Lineno, cfi.contextLines) - contextifiedFrames = append(contextifiedFrames, cfi.addContextLinesToFrame(frame, lines, contextLine)) - } - - return contextifiedFrames -} - -func (cfi *contextifyFramesIntegration) findNearbySourceCodeLocation(originalPath string) string { - trimmedPath := strings.TrimPrefix(originalPath, "/") - components := strings.Split(trimmedPath, "/") - - for len(components) > 0 { - components = components[1:] - possibleLocation := strings.Join(components, "/") - - if fileExists(possibleLocation) { - cfi.cachedLocations.Store(originalPath, possibleLocation) - return possibleLocation - } - } - - cfi.cachedLocations.Store(originalPath, "") - return "" -} - -func (cfi *contextifyFramesIntegration) addContextLinesToFrame(frame Frame, lines [][]byte, contextLine int) Frame { - for i, line := range lines { - switch { - case i < contextLine: - frame.PreContext = append(frame.PreContext, string(line)) - case i == contextLine: - frame.ContextLine = string(line) - default: - frame.PostContext = append(frame.PostContext, string(line)) - } - } - return frame -} - -// ================================ -// Global Tags Integration -// ================================ - -const envTagsPrefix = "SENTRY_TAGS_" - -type globalTagsIntegration struct { - tags map[string]string - envTags map[string]string -} - -func (ti *globalTagsIntegration) Name() string { - return "GlobalTags" -} - -func (ti *globalTagsIntegration) SetupOnce(client *Client) { - ti.tags = make(map[string]string, len(client.options.Tags)) - for k, v := range client.options.Tags { - ti.tags[k] = v - } - - ti.envTags = loadEnvTags() - - client.AddEventProcessor(ti.processor) -} - -func (ti *globalTagsIntegration) processor(event *Event, _ *EventHint) *Event { - if len(ti.tags) == 0 && len(ti.envTags) == 0 { - return event - } - - if event.Tags == nil { - event.Tags = make(map[string]string, len(ti.tags)+len(ti.envTags)) - } - - for k, v := range ti.tags { - if _, ok := event.Tags[k]; !ok { - event.Tags[k] = v - } - } - - for k, v := range ti.envTags { - if _, ok := event.Tags[k]; !ok { - event.Tags[k] = v - } - } - - return event -} - -func loadEnvTags() map[string]string { - tags := map[string]string{} - for _, pair := range os.Environ() { - parts := strings.Split(pair, "=") - if !strings.HasPrefix(parts[0], envTagsPrefix) { - continue - } - tag := strings.TrimPrefix(parts[0], envTagsPrefix) - tags[tag] = parts[1] - } - return tags -} diff --git a/vendor/github.com/getsentry/sentry-go/interfaces.go b/vendor/github.com/getsentry/sentry-go/interfaces.go deleted file mode 100644 index d00539a448b..00000000000 --- a/vendor/github.com/getsentry/sentry-go/interfaces.go +++ /dev/null @@ -1,785 +0,0 @@ -package sentry - -import ( - "context" - "encoding/json" - "fmt" - "net" - "net/http" - "strings" - "time" - - "github.com/getsentry/sentry-go/attribute" - "github.com/getsentry/sentry-go/internal/debuglog" - "github.com/getsentry/sentry-go/internal/protocol" - "github.com/getsentry/sentry-go/internal/ratelimit" -) - -const errorType = "" -const eventType = "event" -const transactionType = "transaction" -const checkInType = "check_in" - -var logEvent = struct { - Type string - ContentType string -}{ - "log", - "application/vnd.sentry.items.log+json", -} - -var traceMetricEvent = struct { - Type string - ContentType string -}{ - "trace_metric", - "application/vnd.sentry.items.trace-metric+json", -} - -// Level marks the severity of the event. -type Level string - -// Describes the severity of the event. -const ( - LevelDebug Level = "debug" - LevelInfo Level = "info" - LevelWarning Level = "warning" - LevelError Level = "error" - LevelFatal Level = "fatal" -) - -// SdkInfo contains all metadata about the SDK. -type SdkInfo = protocol.SdkInfo -type SdkPackage = protocol.SdkPackage - -// TODO: This type could be more useful, as map of interface{} is too generic -// and requires a lot of type assertions in beforeBreadcrumb calls -// plus it could just be map[string]interface{} then. - -// BreadcrumbHint contains information that can be associated with a Breadcrumb. -type BreadcrumbHint map[string]interface{} - -// Breadcrumb specifies an application event that occurred before a Sentry event. -// An event may contain one or more breadcrumbs. -type Breadcrumb struct { - Type string `json:"type,omitempty"` - Category string `json:"category,omitempty"` - Message string `json:"message,omitempty"` - Data map[string]interface{} `json:"data,omitempty"` - Level Level `json:"level,omitempty"` - Timestamp time.Time `json:"timestamp,omitzero"` -} - -// TODO: provide constants for known breadcrumb types. -// See https://develop.sentry.dev/sdk/event-payloads/breadcrumbs/#breadcrumb-types. - -// Logger provides a chaining API for structured logging to Sentry. -type Logger interface { - // Write implements the io.Writer interface. Currently, the [sentry.Hub] is - // context aware, in order to get the correct trace correlation. Using this - // might result in incorrect span association on logs. If you need to use - // Write it is recommended to create a NewLogger so that the associated context - // is passed correctly. - Write(p []byte) (n int, err error) - - // SetAttributes allows attaching parameters to the logger using the attribute API. - // These attributes will be included in all subsequent log entries. - SetAttributes(...attribute.Builder) - - // Trace defines the [sentry.LogLevel] for the log entry. - Trace() LogEntry - // Debug defines the [sentry.LogLevel] for the log entry. - Debug() LogEntry - // Info defines the [sentry.LogLevel] for the log entry. - Info() LogEntry - // Warn defines the [sentry.LogLevel] for the log entry. - Warn() LogEntry - // Error defines the [sentry.LogLevel] for the log entry. - Error() LogEntry - // Fatal defines the [sentry.LogLevel] for the log entry. - Fatal() LogEntry - // Panic defines the [sentry.LogLevel] for the log entry. - Panic() LogEntry - // LFatal defines the [sentry.LogLevel] for the log entry. This only sets - // the level to fatal, but does not panic or exit. - LFatal() LogEntry - // GetCtx returns the [context.Context] set on the logger. - GetCtx() context.Context -} - -// LogEntry defines the interface for a log entry that supports chaining attributes. -type LogEntry interface { - // WithCtx creates a new LogEntry with the specified context without overwriting the previous one. - WithCtx(ctx context.Context) LogEntry - // String adds a string attribute to the LogEntry. - String(key, value string) LogEntry - // Int adds an int attribute to the LogEntry. - Int(key string, value int) LogEntry - // Int64 adds an int64 attribute to the LogEntry. - Int64(key string, value int64) LogEntry - // Float64 adds a float64 attribute to the LogEntry. - Float64(key string, value float64) LogEntry - // Bool adds a bool attribute to the LogEntry. - Bool(key string, value bool) LogEntry - // Emit emits the LogEntry with the provided arguments. - Emit(args ...interface{}) - // Emitf emits the LogEntry using a format string and arguments. - Emitf(format string, args ...interface{}) -} - -// Meter provides an interface for recording metrics. -type Meter interface { - // WithCtx returns a new Meter that uses the given context for trace/span association. - WithCtx(ctx context.Context) Meter - // SetAttributes allows attaching parameters to the meter using the attribute API. - // These attributes will be included in all subsequent metrics. - SetAttributes(attrs ...attribute.Builder) - // Count records a count metric. - Count(name string, count int64, opts ...MeterOption) - // Gauge records a gauge metric. - Gauge(name string, value float64, opts ...MeterOption) - // Distribution records a distribution metric. - Distribution(name string, sample float64, opts ...MeterOption) -} - -// MeterOption configures a metric recording call. -type MeterOption func(*meterOptions) - -type meterOptions struct { - unit string - scope *Scope - attributes map[string]attribute.Value -} - -// WithUnit sets the unit for the metric (e.g., "millisecond", "byte"). -func WithUnit(unit string) MeterOption { - return func(o *meterOptions) { - o.unit = unit - } -} - -// WithScopeOverride sets a custom scope for the metric, overriding the default scope from the hub. -func WithScopeOverride(scope *Scope) MeterOption { - return func(o *meterOptions) { - o.scope = scope - } -} - -// WithAttributes sets attributes for the metric. -func WithAttributes(attrs ...attribute.Builder) MeterOption { - return func(o *meterOptions) { - if o.attributes == nil { - o.attributes = make(map[string]attribute.Value, len(attrs)) - } - for _, a := range attrs { - if a.Value.Type() == attribute.INVALID { - debuglog.Printf("invalid attribute: %v", a) - continue - } - o.attributes[a.Key] = a.Value - } - } -} - -// Attachment allows associating files with your events to aid in investigation. -// An event may contain one or more attachments. -type Attachment struct { - Filename string - ContentType string - Payload []byte -} - -// User describes the user associated with an Event. If this is used, at least -// an ID or an IP address should be provided. -type User struct { - ID string `json:"id,omitempty"` - Email string `json:"email,omitempty"` - IPAddress string `json:"ip_address,omitempty"` - Username string `json:"username,omitempty"` - Name string `json:"name,omitempty"` - Data map[string]string `json:"data,omitempty"` -} - -func (u User) IsEmpty() bool { - if u.ID != "" { - return false - } - - if u.Email != "" { - return false - } - - if u.IPAddress != "" { - return false - } - - if u.Username != "" { - return false - } - - if u.Name != "" { - return false - } - - if len(u.Data) > 0 { - return false - } - - return true -} - -// Request contains information on a HTTP request related to the event. -type Request struct { - URL string `json:"url,omitempty"` - Method string `json:"method,omitempty"` - Data string `json:"data,omitempty"` - QueryString string `json:"query_string,omitempty"` - Cookies string `json:"cookies,omitempty"` - Headers map[string]string `json:"headers,omitempty"` - Env map[string]string `json:"env,omitempty"` -} - -var sensitiveHeaders = map[string]struct{}{ - "_csrf": {}, - "_csrf_token": {}, - "_session": {}, - "_xsrf": {}, - "Api-Key": {}, - "Apikey": {}, - "Auth": {}, - "Authorization": {}, - "Cookie": {}, - "Credentials": {}, - "Csrf": {}, - "Csrf-Token": {}, - "Csrftoken": {}, - "Ip-Address": {}, - "Passwd": {}, - "Password": {}, - "Private-Key": {}, - "Privatekey": {}, - "Proxy-Authorization": {}, - "Remote-Addr": {}, - "Secret": {}, - "Session": {}, - "Sessionid": {}, - "Token": {}, - "User-Session": {}, - "X-Api-Key": {}, - "X-Csrftoken": {}, - "X-Forwarded-For": {}, - "X-Real-Ip": {}, - "XSRF-TOKEN": {}, -} - -// NewRequest returns a new Sentry Request from the given http.Request. -// -// NewRequest avoids operations that depend on network access. In particular, it -// does not read r.Body. -func NewRequest(r *http.Request) *Request { - prot := protocol.SchemeHTTP - if r.TLS != nil || r.Header.Get("X-Forwarded-Proto") == "https" { - prot = protocol.SchemeHTTPS - } - url := fmt.Sprintf("%s://%s%s", prot, r.Host, r.URL.Path) - - var cookies string - var env map[string]string - headers := map[string]string{} - - if client := CurrentHub().Client(); client != nil && client.options.SendDefaultPII { - // We read only the first Cookie header because of the specification: - // https://tools.ietf.org/html/rfc6265#section-5.4 - // When the user agent generates an HTTP request, the user agent MUST NOT - // attach more than one Cookie header field. - cookies = r.Header.Get("Cookie") - - headers = make(map[string]string, len(r.Header)) - for k, v := range r.Header { - headers[k] = strings.Join(v, ",") - } - - if addr, port, err := net.SplitHostPort(r.RemoteAddr); err == nil { - env = map[string]string{"REMOTE_ADDR": addr, "REMOTE_PORT": port} - } - } else { - for k, v := range r.Header { - if _, ok := sensitiveHeaders[k]; !ok { - headers[k] = strings.Join(v, ",") - } - } - } - - headers["Host"] = r.Host - - return &Request{ - URL: url, - Method: r.Method, - QueryString: r.URL.RawQuery, - Cookies: cookies, - Headers: headers, - Env: env, - } -} - -// Mechanism is the mechanism by which an exception was generated and handled. -type Mechanism struct { - Type string `json:"type"` - Description string `json:"description,omitempty"` - HelpLink string `json:"help_link,omitempty"` - Source string `json:"source,omitempty"` - Handled *bool `json:"handled,omitempty"` - ParentID *int `json:"parent_id,omitempty"` - ExceptionID int `json:"exception_id"` - IsExceptionGroup bool `json:"is_exception_group,omitempty"` - Data map[string]any `json:"data,omitempty"` -} - -// SetUnhandled indicates that the exception is an unhandled exception, i.e. -// from a panic. -func (m *Mechanism) SetUnhandled() { - m.Handled = Pointer(false) -} - -// Exception specifies an error that occurred. -type Exception struct { - Type string `json:"type,omitempty"` // used as the main issue title - Value string `json:"value,omitempty"` // used as the main issue subtitle - Module string `json:"module,omitempty"` - ThreadID uint64 `json:"thread_id,omitempty"` - Stacktrace *Stacktrace `json:"stacktrace,omitempty"` - Mechanism *Mechanism `json:"mechanism,omitempty"` -} - -// SDKMetaData is a struct to stash data which is needed at some point in the SDK's event processing pipeline -// but which shouldn't get send to Sentry. -type SDKMetaData struct { - dsc DynamicSamplingContext -} - -// Contains information about how the name of the transaction was determined. -type TransactionInfo struct { - Source TransactionSource `json:"source,omitempty"` -} - -// The DebugMeta interface is not used in Golang apps, but may be populated -// when proxying Events from other platforms, like iOS, Android, and the -// Web. (See: https://develop.sentry.dev/sdk/event-payloads/debugmeta/ ). -type DebugMeta struct { - SdkInfo *DebugMetaSdkInfo `json:"sdk_info,omitempty"` - Images []DebugMetaImage `json:"images,omitempty"` -} - -type DebugMetaSdkInfo struct { - SdkName string `json:"sdk_name,omitempty"` - VersionMajor int `json:"version_major,omitempty"` - VersionMinor int `json:"version_minor,omitempty"` - VersionPatchlevel int `json:"version_patchlevel,omitempty"` -} - -type DebugMetaImage struct { - Type string `json:"type,omitempty"` // all - ImageAddr string `json:"image_addr,omitempty"` // macho,elf,pe - ImageSize int `json:"image_size,omitempty"` // macho,elf,pe - DebugID string `json:"debug_id,omitempty"` // macho,elf,pe,wasm,sourcemap - DebugFile string `json:"debug_file,omitempty"` // macho,elf,pe,wasm - CodeID string `json:"code_id,omitempty"` // macho,elf,pe,wasm - CodeFile string `json:"code_file,omitempty"` // macho,elf,pe,wasm,sourcemap - ImageVmaddr string `json:"image_vmaddr,omitempty"` // macho,elf,pe - Arch string `json:"arch,omitempty"` // macho,elf,pe - UUID string `json:"uuid,omitempty"` // proguard -} - -// EventID is a hexadecimal string representing a unique uuid4 for an Event. -// An EventID must be 32 characters long, lowercase and not have any dashes. -type EventID string - -type Context = map[string]interface{} - -// Event is the fundamental data structure that is sent to Sentry. -type Event struct { - Breadcrumbs []*Breadcrumb `json:"breadcrumbs,omitempty"` - Contexts map[string]Context `json:"contexts,omitempty"` - Dist string `json:"dist,omitempty"` - Environment string `json:"environment,omitempty"` - EventID EventID `json:"event_id,omitempty"` - Extra map[string]interface{} `json:"extra,omitempty"` - Fingerprint []string `json:"fingerprint,omitempty"` - Level Level `json:"level,omitempty"` - Message string `json:"message,omitempty"` - Platform string `json:"platform,omitempty"` - Release string `json:"release,omitempty"` - Sdk SdkInfo `json:"sdk,omitempty"` - ServerName string `json:"server_name,omitempty"` - Threads []Thread `json:"threads,omitempty"` - Tags map[string]string `json:"tags,omitempty"` - Timestamp time.Time `json:"timestamp,omitzero"` - Transaction string `json:"transaction,omitempty"` - User User `json:"user,omitempty"` - Logger string `json:"logger,omitempty"` - Modules map[string]string `json:"modules,omitempty"` - Request *Request `json:"request,omitempty"` - Exception []Exception `json:"exception,omitempty"` - DebugMeta *DebugMeta `json:"debug_meta,omitempty"` - Attachments []*Attachment `json:"-"` - - // The fields below are only relevant for transactions. - - Type string `json:"type,omitempty"` - StartTime time.Time `json:"start_timestamp,omitzero"` - Spans []*Span `json:"spans,omitempty"` - TransactionInfo *TransactionInfo `json:"transaction_info,omitempty"` - - // The fields below are only relevant for crons/check ins - - CheckIn *CheckIn `json:"check_in,omitempty"` - MonitorConfig *MonitorConfig `json:"monitor_config,omitempty"` - - // The fields below are only relevant for logs - Logs []Log `json:"-"` - - // The fields below are only relevant for metrics - Metrics []Metric `json:"-"` - - // The fields below are not part of the final JSON payload. - - sdkMetaData SDKMetaData -} - -// SetException appends the unwrapped errors to the event's exception list. -// -// maxErrorDepth is the maximum depth of the error chain we will look -// into while unwrapping the errors. If maxErrorDepth is -1, we will -// unwrap all errors in the chain. -func (e *Event) SetException(exception error, maxErrorDepth int) { - if exception == nil { - return - } - - exceptions := convertErrorToExceptions(exception, maxErrorDepth) - if len(exceptions) == 0 { - return - } - - e.Exception = exceptions -} - -// ToEnvelopeItem converts the Event to a Sentry envelope item. -func (e *Event) ToEnvelopeItem() (*protocol.EnvelopeItem, error) { - eventBody, err := json.Marshal(e) - if err != nil { - // Try fallback: remove problematic fields and retry - e.Breadcrumbs = nil - e.Contexts = nil - e.Extra = map[string]interface{}{ - "info": fmt.Sprintf("Could not encode original event as JSON. "+ - "Succeeded by removing Breadcrumbs, Contexts and Extra. "+ - "Please verify the data you attach to the scope. "+ - "Error: %s", err), - } - - eventBody, err = json.Marshal(e) - if err != nil { - return nil, fmt.Errorf("event could not be marshaled even with fallback: %w", err) - } - - DebugLogger.Printf("Event marshaling succeeded with fallback after removing problematic fields") - } - - // TODO: all event types should be abstracted to implement EnvelopeItemConvertible and convert themselves. - var item *protocol.EnvelopeItem - switch e.Type { - case transactionType: - item = protocol.NewEnvelopeItem(protocol.EnvelopeItemTypeTransaction, eventBody) - case checkInType: - item = protocol.NewEnvelopeItem(protocol.EnvelopeItemTypeCheckIn, eventBody) - case logEvent.Type: - item = protocol.NewLogItem(len(e.Logs), eventBody) - case traceMetricEvent.Type: - item = protocol.NewTraceMetricItem(len(e.Metrics), eventBody) - default: - item = protocol.NewEnvelopeItem(protocol.EnvelopeItemTypeEvent, eventBody) - } - - return item, nil -} - -// GetCategory returns the rate limit category for this event. -func (e *Event) GetCategory() ratelimit.Category { - return e.toCategory() -} - -// GetEventID returns the event ID. -func (e *Event) GetEventID() string { - return string(e.EventID) -} - -// GetSdkInfo returns SDK information for the envelope header. -func (e *Event) GetSdkInfo() *protocol.SdkInfo { - return &e.Sdk -} - -// GetDynamicSamplingContext returns trace context for the envelope header. -func (e *Event) GetDynamicSamplingContext() map[string]string { - trace := make(map[string]string) - if dsc := e.sdkMetaData.dsc; dsc.HasEntries() { - for k, v := range dsc.Entries { - trace[k] = v - } - } - return trace -} - -// TODO: Event.Contexts map[string]interface{} => map[string]EventContext, -// to prevent accidentally storing T when we mean *T. -// For example, the TraceContext must be stored as *TraceContext to pick up the -// MarshalJSON method (and avoid copying). -// type EventContext interface{ EventContext() } - -// MarshalJSON converts the Event struct to JSON. -func (e *Event) MarshalJSON() ([]byte, error) { - if e.Type == checkInType { - return e.checkInMarshalJSON() - } - return e.defaultMarshalJSON() -} - -func (e *Event) defaultMarshalJSON() ([]byte, error) { - // event aliases Event to allow calling json.Marshal without an infinite - // loop. It preserves all fields while none of the attached methods. - type event Event - - if e.Type == transactionType { - return json.Marshal(struct{ *event }{(*event)(e)}) - } - // metrics and logs should be serialized under the same `items` json field. - if e.Type == logEvent.Type { - type logEvent struct { - *event - Items []Log `json:"items,omitempty"` - Type json.RawMessage `json:"type,omitempty"` - } - return json.Marshal(logEvent{event: (*event)(e), Items: e.Logs}) - } - - if e.Type == traceMetricEvent.Type { - type metricEvent struct { - *event - Items []Metric `json:"items,omitempty"` - Type json.RawMessage `json:"type,omitempty"` - } - return json.Marshal(metricEvent{event: (*event)(e), Items: e.Metrics}) - } - - // errorEvent is like Event with shadowed fields for customizing JSON - // marshaling. - type errorEvent struct { - *event - - // The fields below are not part of error events and only make sense to - // be sent for transactions. They shadow the respective fields in Event - // and are meant to remain nil, triggering the omitempty behavior. - - Type json.RawMessage `json:"type,omitempty"` - StartTime json.RawMessage `json:"start_timestamp,omitempty"` - Spans json.RawMessage `json:"spans,omitempty"` - TransactionInfo json.RawMessage `json:"transaction_info,omitempty"` - } - - x := errorEvent{event: (*event)(e)} - return json.Marshal(x) -} - -func (e *Event) checkInMarshalJSON() ([]byte, error) { - checkIn := serializedCheckIn{ - CheckInID: string(e.CheckIn.ID), - MonitorSlug: e.CheckIn.MonitorSlug, - Status: e.CheckIn.Status, - Duration: e.CheckIn.Duration.Seconds(), - Release: e.Release, - Environment: e.Environment, - MonitorConfig: nil, - } - - if e.MonitorConfig != nil { - checkIn.MonitorConfig = &MonitorConfig{ - Schedule: e.MonitorConfig.Schedule, - CheckInMargin: e.MonitorConfig.CheckInMargin, - MaxRuntime: e.MonitorConfig.MaxRuntime, - Timezone: e.MonitorConfig.Timezone, - FailureIssueThreshold: e.MonitorConfig.FailureIssueThreshold, - RecoveryThreshold: e.MonitorConfig.RecoveryThreshold, - } - } - - return json.Marshal(checkIn) -} - -func (e *Event) toCategory() ratelimit.Category { - switch e.Type { - case errorType: - return ratelimit.CategoryError - case transactionType: - return ratelimit.CategoryTransaction - case logEvent.Type: - return ratelimit.CategoryLog - case checkInType: - return ratelimit.CategoryMonitor - case traceMetricEvent.Type: - return ratelimit.CategoryTraceMetric - default: - return ratelimit.CategoryUnknown - } -} - -// NewEvent creates a new Event. -func NewEvent() *Event { - return &Event{ - Contexts: make(map[string]Context), - Extra: make(map[string]interface{}), - Tags: make(map[string]string), - Modules: make(map[string]string), - } -} - -// Thread specifies threads that were running at the time of an event. -type Thread struct { - ID string `json:"id,omitempty"` - Name string `json:"name,omitempty"` - Stacktrace *Stacktrace `json:"stacktrace,omitempty"` - Crashed bool `json:"crashed,omitempty"` - Current bool `json:"current,omitempty"` -} - -// EventHint contains information that can be associated with an Event. -type EventHint struct { - Data interface{} - EventID string - OriginalException error - RecoveredException interface{} - Context context.Context - Request *http.Request - Response *http.Response -} - -type Log struct { - Timestamp time.Time `json:"timestamp,omitzero"` - TraceID TraceID `json:"trace_id"` - SpanID SpanID `json:"span_id,omitzero"` - Level LogLevel `json:"level"` - Severity int `json:"severity_number,omitempty"` - Body string `json:"body"` - Attributes map[string]attribute.Value `json:"attributes,omitempty"` -} - -// GetCategory returns the rate limit category for logs. -func (l *Log) GetCategory() ratelimit.Category { - return ratelimit.CategoryLog -} - -// GetEventID returns empty string (event ID set when batching). -func (l *Log) GetEventID() string { - return "" -} - -// GetSdkInfo returns nil (SDK info set when batching). -func (l *Log) GetSdkInfo() *protocol.SdkInfo { - return nil -} - -// GetDynamicSamplingContext returns nil (trace context set when batching). -func (l *Log) GetDynamicSamplingContext() map[string]string { - return nil -} - -type MetricType string - -const ( - MetricTypeInvalid MetricType = "" - MetricTypeCounter MetricType = "counter" - MetricTypeGauge MetricType = "gauge" - MetricTypeDistribution MetricType = "distribution" -) - -type Metric struct { - Timestamp time.Time `json:"timestamp,omitzero"` - TraceID TraceID `json:"trace_id"` - SpanID SpanID `json:"span_id,omitzero"` - Type MetricType `json:"type"` - Name string `json:"name"` - Value MetricValue `json:"value"` - Unit string `json:"unit,omitempty"` - Attributes map[string]attribute.Value `json:"attributes,omitempty"` -} - -// GetCategory returns the rate limit category for metrics. -func (m *Metric) GetCategory() ratelimit.Category { - return ratelimit.CategoryTraceMetric -} - -// GetEventID returns empty string (event ID set when batching). -func (m *Metric) GetEventID() string { - return "" -} - -// GetSdkInfo returns nil (SDK info set when batching). -func (m *Metric) GetSdkInfo() *protocol.SdkInfo { - return nil -} - -// GetDynamicSamplingContext returns nil (trace context set when batching). -func (m *Metric) GetDynamicSamplingContext() map[string]string { - return nil -} - -// MetricValue stores metric values with full precision. -// It supports int64 (for counters) and float64 (for gauges and distributions). -type MetricValue struct { - value attribute.Value -} - -// Int64MetricValue creates a MetricValue from an int64. -// Used for counter metrics to preserve full int64 precision. -func Int64MetricValue(v int64) MetricValue { - return MetricValue{value: attribute.Int64Value(v)} -} - -// Float64MetricValue creates a MetricValue from a float64. -// Used for gauge and distribution metrics. -func Float64MetricValue(v float64) MetricValue { - return MetricValue{value: attribute.Float64Value(v)} -} - -// Type returns the type of the stored value (attribute.INT64 or attribute.FLOAT64). -func (v MetricValue) Type() attribute.Type { - return v.value.Type() -} - -// Int64 returns the value as int64 if it holds an int64. -// The second return value indicates whether the type matched. -func (v MetricValue) Int64() (int64, bool) { - if v.value.Type() == attribute.INT64 { - return v.value.AsInt64(), true - } - return 0, false -} - -// Float64 returns the value as float64 if it holds a float64. -// The second return value indicates whether the type matched. -func (v MetricValue) Float64() (float64, bool) { - if v.value.Type() == attribute.FLOAT64 { - return v.value.AsFloat64(), true - } - return 0, false -} - -// AsInterface returns the value as int64 or float64. -// Use type assertion or type switch to handle the result. -func (v MetricValue) AsInterface() any { - return v.value.AsInterface() -} - -// MarshalJSON serializes the value as a bare number. -func (v MetricValue) MarshalJSON() ([]byte, error) { - return json.Marshal(v.value.AsInterface()) -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/debug/transport.go b/vendor/github.com/getsentry/sentry-go/internal/debug/transport.go deleted file mode 100644 index 199c3a30339..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/debug/transport.go +++ /dev/null @@ -1,79 +0,0 @@ -package debug - -import ( - "bytes" - "fmt" - "io" - "net/http" - "net/http/httptrace" - "net/http/httputil" -) - -// Transport implements http.RoundTripper and can be used to wrap other HTTP -// transports for debugging, normally http.DefaultTransport. -type Transport struct { - http.RoundTripper - Output io.Writer - // Dump controls whether to dump HTTP request and responses. - Dump bool - // Trace enables usage of net/http/httptrace. - Trace bool -} - -func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) { - var buf bytes.Buffer - if t.Dump { - b, err := httputil.DumpRequestOut(req, true) - if err != nil { - panic(err) - } - _, err = buf.Write(ensureTrailingNewline(b)) - if err != nil { - panic(err) - } - } - if t.Trace { - trace := &httptrace.ClientTrace{ - DNSDone: func(di httptrace.DNSDoneInfo) { - fmt.Fprintf(&buf, "* DNS %v → %v\n", req.Host, di.Addrs) - }, - GotConn: func(ci httptrace.GotConnInfo) { - fmt.Fprintf(&buf, "* Connection local=%v remote=%v", ci.Conn.LocalAddr(), ci.Conn.RemoteAddr()) - if ci.Reused { - fmt.Fprint(&buf, " (reused)") - } - if ci.WasIdle { - fmt.Fprintf(&buf, " (idle %v)", ci.IdleTime) - } - fmt.Fprintln(&buf) - }, - } - req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace)) - } - resp, err := t.RoundTripper.RoundTrip(req) - if err != nil { - return nil, err - } - if t.Dump { - b, err := httputil.DumpResponse(resp, true) - if err != nil { - panic(err) - } - _, err = buf.Write(ensureTrailingNewline(b)) - if err != nil { - panic(err) - } - } - _, err = io.Copy(t.Output, &buf) - if err != nil { - panic(err) - } - return resp, nil -} - -func ensureTrailingNewline(b []byte) []byte { - if len(b) > 0 && b[len(b)-1] != '\n' { - b = append(b, '\n') - } - return b -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/debuglog/log.go b/vendor/github.com/getsentry/sentry-go/internal/debuglog/log.go deleted file mode 100644 index 37fa4d0f3f4..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/debuglog/log.go +++ /dev/null @@ -1,35 +0,0 @@ -package debuglog - -import ( - "io" - "log" -) - -// logger is the global debug logger instance. -var logger = log.New(io.Discard, "[Sentry] ", log.LstdFlags) - -// SetOutput changes the output destination of the logger. -func SetOutput(w io.Writer) { - logger.SetOutput(w) -} - -// GetLogger returns the current logger instance. -// This function is thread-safe and can be called concurrently. -func GetLogger() *log.Logger { - return logger -} - -// Printf calls Printf on the underlying logger. -func Printf(format string, args ...interface{}) { - logger.Printf(format, args...) -} - -// Println calls Println on the underlying logger. -func Println(args ...interface{}) { - logger.Println(args...) -} - -// Print calls Print on the underlying logger. -func Print(args ...interface{}) { - logger.Print(args...) -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/http/transport.go b/vendor/github.com/getsentry/sentry-go/internal/http/transport.go deleted file mode 100644 index 51bd687780f..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/http/transport.go +++ /dev/null @@ -1,542 +0,0 @@ -package http - -import ( - "bytes" - "context" - "crypto/tls" - "crypto/x509" - "errors" - "fmt" - "io" - "net/http" - "net/url" - "sync" - "sync/atomic" - "time" - - "github.com/getsentry/sentry-go/internal/debuglog" - "github.com/getsentry/sentry-go/internal/protocol" - "github.com/getsentry/sentry-go/internal/ratelimit" - "github.com/getsentry/sentry-go/internal/util" -) - -const ( - apiVersion = 7 - - defaultTimeout = time.Second * 30 - defaultQueueSize = 1000 -) - -var ( - ErrTransportQueueFull = errors.New("transport queue full") - ErrTransportClosed = errors.New("transport is closed") - ErrEmptyEnvelope = errors.New("empty envelope provided") -) - -type TransportOptions struct { - Dsn string - HTTPClient *http.Client - HTTPTransport http.RoundTripper - HTTPProxy string - HTTPSProxy string - CaCerts *x509.CertPool -} - -func getProxyConfig(options TransportOptions) func(*http.Request) (*url.URL, error) { - if len(options.HTTPSProxy) > 0 { - return func(*http.Request) (*url.URL, error) { - return url.Parse(options.HTTPSProxy) - } - } - - if len(options.HTTPProxy) > 0 { - return func(*http.Request) (*url.URL, error) { - return url.Parse(options.HTTPProxy) - } - } - - return http.ProxyFromEnvironment -} - -func getTLSConfig(options TransportOptions) *tls.Config { - if options.CaCerts != nil { - return &tls.Config{ - RootCAs: options.CaCerts, - MinVersion: tls.VersionTLS12, - } - } - - return nil -} - -func getSentryRequestFromEnvelope(ctx context.Context, dsn *protocol.Dsn, envelope *protocol.Envelope) (r *http.Request, err error) { - defer func() { - if r != nil { - sdkName := envelope.Header.Sdk.Name - sdkVersion := envelope.Header.Sdk.Version - - r.Header.Set("User-Agent", fmt.Sprintf("%s/%s", sdkName, sdkVersion)) - r.Header.Set("Content-Type", "application/x-sentry-envelope") - - auth := fmt.Sprintf("Sentry sentry_version=%d, "+ - "sentry_client=%s/%s, sentry_key=%s", apiVersion, sdkName, sdkVersion, dsn.GetPublicKey()) - - if dsn.GetSecretKey() != "" { - auth = fmt.Sprintf("%s, sentry_secret=%s", auth, dsn.GetSecretKey()) - } - - r.Header.Set("X-Sentry-Auth", auth) - } - }() - - var buf bytes.Buffer - _, err = envelope.WriteTo(&buf) - if err != nil { - return nil, err - } - - return http.NewRequestWithContext( - ctx, - http.MethodPost, - dsn.GetAPIURL().String(), - &buf, - ) -} - -func categoryFromEnvelope(envelope *protocol.Envelope) ratelimit.Category { - if envelope == nil || len(envelope.Items) == 0 { - return ratelimit.CategoryAll - } - - for _, item := range envelope.Items { - if item == nil || item.Header == nil { - continue - } - - switch item.Header.Type { - case protocol.EnvelopeItemTypeEvent: - return ratelimit.CategoryError - case protocol.EnvelopeItemTypeTransaction: - return ratelimit.CategoryTransaction - case protocol.EnvelopeItemTypeCheckIn: - return ratelimit.CategoryMonitor - case protocol.EnvelopeItemTypeLog: - return ratelimit.CategoryLog - case protocol.EnvelopeItemTypeAttachment: - continue - default: - return ratelimit.CategoryAll - } - } - - return ratelimit.CategoryAll -} - -// SyncTransport is a blocking implementation of Transport. -// -// Clients using this transport will send requests to Sentry sequentially and -// block until a response is returned. -// -// The blocking behavior is useful in a limited set of use cases. For example, -// use it when deploying code to a Function as a Service ("Serverless") -// platform, where any work happening in a background goroutine is not -// guaranteed to execute. -// -// For most cases, prefer AsyncTransport. -type SyncTransport struct { - dsn *protocol.Dsn - client *http.Client - transport http.RoundTripper - - mu sync.Mutex - limits ratelimit.Map - - Timeout time.Duration -} - -func NewSyncTransport(options TransportOptions) protocol.TelemetryTransport { - dsn, err := protocol.NewDsn(options.Dsn) - if err != nil || dsn == nil { - debuglog.Printf("Transport is disabled: invalid dsn: %v\n", err) - return NewNoopTransport() - } - - transport := &SyncTransport{ - Timeout: defaultTimeout, - limits: make(ratelimit.Map), - dsn: dsn, - } - - if options.HTTPTransport != nil { - transport.transport = options.HTTPTransport - } else { - transport.transport = &http.Transport{ - Proxy: getProxyConfig(options), - TLSClientConfig: getTLSConfig(options), - } - } - - if options.HTTPClient != nil { - transport.client = options.HTTPClient - } else { - transport.client = &http.Client{ - Transport: transport.transport, - Timeout: transport.Timeout, - } - } - - return transport -} - -func (t *SyncTransport) SendEnvelope(envelope *protocol.Envelope) error { - return t.SendEnvelopeWithContext(context.Background(), envelope) -} - -func (t *SyncTransport) Close() {} - -func (t *SyncTransport) IsRateLimited(category ratelimit.Category) bool { - return t.disabled(category) -} - -func (t *SyncTransport) HasCapacity() bool { return true } - -func (t *SyncTransport) SendEnvelopeWithContext(ctx context.Context, envelope *protocol.Envelope) error { - if envelope == nil || len(envelope.Items) == 0 { - return ErrEmptyEnvelope - } - - category := categoryFromEnvelope(envelope) - if t.disabled(category) { - return nil - } - - request, err := getSentryRequestFromEnvelope(ctx, t.dsn, envelope) - if err != nil { - debuglog.Printf("There was an issue creating the request: %v", err) - return err - } - identifier := util.EnvelopeIdentifier(envelope) - debuglog.Printf( - "Sending %s to %s project: %s", - identifier, - t.dsn.GetHost(), - t.dsn.GetProjectID(), - ) - - response, err := t.client.Do(request) - if err != nil { - debuglog.Printf("There was an issue with sending an event: %v", err) - return err - } - util.HandleHTTPResponse(response, identifier) - - t.mu.Lock() - if t.limits == nil { - t.limits = make(ratelimit.Map) - } - t.limits.Merge(ratelimit.FromResponse(response)) - t.mu.Unlock() - - _, _ = io.CopyN(io.Discard, response.Body, util.MaxDrainResponseBytes) - return response.Body.Close() -} - -func (t *SyncTransport) Flush(_ time.Duration) bool { - return true -} - -func (t *SyncTransport) FlushWithContext(_ context.Context) bool { - return true -} - -func (t *SyncTransport) disabled(c ratelimit.Category) bool { - t.mu.Lock() - defer t.mu.Unlock() - disabled := t.limits.IsRateLimited(c) - if disabled { - debuglog.Printf("Too many requests for %q, backing off till: %v", c, t.limits.Deadline(c)) - } - return disabled -} - -// AsyncTransport is the default, non-blocking, implementation of Transport. -// -// Clients using this transport will enqueue requests in a queue and return to -// the caller before any network communication has happened. Requests are sent -// to Sentry sequentially from a background goroutine. -type AsyncTransport struct { - dsn *protocol.Dsn - client *http.Client - transport http.RoundTripper - - queue chan *protocol.Envelope - - mu sync.RWMutex - limits ratelimit.Map - - done chan struct{} - wg sync.WaitGroup - - flushRequest chan chan struct{} - - sentCount int64 - droppedCount int64 - errorCount int64 - - QueueSize int - Timeout time.Duration - - startOnce sync.Once - closeOnce sync.Once -} - -func NewAsyncTransport(options TransportOptions) protocol.TelemetryTransport { - dsn, err := protocol.NewDsn(options.Dsn) - if err != nil || dsn == nil { - debuglog.Printf("Transport is disabled: invalid dsn: %v", err) - return NewNoopTransport() - } - - transport := &AsyncTransport{ - QueueSize: defaultQueueSize, - Timeout: defaultTimeout, - done: make(chan struct{}), - limits: make(ratelimit.Map), - dsn: dsn, - } - - transport.queue = make(chan *protocol.Envelope, transport.QueueSize) - transport.flushRequest = make(chan chan struct{}) - - if options.HTTPTransport != nil { - transport.transport = options.HTTPTransport - } else { - transport.transport = &http.Transport{ - Proxy: getProxyConfig(options), - TLSClientConfig: getTLSConfig(options), - } - } - - if options.HTTPClient != nil { - transport.client = options.HTTPClient - } else { - transport.client = &http.Client{ - Transport: transport.transport, - Timeout: transport.Timeout, - } - } - - transport.start() - return transport -} - -func (t *AsyncTransport) start() { - t.startOnce.Do(func() { - t.wg.Add(1) - go t.worker() - }) -} - -// HasCapacity reports whether the async transport queue appears to have space -// for at least one more envelope. This is a best-effort, non-blocking check. -func (t *AsyncTransport) HasCapacity() bool { - t.mu.RLock() - defer t.mu.RUnlock() - select { - case <-t.done: - return false - default: - } - return len(t.queue) < cap(t.queue) -} - -func (t *AsyncTransport) SendEnvelope(envelope *protocol.Envelope) error { - select { - case <-t.done: - return ErrTransportClosed - default: - } - - if envelope == nil || len(envelope.Items) == 0 { - return ErrEmptyEnvelope - } - - category := categoryFromEnvelope(envelope) - if t.isRateLimited(category) { - return nil - } - - select { - case t.queue <- envelope: - identifier := util.EnvelopeIdentifier(envelope) - debuglog.Printf( - "Sending %s to %s project: %s", - identifier, - t.dsn.GetHost(), - t.dsn.GetProjectID(), - ) - return nil - default: - atomic.AddInt64(&t.droppedCount, 1) - return ErrTransportQueueFull - } -} - -func (t *AsyncTransport) Flush(timeout time.Duration) bool { - ctx, cancel := context.WithTimeout(context.Background(), timeout) - defer cancel() - return t.FlushWithContext(ctx) -} - -func (t *AsyncTransport) FlushWithContext(ctx context.Context) bool { - flushResponse := make(chan struct{}) - select { - case t.flushRequest <- flushResponse: - select { - case <-flushResponse: - debuglog.Println("Buffer flushed successfully.") - return true - case <-ctx.Done(): - debuglog.Println("Failed to flush, buffer timed out.") - return false - } - case <-ctx.Done(): - debuglog.Println("Failed to flush, buffer timed out.") - return false - } -} - -func (t *AsyncTransport) Close() { - t.closeOnce.Do(func() { - close(t.done) - close(t.queue) - close(t.flushRequest) - t.wg.Wait() - }) -} - -func (t *AsyncTransport) IsRateLimited(category ratelimit.Category) bool { - return t.isRateLimited(category) -} - -func (t *AsyncTransport) worker() { - defer t.wg.Done() - - for { - select { - case <-t.done: - return - case envelope, open := <-t.queue: - if !open { - return - } - t.processEnvelope(envelope) - case flushResponse, open := <-t.flushRequest: - if !open { - return - } - t.drainQueue() - close(flushResponse) - } - } -} - -func (t *AsyncTransport) drainQueue() { - for { - select { - case envelope, open := <-t.queue: - if !open { - return - } - t.processEnvelope(envelope) - default: - return - } - } -} - -func (t *AsyncTransport) processEnvelope(envelope *protocol.Envelope) { - if t.sendEnvelopeHTTP(envelope) { - atomic.AddInt64(&t.sentCount, 1) - } else { - atomic.AddInt64(&t.errorCount, 1) - } -} - -func (t *AsyncTransport) sendEnvelopeHTTP(envelope *protocol.Envelope) bool { - category := categoryFromEnvelope(envelope) - if t.isRateLimited(category) { - return false - } - - ctx, cancel := context.WithTimeout(context.Background(), defaultTimeout) - defer cancel() - - request, err := getSentryRequestFromEnvelope(ctx, t.dsn, envelope) - if err != nil { - debuglog.Printf("Failed to create request from envelope: %v", err) - return false - } - - response, err := t.client.Do(request) - if err != nil { - debuglog.Printf("HTTP request failed: %v", err) - return false - } - defer response.Body.Close() - - identifier := util.EnvelopeIdentifier(envelope) - success := util.HandleHTTPResponse(response, identifier) - - t.mu.Lock() - if t.limits == nil { - t.limits = make(ratelimit.Map) - } - t.limits.Merge(ratelimit.FromResponse(response)) - t.mu.Unlock() - - _, _ = io.CopyN(io.Discard, response.Body, util.MaxDrainResponseBytes) - return success -} - -func (t *AsyncTransport) isRateLimited(category ratelimit.Category) bool { - t.mu.RLock() - defer t.mu.RUnlock() - limited := t.limits.IsRateLimited(category) - if limited { - debuglog.Printf("Rate limited for category %q until %v", category, t.limits.Deadline(category)) - } - return limited -} - -// NoopTransport is a transport implementation that drops all events. -// Used internally when an empty or invalid DSN is provided. -type NoopTransport struct{} - -func NewNoopTransport() *NoopTransport { - debuglog.Println("Transport initialized with invalid DSN. Using NoopTransport. No events will be delivered.") - return &NoopTransport{} -} - -func (t *NoopTransport) SendEnvelope(_ *protocol.Envelope) error { - debuglog.Println("Envelope dropped due to NoopTransport usage.") - return nil -} - -func (t *NoopTransport) IsRateLimited(_ ratelimit.Category) bool { - return false -} - -func (t *NoopTransport) Flush(_ time.Duration) bool { - return true -} - -func (t *NoopTransport) FlushWithContext(_ context.Context) bool { - return true -} - -func (t *NoopTransport) Close() { - // Nothing to close -} - -func (t *NoopTransport) HasCapacity() bool { return true } diff --git a/vendor/github.com/getsentry/sentry-go/internal/otel/baggage/README.md b/vendor/github.com/getsentry/sentry-go/internal/otel/baggage/README.md deleted file mode 100644 index 2718f314b4e..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/otel/baggage/README.md +++ /dev/null @@ -1,12 +0,0 @@ -## Why do we have this "otel/baggage" folder? - -The root sentry-go SDK (namely, the Dynamic Sampling functionality) needs an implementation of the [baggage spec](https://www.w3.org/TR/baggage/). -For that reason, we've taken the existing baggage implementation from the [opentelemetry-go](https://github.com/open-telemetry/opentelemetry-go/) repository, and fixed a few things that in our opinion were violating the specification. - -These issues are: -1. Baggage string value `one%20two` should be properly parsed as "one two" -1. Baggage string value `one+two` should be parsed as "one+two" -1. Go string value "one two" should be encoded as `one%20two` (percent encoding), and NOT as `one+two` (URL query encoding). -1. Go string value "1=1" might be encoded as `1=1`, because the spec says: "Note, value MAY contain any number of the equal sign (=) characters. Parsers MUST NOT assume that the equal sign is only used to separate key and value.". `1%3D1` is also valid, but to simplify the implementation we're not doing it. - -Changes were made in this PR: https://github.com/getsentry/sentry-go/pull/568 diff --git a/vendor/github.com/getsentry/sentry-go/internal/otel/baggage/baggage.go b/vendor/github.com/getsentry/sentry-go/internal/otel/baggage/baggage.go deleted file mode 100644 index 18065550693..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/otel/baggage/baggage.go +++ /dev/null @@ -1,604 +0,0 @@ -// Adapted from https://github.com/open-telemetry/opentelemetry-go/blob/c21b6b6bb31a2f74edd06e262f1690f3f6ea3d5c/baggage/baggage.go -// -// Copyright The OpenTelemetry Authors -// -// 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 baggage - -import ( - "errors" - "fmt" - "net/url" - "regexp" - "strings" - "unicode/utf8" - - "github.com/getsentry/sentry-go/internal/otel/baggage/internal/baggage" -) - -const ( - maxMembers = 180 - maxBytesPerMembers = 4096 - maxBytesPerBaggageString = 8192 - - listDelimiter = "," - keyValueDelimiter = "=" - propertyDelimiter = ";" - - keyDef = `([\x21\x23-\x27\x2A\x2B\x2D\x2E\x30-\x39\x41-\x5a\x5e-\x7a\x7c\x7e]+)` - valueDef = `([\x21\x23-\x2b\x2d-\x3a\x3c-\x5B\x5D-\x7e]*)` - keyValueDef = `\s*` + keyDef + `\s*` + keyValueDelimiter + `\s*` + valueDef + `\s*` -) - -var ( - keyRe = regexp.MustCompile(`^` + keyDef + `$`) - valueRe = regexp.MustCompile(`^` + valueDef + `$`) - propertyRe = regexp.MustCompile(`^(?:\s*` + keyDef + `\s*|` + keyValueDef + `)$`) -) - -var ( - errInvalidKey = errors.New("invalid key") - errInvalidValue = errors.New("invalid value") - errInvalidProperty = errors.New("invalid baggage list-member property") - errInvalidMember = errors.New("invalid baggage list-member") - errMemberNumber = errors.New("too many list-members in baggage-string") - errMemberBytes = errors.New("list-member too large") - errBaggageBytes = errors.New("baggage-string too large") -) - -// Property is an additional metadata entry for a baggage list-member. -type Property struct { - key, value string - - // hasValue indicates if a zero-value value means the property does not - // have a value or if it was the zero-value. - hasValue bool - - // hasData indicates whether the created property contains data or not. - // Properties that do not contain data are invalid with no other check - // required. - hasData bool -} - -// NewKeyProperty returns a new Property for key. -// -// If key is invalid, an error will be returned. -func NewKeyProperty(key string) (Property, error) { - if !keyRe.MatchString(key) { - return newInvalidProperty(), fmt.Errorf("%w: %q", errInvalidKey, key) - } - - p := Property{key: key, hasData: true} - return p, nil -} - -// NewKeyValueProperty returns a new Property for key with value. -// -// If key or value are invalid, an error will be returned. -func NewKeyValueProperty(key, value string) (Property, error) { - if !keyRe.MatchString(key) { - return newInvalidProperty(), fmt.Errorf("%w: %q", errInvalidKey, key) - } - if !valueRe.MatchString(value) { - return newInvalidProperty(), fmt.Errorf("%w: %q", errInvalidValue, value) - } - - p := Property{ - key: key, - value: value, - hasValue: true, - hasData: true, - } - return p, nil -} - -func newInvalidProperty() Property { - return Property{} -} - -// parseProperty attempts to decode a Property from the passed string. It -// returns an error if the input is invalid according to the W3C Baggage -// specification. -func parseProperty(property string) (Property, error) { - if property == "" { - return newInvalidProperty(), nil - } - - match := propertyRe.FindStringSubmatch(property) - if len(match) != 4 { - return newInvalidProperty(), fmt.Errorf("%w: %q", errInvalidProperty, property) - } - - p := Property{hasData: true} - if match[1] != "" { - p.key = match[1] - } else { - p.key = match[2] - p.value = match[3] - p.hasValue = true - } - - return p, nil -} - -// validate ensures p conforms to the W3C Baggage specification, returning an -// error otherwise. -func (p Property) validate() error { - errFunc := func(err error) error { - return fmt.Errorf("invalid property: %w", err) - } - - if !p.hasData { - return errFunc(fmt.Errorf("%w: %q", errInvalidProperty, p)) - } - - if !keyRe.MatchString(p.key) { - return errFunc(fmt.Errorf("%w: %q", errInvalidKey, p.key)) - } - if p.hasValue && !valueRe.MatchString(p.value) { - return errFunc(fmt.Errorf("%w: %q", errInvalidValue, p.value)) - } - if !p.hasValue && p.value != "" { - return errFunc(errors.New("inconsistent value")) - } - return nil -} - -// Key returns the Property key. -func (p Property) Key() string { - return p.key -} - -// Value returns the Property value. Additionally, a boolean value is returned -// indicating if the returned value is the empty if the Property has a value -// that is empty or if the value is not set. -func (p Property) Value() (string, bool) { - return p.value, p.hasValue -} - -// String encodes Property into a string compliant with the W3C Baggage -// specification. -func (p Property) String() string { - if p.hasValue { - return fmt.Sprintf("%s%s%v", p.key, keyValueDelimiter, p.value) - } - return p.key -} - -type properties []Property - -func fromInternalProperties(iProps []baggage.Property) properties { - if len(iProps) == 0 { - return nil - } - - props := make(properties, len(iProps)) - for i, p := range iProps { - props[i] = Property{ - key: p.Key, - value: p.Value, - hasValue: p.HasValue, - } - } - return props -} - -func (p properties) asInternal() []baggage.Property { - if len(p) == 0 { - return nil - } - - iProps := make([]baggage.Property, len(p)) - for i, prop := range p { - iProps[i] = baggage.Property{ - Key: prop.key, - Value: prop.value, - HasValue: prop.hasValue, - } - } - return iProps -} - -func (p properties) Copy() properties { - if len(p) == 0 { - return nil - } - - props := make(properties, len(p)) - copy(props, p) - return props -} - -// validate ensures each Property in p conforms to the W3C Baggage -// specification, returning an error otherwise. -func (p properties) validate() error { - for _, prop := range p { - if err := prop.validate(); err != nil { - return err - } - } - return nil -} - -// String encodes properties into a string compliant with the W3C Baggage -// specification. -func (p properties) String() string { - props := make([]string, len(p)) - for i, prop := range p { - props[i] = prop.String() - } - return strings.Join(props, propertyDelimiter) -} - -// Member is a list-member of a baggage-string as defined by the W3C Baggage -// specification. -type Member struct { - key, value string - properties properties - - // hasData indicates whether the created property contains data or not. - // Properties that do not contain data are invalid with no other check - // required. - hasData bool -} - -// NewMember returns a new Member from the passed arguments. The key will be -// used directly while the value will be url decoded after validation. An error -// is returned if the created Member would be invalid according to the W3C -// Baggage specification. -func NewMember(key, value string, props ...Property) (Member, error) { - m := Member{ - key: key, - value: value, - properties: properties(props).Copy(), - hasData: true, - } - if err := m.validate(); err != nil { - return newInvalidMember(), err - } - //// NOTE(anton): I don't think we need to unescape here - // decodedValue, err := url.PathUnescape(value) - // if err != nil { - // return newInvalidMember(), fmt.Errorf("%w: %q", errInvalidValue, value) - // } - // m.value = decodedValue - return m, nil -} - -func newInvalidMember() Member { - return Member{} -} - -// parseMember attempts to decode a Member from the passed string. It returns -// an error if the input is invalid according to the W3C Baggage -// specification. -func parseMember(member string) (Member, error) { - if n := len(member); n > maxBytesPerMembers { - return newInvalidMember(), fmt.Errorf("%w: %d", errMemberBytes, n) - } - - var ( - key, value string - props properties - ) - - parts := strings.SplitN(member, propertyDelimiter, 2) - switch len(parts) { - case 2: - // Parse the member properties. - for _, pStr := range strings.Split(parts[1], propertyDelimiter) { - p, err := parseProperty(pStr) - if err != nil { - return newInvalidMember(), err - } - props = append(props, p) - } - fallthrough - case 1: - // Parse the member key/value pair. - - // Take into account a value can contain equal signs (=). - kv := strings.SplitN(parts[0], keyValueDelimiter, 2) - if len(kv) != 2 { - return newInvalidMember(), fmt.Errorf("%w: %q", errInvalidMember, member) - } - // "Leading and trailing whitespaces are allowed but MUST be trimmed - // when converting the header into a data structure." - key = strings.TrimSpace(kv[0]) - value = strings.TrimSpace(kv[1]) - var err error - if !keyRe.MatchString(key) { - return newInvalidMember(), fmt.Errorf("%w: %q", errInvalidKey, key) - } - if !valueRe.MatchString(value) { - return newInvalidMember(), fmt.Errorf("%w: %q", errInvalidValue, value) - } - decodedValue, err := url.PathUnescape(value) - if err != nil { - return newInvalidMember(), fmt.Errorf("%w: %q", err, value) - } - value = decodedValue - default: - // This should never happen unless a developer has changed the string - // splitting somehow. Panic instead of failing silently and allowing - // the bug to slip past the CI checks. - panic("failed to parse baggage member") - } - - return Member{key: key, value: value, properties: props, hasData: true}, nil -} - -// validate ensures m conforms to the W3C Baggage specification. -// A key is just an ASCII string, but a value must be URL encoded UTF-8, -// returning an error otherwise. -func (m Member) validate() error { - if !m.hasData { - return fmt.Errorf("%w: %q", errInvalidMember, m) - } - - if !keyRe.MatchString(m.key) { - return fmt.Errorf("%w: %q", errInvalidKey, m.key) - } - //// NOTE(anton): IMO it's too early to validate the value here. - // if !valueRe.MatchString(m.value) { - // return fmt.Errorf("%w: %q", errInvalidValue, m.value) - // } - return m.properties.validate() -} - -// Key returns the Member key. -func (m Member) Key() string { return m.key } - -// Value returns the Member value. -func (m Member) Value() string { return m.value } - -// Properties returns a copy of the Member properties. -func (m Member) Properties() []Property { return m.properties.Copy() } - -// String encodes Member into a string compliant with the W3C Baggage -// specification. -func (m Member) String() string { - // A key is just an ASCII string, but a value is URL encoded UTF-8. - s := fmt.Sprintf("%s%s%s", m.key, keyValueDelimiter, percentEncodeValue(m.value)) - if len(m.properties) > 0 { - s = fmt.Sprintf("%s%s%s", s, propertyDelimiter, m.properties.String()) - } - return s -} - -// percentEncodeValue encodes the baggage value, using percent-encoding for -// disallowed octets. -func percentEncodeValue(s string) string { - const upperhex = "0123456789ABCDEF" - var sb strings.Builder - - for byteIndex, width := 0, 0; byteIndex < len(s); byteIndex += width { - runeValue, w := utf8.DecodeRuneInString(s[byteIndex:]) - width = w - char := string(runeValue) - if valueRe.MatchString(char) && char != "%" { - // The character is returned as is, no need to percent-encode - sb.WriteString(char) - } else { - // We need to percent-encode each byte of the multi-octet character - for j := 0; j < width; j++ { - b := s[byteIndex+j] - sb.WriteByte('%') - // Bitwise operations are inspired by "net/url" - sb.WriteByte(upperhex[b>>4]) - sb.WriteByte(upperhex[b&15]) - } - } - } - return sb.String() -} - -// Baggage is a list of baggage members representing the baggage-string as -// defined by the W3C Baggage specification. -type Baggage struct { //nolint:golint - list baggage.List -} - -// New returns a new valid Baggage. It returns an error if it results in a -// Baggage exceeding limits set in that specification. -// -// It expects all the provided members to have already been validated. -func New(members ...Member) (Baggage, error) { - if len(members) == 0 { - return Baggage{}, nil - } - - b := make(baggage.List) - for _, m := range members { - if !m.hasData { - return Baggage{}, errInvalidMember - } - - // OpenTelemetry resolves duplicates by last-one-wins. - b[m.key] = baggage.Item{ - Value: m.value, - Properties: m.properties.asInternal(), - } - } - - // Check member numbers after deduplication. - if len(b) > maxMembers { - return Baggage{}, errMemberNumber - } - - bag := Baggage{b} - if n := len(bag.String()); n > maxBytesPerBaggageString { - return Baggage{}, fmt.Errorf("%w: %d", errBaggageBytes, n) - } - - return bag, nil -} - -// Parse attempts to decode a baggage-string from the passed string. It -// returns an error if the input is invalid according to the W3C Baggage -// specification. -// -// If there are duplicate list-members contained in baggage, the last one -// defined (reading left-to-right) will be the only one kept. This diverges -// from the W3C Baggage specification which allows duplicate list-members, but -// conforms to the OpenTelemetry Baggage specification. -func Parse(bStr string) (Baggage, error) { - if bStr == "" { - return Baggage{}, nil - } - - if n := len(bStr); n > maxBytesPerBaggageString { - return Baggage{}, fmt.Errorf("%w: %d", errBaggageBytes, n) - } - - b := make(baggage.List) - for _, memberStr := range strings.Split(bStr, listDelimiter) { - m, err := parseMember(memberStr) - if err != nil { - return Baggage{}, err - } - // OpenTelemetry resolves duplicates by last-one-wins. - b[m.key] = baggage.Item{ - Value: m.value, - Properties: m.properties.asInternal(), - } - } - - // OpenTelemetry does not allow for duplicate list-members, but the W3C - // specification does. Now that we have deduplicated, ensure the baggage - // does not exceed list-member limits. - if len(b) > maxMembers { - return Baggage{}, errMemberNumber - } - - return Baggage{b}, nil -} - -// Member returns the baggage list-member identified by key. -// -// If there is no list-member matching the passed key the returned Member will -// be a zero-value Member. -// The returned member is not validated, as we assume the validation happened -// when it was added to the Baggage. -func (b Baggage) Member(key string) Member { - v, ok := b.list[key] - if !ok { - // We do not need to worry about distinguishing between the situation - // where a zero-valued Member is included in the Baggage because a - // zero-valued Member is invalid according to the W3C Baggage - // specification (it has an empty key). - return newInvalidMember() - } - - return Member{ - key: key, - value: v.Value, - properties: fromInternalProperties(v.Properties), - hasData: true, - } -} - -// Members returns all the baggage list-members. -// The order of the returned list-members does not have significance. -// -// The returned members are not validated, as we assume the validation happened -// when they were added to the Baggage. -func (b Baggage) Members() []Member { - if len(b.list) == 0 { - return nil - } - - members := make([]Member, 0, len(b.list)) - for k, v := range b.list { - members = append(members, Member{ - key: k, - value: v.Value, - properties: fromInternalProperties(v.Properties), - hasData: true, - }) - } - return members -} - -// SetMember returns a copy the Baggage with the member included. If the -// baggage contains a Member with the same key the existing Member is -// replaced. -// -// If member is invalid according to the W3C Baggage specification, an error -// is returned with the original Baggage. -func (b Baggage) SetMember(member Member) (Baggage, error) { - if !member.hasData { - return b, errInvalidMember - } - - n := len(b.list) - if _, ok := b.list[member.key]; !ok { - n++ - } - list := make(baggage.List, n) - - for k, v := range b.list { - // Do not copy if we are just going to overwrite. - if k == member.key { - continue - } - list[k] = v - } - - list[member.key] = baggage.Item{ - Value: member.value, - Properties: member.properties.asInternal(), - } - - return Baggage{list: list}, nil -} - -// DeleteMember returns a copy of the Baggage with the list-member identified -// by key removed. -func (b Baggage) DeleteMember(key string) Baggage { - n := len(b.list) - if _, ok := b.list[key]; ok { - n-- - } - list := make(baggage.List, n) - - for k, v := range b.list { - if k == key { - continue - } - list[k] = v - } - - return Baggage{list: list} -} - -// Len returns the number of list-members in the Baggage. -func (b Baggage) Len() int { - return len(b.list) -} - -// String encodes Baggage into a string compliant with the W3C Baggage -// specification. The returned string will be invalid if the Baggage contains -// any invalid list-members. -func (b Baggage) String() string { - members := make([]string, 0, len(b.list)) - for k, v := range b.list { - members = append(members, Member{ - key: k, - value: v.Value, - properties: fromInternalProperties(v.Properties), - }.String()) - } - return strings.Join(members, listDelimiter) -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/otel/baggage/internal/baggage/baggage.go b/vendor/github.com/getsentry/sentry-go/internal/otel/baggage/internal/baggage/baggage.go deleted file mode 100644 index ea99ccbffde..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/otel/baggage/internal/baggage/baggage.go +++ /dev/null @@ -1,45 +0,0 @@ -// Adapted from https://github.com/open-telemetry/opentelemetry-go/blob/c21b6b6bb31a2f74edd06e262f1690f3f6ea3d5c/internal/baggage/baggage.go -// -// Copyright The OpenTelemetry Authors -// -// 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 baggage provides base types and functionality to store and retrieve -baggage in Go context. This package exists because the OpenTracing bridge to -OpenTelemetry needs to synchronize state whenever baggage for a context is -modified and that context contains an OpenTracing span. If it were not for -this need this package would not need to exist and the -`go.opentelemetry.io/otel/baggage` package would be the singular place where -W3C baggage is handled. -*/ -package baggage - -// List is the collection of baggage members. The W3C allows for duplicates, -// but OpenTelemetry does not, therefore, this is represented as a map. -type List map[string]Item - -// Item is the value and metadata properties part of a list-member. -type Item struct { - Value string - Properties []Property -} - -// Property is a metadata entry for a list-member. -type Property struct { - Key, Value string - - // HasValue indicates if a zero-value value means the property does not - // have a value or if it was the zero-value. - HasValue bool -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/protocol/dsn.go b/vendor/github.com/getsentry/sentry-go/internal/protocol/dsn.go deleted file mode 100644 index 42aff31427b..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/protocol/dsn.go +++ /dev/null @@ -1,236 +0,0 @@ -package protocol - -import ( - "encoding/json" - "fmt" - "net/url" - "strconv" - "strings" - "time" -) - -// apiVersion is the version of the Sentry API. -const apiVersion = "7" - -type scheme string - -const ( - SchemeHTTP scheme = "http" - SchemeHTTPS scheme = "https" -) - -func (scheme scheme) defaultPort() int { - switch scheme { - case SchemeHTTPS: - return 443 - case SchemeHTTP: - return 80 - default: - return 80 - } -} - -// DsnParseError represents an error that occurs if a Sentry -// DSN cannot be parsed. -type DsnParseError struct { - Message string -} - -func (e DsnParseError) Error() string { - return "[Sentry] DsnParseError: " + e.Message -} - -// Dsn is used as the remote address source to client transport. -type Dsn struct { - scheme scheme - publicKey string - secretKey string - host string - port int - path string - projectID string -} - -// NewDsn creates a Dsn by parsing rawURL. Most users will never call this -// function directly. It is provided for use in custom Transport -// implementations. -func NewDsn(rawURL string) (*Dsn, error) { - // Parse - parsedURL, err := url.Parse(rawURL) - if err != nil { - return nil, &DsnParseError{fmt.Sprintf("invalid url: %v", err)} - } - - // Scheme - var scheme scheme - switch parsedURL.Scheme { - case "http": - scheme = SchemeHTTP - case "https": - scheme = SchemeHTTPS - default: - return nil, &DsnParseError{"invalid scheme"} - } - - // PublicKey - publicKey := parsedURL.User.Username() - if publicKey == "" { - return nil, &DsnParseError{"empty username"} - } - - // SecretKey - var secretKey string - if parsedSecretKey, ok := parsedURL.User.Password(); ok { - secretKey = parsedSecretKey - } - - // Host - host := parsedURL.Hostname() - if host == "" { - return nil, &DsnParseError{"empty host"} - } - - // Port - var port int - if p := parsedURL.Port(); p != "" { - port, err = strconv.Atoi(p) - if err != nil { - return nil, &DsnParseError{"invalid port"} - } - } else { - port = scheme.defaultPort() - } - - // ProjectID - if parsedURL.Path == "" || parsedURL.Path == "/" { - return nil, &DsnParseError{"empty project id"} - } - pathSegments := strings.Split(parsedURL.Path[1:], "/") - projectID := pathSegments[len(pathSegments)-1] - - if projectID == "" { - return nil, &DsnParseError{"empty project id"} - } - - // Path - var path string - if len(pathSegments) > 1 { - path = "/" + strings.Join(pathSegments[0:len(pathSegments)-1], "/") - } - - return &Dsn{ - scheme: scheme, - publicKey: publicKey, - secretKey: secretKey, - host: host, - port: port, - path: path, - projectID: projectID, - }, nil -} - -// String formats Dsn struct into a valid string url. -func (dsn Dsn) String() string { - var url string - url += fmt.Sprintf("%s://%s", dsn.scheme, dsn.publicKey) - if dsn.secretKey != "" { - url += fmt.Sprintf(":%s", dsn.secretKey) - } - url += fmt.Sprintf("@%s", dsn.host) - if dsn.port != dsn.scheme.defaultPort() { - url += fmt.Sprintf(":%d", dsn.port) - } - if dsn.path != "" { - url += dsn.path - } - url += fmt.Sprintf("/%s", dsn.projectID) - return url -} - -// Get the scheme of the DSN. -func (dsn Dsn) GetScheme() string { - return string(dsn.scheme) -} - -// Get the public key of the DSN. -func (dsn Dsn) GetPublicKey() string { - return dsn.publicKey -} - -// Get the secret key of the DSN. -func (dsn Dsn) GetSecretKey() string { - return dsn.secretKey -} - -// Get the host of the DSN. -func (dsn Dsn) GetHost() string { - return dsn.host -} - -// Get the port of the DSN. -func (dsn Dsn) GetPort() int { - return dsn.port -} - -// Get the path of the DSN. -func (dsn Dsn) GetPath() string { - return dsn.path -} - -// Get the project ID of the DSN. -func (dsn Dsn) GetProjectID() string { - return dsn.projectID -} - -// GetAPIURL returns the URL of the envelope endpoint of the project -// associated with the DSN. -func (dsn Dsn) GetAPIURL() *url.URL { - var rawURL string - rawURL += fmt.Sprintf("%s://%s", dsn.scheme, dsn.host) - if dsn.port != dsn.scheme.defaultPort() { - rawURL += fmt.Sprintf(":%d", dsn.port) - } - if dsn.path != "" { - rawURL += dsn.path - } - rawURL += fmt.Sprintf("/api/%s/%s/", dsn.projectID, "envelope") - parsedURL, _ := url.Parse(rawURL) - return parsedURL -} - -// RequestHeaders returns all the necessary headers that have to be used in the transport when sending events -// to the /store endpoint. -// -// Deprecated: This method shall only be used if you want to implement your own transport that sends events to -// the /store endpoint. If you're using the transport provided by the SDK, all necessary headers to authenticate -// against the /envelope endpoint are added automatically. -func (dsn Dsn) RequestHeaders(sdkVersion string) map[string]string { - auth := fmt.Sprintf("Sentry sentry_version=%s, sentry_timestamp=%d, "+ - "sentry_client=sentry.go/%s, sentry_key=%s", apiVersion, time.Now().Unix(), sdkVersion, dsn.publicKey) - - if dsn.secretKey != "" { - auth = fmt.Sprintf("%s, sentry_secret=%s", auth, dsn.secretKey) - } - - return map[string]string{ - "Content-Type": "application/json", - "X-Sentry-Auth": auth, - } -} - -// MarshalJSON converts the Dsn struct to JSON. -func (dsn Dsn) MarshalJSON() ([]byte, error) { - return json.Marshal(dsn.String()) -} - -// UnmarshalJSON converts JSON data to the Dsn struct. -func (dsn *Dsn) UnmarshalJSON(data []byte) error { - var str string - _ = json.Unmarshal(data, &str) - newDsn, err := NewDsn(str) - if err != nil { - return err - } - *dsn = *newDsn - return nil -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/protocol/envelope.go b/vendor/github.com/getsentry/sentry-go/internal/protocol/envelope.go deleted file mode 100644 index c588b107ff3..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/protocol/envelope.go +++ /dev/null @@ -1,225 +0,0 @@ -package protocol - -import ( - "bytes" - "encoding/json" - "fmt" - "io" - "time" -) - -// Envelope represents a Sentry envelope containing headers and items. -type Envelope struct { - Header *EnvelopeHeader `json:"-"` - Items []*EnvelopeItem `json:"-"` -} - -// EnvelopeHeader represents the header of a Sentry envelope. -type EnvelopeHeader struct { - // EventID is the unique identifier for this event - EventID string `json:"event_id"` - - // SentAt is the timestamp when the event was sent from the SDK as string in RFC 3339 format. - // Used for clock drift correction of the event timestamp. The time zone must be UTC. - SentAt time.Time `json:"sent_at,omitzero"` - - // Dsn can be used for self-authenticated envelopes. - // This means that the envelope has all the information necessary to be sent to sentry. - // In this case the full DSN must be stored in this key. - Dsn string `json:"dsn,omitempty"` - - // Sdk carries the same payload as the sdk interface in the event payload but can be carried for all events. - // This means that SDK information can be carried for minidumps, session data and other submissions. - Sdk *SdkInfo `json:"sdk,omitempty"` - - // Trace contains the [Dynamic Sampling Context](https://develop.sentry.dev/sdk/telemetry/traces/dynamic-sampling-context/) - Trace map[string]string `json:"trace,omitempty"` -} - -// EnvelopeItemType represents the type of envelope item. -type EnvelopeItemType string - -// Constants for envelope item types as defined in the Sentry documentation. -const ( - EnvelopeItemTypeEvent EnvelopeItemType = "event" - EnvelopeItemTypeTransaction EnvelopeItemType = "transaction" - EnvelopeItemTypeCheckIn EnvelopeItemType = "check_in" - EnvelopeItemTypeAttachment EnvelopeItemType = "attachment" - EnvelopeItemTypeLog EnvelopeItemType = "log" - EnvelopeItemTypeTraceMetric EnvelopeItemType = "trace_metric" -) - -// EnvelopeItemHeader represents the header of an envelope item. -type EnvelopeItemHeader struct { - // Type specifies the type of this Item and its contents. - // Based on the Item type, more headers may be required. - Type EnvelopeItemType `json:"type"` - - // Length is the length of the payload in bytes. - // If no length is specified, the payload implicitly goes to the next newline. - // For payloads containing newline characters, the length must be specified. - Length *int `json:"length,omitempty"` - - // Filename is the name of the attachment file (used for attachments) - Filename string `json:"filename,omitempty"` - - // ContentType is the MIME type of the item payload (used for attachments and some other item types) - ContentType string `json:"content_type,omitempty"` - - // ItemCount is the number of items in a batch (used for logs) - ItemCount *int `json:"item_count,omitempty"` -} - -// EnvelopeItem represents a single item or batch within an envelope. -type EnvelopeItem struct { - Header *EnvelopeItemHeader `json:"-"` - Payload []byte `json:"-"` -} - -// NewEnvelope creates a new envelope with the given header. -func NewEnvelope(header *EnvelopeHeader) *Envelope { - return &Envelope{ - Header: header, - Items: make([]*EnvelopeItem, 0), - } -} - -// AddItem adds an item to the envelope. -func (e *Envelope) AddItem(item *EnvelopeItem) { - if item == nil { - return - } - e.Items = append(e.Items, item) -} - -// Serialize serializes the envelope to the Sentry envelope format. -// -// Format: Headers "\n" { Item } [ "\n" ] -// Item: Headers "\n" Payload "\n". -func (e *Envelope) Serialize() ([]byte, error) { - var buf bytes.Buffer - - headerBytes, err := json.Marshal(e.Header) - if err != nil { - return nil, fmt.Errorf("failed to marshal envelope header: %w", err) - } - - if _, err := buf.Write(headerBytes); err != nil { - return nil, fmt.Errorf("failed to write envelope header: %w", err) - } - - if _, err := buf.WriteString("\n"); err != nil { - return nil, fmt.Errorf("failed to write newline after envelope header: %w", err) - } - - for _, item := range e.Items { - if err := e.writeItem(&buf, item); err != nil { - return nil, fmt.Errorf("failed to write envelope item: %w", err) - } - } - - return buf.Bytes(), nil -} - -// WriteTo writes the envelope to the given writer in the Sentry envelope format. -func (e *Envelope) WriteTo(w io.Writer) (int64, error) { - data, err := e.Serialize() - if err != nil { - return 0, err - } - - n, err := w.Write(data) - return int64(n), err -} - -// writeItem writes a single envelope item to the buffer. -func (e *Envelope) writeItem(buf *bytes.Buffer, item *EnvelopeItem) error { - headerBytes, err := json.Marshal(item.Header) - if err != nil { - return fmt.Errorf("failed to marshal item header: %w", err) - } - - if _, err := buf.Write(headerBytes); err != nil { - return fmt.Errorf("failed to write item header: %w", err) - } - - if _, err := buf.WriteString("\n"); err != nil { - return fmt.Errorf("failed to write newline after item header: %w", err) - } - - if len(item.Payload) > 0 { - if _, err := buf.Write(item.Payload); err != nil { - return fmt.Errorf("failed to write item payload: %w", err) - } - } - - if _, err := buf.WriteString("\n"); err != nil { - return fmt.Errorf("failed to write newline after item payload: %w", err) - } - - return nil -} - -// Size returns the total size of the envelope when serialized. -func (e *Envelope) Size() (int, error) { - data, err := e.Serialize() - if err != nil { - return 0, err - } - return len(data), nil -} - -// NewEnvelopeItem creates a new envelope item with the specified type and payload. -func NewEnvelopeItem(itemType EnvelopeItemType, payload []byte) *EnvelopeItem { - length := len(payload) - return &EnvelopeItem{ - Header: &EnvelopeItemHeader{ - Type: itemType, - Length: &length, - }, - Payload: payload, - } -} - -// NewAttachmentItem creates a new envelope item for an attachment. -// Parameters: filename, contentType, payload. -func NewAttachmentItem(filename, contentType string, payload []byte) *EnvelopeItem { - length := len(payload) - return &EnvelopeItem{ - Header: &EnvelopeItemHeader{ - Type: EnvelopeItemTypeAttachment, - Length: &length, - ContentType: contentType, - Filename: filename, - }, - Payload: payload, - } -} - -// NewLogItem creates a new envelope item for logs. -func NewLogItem(itemCount int, payload []byte) *EnvelopeItem { - length := len(payload) - return &EnvelopeItem{ - Header: &EnvelopeItemHeader{ - Type: EnvelopeItemTypeLog, - Length: &length, - ItemCount: &itemCount, - ContentType: "application/vnd.sentry.items.log+json", - }, - Payload: payload, - } -} - -// NewTraceMetricItem creates a new envelope item for trace metrics. -func NewTraceMetricItem(itemCount int, payload []byte) *EnvelopeItem { - length := len(payload) - return &EnvelopeItem{ - Header: &EnvelopeItemHeader{ - Type: EnvelopeItemTypeTraceMetric, - Length: &length, - ItemCount: &itemCount, - ContentType: "application/vnd.sentry.items.trace-metric+json", - }, - Payload: payload, - } -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/protocol/interfaces.go b/vendor/github.com/getsentry/sentry-go/internal/protocol/interfaces.go deleted file mode 100644 index d5641b0e97c..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/protocol/interfaces.go +++ /dev/null @@ -1,56 +0,0 @@ -package protocol - -import ( - "context" - "time" - - "github.com/getsentry/sentry-go/internal/ratelimit" -) - -// TelemetryItem represents any telemetry data that can be stored in buffers and sent to Sentry. -// This is the base interface that all telemetry items must implement. -type TelemetryItem interface { - // GetCategory returns the rate limit category for this item. - GetCategory() ratelimit.Category - - // GetEventID returns the event ID for this item. - GetEventID() string - - // GetSdkInfo returns SDK information for the envelope header. - GetSdkInfo() *SdkInfo - - // GetDynamicSamplingContext returns trace context for the envelope header. - GetDynamicSamplingContext() map[string]string -} - -// EnvelopeItemConvertible represents items that can be converted directly to envelope items. -type EnvelopeItemConvertible interface { - TelemetryItem - - // ToEnvelopeItem converts the item to a Sentry envelope item. - ToEnvelopeItem() (*EnvelopeItem, error) -} - -// TelemetryTransport represents the envelope-first transport interface. -// This interface is designed for the telemetry buffer system and provides -// non-blocking sends with backpressure signals. -type TelemetryTransport interface { - // SendEnvelope sends an envelope to Sentry. Returns immediately with - // backpressure error if the queue is full. - SendEnvelope(envelope *Envelope) error - - // HasCapacity reports whether the transport has capacity to accept at least one more envelope. - HasCapacity() bool - - // IsRateLimited checks if a specific category is currently rate limited - IsRateLimited(category ratelimit.Category) bool - - // Flush waits for all pending envelopes to be sent, with timeout - Flush(timeout time.Duration) bool - - // FlushWithContext waits for all pending envelopes to be sent - FlushWithContext(ctx context.Context) bool - - // Close shuts down the transport gracefully - Close() -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/protocol/log_batch.go b/vendor/github.com/getsentry/sentry-go/internal/protocol/log_batch.go deleted file mode 100644 index 571946b76d6..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/protocol/log_batch.go +++ /dev/null @@ -1,48 +0,0 @@ -package protocol - -import ( - "encoding/json" - - "github.com/getsentry/sentry-go/internal/ratelimit" -) - -// LogAttribute is the JSON representation for a single log attribute value. -type LogAttribute struct { - Value any `json:"value"` - Type string `json:"type"` -} - -// Logs is a container for multiple log items which knows how to convert -// itself into a single batched log envelope item. -type Logs []TelemetryItem - -func (ls Logs) ToEnvelopeItem() (*EnvelopeItem, error) { - // Convert each log to its JSON representation - items := make([]json.RawMessage, 0, len(ls)) - for _, log := range ls { - logPayload, err := json.Marshal(log) - if err != nil { - continue - } - items = append(items, logPayload) - } - - if len(items) == 0 { - return nil, nil - } - - wrapper := struct { - Items []json.RawMessage `json:"items"` - }{Items: items} - - payload, err := json.Marshal(wrapper) - if err != nil { - return nil, err - } - return NewLogItem(len(ls), payload), nil -} - -func (Logs) GetCategory() ratelimit.Category { return ratelimit.CategoryLog } -func (Logs) GetEventID() string { return "" } -func (Logs) GetSdkInfo() *SdkInfo { return nil } -func (Logs) GetDynamicSamplingContext() map[string]string { return nil } diff --git a/vendor/github.com/getsentry/sentry-go/internal/protocol/metric_batch.go b/vendor/github.com/getsentry/sentry-go/internal/protocol/metric_batch.go deleted file mode 100644 index e6e76ba96c8..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/protocol/metric_batch.go +++ /dev/null @@ -1,41 +0,0 @@ -package protocol - -import ( - "encoding/json" - - "github.com/getsentry/sentry-go/internal/ratelimit" -) - -type Metrics []TelemetryItem - -func (ms Metrics) ToEnvelopeItem() (*EnvelopeItem, error) { - // Convert each metric to its JSON representation - items := make([]json.RawMessage, 0, len(ms)) - for _, metric := range ms { - metricPayload, err := json.Marshal(metric) - if err != nil { - continue - } - items = append(items, metricPayload) - } - - if len(items) == 0 { - return nil, nil - } - - wrapper := struct { - Items []json.RawMessage `json:"items"` - }{Items: items} - - payload, err := json.Marshal(wrapper) - if err != nil { - return nil, err - } - - return NewTraceMetricItem(len(items), payload), nil -} - -func (Metrics) GetCategory() ratelimit.Category { return ratelimit.CategoryTraceMetric } -func (Metrics) GetEventID() string { return "" } -func (Metrics) GetSdkInfo() *SdkInfo { return nil } -func (Metrics) GetDynamicSamplingContext() map[string]string { return nil } diff --git a/vendor/github.com/getsentry/sentry-go/internal/protocol/types.go b/vendor/github.com/getsentry/sentry-go/internal/protocol/types.go deleted file mode 100644 index 5237c9ed1cc..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/protocol/types.go +++ /dev/null @@ -1,15 +0,0 @@ -package protocol - -// SdkInfo contains SDK metadata. -type SdkInfo struct { - Name string `json:"name,omitempty"` - Version string `json:"version,omitempty"` - Integrations []string `json:"integrations,omitempty"` - Packages []SdkPackage `json:"packages,omitempty"` -} - -// SdkPackage describes a package that was installed. -type SdkPackage struct { - Name string `json:"name,omitempty"` - Version string `json:"version,omitempty"` -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/protocol/uuid.go b/vendor/github.com/getsentry/sentry-go/internal/protocol/uuid.go deleted file mode 100644 index 5aff3b19f01..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/protocol/uuid.go +++ /dev/null @@ -1,18 +0,0 @@ -package protocol - -import ( - "crypto/rand" - "encoding/hex" -) - -// GenerateEventID generates a random UUID v4 for use as a Sentry event ID. -func GenerateEventID() string { - id := make([]byte, 16) - // Prefer rand.Read over rand.Reader, see https://go-review.googlesource.com/c/go/+/272326/. - _, _ = rand.Read(id) - id[6] &= 0x0F // clear version - id[6] |= 0x40 // set version to 4 (random uuid) - id[8] &= 0x3F // clear variant - id[8] |= 0x80 // set to IETF variant - return hex.EncodeToString(id) -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/ratelimit/category.go b/vendor/github.com/getsentry/sentry-go/internal/ratelimit/category.go deleted file mode 100644 index aec8bb8d081..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/ratelimit/category.go +++ /dev/null @@ -1,109 +0,0 @@ -package ratelimit - -import ( - "strings" - - "golang.org/x/text/cases" - "golang.org/x/text/language" -) - -// Reference: -// https://github.com/getsentry/relay/blob/46dfaa850b8717a6e22c3e9a275ba17fe673b9da/relay-base-schema/src/data_category.rs#L231-L271 - -// Category classifies supported payload types that can be ingested by Sentry -// and, therefore, rate limited. -type Category string - -// Known rate limit categories that are specified in rate limit headers. -const ( - CategoryUnknown Category = "unknown" // Unknown category should not get rate limited - CategoryAll Category = "" // Special category for empty categories (applies to all) - CategoryError Category = "error" - CategoryTransaction Category = "transaction" - CategoryLog Category = "log_item" - CategoryMonitor Category = "monitor" - CategoryTraceMetric Category = "trace_metric" -) - -// knownCategories is the set of currently known categories. Other categories -// are ignored for the purpose of rate-limiting. -var knownCategories = map[Category]struct{}{ - CategoryAll: {}, - CategoryError: {}, - CategoryTransaction: {}, - CategoryLog: {}, - CategoryMonitor: {}, - CategoryTraceMetric: {}, -} - -// String returns the category formatted for debugging. -func (c Category) String() string { - switch c { - case CategoryAll: - return "CategoryAll" - case CategoryError: - return "CategoryError" - case CategoryTransaction: - return "CategoryTransaction" - case CategoryLog: - return "CategoryLog" - case CategoryMonitor: - return "CategoryMonitor" - case CategoryTraceMetric: - return "CategoryTraceMetric" - default: - // For unknown categories, use the original formatting logic - caser := cases.Title(language.English) - rv := "Category" - for _, w := range strings.Fields(string(c)) { - rv += caser.String(w) - } - return rv - } -} - -// Priority represents the importance level of a category for buffer management. -type Priority int - -const ( - PriorityCritical Priority = iota + 1 - PriorityHigh - PriorityMedium - PriorityLow - PriorityLowest -) - -func (p Priority) String() string { - switch p { - case PriorityCritical: - return "critical" - case PriorityHigh: - return "high" - case PriorityMedium: - return "medium" - case PriorityLow: - return "low" - case PriorityLowest: - return "lowest" - default: - return "unknown" - } -} - -// GetPriority returns the priority level for this category. -func (c Category) GetPriority() Priority { - switch c { - case CategoryError: - return PriorityCritical - case CategoryMonitor: - return PriorityHigh - case CategoryLog: - return PriorityLow - case CategoryTransaction: - return PriorityMedium - case CategoryTraceMetric: - return PriorityLow - default: - return PriorityMedium - } -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/ratelimit/deadline.go b/vendor/github.com/getsentry/sentry-go/internal/ratelimit/deadline.go deleted file mode 100644 index c00258335f4..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/ratelimit/deadline.go +++ /dev/null @@ -1,22 +0,0 @@ -package ratelimit - -import "time" - -// A Deadline is a time instant when a rate limit expires. -type Deadline time.Time - -// After reports whether the deadline d is after other. -func (d Deadline) After(other Deadline) bool { - return time.Time(d).After(time.Time(other)) -} - -// Equal reports whether d and e represent the same deadline. -func (d Deadline) Equal(e Deadline) bool { - return time.Time(d).Equal(time.Time(e)) -} - -// String returns the deadline formatted for debugging. -func (d Deadline) String() string { - // Like time.Time.String, but without the monotonic clock reading. - return time.Time(d).Round(0).String() -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/ratelimit/doc.go b/vendor/github.com/getsentry/sentry-go/internal/ratelimit/doc.go deleted file mode 100644 index 80b9fdda271..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/ratelimit/doc.go +++ /dev/null @@ -1,3 +0,0 @@ -// Package ratelimit provides tools to work with rate limits imposed by Sentry's -// data ingestion pipeline. -package ratelimit diff --git a/vendor/github.com/getsentry/sentry-go/internal/ratelimit/map.go b/vendor/github.com/getsentry/sentry-go/internal/ratelimit/map.go deleted file mode 100644 index e590430eccd..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/ratelimit/map.go +++ /dev/null @@ -1,64 +0,0 @@ -package ratelimit - -import ( - "net/http" - "time" -) - -// Map maps categories to rate limit deadlines. -// -// A rate limit is in effect for a given category if either the category's -// deadline or the deadline for the special CategoryAll has not yet expired. -// -// Use IsRateLimited to check whether a category is rate-limited. -type Map map[Category]Deadline - -// IsRateLimited returns true if the category is currently rate limited. -func (m Map) IsRateLimited(c Category) bool { - return m.isRateLimited(c, time.Now()) -} - -func (m Map) isRateLimited(c Category, now time.Time) bool { - return m.Deadline(c).After(Deadline(now)) -} - -// Deadline returns the deadline when the rate limit for the given category or -// the special CategoryAll expire, whichever is furthest into the future. -func (m Map) Deadline(c Category) Deadline { - categoryDeadline := m[c] - allDeadline := m[CategoryAll] - if categoryDeadline.After(allDeadline) { - return categoryDeadline - } - return allDeadline -} - -// Merge merges the other map into m. -// -// If a category appears in both maps, the deadline that is furthest into the -// future is preserved. -func (m Map) Merge(other Map) { - for c, d := range other { - if d.After(m[c]) { - m[c] = d - } - } -} - -// FromResponse returns a rate limit map from an HTTP response. -func FromResponse(r *http.Response) Map { - return fromResponse(r, time.Now()) -} - -func fromResponse(r *http.Response, now time.Time) Map { - s := r.Header.Get("X-Sentry-Rate-Limits") - if s != "" { - return parseXSentryRateLimits(s, now) - } - if r.StatusCode == http.StatusTooManyRequests { - s := r.Header.Get("Retry-After") - deadline, _ := parseRetryAfter(s, now) - return Map{CategoryAll: deadline} - } - return Map{} -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/ratelimit/rate_limits.go b/vendor/github.com/getsentry/sentry-go/internal/ratelimit/rate_limits.go deleted file mode 100644 index 579297e4248..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/ratelimit/rate_limits.go +++ /dev/null @@ -1,76 +0,0 @@ -package ratelimit - -import ( - "errors" - "math" - "strconv" - "strings" - "time" -) - -var errInvalidXSRLRetryAfter = errors.New("invalid retry-after value") - -// parseXSentryRateLimits returns a RateLimits map by parsing an input string in -// the format of the X-Sentry-Rate-Limits header. -// -// Example -// -// X-Sentry-Rate-Limits: 60:transaction, 2700:default;error;security -// -// This will rate limit transactions for the next 60 seconds and errors for the -// next 2700 seconds. -// -// Limits for unknown categories are ignored. -func parseXSentryRateLimits(s string, now time.Time) Map { - // https://github.com/getsentry/relay/blob/0424a2e017d193a93918053c90cdae9472d164bf/relay-server/src/utils/rate_limits.rs#L44-L82 - m := make(Map, len(knownCategories)) - for _, limit := range strings.Split(s, ",") { - limit = strings.TrimSpace(limit) - if limit == "" { - continue - } - components := strings.Split(limit, ":") - if len(components) == 0 { - continue - } - retryAfter, err := parseXSRLRetryAfter(strings.TrimSpace(components[0]), now) - if err != nil { - continue - } - categories := "" - if len(components) > 1 { - categories = components[1] - } - for _, category := range strings.Split(categories, ";") { - c := Category(strings.ToLower(strings.TrimSpace(category))) - if _, ok := knownCategories[c]; !ok { - // skip unknown categories, keep m small - continue - } - // always keep the deadline furthest into the future - if retryAfter.After(m[c]) { - m[c] = retryAfter - } - } - } - return m -} - -// parseXSRLRetryAfter parses a string into a retry-after rate limit deadline. -// -// Valid input is a number, possibly signed and possibly floating-point, -// indicating the number of seconds to wait before sending another request. -// Negative values are treated as zero. Fractional values are rounded to the -// next integer. -func parseXSRLRetryAfter(s string, now time.Time) (Deadline, error) { - // https://github.com/getsentry/relay/blob/0424a2e017d193a93918053c90cdae9472d164bf/relay-quotas/src/rate_limit.rs#L88-L96 - f, err := strconv.ParseFloat(s, 64) - if err != nil { - return Deadline{}, errInvalidXSRLRetryAfter - } - d := time.Duration(math.Ceil(math.Max(f, 0.0))) * time.Second - if d < 0 { - d = 0 - } - return Deadline(now.Add(d)), nil -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/ratelimit/retry_after.go b/vendor/github.com/getsentry/sentry-go/internal/ratelimit/retry_after.go deleted file mode 100644 index 576e29dcd45..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/ratelimit/retry_after.go +++ /dev/null @@ -1,40 +0,0 @@ -package ratelimit - -import ( - "errors" - "strconv" - "time" -) - -const defaultRetryAfter = 1 * time.Minute - -var errInvalidRetryAfter = errors.New("invalid input") - -// parseRetryAfter parses a string s as in the standard Retry-After HTTP header -// and returns a deadline until when requests are rate limited and therefore new -// requests should not be sent. The input may be either a date or a non-negative -// integer number of seconds. -// -// See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After -// -// parseRetryAfter always returns a usable deadline, even in case of an error. -// -// This is the original rate limiting mechanism used by Sentry, superseeded by -// the X-Sentry-Rate-Limits response header. -func parseRetryAfter(s string, now time.Time) (Deadline, error) { - if s == "" { - goto invalid - } - if n, err := strconv.Atoi(s); err == nil { - if n < 0 { - goto invalid - } - d := time.Duration(n) * time.Second - return Deadline(now.Add(d)), nil - } - if date, err := time.Parse(time.RFC1123, s); err == nil { - return Deadline(date), nil - } -invalid: - return Deadline(now.Add(defaultRetryAfter)), errInvalidRetryAfter -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/telemetry/bucketed_buffer.go b/vendor/github.com/getsentry/sentry-go/internal/telemetry/bucketed_buffer.go deleted file mode 100644 index 75e621e5579..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/telemetry/bucketed_buffer.go +++ /dev/null @@ -1,398 +0,0 @@ -package telemetry - -import ( - "sync" - "sync/atomic" - "time" - - "github.com/getsentry/sentry-go/internal/ratelimit" -) - -const ( - defaultBucketedCapacity = 100 - perBucketItemLimit = 100 -) - -type Bucket[T any] struct { - traceID string - items []T - createdAt time.Time - lastUpdatedAt time.Time -} - -// BucketedBuffer groups items by trace id, flushing per bucket. -type BucketedBuffer[T any] struct { - mu sync.RWMutex - - buckets []*Bucket[T] - traceIndex map[string]int - - head int - tail int - - itemCapacity int - bucketCapacity int - - totalItems int - bucketCount int - - category ratelimit.Category - priority ratelimit.Priority - overflowPolicy OverflowPolicy - batchSize int - timeout time.Duration - lastFlushTime time.Time - - offered int64 - dropped int64 - onDropped func(item T, reason string) -} - -func NewBucketedBuffer[T any]( - category ratelimit.Category, - capacity int, - overflowPolicy OverflowPolicy, - batchSize int, - timeout time.Duration, -) *BucketedBuffer[T] { - if capacity <= 0 { - capacity = defaultBucketedCapacity - } - if batchSize <= 0 { - batchSize = 1 - } - if timeout < 0 { - timeout = 0 - } - - bucketCapacity := capacity / 10 - if bucketCapacity < 10 { - bucketCapacity = 10 - } - - return &BucketedBuffer[T]{ - buckets: make([]*Bucket[T], bucketCapacity), - traceIndex: make(map[string]int), - itemCapacity: capacity, - bucketCapacity: bucketCapacity, - category: category, - priority: category.GetPriority(), - overflowPolicy: overflowPolicy, - batchSize: batchSize, - timeout: timeout, - lastFlushTime: time.Now(), - } -} - -func (b *BucketedBuffer[T]) Offer(item T) bool { - atomic.AddInt64(&b.offered, 1) - - traceID := "" - if ta, ok := any(item).(TraceAware); ok { - if tid, hasTrace := ta.GetTraceID(); hasTrace { - traceID = tid - } - } - - b.mu.Lock() - defer b.mu.Unlock() - return b.offerToBucket(item, traceID) -} - -func (b *BucketedBuffer[T]) offerToBucket(item T, traceID string) bool { - if traceID != "" { - if idx, exists := b.traceIndex[traceID]; exists { - bucket := b.buckets[idx] - if len(bucket.items) >= perBucketItemLimit { - delete(b.traceIndex, traceID) - } else { - bucket.items = append(bucket.items, item) - bucket.lastUpdatedAt = time.Now() - b.totalItems++ - return true - } - } - } - - if b.totalItems >= b.itemCapacity { - return b.handleOverflow(item, traceID) - } - if b.bucketCount >= b.bucketCapacity { - return b.handleOverflow(item, traceID) - } - - bucket := &Bucket[T]{ - traceID: traceID, - items: []T{item}, - createdAt: time.Now(), - lastUpdatedAt: time.Now(), - } - b.buckets[b.tail] = bucket - if traceID != "" { - b.traceIndex[traceID] = b.tail - } - b.tail = (b.tail + 1) % b.bucketCapacity - b.bucketCount++ - b.totalItems++ - return true -} - -func (b *BucketedBuffer[T]) handleOverflow(item T, traceID string) bool { - switch b.overflowPolicy { - case OverflowPolicyDropOldest: - oldestBucket := b.buckets[b.head] - if oldestBucket == nil { - atomic.AddInt64(&b.dropped, 1) - if b.onDropped != nil { - b.onDropped(item, "buffer_full_invalid_state") - } - return false - } - if oldestBucket.traceID != "" { - delete(b.traceIndex, oldestBucket.traceID) - } - droppedCount := len(oldestBucket.items) - atomic.AddInt64(&b.dropped, int64(droppedCount)) - if b.onDropped != nil { - for _, di := range oldestBucket.items { - b.onDropped(di, "buffer_full_drop_oldest_bucket") - } - } - b.totalItems -= droppedCount - b.bucketCount-- - b.head = (b.head + 1) % b.bucketCapacity - // add new bucket - bucket := &Bucket[T]{traceID: traceID, items: []T{item}, createdAt: time.Now(), lastUpdatedAt: time.Now()} - b.buckets[b.tail] = bucket - if traceID != "" { - b.traceIndex[traceID] = b.tail - } - b.tail = (b.tail + 1) % b.bucketCapacity - b.bucketCount++ - b.totalItems++ - return true - case OverflowPolicyDropNewest: - atomic.AddInt64(&b.dropped, 1) - if b.onDropped != nil { - b.onDropped(item, "buffer_full_drop_newest") - } - return false - default: - atomic.AddInt64(&b.dropped, 1) - if b.onDropped != nil { - b.onDropped(item, "unknown_overflow_policy") - } - return false - } -} - -func (b *BucketedBuffer[T]) Poll() (T, bool) { - b.mu.Lock() - defer b.mu.Unlock() - var zero T - if b.bucketCount == 0 { - return zero, false - } - bucket := b.buckets[b.head] - if bucket == nil || len(bucket.items) == 0 { - return zero, false - } - item := bucket.items[0] - bucket.items = bucket.items[1:] - b.totalItems-- - if len(bucket.items) == 0 { - if bucket.traceID != "" { - delete(b.traceIndex, bucket.traceID) - } - b.buckets[b.head] = nil - b.head = (b.head + 1) % b.bucketCapacity - b.bucketCount-- - } - return item, true -} - -func (b *BucketedBuffer[T]) PollBatch(maxItems int) []T { - if maxItems <= 0 { - return nil - } - b.mu.Lock() - defer b.mu.Unlock() - if b.bucketCount == 0 { - return nil - } - res := make([]T, 0, maxItems) - for len(res) < maxItems && b.bucketCount > 0 { - bucket := b.buckets[b.head] - if bucket == nil { - break - } - n := maxItems - len(res) - if n > len(bucket.items) { - n = len(bucket.items) - } - res = append(res, bucket.items[:n]...) - bucket.items = bucket.items[n:] - b.totalItems -= n - if len(bucket.items) == 0 { - if bucket.traceID != "" { - delete(b.traceIndex, bucket.traceID) - } - b.buckets[b.head] = nil - b.head = (b.head + 1) % b.bucketCapacity - b.bucketCount-- - } - } - return res -} - -func (b *BucketedBuffer[T]) PollIfReady() []T { - b.mu.Lock() - defer b.mu.Unlock() - if b.bucketCount == 0 { - return nil - } - ready := b.totalItems >= b.batchSize || (b.timeout > 0 && time.Since(b.lastFlushTime) >= b.timeout) - if !ready { - return nil - } - oldest := b.buckets[b.head] - if oldest == nil { - return nil - } - items := oldest.items - if oldest.traceID != "" { - delete(b.traceIndex, oldest.traceID) - } - b.buckets[b.head] = nil - b.head = (b.head + 1) % b.bucketCapacity - b.totalItems -= len(items) - b.bucketCount-- - b.lastFlushTime = time.Now() - return items -} - -func (b *BucketedBuffer[T]) Drain() []T { - b.mu.Lock() - defer b.mu.Unlock() - if b.bucketCount == 0 { - return nil - } - res := make([]T, 0, b.totalItems) - for i := 0; i < b.bucketCount; i++ { - idx := (b.head + i) % b.bucketCapacity - bucket := b.buckets[idx] - if bucket != nil { - res = append(res, bucket.items...) - b.buckets[idx] = nil - } - } - b.traceIndex = make(map[string]int) - b.head = 0 - b.tail = 0 - b.totalItems = 0 - b.bucketCount = 0 - return res -} - -func (b *BucketedBuffer[T]) Peek() (T, bool) { - b.mu.RLock() - defer b.mu.RUnlock() - var zero T - if b.bucketCount == 0 { - return zero, false - } - bucket := b.buckets[b.head] - if bucket == nil || len(bucket.items) == 0 { - return zero, false - } - return bucket.items[0], true -} - -func (b *BucketedBuffer[T]) Size() int { b.mu.RLock(); defer b.mu.RUnlock(); return b.totalItems } -func (b *BucketedBuffer[T]) Capacity() int { b.mu.RLock(); defer b.mu.RUnlock(); return b.itemCapacity } -func (b *BucketedBuffer[T]) Category() ratelimit.Category { - b.mu.RLock() - defer b.mu.RUnlock() - return b.category -} -func (b *BucketedBuffer[T]) Priority() ratelimit.Priority { - b.mu.RLock() - defer b.mu.RUnlock() - return b.priority -} -func (b *BucketedBuffer[T]) IsEmpty() bool { - b.mu.RLock() - defer b.mu.RUnlock() - return b.bucketCount == 0 -} -func (b *BucketedBuffer[T]) IsFull() bool { - b.mu.RLock() - defer b.mu.RUnlock() - return b.totalItems >= b.itemCapacity -} -func (b *BucketedBuffer[T]) Utilization() float64 { - b.mu.RLock() - defer b.mu.RUnlock() - if b.itemCapacity == 0 { - return 0 - } - return float64(b.totalItems) / float64(b.itemCapacity) -} -func (b *BucketedBuffer[T]) OfferedCount() int64 { return atomic.LoadInt64(&b.offered) } -func (b *BucketedBuffer[T]) DroppedCount() int64 { return atomic.LoadInt64(&b.dropped) } -func (b *BucketedBuffer[T]) AcceptedCount() int64 { return b.OfferedCount() - b.DroppedCount() } -func (b *BucketedBuffer[T]) DropRate() float64 { - off := b.OfferedCount() - if off == 0 { - return 0 - } - return float64(b.DroppedCount()) / float64(off) -} - -func (b *BucketedBuffer[T]) GetMetrics() BufferMetrics { - b.mu.RLock() - size := b.totalItems - util := 0.0 - if b.itemCapacity > 0 { - util = float64(b.totalItems) / float64(b.itemCapacity) - } - b.mu.RUnlock() - return BufferMetrics{Category: b.category, Priority: b.priority, Capacity: b.itemCapacity, Size: size, Utilization: util, OfferedCount: b.OfferedCount(), DroppedCount: b.DroppedCount(), AcceptedCount: b.AcceptedCount(), DropRate: b.DropRate(), LastUpdated: time.Now()} -} - -func (b *BucketedBuffer[T]) SetDroppedCallback(callback func(item T, reason string)) { - b.mu.Lock() - defer b.mu.Unlock() - b.onDropped = callback -} -func (b *BucketedBuffer[T]) Clear() { - b.mu.Lock() - defer b.mu.Unlock() - for i := 0; i < b.bucketCapacity; i++ { - b.buckets[i] = nil - } - b.traceIndex = make(map[string]int) - b.head = 0 - b.tail = 0 - b.totalItems = 0 - b.bucketCount = 0 -} -func (b *BucketedBuffer[T]) IsReadyToFlush() bool { - b.mu.RLock() - defer b.mu.RUnlock() - if b.bucketCount == 0 { - return false - } - if b.totalItems >= b.batchSize { - return true - } - if b.timeout > 0 && time.Since(b.lastFlushTime) >= b.timeout { - return true - } - return false -} -func (b *BucketedBuffer[T]) MarkFlushed() { - b.mu.Lock() - defer b.mu.Unlock() - b.lastFlushTime = time.Now() -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/telemetry/buffer.go b/vendor/github.com/getsentry/sentry-go/internal/telemetry/buffer.go deleted file mode 100644 index 011a60a293a..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/telemetry/buffer.go +++ /dev/null @@ -1,42 +0,0 @@ -package telemetry - -import ( - "github.com/getsentry/sentry-go/internal/ratelimit" -) - -// Buffer defines the common interface for all buffer implementations. -type Buffer[T any] interface { - // Core operations - Offer(item T) bool - Poll() (T, bool) - PollBatch(maxItems int) []T - PollIfReady() []T - Drain() []T - Peek() (T, bool) - - // State queries - Size() int - Capacity() int - IsEmpty() bool - IsFull() bool - Utilization() float64 - - // Flush management - IsReadyToFlush() bool - MarkFlushed() - - // Category/Priority - Category() ratelimit.Category - Priority() ratelimit.Priority - - // Metrics - OfferedCount() int64 - DroppedCount() int64 - AcceptedCount() int64 - DropRate() float64 - GetMetrics() BufferMetrics - - // Configuration - SetDroppedCallback(callback func(item T, reason string)) - Clear() -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/telemetry/processor.go b/vendor/github.com/getsentry/sentry-go/internal/telemetry/processor.go deleted file mode 100644 index 187a44a6864..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/telemetry/processor.go +++ /dev/null @@ -1,49 +0,0 @@ -package telemetry - -import ( - "context" - "time" - - "github.com/getsentry/sentry-go/internal/protocol" - "github.com/getsentry/sentry-go/internal/ratelimit" -) - -// Processor is the top-level object that wraps the scheduler and buffers. -type Processor struct { - scheduler *Scheduler -} - -// NewProcessor creates a new Processor with the given configuration. -func NewProcessor( - buffers map[ratelimit.Category]Buffer[protocol.TelemetryItem], - transport protocol.TelemetryTransport, - dsn *protocol.Dsn, - sdkInfo *protocol.SdkInfo, -) *Processor { - scheduler := NewScheduler(buffers, transport, dsn, sdkInfo) - scheduler.Start() - - return &Processor{ - scheduler: scheduler, - } -} - -// Add adds a TelemetryItem to the appropriate buffer based on its category. -func (b *Processor) Add(item protocol.TelemetryItem) bool { - return b.scheduler.Add(item) -} - -// Flush forces all buffers to flush within the given timeout. -func (b *Processor) Flush(timeout time.Duration) bool { - return b.scheduler.Flush(timeout) -} - -// FlushWithContext flushes with a custom context for cancellation. -func (b *Processor) FlushWithContext(ctx context.Context) bool { - return b.scheduler.FlushWithContext(ctx) -} - -// Close stops the buffer, flushes remaining data, and releases resources. -func (b *Processor) Close(timeout time.Duration) { - b.scheduler.Stop(timeout) -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/telemetry/ring_buffer.go b/vendor/github.com/getsentry/sentry-go/internal/telemetry/ring_buffer.go deleted file mode 100644 index 7305d1fc84b..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/telemetry/ring_buffer.go +++ /dev/null @@ -1,378 +0,0 @@ -package telemetry - -import ( - "sync" - "sync/atomic" - "time" - - "github.com/getsentry/sentry-go/internal/ratelimit" -) - -const defaultCapacity = 100 - -// RingBuffer is a thread-safe ring buffer with overflow policies. -type RingBuffer[T any] struct { - mu sync.RWMutex - items []T - head int - tail int - size int - capacity int - - category ratelimit.Category - priority ratelimit.Priority - overflowPolicy OverflowPolicy - - batchSize int - timeout time.Duration - lastFlushTime time.Time - - offered int64 - dropped int64 - onDropped func(item T, reason string) -} - -func NewRingBuffer[T any](category ratelimit.Category, capacity int, overflowPolicy OverflowPolicy, batchSize int, timeout time.Duration) *RingBuffer[T] { - if capacity <= 0 { - capacity = defaultCapacity - } - - if batchSize <= 0 { - batchSize = 1 - } - - if timeout < 0 { - timeout = 0 - } - - return &RingBuffer[T]{ - items: make([]T, capacity), - capacity: capacity, - category: category, - priority: category.GetPriority(), - overflowPolicy: overflowPolicy, - batchSize: batchSize, - timeout: timeout, - lastFlushTime: time.Now(), - } -} - -func (b *RingBuffer[T]) SetDroppedCallback(callback func(item T, reason string)) { - b.mu.Lock() - defer b.mu.Unlock() - b.onDropped = callback -} - -func (b *RingBuffer[T]) Offer(item T) bool { - atomic.AddInt64(&b.offered, 1) - - b.mu.Lock() - defer b.mu.Unlock() - - if b.size < b.capacity { - b.items[b.tail] = item - b.tail = (b.tail + 1) % b.capacity - b.size++ - return true - } - - switch b.overflowPolicy { - case OverflowPolicyDropOldest: - oldItem := b.items[b.head] - b.items[b.head] = item - b.head = (b.head + 1) % b.capacity - b.tail = (b.tail + 1) % b.capacity - - atomic.AddInt64(&b.dropped, 1) - if b.onDropped != nil { - b.onDropped(oldItem, "buffer_full_drop_oldest") - } - return true - - case OverflowPolicyDropNewest: - atomic.AddInt64(&b.dropped, 1) - if b.onDropped != nil { - b.onDropped(item, "buffer_full_drop_newest") - } - return false - - default: - atomic.AddInt64(&b.dropped, 1) - if b.onDropped != nil { - b.onDropped(item, "unknown_overflow_policy") - } - return false - } -} - -func (b *RingBuffer[T]) Poll() (T, bool) { - b.mu.Lock() - defer b.mu.Unlock() - - var zero T - if b.size == 0 { - return zero, false - } - - item := b.items[b.head] - b.items[b.head] = zero - b.head = (b.head + 1) % b.capacity - b.size-- - - return item, true -} - -func (b *RingBuffer[T]) PollBatch(maxItems int) []T { - if maxItems <= 0 { - return nil - } - - b.mu.Lock() - defer b.mu.Unlock() - - if b.size == 0 { - return nil - } - - itemCount := maxItems - if itemCount > b.size { - itemCount = b.size - } - - result := make([]T, itemCount) - var zero T - - for i := 0; i < itemCount; i++ { - result[i] = b.items[b.head] - b.items[b.head] = zero - b.head = (b.head + 1) % b.capacity - b.size-- - } - - return result -} - -func (b *RingBuffer[T]) Drain() []T { - b.mu.Lock() - defer b.mu.Unlock() - - if b.size == 0 { - return nil - } - - result := make([]T, b.size) - index := 0 - var zero T - - for i := 0; i < b.size; i++ { - pos := (b.head + i) % b.capacity - result[index] = b.items[pos] - b.items[pos] = zero - index++ - } - - b.head = 0 - b.tail = 0 - b.size = 0 - - return result -} - -func (b *RingBuffer[T]) Peek() (T, bool) { - b.mu.RLock() - defer b.mu.RUnlock() - - var zero T - if b.size == 0 { - return zero, false - } - - return b.items[b.head], true -} - -func (b *RingBuffer[T]) Size() int { - b.mu.RLock() - defer b.mu.RUnlock() - return b.size -} - -func (b *RingBuffer[T]) Capacity() int { - b.mu.RLock() - defer b.mu.RUnlock() - return b.capacity -} - -func (b *RingBuffer[T]) Category() ratelimit.Category { - b.mu.RLock() - defer b.mu.RUnlock() - return b.category -} - -func (b *RingBuffer[T]) Priority() ratelimit.Priority { - b.mu.RLock() - defer b.mu.RUnlock() - return b.priority -} - -func (b *RingBuffer[T]) IsEmpty() bool { - b.mu.RLock() - defer b.mu.RUnlock() - return b.size == 0 -} - -func (b *RingBuffer[T]) IsFull() bool { - b.mu.RLock() - defer b.mu.RUnlock() - return b.size == b.capacity -} - -func (b *RingBuffer[T]) Utilization() float64 { - b.mu.RLock() - defer b.mu.RUnlock() - return float64(b.size) / float64(b.capacity) -} - -func (b *RingBuffer[T]) OfferedCount() int64 { - return atomic.LoadInt64(&b.offered) -} - -func (b *RingBuffer[T]) DroppedCount() int64 { - return atomic.LoadInt64(&b.dropped) -} - -func (b *RingBuffer[T]) AcceptedCount() int64 { - return b.OfferedCount() - b.DroppedCount() -} - -func (b *RingBuffer[T]) DropRate() float64 { - offered := b.OfferedCount() - if offered == 0 { - return 0.0 - } - return float64(b.DroppedCount()) / float64(offered) -} - -func (b *RingBuffer[T]) Clear() { - b.mu.Lock() - defer b.mu.Unlock() - - var zero T - for i := 0; i < b.capacity; i++ { - b.items[i] = zero - } - - b.head = 0 - b.tail = 0 - b.size = 0 -} - -func (b *RingBuffer[T]) GetMetrics() BufferMetrics { - b.mu.RLock() - size := b.size - util := float64(b.size) / float64(b.capacity) - b.mu.RUnlock() - - return BufferMetrics{ - Category: b.category, - Priority: b.priority, - Capacity: b.capacity, - Size: size, - Utilization: util, - OfferedCount: b.OfferedCount(), - DroppedCount: b.DroppedCount(), - AcceptedCount: b.AcceptedCount(), - DropRate: b.DropRate(), - LastUpdated: time.Now(), - } -} - -func (b *RingBuffer[T]) IsReadyToFlush() bool { - b.mu.RLock() - defer b.mu.RUnlock() - - if b.size == 0 { - return false - } - - if b.size >= b.batchSize { - return true - } - - if b.timeout > 0 && time.Since(b.lastFlushTime) >= b.timeout { - return true - } - - return false -} - -func (b *RingBuffer[T]) MarkFlushed() { - b.mu.Lock() - defer b.mu.Unlock() - b.lastFlushTime = time.Now() -} - -func (b *RingBuffer[T]) PollIfReady() []T { - b.mu.Lock() - defer b.mu.Unlock() - - if b.size == 0 { - return nil - } - - ready := b.size >= b.batchSize || - (b.timeout > 0 && time.Since(b.lastFlushTime) >= b.timeout) - - if !ready { - return nil - } - - itemCount := b.batchSize - if itemCount > b.size { - itemCount = b.size - } - - result := make([]T, itemCount) - var zero T - - for i := 0; i < itemCount; i++ { - result[i] = b.items[b.head] - b.items[b.head] = zero - b.head = (b.head + 1) % b.capacity - b.size-- - } - - b.lastFlushTime = time.Now() - return result -} - -type BufferMetrics struct { - Category ratelimit.Category `json:"category"` - Priority ratelimit.Priority `json:"priority"` - Capacity int `json:"capacity"` - Size int `json:"size"` - Utilization float64 `json:"utilization"` - OfferedCount int64 `json:"offered_count"` - DroppedCount int64 `json:"dropped_count"` - AcceptedCount int64 `json:"accepted_count"` - DropRate float64 `json:"drop_rate"` - LastUpdated time.Time `json:"last_updated"` -} - -// OverflowPolicy defines how the ring buffer handles overflow. -type OverflowPolicy int - -const ( - OverflowPolicyDropOldest OverflowPolicy = iota - OverflowPolicyDropNewest -) - -func (op OverflowPolicy) String() string { - switch op { - case OverflowPolicyDropOldest: - return "drop_oldest" - case OverflowPolicyDropNewest: - return "drop_newest" - default: - return "unknown" - } -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/telemetry/scheduler.go b/vendor/github.com/getsentry/sentry-go/internal/telemetry/scheduler.go deleted file mode 100644 index 5bf206a54e4..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/telemetry/scheduler.go +++ /dev/null @@ -1,301 +0,0 @@ -package telemetry - -import ( - "context" - "sync" - "time" - - "github.com/getsentry/sentry-go/internal/debuglog" - "github.com/getsentry/sentry-go/internal/protocol" - "github.com/getsentry/sentry-go/internal/ratelimit" -) - -// Scheduler implements a weighted round-robin scheduler for processing buffered events. -type Scheduler struct { - buffers map[ratelimit.Category]Buffer[protocol.TelemetryItem] - transport protocol.TelemetryTransport - dsn *protocol.Dsn - sdkInfo *protocol.SdkInfo - - currentCycle []ratelimit.Priority - cyclePos int - - ctx context.Context - cancel context.CancelFunc - processingWg sync.WaitGroup - - mu sync.Mutex - cond *sync.Cond - startOnce sync.Once - finishOnce sync.Once -} - -func NewScheduler( - buffers map[ratelimit.Category]Buffer[protocol.TelemetryItem], - transport protocol.TelemetryTransport, - dsn *protocol.Dsn, - sdkInfo *protocol.SdkInfo, -) *Scheduler { - ctx, cancel := context.WithCancel(context.Background()) - - priorityWeights := map[ratelimit.Priority]int{ - ratelimit.PriorityCritical: 5, - ratelimit.PriorityHigh: 4, - ratelimit.PriorityMedium: 3, - ratelimit.PriorityLow: 2, - ratelimit.PriorityLowest: 1, - } - - var currentCycle []ratelimit.Priority - for priority, weight := range priorityWeights { - hasBuffers := false - for _, buffer := range buffers { - if buffer.Priority() == priority { - hasBuffers = true - break - } - } - - if hasBuffers { - for i := 0; i < weight; i++ { - currentCycle = append(currentCycle, priority) - } - } - } - - s := &Scheduler{ - buffers: buffers, - transport: transport, - dsn: dsn, - sdkInfo: sdkInfo, - currentCycle: currentCycle, - ctx: ctx, - cancel: cancel, - } - s.cond = sync.NewCond(&s.mu) - - return s -} - -func (s *Scheduler) Start() { - s.startOnce.Do(func() { - s.processingWg.Add(1) - go s.run() - }) -} - -func (s *Scheduler) Stop(timeout time.Duration) { - s.finishOnce.Do(func() { - s.Flush(timeout) - - s.cancel() - s.cond.Broadcast() - - done := make(chan struct{}) - go func() { - defer close(done) - s.processingWg.Wait() - }() - - select { - case <-done: - case <-time.After(timeout): - debuglog.Printf("scheduler stop timed out after %v", timeout) - } - }) -} - -func (s *Scheduler) Signal() { - s.cond.Signal() -} - -func (s *Scheduler) Add(item protocol.TelemetryItem) bool { - category := item.GetCategory() - buffer, exists := s.buffers[category] - if !exists { - return false - } - - accepted := buffer.Offer(item) - if accepted { - s.Signal() - } - return accepted -} - -func (s *Scheduler) Flush(timeout time.Duration) bool { - ctx, cancel := context.WithTimeout(context.Background(), timeout) - defer cancel() - return s.FlushWithContext(ctx) -} - -func (s *Scheduler) FlushWithContext(ctx context.Context) bool { - s.flushBuffers() - return s.transport.FlushWithContext(ctx) -} - -func (s *Scheduler) run() { - defer s.processingWg.Done() - - go func() { - ticker := time.NewTicker(100 * time.Millisecond) - defer ticker.Stop() - - for { - select { - case <-ticker.C: - s.cond.Broadcast() - case <-s.ctx.Done(): - return - } - } - }() - - for { - s.mu.Lock() - - for !s.hasWork() && s.ctx.Err() == nil { - s.cond.Wait() - } - - if s.ctx.Err() != nil { - s.mu.Unlock() - return - } - - s.mu.Unlock() - s.processNextBatch() - } -} - -func (s *Scheduler) hasWork() bool { - for _, buffer := range s.buffers { - if buffer.IsReadyToFlush() { - return true - } - } - return false -} - -func (s *Scheduler) processNextBatch() { - if len(s.currentCycle) == 0 { - return - } - - priority := s.currentCycle[s.cyclePos] - s.cyclePos = (s.cyclePos + 1) % len(s.currentCycle) - - var bufferToProcess Buffer[protocol.TelemetryItem] - var categoryToProcess ratelimit.Category - for category, buffer := range s.buffers { - if buffer.Priority() == priority && buffer.IsReadyToFlush() { - bufferToProcess = buffer - categoryToProcess = category - break - } - } - - if bufferToProcess != nil { - s.processItems(bufferToProcess, categoryToProcess, false) - } -} - -func (s *Scheduler) processItems(buffer Buffer[protocol.TelemetryItem], category ratelimit.Category, force bool) { - var items []protocol.TelemetryItem - - if force { - items = buffer.Drain() - } else { - items = buffer.PollIfReady() - } - - // drop the current batch if rate-limited or if transport is full - if len(items) == 0 || s.isRateLimited(category) || !s.transport.HasCapacity() { - return - } - - switch category { - case ratelimit.CategoryLog: - logs := protocol.Logs(items) - header := &protocol.EnvelopeHeader{EventID: protocol.GenerateEventID(), SentAt: time.Now(), Sdk: s.sdkInfo} - if s.dsn != nil { - header.Dsn = s.dsn.String() - } - envelope := protocol.NewEnvelope(header) - item, err := logs.ToEnvelopeItem() - if err != nil { - debuglog.Printf("error creating log batch envelope item: %v", err) - return - } - envelope.AddItem(item) - if err := s.transport.SendEnvelope(envelope); err != nil { - debuglog.Printf("error sending envelope: %v", err) - } - return - case ratelimit.CategoryTraceMetric: - metrics := protocol.Metrics(items) - header := &protocol.EnvelopeHeader{EventID: protocol.GenerateEventID(), SentAt: time.Now(), Sdk: s.sdkInfo} - if s.dsn != nil { - header.Dsn = s.dsn.String() - } - envelope := protocol.NewEnvelope(header) - item, err := metrics.ToEnvelopeItem() - if err != nil { - debuglog.Printf("error creating trace metric batch envelope item: %v", err) - return - } - envelope.AddItem(item) - if err := s.transport.SendEnvelope(envelope); err != nil { - debuglog.Printf("error sending envelope: %v", err) - } - return - default: - // if the buffers are properly configured, buffer.PollIfReady should return a single item for every category - // other than logs. We still iterate over the items just in case, because we don't want to send broken envelopes. - for _, it := range items { - convertible, ok := it.(protocol.EnvelopeItemConvertible) - if !ok { - debuglog.Printf("item does not implement EnvelopeItemConvertible: %T", it) - continue - } - s.sendItem(convertible) - } - } -} - -func (s *Scheduler) sendItem(item protocol.EnvelopeItemConvertible) { - header := &protocol.EnvelopeHeader{ - EventID: item.GetEventID(), - SentAt: time.Now(), - Trace: item.GetDynamicSamplingContext(), - Sdk: s.sdkInfo, - } - if header.EventID == "" { - header.EventID = protocol.GenerateEventID() - } - if s.dsn != nil { - header.Dsn = s.dsn.String() - } - envelope := protocol.NewEnvelope(header) - envItem, err := item.ToEnvelopeItem() - if err != nil { - debuglog.Printf("error while converting to envelope item: %v", err) - return - } - envelope.AddItem(envItem) - if err := s.transport.SendEnvelope(envelope); err != nil { - debuglog.Printf("error sending envelope: %v", err) - } -} - -func (s *Scheduler) flushBuffers() { - for category, buffer := range s.buffers { - if !buffer.IsEmpty() { - s.processItems(buffer, category, true) - } - } -} - -func (s *Scheduler) isRateLimited(category ratelimit.Category) bool { - return s.transport.IsRateLimited(category) -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/telemetry/trace_aware.go b/vendor/github.com/getsentry/sentry-go/internal/telemetry/trace_aware.go deleted file mode 100644 index a3210337104..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/telemetry/trace_aware.go +++ /dev/null @@ -1,7 +0,0 @@ -package telemetry - -// TraceAware is implemented by items that can expose a trace ID. -// BucketedBuffer uses this to group items by trace. -type TraceAware interface { - GetTraceID() (string, bool) -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/util/map.go b/vendor/github.com/getsentry/sentry-go/internal/util/map.go deleted file mode 100644 index 7ca9d17a8fc..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/util/map.go +++ /dev/null @@ -1,43 +0,0 @@ -package util - -import "sync" - -type SyncMap[K comparable, V any] struct { - m sync.Map -} - -func (s *SyncMap[K, V]) Store(key K, value V) { - s.m.Store(key, value) -} - -func (s *SyncMap[K, V]) CompareAndDelete(key K, value V) { - s.m.CompareAndDelete(key, value) -} - -func (s *SyncMap[K, V]) Load(key K) (V, bool) { - v, ok := s.m.Load(key) - if !ok { - var zero V - return zero, false - } - return v.(V), true -} - -func (s *SyncMap[K, V]) Delete(key K) { - s.m.Delete(key) -} - -func (s *SyncMap[K, V]) LoadOrStore(key K, value V) (V, bool) { - actual, loaded := s.m.LoadOrStore(key, value) - return actual.(V), loaded -} - -func (s *SyncMap[K, V]) Clear() { - s.m.Clear() -} - -func (s *SyncMap[K, V]) Range(f func(key K, value V) bool) { - s.m.Range(func(key, value any) bool { - return f(key.(K), value.(V)) - }) -} diff --git a/vendor/github.com/getsentry/sentry-go/internal/util/util.go b/vendor/github.com/getsentry/sentry-go/internal/util/util.go deleted file mode 100644 index 375d5c186b4..00000000000 --- a/vendor/github.com/getsentry/sentry-go/internal/util/util.go +++ /dev/null @@ -1,83 +0,0 @@ -package util - -import ( - "fmt" - "io" - "net/http" - - "github.com/getsentry/sentry-go/internal/debuglog" - "github.com/getsentry/sentry-go/internal/protocol" -) - -// MaxDrainResponseBytes is the maximum number of bytes that transport -// implementations will read from response bodies when draining them. -const MaxDrainResponseBytes = 16 << 10 - -// HandleHTTPResponse is a helper method that reads the HTTP response and handles debug output. -func HandleHTTPResponse(response *http.Response, identifier string) bool { - if response.StatusCode >= 200 && response.StatusCode < 300 { - return true - } - - if response.StatusCode >= 400 && response.StatusCode <= 599 { - body, err := io.ReadAll(io.LimitReader(response.Body, MaxDrainResponseBytes)) - if err != nil { - debuglog.Printf("Error while reading response body: %v", err) - return false - } - - switch { - case response.StatusCode == http.StatusRequestEntityTooLarge: - debuglog.Printf("Sending %s failed because the request was too large: %s", identifier, string(body)) - case response.StatusCode >= 500: - debuglog.Printf("Sending %s failed with server error %d: %s", identifier, response.StatusCode, string(body)) - default: - debuglog.Printf("Sending %s failed with client error %d: %s", identifier, response.StatusCode, string(body)) - } - return false - } - - debuglog.Printf("Unexpected status code %d for event %s", response.StatusCode, identifier) - return false -} - -// EnvelopeIdentifier returns a human-readable identifier for the event to be used in log messages. -// Format: " []". -func EnvelopeIdentifier(envelope *protocol.Envelope) string { - if envelope == nil || len(envelope.Items) == 0 { - return "empty envelope" - } - - var description string - // we don't currently support mixed envelope types, so all event types would have the same type. - itemType := envelope.Items[0].Header.Type - - switch itemType { - case protocol.EnvelopeItemTypeEvent: - description = "error" - case protocol.EnvelopeItemTypeTransaction: - description = "transaction" - case protocol.EnvelopeItemTypeCheckIn: - description = "check-in" - case protocol.EnvelopeItemTypeLog: - logCount := 0 - for _, item := range envelope.Items { - if item != nil && item.Header != nil && item.Header.Type == protocol.EnvelopeItemTypeLog && item.Header.ItemCount != nil { - logCount += *item.Header.ItemCount - } - } - description = fmt.Sprintf("%d log events", logCount) - case protocol.EnvelopeItemTypeTraceMetric: - metricCount := 0 - for _, item := range envelope.Items { - if item != nil && item.Header != nil && item.Header.Type == protocol.EnvelopeItemTypeTraceMetric && item.Header.ItemCount != nil { - metricCount += *item.Header.ItemCount - } - } - description = fmt.Sprintf("%d metric events", metricCount) - default: - description = fmt.Sprintf("%s event", itemType) - } - - return fmt.Sprintf("%s [%s]", description, envelope.Header.EventID) -} diff --git a/vendor/github.com/getsentry/sentry-go/log.go b/vendor/github.com/getsentry/sentry-go/log.go deleted file mode 100644 index a9cd1095a22..00000000000 --- a/vendor/github.com/getsentry/sentry-go/log.go +++ /dev/null @@ -1,333 +0,0 @@ -package sentry - -import ( - "context" - "fmt" - "maps" - "os" - "strings" - "sync" - "time" - - "github.com/getsentry/sentry-go/attribute" - "github.com/getsentry/sentry-go/internal/debuglog" -) - -type LogLevel string - -const ( - LogLevelTrace LogLevel = "trace" - LogLevelDebug LogLevel = "debug" - LogLevelInfo LogLevel = "info" - LogLevelWarn LogLevel = "warn" - LogLevelError LogLevel = "error" - LogLevelFatal LogLevel = "fatal" -) - -const ( - LogSeverityTrace int = 1 - LogSeverityDebug int = 5 - LogSeverityInfo int = 9 - LogSeverityWarning int = 13 - LogSeverityError int = 17 - LogSeverityFatal int = 21 -) - -type sentryLogger struct { - ctx context.Context - hub *Hub - attributes map[string]attribute.Value - defaultAttributes map[string]attribute.Value - mu sync.RWMutex -} - -type logEntry struct { - logger *sentryLogger - ctx context.Context - level LogLevel - severity int - attributes map[string]attribute.Value - shouldPanic bool - shouldFatal bool -} - -// NewLogger returns a Logger that emits logs to Sentry. If logging is turned off, all logs get discarded. -func NewLogger(ctx context.Context) Logger { // nolint: dupl - var hub *Hub - hub = GetHubFromContext(ctx) - if hub == nil { - hub = CurrentHub() - } - - client := hub.Client() - if client != nil && client.options.EnableLogs { - // Build default attrs - serverAddr := client.options.ServerName - if serverAddr == "" { - serverAddr, _ = os.Hostname() - } - - defaults := map[string]string{ - "sentry.release": client.options.Release, - "sentry.environment": client.options.Environment, - "sentry.server.address": serverAddr, - "sentry.sdk.name": client.sdkIdentifier, - "sentry.sdk.version": client.sdkVersion, - } - - defaultAttrs := make(map[string]attribute.Value, len(defaults)) - for k, v := range defaults { - if v != "" { - defaultAttrs[k] = attribute.StringValue(v) - } - } - - return &sentryLogger{ - ctx: ctx, - hub: hub, - attributes: make(map[string]attribute.Value), - defaultAttributes: defaultAttrs, - mu: sync.RWMutex{}, - } - } - - debuglog.Println("fallback to noopLogger: enableLogs disabled") - return &noopLogger{} -} - -func (l *sentryLogger) Write(p []byte) (int, error) { - msg := strings.TrimRight(string(p), "\n") - l.Info().Emit(msg) - return len(p), nil -} - -func (l *sentryLogger) log(ctx context.Context, level LogLevel, severity int, message string, entryAttrs map[string]attribute.Value, args ...interface{}) { - if message == "" { - return - } - - hub := hubFromContexts(ctx, l.ctx) - if hub == nil { - hub = l.hub - } - client := hub.Client() - if client == nil { - return - } - - scope := hub.Scope() - traceID, spanID := resolveTrace(scope, ctx, l.ctx) - - // Pre-allocate with capacity hint to avoid map growth reallocations - estimatedCap := len(l.defaultAttributes) + len(entryAttrs) + len(args) + 8 // scope ~3 + instance ~5 - attrs := make(map[string]attribute.Value, estimatedCap) - - // attribute precedence: default -> scope -> instance (from SetAttrs) -> entry-specific - for k, v := range l.defaultAttributes { - attrs[k] = v - } - scope.populateAttrs(attrs) - - l.mu.RLock() - for k, v := range l.attributes { - attrs[k] = v - } - l.mu.RUnlock() - - for k, v := range entryAttrs { - attrs[k] = v - } - - if len(args) > 0 { - attrs["sentry.message.template"] = attribute.StringValue(message) - for i, p := range args { - attrs[fmt.Sprintf("sentry.message.parameters.%d", i)] = attribute.StringValue(fmt.Sprintf("%+v", p)) - } - } - - log := &Log{ - Timestamp: time.Now(), - TraceID: traceID, - SpanID: spanID, - Level: level, - Severity: severity, - Body: fmt.Sprintf(message, args...), - Attributes: attrs, - } - - client.captureLog(log, scope) - if client.options.Debug { - debuglog.Printf(message, args...) - } -} - -func (l *sentryLogger) SetAttributes(attrs ...attribute.Builder) { - l.mu.Lock() - defer l.mu.Unlock() - - for _, a := range attrs { - if a.Value.Type() == attribute.INVALID { - debuglog.Printf("invalid attribute: %v", a) - continue - } - l.attributes[a.Key] = a.Value - } -} - -func (l *sentryLogger) Trace() LogEntry { - return &logEntry{ - logger: l, - ctx: l.ctx, - level: LogLevelTrace, - severity: LogSeverityTrace, - attributes: make(map[string]attribute.Value), - } -} - -func (l *sentryLogger) Debug() LogEntry { - return &logEntry{ - logger: l, - ctx: l.ctx, - level: LogLevelDebug, - severity: LogSeverityDebug, - attributes: make(map[string]attribute.Value), - } -} - -func (l *sentryLogger) Info() LogEntry { - return &logEntry{ - logger: l, - ctx: l.ctx, - level: LogLevelInfo, - severity: LogSeverityInfo, - attributes: make(map[string]attribute.Value), - } -} - -func (l *sentryLogger) Warn() LogEntry { - return &logEntry{ - logger: l, - ctx: l.ctx, - level: LogLevelWarn, - severity: LogSeverityWarning, - attributes: make(map[string]attribute.Value), - } -} - -func (l *sentryLogger) Error() LogEntry { - return &logEntry{ - logger: l, - ctx: l.ctx, - level: LogLevelError, - severity: LogSeverityError, - attributes: make(map[string]attribute.Value), - } -} - -func (l *sentryLogger) Fatal() LogEntry { - return &logEntry{ - logger: l, - ctx: l.ctx, - level: LogLevelFatal, - severity: LogSeverityFatal, - attributes: make(map[string]attribute.Value), - shouldFatal: true, - } -} - -func (l *sentryLogger) Panic() LogEntry { - return &logEntry{ - logger: l, - ctx: l.ctx, - level: LogLevelFatal, - severity: LogSeverityFatal, - attributes: make(map[string]attribute.Value), - shouldPanic: true, - } -} - -func (l *sentryLogger) LFatal() LogEntry { - return &logEntry{ - logger: l, - ctx: l.ctx, - level: LogLevelFatal, - severity: LogSeverityFatal, - attributes: make(map[string]attribute.Value), - } -} - -func (l *sentryLogger) GetCtx() context.Context { - return l.ctx -} - -func (e *logEntry) WithCtx(ctx context.Context) LogEntry { - return &logEntry{ - logger: e.logger, - ctx: ctx, - level: e.level, - severity: e.severity, - attributes: maps.Clone(e.attributes), - shouldPanic: e.shouldPanic, - shouldFatal: e.shouldFatal, - } -} - -func (e *logEntry) String(key, value string) LogEntry { - e.attributes[key] = attribute.StringValue(value) - return e -} - -func (e *logEntry) Int(key string, value int) LogEntry { - e.attributes[key] = attribute.Int64Value(int64(value)) - return e -} - -func (e *logEntry) Int64(key string, value int64) LogEntry { - e.attributes[key] = attribute.Int64Value(value) - return e -} - -func (e *logEntry) Float64(key string, value float64) LogEntry { - e.attributes[key] = attribute.Float64Value(value) - return e -} - -func (e *logEntry) Bool(key string, value bool) LogEntry { - e.attributes[key] = attribute.BoolValue(value) - return e -} - -// Uint64 adds uint64 attributes to the log entry. -// -// This method is intentionally not part of the LogEntry interface to avoid exposing uint64 in the public API. -func (e *logEntry) Uint64(key string, value uint64) LogEntry { - e.attributes[key] = attribute.Uint64Value(value) - return e -} - -func (e *logEntry) Emit(args ...interface{}) { - e.logger.log(e.ctx, e.level, e.severity, fmt.Sprint(args...), e.attributes) - - if e.level == LogLevelFatal { - if e.shouldPanic { - panic(fmt.Sprint(args...)) - } - if e.shouldFatal { - os.Exit(1) - } - } -} - -func (e *logEntry) Emitf(format string, args ...interface{}) { - e.logger.log(e.ctx, e.level, e.severity, format, e.attributes, args...) - - if e.level == LogLevelFatal { - if e.shouldPanic { - formattedMessage := fmt.Sprintf(format, args...) - panic(formattedMessage) - } - if e.shouldFatal { - os.Exit(1) - } - } -} diff --git a/vendor/github.com/getsentry/sentry-go/log_batch_processor.go b/vendor/github.com/getsentry/sentry-go/log_batch_processor.go deleted file mode 100644 index e361a3937e1..00000000000 --- a/vendor/github.com/getsentry/sentry-go/log_batch_processor.go +++ /dev/null @@ -1,32 +0,0 @@ -package sentry - -import ( - "time" -) - -// logBatchProcessor batches logs and sends them to Sentry. -type logBatchProcessor struct { - *batchProcessor[Log] -} - -func newLogBatchProcessor(client *Client) *logBatchProcessor { - return &logBatchProcessor{ - batchProcessor: newBatchProcessor(func(items []Log) { - if len(items) == 0 { - return - } - - event := NewEvent() - event.Timestamp = time.Now() - event.EventID = EventID(uuid()) - event.Type = logEvent.Type - event.Logs = items - - client.Transport.SendEvent(event) - }), - } -} - -func (p *logBatchProcessor) Send(log *Log) bool { - return p.batchProcessor.Send(*log) -} diff --git a/vendor/github.com/getsentry/sentry-go/log_fallback.go b/vendor/github.com/getsentry/sentry-go/log_fallback.go deleted file mode 100644 index 9617bf9760c..00000000000 --- a/vendor/github.com/getsentry/sentry-go/log_fallback.go +++ /dev/null @@ -1,114 +0,0 @@ -package sentry - -import ( - "context" - "fmt" - "os" - - "github.com/getsentry/sentry-go/attribute" - "github.com/getsentry/sentry-go/internal/debuglog" -) - -// Fallback, no-op logger if logging is disabled. -type noopLogger struct{} - -// noopLogEntry implements LogEntry for the no-op logger. -type noopLogEntry struct { - level LogLevel - shouldPanic bool - shouldFatal bool -} - -func (n *noopLogEntry) WithCtx(_ context.Context) LogEntry { - return n -} - -func (n *noopLogEntry) String(_, _ string) LogEntry { - return n -} - -func (n *noopLogEntry) Int(_ string, _ int) LogEntry { - return n -} - -func (n *noopLogEntry) Int64(_ string, _ int64) LogEntry { - return n -} - -func (n *noopLogEntry) Float64(_ string, _ float64) LogEntry { - return n -} - -func (n *noopLogEntry) Bool(_ string, _ bool) LogEntry { - return n -} - -func (n *noopLogEntry) Attributes(_ ...attribute.Builder) LogEntry { - return n -} - -func (n *noopLogEntry) Emit(args ...interface{}) { - debuglog.Printf("Log with level=[%v] is being dropped. Turn on logging via EnableLogs", n.level) - if n.level == LogLevelFatal { - if n.shouldPanic { - panic(args) - } - if n.shouldFatal { - os.Exit(1) - } - } -} - -func (n *noopLogEntry) Emitf(message string, args ...interface{}) { - debuglog.Printf("Log with level=[%v] is being dropped. Turn on logging via EnableLogs", n.level) - if n.level == LogLevelFatal { - if n.shouldPanic { - panic(fmt.Sprintf(message, args...)) - } - if n.shouldFatal { - os.Exit(1) - } - } -} - -func (n *noopLogger) GetCtx() context.Context { return context.Background() } - -func (*noopLogger) Trace() LogEntry { - return &noopLogEntry{level: LogLevelTrace} -} - -func (*noopLogger) Debug() LogEntry { - return &noopLogEntry{level: LogLevelDebug} -} - -func (*noopLogger) Info() LogEntry { - return &noopLogEntry{level: LogLevelInfo} -} - -func (*noopLogger) Warn() LogEntry { - return &noopLogEntry{level: LogLevelWarn} -} - -func (*noopLogger) Error() LogEntry { - return &noopLogEntry{level: LogLevelError} -} - -func (*noopLogger) Fatal() LogEntry { - return &noopLogEntry{level: LogLevelFatal, shouldFatal: true} -} - -func (*noopLogger) Panic() LogEntry { - return &noopLogEntry{level: LogLevelFatal, shouldPanic: true} -} - -func (*noopLogger) LFatal() LogEntry { - return &noopLogEntry{level: LogLevelFatal} -} - -func (*noopLogger) SetAttributes(...attribute.Builder) { - debuglog.Printf("No attributes attached. Turn on logging via EnableLogs") -} - -func (*noopLogger) Write(_ []byte) (n int, err error) { - return 0, fmt.Errorf("log with level=[%v] is being dropped. Turn on logging via EnableLogs", LogLevelInfo) -} diff --git a/vendor/github.com/getsentry/sentry-go/metric_batch_processor.go b/vendor/github.com/getsentry/sentry-go/metric_batch_processor.go deleted file mode 100644 index 788d3adfb76..00000000000 --- a/vendor/github.com/getsentry/sentry-go/metric_batch_processor.go +++ /dev/null @@ -1,32 +0,0 @@ -package sentry - -import ( - "time" -) - -// metricBatchProcessor batches metrics and sends them to Sentry. -type metricBatchProcessor struct { - *batchProcessor[Metric] -} - -func newMetricBatchProcessor(client *Client) *metricBatchProcessor { - return &metricBatchProcessor{ - batchProcessor: newBatchProcessor(func(items []Metric) { - if len(items) == 0 { - return - } - - event := NewEvent() - event.Timestamp = time.Now() - event.EventID = EventID(uuid()) - event.Type = traceMetricEvent.Type - event.Metrics = items - - client.Transport.SendEvent(event) - }), - } -} - -func (p *metricBatchProcessor) Send(metric *Metric) bool { - return p.batchProcessor.Send(*metric) -} diff --git a/vendor/github.com/getsentry/sentry-go/metrics.go b/vendor/github.com/getsentry/sentry-go/metrics.go deleted file mode 100644 index 7869e406c8a..00000000000 --- a/vendor/github.com/getsentry/sentry-go/metrics.go +++ /dev/null @@ -1,241 +0,0 @@ -package sentry - -import ( - "context" - "maps" - "os" - "sync" - "time" - - "github.com/getsentry/sentry-go/attribute" - "github.com/getsentry/sentry-go/internal/debuglog" -) - -// Duration Units. -const ( - UnitNanosecond = "nanosecond" - UnitMicrosecond = "microsecond" - UnitMillisecond = "millisecond" - UnitSecond = "second" - UnitMinute = "minute" - UnitHour = "hour" - UnitDay = "day" - UnitWeek = "week" -) - -// Information Units. -const ( - UnitBit = "bit" - UnitByte = "byte" - UnitKilobyte = "kilobyte" - UnitKibibyte = "kibibyte" - UnitMegabyte = "megabyte" - UnitMebibyte = "mebibyte" - UnitGigabyte = "gigabyte" - UnitGibibyte = "gibibyte" - UnitTerabyte = "terabyte" - UnitTebibyte = "tebibyte" - UnitPetabyte = "petabyte" - UnitPebibyte = "pebibyte" - UnitExabyte = "exabyte" - UnitExbibyte = "exbibyte" -) - -// Fraction Units. -const ( - UnitRatio = "ratio" - UnitPercent = "percent" -) - -// NewMeter returns a new Meter. If there is no Client bound to the current hub, or if metrics are disabled, -// it returns a no-op Meter that discards all metrics. -func NewMeter(ctx context.Context) Meter { - hub := GetHubFromContext(ctx) - if hub == nil { - hub = CurrentHub() - } - client := hub.Client() - if client != nil && !client.options.DisableMetrics { - // build default attrs - serverAddr := client.options.ServerName - if serverAddr == "" { - serverAddr, _ = os.Hostname() - } - - defaults := map[string]string{ - "sentry.release": client.options.Release, - "sentry.environment": client.options.Environment, - "sentry.server.address": serverAddr, - "sentry.sdk.name": client.sdkIdentifier, - "sentry.sdk.version": client.sdkVersion, - } - - defaultAttrs := make(map[string]attribute.Value) - for k, v := range defaults { - if v != "" { - defaultAttrs[k] = attribute.StringValue(v) - } - } - - return &sentryMeter{ - ctx: ctx, - hub: hub, - attributes: make(map[string]attribute.Value), - defaultAttributes: defaultAttrs, - mu: sync.RWMutex{}, - } - } - - debuglog.Printf("fallback to noopMeter: metrics disabled") - return &noopMeter{} -} - -type sentryMeter struct { - ctx context.Context - hub *Hub - attributes map[string]attribute.Value - defaultAttributes map[string]attribute.Value - mu sync.RWMutex -} - -func (m *sentryMeter) emit(ctx context.Context, metricType MetricType, name string, value MetricValue, unit string, attributes map[string]attribute.Value, customScope *Scope) { - if name == "" { - debuglog.Println("empty name provided, dropping metric") - return - } - - hub := hubFromContexts(ctx, m.ctx) - if hub == nil { - hub = m.hub - } - - client := hub.Client() - if client == nil { - return - } - - scope := hub.Scope() - if customScope != nil { - scope = customScope - } - traceID, spanID := resolveTrace(scope, ctx, m.ctx) - - // Pre-allocate with capacity hint to avoid map growth reallocations - estimatedCap := len(m.defaultAttributes) + len(attributes) + 8 // scope ~3 + call-specific ~5 - attrs := make(map[string]attribute.Value, estimatedCap) - - // attribute precedence: default -> scope -> instance (from SetAttrs) -> entry-specific - for k, v := range m.defaultAttributes { - attrs[k] = v - } - scope.populateAttrs(attrs) - - m.mu.RLock() - for k, v := range m.attributes { - attrs[k] = v - } - m.mu.RUnlock() - - for k, v := range attributes { - attrs[k] = v - } - - metric := &Metric{ - Timestamp: time.Now(), - TraceID: traceID, - SpanID: spanID, - Type: metricType, - Name: name, - Value: value, - Unit: unit, - Attributes: attrs, - } - - if client.captureMetric(metric, scope) && client.options.Debug { - debuglog.Printf("Metric %s [%s]: %v %s", metricType, name, value.AsInterface(), unit) - } -} - -// WithCtx returns a new Meter that uses the given context for trace/span association. -func (m *sentryMeter) WithCtx(ctx context.Context) Meter { - m.mu.RLock() - attrsCopy := maps.Clone(m.attributes) - m.mu.RUnlock() - - return &sentryMeter{ - ctx: ctx, - hub: m.hub, - attributes: attrsCopy, - defaultAttributes: m.defaultAttributes, - mu: sync.RWMutex{}, - } -} - -func (m *sentryMeter) applyOptions(opts []MeterOption) *meterOptions { - o := &meterOptions{} - for _, opt := range opts { - opt(o) - } - return o -} - -// Count implements Meter. -func (m *sentryMeter) Count(name string, count int64, opts ...MeterOption) { - o := m.applyOptions(opts) - m.emit(m.ctx, MetricTypeCounter, name, Int64MetricValue(count), o.unit, o.attributes, o.scope) -} - -// Distribution implements Meter. -func (m *sentryMeter) Distribution(name string, sample float64, opts ...MeterOption) { - o := m.applyOptions(opts) - m.emit(m.ctx, MetricTypeDistribution, name, Float64MetricValue(sample), o.unit, o.attributes, o.scope) -} - -// Gauge implements Meter. -func (m *sentryMeter) Gauge(name string, value float64, opts ...MeterOption) { - o := m.applyOptions(opts) - m.emit(m.ctx, MetricTypeGauge, name, Float64MetricValue(value), o.unit, o.attributes, o.scope) -} - -// SetAttributes implements Meter. -func (m *sentryMeter) SetAttributes(attrs ...attribute.Builder) { - m.mu.Lock() - defer m.mu.Unlock() - - for _, a := range attrs { - if a.Value.Type() == attribute.INVALID { - debuglog.Printf("invalid attribute: %v", a) - continue - } - m.attributes[a.Key] = a.Value - } -} - -// noopMeter is a no-operation implementation of Meter. -// This is used when there is no client available in the context or when metrics are disabled. -type noopMeter struct{} - -// WithCtx implements Meter. -func (n *noopMeter) WithCtx(_ context.Context) Meter { - return n -} - -// Count implements Meter. -func (n *noopMeter) Count(name string, _ int64, _ ...MeterOption) { - debuglog.Printf("Metric %q is being dropped. Turn on metrics by setting DisableMetrics to false", name) -} - -// Distribution implements Meter. -func (n *noopMeter) Distribution(name string, _ float64, _ ...MeterOption) { - debuglog.Printf("Metric %q is being dropped. Turn on metrics by setting DisableMetrics to false", name) -} - -// Gauge implements Meter. -func (n *noopMeter) Gauge(name string, _ float64, _ ...MeterOption) { - debuglog.Printf("Metric %q is being dropped. Turn on metrics by setting DisableMetrics to false", name) -} - -// SetAttributes implements Meter. -func (n *noopMeter) SetAttributes(_ ...attribute.Builder) { - debuglog.Printf("No attributes attached. Turn on metrics by setting DisableMetrics to false") -} diff --git a/vendor/github.com/getsentry/sentry-go/mocks.go b/vendor/github.com/getsentry/sentry-go/mocks.go deleted file mode 100644 index 51cba52450b..00000000000 --- a/vendor/github.com/getsentry/sentry-go/mocks.go +++ /dev/null @@ -1,79 +0,0 @@ -package sentry - -import ( - "context" - "sync" - "time" -) - -// MockScope implements [Scope] for use in tests. -type MockScope struct { - breadcrumb *Breadcrumb - shouldDropEvent bool -} - -func (scope *MockScope) AddBreadcrumb(breadcrumb *Breadcrumb, _ int) { - scope.breadcrumb = breadcrumb -} - -func (scope *MockScope) ApplyToEvent(event *Event, _ *EventHint, _ *Client) *Event { - if scope.shouldDropEvent { - return nil - } - return event -} - -// MockTransport implements [Transport] for use in tests. -type MockTransport struct { - mu sync.Mutex - events []*Event - lastEvent *Event -} - -func (t *MockTransport) Configure(_ ClientOptions) {} -func (t *MockTransport) SendEvent(event *Event) { - t.mu.Lock() - defer t.mu.Unlock() - t.events = append(t.events, event) - t.lastEvent = event -} -func (t *MockTransport) Flush(_ time.Duration) bool { - return true -} -func (t *MockTransport) FlushWithContext(_ context.Context) bool { return true } -func (t *MockTransport) Events() []*Event { - t.mu.Lock() - defer t.mu.Unlock() - return t.events -} -func (t *MockTransport) Close() {} - -// MockLogEntry implements [sentry.LogEntry] for use in tests. -type MockLogEntry struct { - Attributes map[string]any -} - -func NewMockLogEntry() *MockLogEntry { - return &MockLogEntry{Attributes: make(map[string]any)} -} - -func (m *MockLogEntry) WithCtx(_ context.Context) LogEntry { return m } -func (m *MockLogEntry) String(key, value string) LogEntry { m.Attributes[key] = value; return m } -func (m *MockLogEntry) Int(key string, value int) LogEntry { - m.Attributes[key] = int64(value) - return m -} -func (m *MockLogEntry) Int64(key string, value int64) LogEntry { - m.Attributes[key] = value - return m -} -func (m *MockLogEntry) Float64(key string, value float64) LogEntry { - m.Attributes[key] = value - return m -} -func (m *MockLogEntry) Bool(key string, value bool) LogEntry { - m.Attributes[key] = value - return m -} -func (m *MockLogEntry) Emit(...any) {} -func (m *MockLogEntry) Emitf(string, ...any) {} diff --git a/vendor/github.com/getsentry/sentry-go/propagation_context.go b/vendor/github.com/getsentry/sentry-go/propagation_context.go deleted file mode 100644 index 310de72b0dc..00000000000 --- a/vendor/github.com/getsentry/sentry-go/propagation_context.go +++ /dev/null @@ -1,74 +0,0 @@ -package sentry - -import ( - "crypto/rand" -) - -type PropagationContext struct { - TraceID TraceID `json:"trace_id"` - SpanID SpanID `json:"span_id"` - ParentSpanID SpanID `json:"parent_span_id,omitzero"` - DynamicSamplingContext DynamicSamplingContext `json:"-"` -} - -func (p PropagationContext) Map() map[string]interface{} { - m := map[string]interface{}{ - "trace_id": p.TraceID, - "span_id": p.SpanID, - } - - if p.ParentSpanID != zeroSpanID { - m["parent_span_id"] = p.ParentSpanID - } - - return m -} - -func NewPropagationContext() PropagationContext { - p := PropagationContext{} - - if _, err := rand.Read(p.TraceID[:]); err != nil { - panic(err) - } - - if _, err := rand.Read(p.SpanID[:]); err != nil { - panic(err) - } - - return p -} - -func PropagationContextFromHeaders(trace, baggage string) (PropagationContext, error) { - p := NewPropagationContext() - - if _, err := rand.Read(p.SpanID[:]); err != nil { - panic(err) - } - - hasTrace := false - if trace != "" { - if tpc, valid := ParseTraceParentContext([]byte(trace)); valid { - hasTrace = true - p.TraceID = tpc.TraceID - p.ParentSpanID = tpc.ParentSpanID - } - } - - if baggage != "" { - dsc, err := DynamicSamplingContextFromHeader([]byte(baggage)) - if err != nil { - return PropagationContext{}, err - } - p.DynamicSamplingContext = dsc - } - - // In case a sentry-trace header is present but there are no sentry-related - // values in the baggage, create an empty, frozen DynamicSamplingContext. - if hasTrace && !p.DynamicSamplingContext.HasEntries() { - p.DynamicSamplingContext = DynamicSamplingContext{ - Frozen: true, - } - } - - return p, nil -} diff --git a/vendor/github.com/getsentry/sentry-go/scope.go b/vendor/github.com/getsentry/sentry-go/scope.go deleted file mode 100644 index fc9577023d3..00000000000 --- a/vendor/github.com/getsentry/sentry-go/scope.go +++ /dev/null @@ -1,578 +0,0 @@ -package sentry - -import ( - "bytes" - "context" - "io" - "net/http" - "sync" - "time" - - "github.com/getsentry/sentry-go/attribute" - "github.com/getsentry/sentry-go/internal/debuglog" -) - -// Scope holds contextual data for the current scope. -// -// The scope is an object that can cloned efficiently and stores data that is -// locally relevant to an event. For instance the scope will hold recorded -// breadcrumbs and similar information. -// -// The scope can be interacted with in two ways. First, the scope is routinely -// updated with information by functions such as AddBreadcrumb which will modify -// the current scope. Second, the current scope can be configured through the -// ConfigureScope function or Hub method of the same name. -// -// The scope is meant to be modified but not inspected directly. When preparing -// an event for reporting, the current client adds information from the current -// scope into the event. -type Scope struct { - mu sync.RWMutex - breadcrumbs []*Breadcrumb - attachments []*Attachment - user User - tags map[string]string - contexts map[string]Context - extra map[string]interface{} - fingerprint []string - level Level - request *http.Request - // requestBody holds a reference to the original request.Body. - requestBody interface { - // Bytes returns bytes from the original body, lazily buffered as the - // original body is read. - Bytes() []byte - // Overflow returns true if the body is larger than the maximum buffer - // size. - Overflow() bool - } - eventProcessors []EventProcessor - - propagationContext PropagationContext - span *Span -} - -// NewScope creates a new Scope. -func NewScope() *Scope { - return &Scope{ - breadcrumbs: make([]*Breadcrumb, 0), - attachments: make([]*Attachment, 0), - tags: make(map[string]string), - contexts: make(map[string]Context), - extra: make(map[string]interface{}), - fingerprint: make([]string, 0), - propagationContext: NewPropagationContext(), - } -} - -// AddBreadcrumb adds new breadcrumb to the current scope -// and optionally throws the old one if limit is reached. -func (scope *Scope) AddBreadcrumb(breadcrumb *Breadcrumb, limit int) { - if breadcrumb.Timestamp.IsZero() { - breadcrumb.Timestamp = time.Now() - } - - scope.mu.Lock() - defer scope.mu.Unlock() - - scope.breadcrumbs = append(scope.breadcrumbs, breadcrumb) - if len(scope.breadcrumbs) > limit { - scope.breadcrumbs = scope.breadcrumbs[1 : limit+1] - } -} - -// ClearBreadcrumbs clears all breadcrumbs from the current scope. -func (scope *Scope) ClearBreadcrumbs() { - scope.mu.Lock() - defer scope.mu.Unlock() - - scope.breadcrumbs = []*Breadcrumb{} -} - -// AddAttachment adds new attachment to the current scope. -func (scope *Scope) AddAttachment(attachment *Attachment) { - scope.mu.Lock() - defer scope.mu.Unlock() - - scope.attachments = append(scope.attachments, attachment) -} - -// ClearAttachments clears all attachments from the current scope. -func (scope *Scope) ClearAttachments() { - scope.mu.Lock() - defer scope.mu.Unlock() - - scope.attachments = []*Attachment{} -} - -// SetUser sets the user for the current scope. -func (scope *Scope) SetUser(user User) { - scope.mu.Lock() - defer scope.mu.Unlock() - - scope.user = user -} - -// SetRequest sets the request for the current scope. -func (scope *Scope) SetRequest(r *http.Request) { - scope.mu.Lock() - defer scope.mu.Unlock() - - scope.request = r - - if r == nil { - return - } - - // Don't buffer request body if we know it is oversized. - if r.ContentLength > maxRequestBodyBytes { - return - } - // Don't buffer if there is no body. - if r.Body == nil || r.Body == http.NoBody { - return - } - buf := &limitedBuffer{Capacity: maxRequestBodyBytes} - r.Body = readCloser{ - Reader: io.TeeReader(r.Body, buf), - Closer: r.Body, - } - scope.requestBody = buf -} - -// SetRequestBody sets the request body for the current scope. -// -// This method should only be called when the body bytes are already available -// in memory. Typically, the request body is buffered lazily from the -// Request.Body from SetRequest. -func (scope *Scope) SetRequestBody(b []byte) { - scope.mu.Lock() - defer scope.mu.Unlock() - - capacity := maxRequestBodyBytes - overflow := false - if len(b) > capacity { - overflow = true - b = b[:capacity] - } - scope.requestBody = &limitedBuffer{ - Capacity: capacity, - Buffer: *bytes.NewBuffer(b), - overflow: overflow, - } -} - -// maxRequestBodyBytes is the default maximum request body size to send to -// Sentry. -const maxRequestBodyBytes = 10 * 1024 - -// A limitedBuffer is like a bytes.Buffer, but limited to store at most Capacity -// bytes. Any writes past the capacity are silently discarded, similar to -// io.Discard. -type limitedBuffer struct { - Capacity int - - bytes.Buffer - overflow bool -} - -// Write implements io.Writer. -func (b *limitedBuffer) Write(p []byte) (n int, err error) { - // Silently ignore writes after overflow. - if b.overflow { - return len(p), nil - } - left := b.Capacity - b.Len() - if left < 0 { - left = 0 - } - if len(p) > left { - b.overflow = true - p = p[:left] - } - return b.Buffer.Write(p) -} - -// Overflow returns true if the limitedBuffer discarded bytes written to it. -func (b *limitedBuffer) Overflow() bool { - return b.overflow -} - -// readCloser combines an io.Reader and an io.Closer to implement io.ReadCloser. -type readCloser struct { - io.Reader - io.Closer -} - -// SetTag adds a tag to the current scope. -func (scope *Scope) SetTag(key, value string) { - scope.mu.Lock() - defer scope.mu.Unlock() - - scope.tags[key] = value -} - -// SetTags assigns multiple tags to the current scope. -func (scope *Scope) SetTags(tags map[string]string) { - scope.mu.Lock() - defer scope.mu.Unlock() - - for k, v := range tags { - scope.tags[k] = v - } -} - -// RemoveTag removes a tag from the current scope. -func (scope *Scope) RemoveTag(key string) { - scope.mu.Lock() - defer scope.mu.Unlock() - - delete(scope.tags, key) -} - -// SetContext adds a context to the current scope. -func (scope *Scope) SetContext(key string, value Context) { - scope.mu.Lock() - defer scope.mu.Unlock() - - scope.contexts[key] = value -} - -// SetContexts assigns multiple contexts to the current scope. -func (scope *Scope) SetContexts(contexts map[string]Context) { - scope.mu.Lock() - defer scope.mu.Unlock() - - for k, v := range contexts { - scope.contexts[k] = v - } -} - -// RemoveContext removes a context from the current scope. -func (scope *Scope) RemoveContext(key string) { - scope.mu.Lock() - defer scope.mu.Unlock() - - delete(scope.contexts, key) -} - -// SetExtra adds an extra to the current scope. -func (scope *Scope) SetExtra(key string, value interface{}) { - scope.mu.Lock() - defer scope.mu.Unlock() - - scope.extra[key] = value -} - -// SetExtras assigns multiple extras to the current scope. -func (scope *Scope) SetExtras(extra map[string]interface{}) { - scope.mu.Lock() - defer scope.mu.Unlock() - - for k, v := range extra { - scope.extra[k] = v - } -} - -// RemoveExtra removes a extra from the current scope. -func (scope *Scope) RemoveExtra(key string) { - scope.mu.Lock() - defer scope.mu.Unlock() - - delete(scope.extra, key) -} - -// SetFingerprint sets new fingerprint for the current scope. -func (scope *Scope) SetFingerprint(fingerprint []string) { - scope.mu.Lock() - defer scope.mu.Unlock() - - scope.fingerprint = fingerprint -} - -// SetLevel sets new level for the current scope. -func (scope *Scope) SetLevel(level Level) { - scope.mu.Lock() - defer scope.mu.Unlock() - - scope.level = level -} - -// SetPropagationContext sets the propagation context for the current scope. -func (scope *Scope) SetPropagationContext(propagationContext PropagationContext) { - scope.mu.Lock() - defer scope.mu.Unlock() - - scope.propagationContext = propagationContext -} - -// GetSpan returns the span from the current scope. -func (scope *Scope) GetSpan() *Span { - scope.mu.RLock() - defer scope.mu.RUnlock() - - return scope.span -} - -// SetSpan sets a span for the current scope. -func (scope *Scope) SetSpan(span *Span) { - scope.mu.Lock() - defer scope.mu.Unlock() - - scope.span = span -} - -// Clone returns a copy of the current scope with all data copied over. -func (scope *Scope) Clone() *Scope { - scope.mu.RLock() - defer scope.mu.RUnlock() - - clone := NewScope() - clone.user = scope.user - clone.breadcrumbs = make([]*Breadcrumb, len(scope.breadcrumbs)) - copy(clone.breadcrumbs, scope.breadcrumbs) - clone.attachments = make([]*Attachment, len(scope.attachments)) - copy(clone.attachments, scope.attachments) - for key, value := range scope.tags { - clone.tags[key] = value - } - for key, value := range scope.contexts { - clone.contexts[key] = cloneContext(value) - } - for key, value := range scope.extra { - clone.extra[key] = value - } - clone.fingerprint = make([]string, len(scope.fingerprint)) - copy(clone.fingerprint, scope.fingerprint) - clone.level = scope.level - clone.request = scope.request - clone.requestBody = scope.requestBody - clone.eventProcessors = scope.eventProcessors - clone.propagationContext = scope.propagationContext - clone.span = scope.span - return clone -} - -// Clear removes the data from the current scope. Not safe for concurrent use. -func (scope *Scope) Clear() { - *scope = *NewScope() -} - -// AddEventProcessor adds an event processor to the current scope. -func (scope *Scope) AddEventProcessor(processor EventProcessor) { - scope.mu.Lock() - defer scope.mu.Unlock() - - scope.eventProcessors = append(scope.eventProcessors, processor) -} - -// ApplyToEvent takes the data from the current scope and attaches it to the event. -func (scope *Scope) ApplyToEvent(event *Event, hint *EventHint, client *Client) *Event { - scope.mu.RLock() - defer scope.mu.RUnlock() - - if len(scope.breadcrumbs) > 0 { - event.Breadcrumbs = append(event.Breadcrumbs, scope.breadcrumbs...) - } - - if len(scope.attachments) > 0 { - event.Attachments = append(event.Attachments, scope.attachments...) - } - - if len(scope.tags) > 0 { - if event.Tags == nil { - event.Tags = make(map[string]string, len(scope.tags)) - } - - for key, value := range scope.tags { - event.Tags[key] = value - } - } - - if len(scope.contexts) > 0 { - if event.Contexts == nil { - event.Contexts = make(map[string]Context) - } - - for key, value := range scope.contexts { - if key == "trace" && event.Type == transactionType { - // Do not override trace context of - // transactions, otherwise it breaks the - // transaction event representation. - // For error events, the trace context is used - // to link errors and traces/spans in Sentry. - continue - } - - // Ensure we are not overwriting event fields - if _, ok := event.Contexts[key]; !ok { - event.Contexts[key] = cloneContext(value) - } - } - } - - if event.Contexts == nil { - event.Contexts = make(map[string]Context) - } - - if scope.span != nil { - if _, ok := event.Contexts["trace"]; !ok { - event.Contexts["trace"] = scope.span.traceContext().Map() - } - - transaction := scope.span.GetTransaction() - if transaction != nil { - event.sdkMetaData.dsc = DynamicSamplingContextFromTransaction(transaction) - } - } else { - event.Contexts["trace"] = scope.propagationContext.Map() - - dsc := scope.propagationContext.DynamicSamplingContext - if !dsc.HasEntries() && client != nil { - dsc = DynamicSamplingContextFromScope(scope, client) - } - event.sdkMetaData.dsc = dsc - } - - if len(scope.extra) > 0 { - if event.Extra == nil { - event.Extra = make(map[string]interface{}, len(scope.extra)) - } - - for key, value := range scope.extra { - event.Extra[key] = value - } - } - - if event.User.IsEmpty() { - event.User = scope.user - } - - if len(event.Fingerprint) == 0 { - event.Fingerprint = append(event.Fingerprint, scope.fingerprint...) - } - - if scope.level != "" { - event.Level = scope.level - } - - if event.Request == nil && scope.request != nil { - event.Request = NewRequest(scope.request) - // NOTE: The SDK does not attempt to send partial request body data. - // - // The reason being that Sentry's ingest pipeline and UI are optimized - // to show structured data. Additionally, tooling around PII scrubbing - // relies on structured data; truncated request bodies would create - // invalid payloads that are more prone to leaking PII data. - // - // Users can still send more data along their events if they want to, - // for example using Event.Extra. - if scope.requestBody != nil && !scope.requestBody.Overflow() { - event.Request.Data = string(scope.requestBody.Bytes()) - } - } - - for _, processor := range scope.eventProcessors { - id := event.EventID - event = processor(event, hint) - if event == nil { - debuglog.Printf("Event dropped by one of the Scope EventProcessors: %s\n", id) - return nil - } - } - - return event -} - -// cloneContext returns a new context with keys and values copied from the passed one. -// -// Note: a new Context (map) is returned, but the function does NOT do -// a proper deep copy: if some context values are pointer types (e.g. maps), -// they won't be properly copied. -func cloneContext(c Context) Context { - res := make(Context, len(c)) - for k, v := range c { - res[k] = v - } - return res -} - -func (scope *Scope) populateAttrs(attrs map[string]attribute.Value) { - if scope == nil { - return - } - - scope.mu.RLock() - defer scope.mu.RUnlock() - - // Add user-related attributes - if !scope.user.IsEmpty() { - if scope.user.ID != "" { - attrs["user.id"] = attribute.StringValue(scope.user.ID) - } - if scope.user.Name != "" { - attrs["user.name"] = attribute.StringValue(scope.user.Name) - } - if scope.user.Email != "" { - attrs["user.email"] = attribute.StringValue(scope.user.Email) - } - } - - // In the future, add scope.attributes here - // for k, v := range scope.attributes { - // attrs[k] = v - // } -} - -// hubFromContexts is a helper to return the first hub found in the given contexts. -func hubFromContexts(ctxs ...context.Context) *Hub { - for _, ctx := range ctxs { - if ctx == nil { - continue - } - if hub := GetHubFromContext(ctx); hub != nil { - return hub - } - } - return nil -} - -// resolveTrace resolves trace ID and span ID from the given scope and contexts. -// -// The resolution order follows a most-specific-to-least-specific pattern: -// 1. Check for span directly in contexts (SpanFromContext) - this is the most specific -// source as it represents a span explicitly attached to the current operation's context -// 2. Check scope's span - provides access to span set on the hub's scope -// 3. Fall back to scope's propagation context trace ID -// -// This ordering ensures we always use the most contextually relevant tracing information. -// For example, if a specific span is active for an operation, we use that span's trace/span IDs -// rather than accidentally using a different span that might be set on the hub's scope. -func resolveTrace(scope *Scope, ctxs ...context.Context) (traceID TraceID, spanID SpanID) { - var span *Span - - for _, ctx := range ctxs { - if ctx == nil { - continue - } - if span = SpanFromContext(ctx); span != nil { - break - } - } - - if scope != nil { - scope.mu.RLock() - if span == nil { - span = scope.span - } - if span != nil { - traceID = span.TraceID - spanID = span.SpanID - } else { - traceID = scope.propagationContext.TraceID - } - scope.mu.RUnlock() - } - - return traceID, spanID -} diff --git a/vendor/github.com/getsentry/sentry-go/sentry.go b/vendor/github.com/getsentry/sentry-go/sentry.go deleted file mode 100644 index 8d4113ededb..00000000000 --- a/vendor/github.com/getsentry/sentry-go/sentry.go +++ /dev/null @@ -1,149 +0,0 @@ -package sentry - -import ( - "context" - "time" -) - -// The version of the SDK. -const SDKVersion = "0.43.0" - -// apiVersion is the minimum version of the Sentry API compatible with the -// sentry-go SDK. -const apiVersion = "7" - -// Init initializes the SDK with options. The returned error is non-nil if -// options is invalid, for instance if a malformed DSN is provided. -func Init(options ClientOptions) error { - hub := CurrentHub() - client, err := NewClient(options) - if err != nil { - return err - } - hub.BindClient(client) - return nil -} - -// AddBreadcrumb records a new breadcrumb. -// -// The total number of breadcrumbs that can be recorded are limited by the -// configuration on the client. -func AddBreadcrumb(breadcrumb *Breadcrumb) { - hub := CurrentHub() - hub.AddBreadcrumb(breadcrumb, nil) -} - -// CaptureMessage captures an arbitrary message. -func CaptureMessage(message string) *EventID { - hub := CurrentHub() - return hub.CaptureMessage(message) -} - -// CaptureException captures an error. -func CaptureException(exception error) *EventID { - hub := CurrentHub() - return hub.CaptureException(exception) -} - -// CaptureCheckIn captures a (cron) monitor check-in. -func CaptureCheckIn(checkIn *CheckIn, monitorConfig *MonitorConfig) *EventID { - hub := CurrentHub() - return hub.CaptureCheckIn(checkIn, monitorConfig) -} - -// CaptureEvent captures an event on the currently active client if any. -// -// The event must already be assembled. Typically code would instead use -// the utility methods like CaptureException. The return value is the -// event ID. In case Sentry is disabled or event was dropped, the return value will be nil. -func CaptureEvent(event *Event) *EventID { - hub := CurrentHub() - return hub.CaptureEvent(event) -} - -// Recover captures a panic. -func Recover() *EventID { - if err := recover(); err != nil { - hub := CurrentHub() - return hub.Recover(err) - } - return nil -} - -// RecoverWithContext captures a panic and passes relevant context object. -func RecoverWithContext(ctx context.Context) *EventID { - err := recover() - if err == nil { - return nil - } - - hub := GetHubFromContext(ctx) - if hub == nil { - hub = CurrentHub() - } - - return hub.RecoverWithContext(ctx, err) -} - -// WithScope is a shorthand for CurrentHub().WithScope. -func WithScope(f func(scope *Scope)) { - hub := CurrentHub() - hub.WithScope(f) -} - -// ConfigureScope is a shorthand for CurrentHub().ConfigureScope. -func ConfigureScope(f func(scope *Scope)) { - hub := CurrentHub() - hub.ConfigureScope(f) -} - -// PushScope is a shorthand for CurrentHub().PushScope. -func PushScope() { - hub := CurrentHub() - hub.PushScope() -} - -// PopScope is a shorthand for CurrentHub().PopScope. -func PopScope() { - hub := CurrentHub() - hub.PopScope() -} - -// Flush waits until the underlying Transport sends any buffered events to the -// Sentry server, blocking for at most the given timeout. It returns false if -// the timeout was reached. In that case, some events may not have been sent. -// -// Flush should be called before terminating the program to avoid -// unintentionally dropping events. -// -// Do not call Flush indiscriminately after every call to CaptureEvent, -// CaptureException or CaptureMessage. Instead, to have the SDK send events over -// the network synchronously, configure it to use the HTTPSyncTransport in the -// call to Init. -func Flush(timeout time.Duration) bool { - hub := CurrentHub() - return hub.Flush(timeout) -} - -// FlushWithContext waits until the underlying Transport sends any buffered events -// to the Sentry server, blocking for at most the duration specified by the context. -// It returns false if the context is canceled before the events are sent. In such a case, -// some events may not be delivered. -// -// FlushWithContext should be called before terminating the program to ensure no -// events are unintentionally dropped. -// -// Avoid calling FlushWithContext indiscriminately after each call to CaptureEvent, -// CaptureException, or CaptureMessage. To send events synchronously over the network, -// configure the SDK to use HTTPSyncTransport during initialization with Init. - -func FlushWithContext(ctx context.Context) bool { - hub := CurrentHub() - return hub.FlushWithContext(ctx) -} - -// LastEventID returns an ID of last captured event. -func LastEventID() EventID { - hub := CurrentHub() - return hub.LastEventID() -} diff --git a/vendor/github.com/getsentry/sentry-go/sourcereader.go b/vendor/github.com/getsentry/sentry-go/sourcereader.go deleted file mode 100644 index 74a08384858..00000000000 --- a/vendor/github.com/getsentry/sentry-go/sourcereader.go +++ /dev/null @@ -1,70 +0,0 @@ -package sentry - -import ( - "bytes" - "os" - "sync" -) - -type sourceReader struct { - mu sync.Mutex - cache map[string][][]byte -} - -func newSourceReader() sourceReader { - return sourceReader{ - cache: make(map[string][][]byte), - } -} - -func (sr *sourceReader) readContextLines(filename string, line, context int) ([][]byte, int) { - sr.mu.Lock() - defer sr.mu.Unlock() - - lines, ok := sr.cache[filename] - - if !ok { - data, err := os.ReadFile(filename) - if err != nil { - sr.cache[filename] = nil - return nil, 0 - } - lines = bytes.Split(data, []byte{'\n'}) - sr.cache[filename] = lines - } - - return sr.calculateContextLines(lines, line, context) -} - -func (sr *sourceReader) calculateContextLines(lines [][]byte, line, context int) ([][]byte, int) { - // Stacktrace lines are 1-indexed, slices are 0-indexed - line-- - - // contextLine points to a line that caused an issue itself, in relation to - // returned slice. - contextLine := context - - if lines == nil || line >= len(lines) || line < 0 { - return nil, 0 - } - - if context < 0 { - context = 0 - contextLine = 0 - } - - start := line - context - - if start < 0 { - contextLine += start - start = 0 - } - - end := line + context + 1 - - if end > len(lines) { - end = len(lines) - } - - return lines[start:end], contextLine -} diff --git a/vendor/github.com/getsentry/sentry-go/span_recorder.go b/vendor/github.com/getsentry/sentry-go/span_recorder.go deleted file mode 100644 index ba04101506f..00000000000 --- a/vendor/github.com/getsentry/sentry-go/span_recorder.go +++ /dev/null @@ -1,58 +0,0 @@ -package sentry - -import ( - "sync" - - "github.com/getsentry/sentry-go/internal/debuglog" -) - -// A spanRecorder stores a span tree that makes up a transaction. Safe for -// concurrent use. It is okay to add child spans from multiple goroutines. -type spanRecorder struct { - mu sync.Mutex - spans []*Span - overflowOnce sync.Once -} - -// record stores a span. The first stored span is assumed to be the root of a -// span tree. -func (r *spanRecorder) record(s *Span) { - maxSpans := defaultMaxSpans - if client := CurrentHub().Client(); client != nil { - maxSpans = client.options.MaxSpans - } - r.mu.Lock() - defer r.mu.Unlock() - if len(r.spans) >= maxSpans { - r.overflowOnce.Do(func() { - root := r.spans[0] - debuglog.Printf("Too many spans: dropping spans from transaction with TraceID=%s SpanID=%s limit=%d", - root.TraceID, root.SpanID, maxSpans) - }) - // TODO(tracing): mark the transaction event in some way to - // communicate that spans were dropped. - return - } - r.spans = append(r.spans, s) -} - -// root returns the first recorded span. Returns nil if none have been recorded. -func (r *spanRecorder) root() *Span { - r.mu.Lock() - defer r.mu.Unlock() - if len(r.spans) == 0 { - return nil - } - return r.spans[0] -} - -// children returns a list of all recorded spans, except the root. Returns nil -// if there are no children. -func (r *spanRecorder) children() []*Span { - r.mu.Lock() - defer r.mu.Unlock() - if len(r.spans) < 2 { - return nil - } - return r.spans[1:] -} diff --git a/vendor/github.com/getsentry/sentry-go/stacktrace.go b/vendor/github.com/getsentry/sentry-go/stacktrace.go deleted file mode 100644 index f59e2366448..00000000000 --- a/vendor/github.com/getsentry/sentry-go/stacktrace.go +++ /dev/null @@ -1,407 +0,0 @@ -package sentry - -import ( - "go/build" - "reflect" - "runtime" - "slices" - "strings" -) - -const unknown string = "unknown" - -// The module download is split into two parts: downloading the go.mod and downloading the actual code. -// If you have dependencies only needed for tests, then they will show up in your go.mod, -// and go get will download their go.mods, but it will not download their code. -// The test-only dependencies get downloaded only when you need it, such as the first time you run go test. -// -// https://github.com/golang/go/issues/26913#issuecomment-411976222 - -// Stacktrace holds information about the frames of the stack. -type Stacktrace struct { - Frames []Frame `json:"frames,omitempty"` - FramesOmitted []uint `json:"frames_omitted,omitempty"` -} - -// NewStacktrace creates a stacktrace using runtime.Callers. -func NewStacktrace() *Stacktrace { - pcs := make([]uintptr, 100) - n := runtime.Callers(1, pcs) - - if n == 0 { - return nil - } - - runtimeFrames := extractFrames(pcs[:n]) - frames := createFrames(runtimeFrames) - - stacktrace := Stacktrace{ - Frames: frames, - } - - return &stacktrace -} - -// TODO: Make it configurable so that anyone can provide their own implementation? -// Use of reflection allows us to not have a hard dependency on any given -// package, so we don't have to import it. - -// ExtractStacktrace creates a new Stacktrace based on the given error. -func ExtractStacktrace(err error) *Stacktrace { - method := extractReflectedStacktraceMethod(err) - - var pcs []uintptr - - if method.IsValid() { - pcs = extractPcs(method) - } else { - pcs = extractXErrorsPC(err) - } - - if len(pcs) == 0 { - return nil - } - - runtimeFrames := extractFrames(pcs) - frames := createFrames(runtimeFrames) - - stacktrace := Stacktrace{ - Frames: frames, - } - - return &stacktrace -} - -func extractReflectedStacktraceMethod(err error) reflect.Value { - errValue := reflect.ValueOf(err) - - // https://github.com/go-errors/errors - methodStackFrames := errValue.MethodByName("StackFrames") - if methodStackFrames.IsValid() { - return methodStackFrames - } - - // https://github.com/pkg/errors - methodStackTrace := errValue.MethodByName("StackTrace") - if methodStackTrace.IsValid() { - return methodStackTrace - } - - // https://github.com/pingcap/errors - methodGetStackTracer := errValue.MethodByName("GetStackTracer") - if methodGetStackTracer.IsValid() { - stacktracer := methodGetStackTracer.Call(nil)[0] - stacktracerStackTrace := reflect.ValueOf(stacktracer).MethodByName("StackTrace") - - if stacktracerStackTrace.IsValid() { - return stacktracerStackTrace - } - } - - return reflect.Value{} -} - -func extractPcs(method reflect.Value) []uintptr { - var pcs []uintptr - - stacktrace := method.Call(nil)[0] - - if stacktrace.Kind() != reflect.Slice { - return nil - } - - for i := 0; i < stacktrace.Len(); i++ { - pc := stacktrace.Index(i) - - switch pc.Kind() { - case reflect.Uintptr: - pcs = append(pcs, uintptr(pc.Uint())) - case reflect.Struct: - for _, fieldName := range []string{"ProgramCounter", "PC"} { - field := pc.FieldByName(fieldName) - if !field.IsValid() { - continue - } - if field.Kind() == reflect.Uintptr { - pcs = append(pcs, uintptr(field.Uint())) - break - } - } - } - } - - return pcs -} - -// extractXErrorsPC extracts program counters from error values compatible with -// the error types from golang.org/x/xerrors. -// -// It returns nil if err is not compatible with errors from that package or if -// no program counters are stored in err. -func extractXErrorsPC(err error) []uintptr { - // This implementation uses the reflect package to avoid a hard dependency - // on third-party packages. - - // We don't know if err matches the expected type. For simplicity, instead - // of trying to account for all possible ways things can go wrong, some - // assumptions are made and if they are violated the code will panic. We - // recover from any panic and ignore it, returning nil. - //nolint: errcheck - defer func() { recover() }() - - field := reflect.ValueOf(err).Elem().FieldByName("frame") // type Frame struct{ frames [3]uintptr } - field = field.FieldByName("frames") - field = field.Slice(1, field.Len()) // drop first pc pointing to xerrors.New - pc := make([]uintptr, field.Len()) - for i := 0; i < field.Len(); i++ { - pc[i] = uintptr(field.Index(i).Uint()) - } - return pc -} - -// Frame represents a function call and it's metadata. Frames are associated -// with a Stacktrace. -type Frame struct { - Function string `json:"function,omitempty"` - Symbol string `json:"symbol,omitempty"` - // Module is, despite the name, the Sentry protocol equivalent of a Go - // package's import path. - Module string `json:"module,omitempty"` - Filename string `json:"filename,omitempty"` - AbsPath string `json:"abs_path,omitempty"` - Lineno int `json:"lineno,omitempty"` - Colno int `json:"colno,omitempty"` - PreContext []string `json:"pre_context,omitempty"` - ContextLine string `json:"context_line,omitempty"` - PostContext []string `json:"post_context,omitempty"` - InApp bool `json:"in_app"` - Vars map[string]interface{} `json:"vars,omitempty"` - // Package and the below are not used for Go stack trace frames. In - // other platforms it refers to a container where the Module can be - // found. For example, a Java JAR, a .NET Assembly, or a native - // dynamic library. They exists for completeness, allowing the - // construction and reporting of custom event payloads. - Package string `json:"package,omitempty"` - InstructionAddr string `json:"instruction_addr,omitempty"` - AddrMode string `json:"addr_mode,omitempty"` - SymbolAddr string `json:"symbol_addr,omitempty"` - ImageAddr string `json:"image_addr,omitempty"` - Platform string `json:"platform,omitempty"` - StackStart bool `json:"stack_start,omitempty"` -} - -// NewFrame assembles a stacktrace frame out of runtime.Frame. -func NewFrame(f runtime.Frame) Frame { - function := f.Function - var pkg string - - if function != "" { - pkg, function = splitQualifiedFunctionName(function) - } - - return newFrame(pkg, function, f.File, f.Line) -} - -// Like filepath.IsAbs() but doesn't care what platform you run this on. -// I.e. it also recognizies `/path/to/file` when run on Windows. -func isAbsPath(path string) bool { - if len(path) == 0 { - return false - } - - // If the volume name starts with a double slash, this is an absolute path. - if len(path) >= 1 && (path[0] == '/' || path[0] == '\\') { - return true - } - - // Windows absolute path, see https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats - if len(path) >= 3 && path[1] == ':' && (path[2] == '/' || path[2] == '\\') { - return true - } - - return false -} - -func newFrame(module string, function string, file string, line int) Frame { - frame := Frame{ - Lineno: line, - Module: module, - Function: function, - } - - switch { - case len(file) == 0: - frame.Filename = unknown - // Leave abspath as the empty string to be omitted when serializing event as JSON. - case isAbsPath(file): - frame.AbsPath = file - // TODO: in the general case, it is not trivial to come up with a - // "project relative" path with the data we have in run time. - // We shall not use filepath.Base because it creates ambiguous paths and - // affects the "Suspect Commits" feature. - // For now, leave relpath empty to be omitted when serializing the event - // as JSON. Improve this later. - default: - // f.File is a relative path. This may happen when the binary is built - // with the -trimpath flag. - frame.Filename = file - // Omit abspath when serializing the event as JSON. - } - - setInAppFrame(&frame) - - return frame -} - -// splitQualifiedFunctionName splits a package path-qualified function name into -// package name and function name. Such qualified names are found in -// runtime.Frame.Function values. -func splitQualifiedFunctionName(name string) (pkg string, fun string) { - pkg = packageName(name) - if len(pkg) > 0 { - fun = name[len(pkg)+1:] - } - return -} - -func extractFrames(pcs []uintptr) []runtime.Frame { - var frames = make([]runtime.Frame, 0, len(pcs)) - callersFrames := runtime.CallersFrames(pcs) - - for { - callerFrame, more := callersFrames.Next() - - frames = append(frames, callerFrame) - - if !more { - break - } - } - - slices.Reverse(frames) - return frames -} - -// createFrames creates Frame objects while filtering out frames that are not -// meant to be reported to Sentry, those are frames internal to the SDK or Go. -func createFrames(frames []runtime.Frame) []Frame { - if len(frames) == 0 { - return nil - } - - result := make([]Frame, 0, len(frames)) - - for _, frame := range frames { - function := frame.Function - var pkg string - if function != "" { - pkg, function = splitQualifiedFunctionName(function) - } - - if !shouldSkipFrame(pkg) { - result = append(result, newFrame(pkg, function, frame.File, frame.Line)) - } - } - - // Fix issues grouping errors with the new fully qualified function names - // introduced from Go 1.21 - result = cleanupFunctionNamePrefix(result) - return result -} - -// TODO ID: why do we want to do this? -// I'm not aware of other SDKs skipping all Sentry frames, regardless of their position in the stactrace. -// For example, in the .NET SDK, only the first frames are skipped until the call to the SDK. -// As is, this will also hide any intermediate frames in the stack and make debugging issues harder. -func shouldSkipFrame(module string) bool { - // Skip Go internal frames. - if module == "runtime" || module == "testing" { - return true - } - - // Skip Sentry internal frames, except for frames in _test packages (for testing). - if strings.HasPrefix(module, "github.com/getsentry/sentry-go") && - !strings.HasSuffix(module, "_test") { - return true - } - - return false -} - -// On Windows, GOROOT has backslashes, but we want forward slashes. -var goRoot = strings.ReplaceAll(build.Default.GOROOT, "\\", "/") - -func setInAppFrame(frame *Frame) { - frame.InApp = true - if strings.HasPrefix(frame.AbsPath, goRoot) || strings.Contains(frame.Module, "vendor") || - strings.Contains(frame.Module, "third_party") { - frame.InApp = false - } -} - -func callerFunctionName() string { - pcs := make([]uintptr, 1) - runtime.Callers(3, pcs) - callersFrames := runtime.CallersFrames(pcs) - callerFrame, _ := callersFrames.Next() - return baseName(callerFrame.Function) -} - -// packageName returns the package part of the symbol name, or the empty string -// if there is none. -// It replicates https://golang.org/pkg/debug/gosym/#Sym.PackageName, avoiding a -// dependency on debug/gosym. -func packageName(name string) string { - if isCompilerGeneratedSymbol(name) { - return "" - } - - pathend := strings.LastIndex(name, "/") - if pathend < 0 { - pathend = 0 - } - - if i := strings.Index(name[pathend:], "."); i != -1 { - return name[:pathend+i] - } - return "" -} - -// baseName returns the symbol name without the package or receiver name. -// It replicates https://golang.org/pkg/debug/gosym/#Sym.BaseName, avoiding a -// dependency on debug/gosym. -func baseName(name string) string { - if i := strings.LastIndex(name, "."); i != -1 { - return name[i+1:] - } - return name -} - -func isCompilerGeneratedSymbol(name string) bool { - // In versions of Go 1.20 and above a prefix of "type:" and "go:" is a - // compiler-generated symbol that doesn't belong to any package. - // See variable reservedimports in cmd/compile/internal/gc/subr.go - if strings.HasPrefix(name, "go:") || strings.HasPrefix(name, "type:") { - return true - } - return false -} - -// Walk backwards through the results and for the current function name -// remove it's parent function's prefix, leaving only it's actual name. This -// fixes issues grouping errors with the new fully qualified function names -// introduced from Go 1.21. -func cleanupFunctionNamePrefix(f []Frame) []Frame { - for i := len(f) - 1; i > 0; i-- { - name := f[i].Function - parentName := f[i-1].Function + "." - - if !strings.HasPrefix(name, parentName) { - continue - } - - f[i].Function = name[len(parentName):] - } - - return f -} diff --git a/vendor/github.com/getsentry/sentry-go/traces_sampler.go b/vendor/github.com/getsentry/sentry-go/traces_sampler.go deleted file mode 100644 index 69e7cb7fa5d..00000000000 --- a/vendor/github.com/getsentry/sentry-go/traces_sampler.go +++ /dev/null @@ -1,19 +0,0 @@ -package sentry - -// A SamplingContext is passed to a TracesSampler to determine a sampling -// decision. -// -// TODO(tracing): possibly expand SamplingContext to include custom / -// user-provided data. -type SamplingContext struct { - Span *Span // The current span, always non-nil. - Parent *Span // The parent span, may be nil. -} - -// The TracesSample type is an adapter to allow the use of ordinary -// functions as a TracesSampler. -type TracesSampler func(ctx SamplingContext) float64 - -func (f TracesSampler) Sample(ctx SamplingContext) float64 { - return f(ctx) -} diff --git a/vendor/github.com/getsentry/sentry-go/tracing.go b/vendor/github.com/getsentry/sentry-go/tracing.go deleted file mode 100644 index 70b146d5ecf..00000000000 --- a/vendor/github.com/getsentry/sentry-go/tracing.go +++ /dev/null @@ -1,1079 +0,0 @@ -package sentry - -import ( - "context" - "crypto/rand" - "encoding/hex" - "encoding/json" - "fmt" - "net/http" - "regexp" - "strconv" - "strings" - "sync" - "time" - - "github.com/getsentry/sentry-go/internal/debuglog" -) - -const ( - SentryTraceHeader = "sentry-trace" - SentryBaggageHeader = "baggage" - TraceparentHeader = "traceparent" -) - -// SpanOrigin indicates what created a trace or a span. See: https://develop.sentry.dev/sdk/performance/trace-origin/ -type SpanOrigin string - -const ( - SpanOriginManual = "manual" - SpanOriginEcho = "auto.http.echo" - SpanOriginFastHTTP = "auto.http.fasthttp" - SpanOriginFiber = "auto.http.fiber" - SpanOriginGin = "auto.http.gin" - SpanOriginStdLib = "auto.http.stdlib" - SpanOriginIris = "auto.http.iris" - SpanOriginNegroni = "auto.http.negroni" -) - -// A Span is the building block of a Sentry transaction. Spans build up a tree -// structure of timed operations. The span tree makes up a transaction event -// that is sent to Sentry when the root span is finished. -// -// Spans must be started with either StartSpan or Span.StartChild. -type Span struct { //nolint: maligned // prefer readability over optimal memory layout (see note below *) - TraceID TraceID `json:"trace_id"` - SpanID SpanID `json:"span_id"` - ParentSpanID SpanID `json:"parent_span_id,omitzero"` - Name string `json:"name,omitempty"` - Op string `json:"op,omitempty"` - Description string `json:"description,omitempty"` - Status SpanStatus `json:"status,omitempty"` - Tags map[string]string `json:"tags,omitempty"` - StartTime time.Time `json:"start_timestamp,omitzero"` - EndTime time.Time `json:"timestamp,omitzero"` - // Deprecated: use Data instead. To be removed in 0.33.0 - Extra map[string]interface{} `json:"-"` - Data map[string]interface{} `json:"data,omitempty"` - Sampled Sampled `json:"-"` - Source TransactionSource `json:"-"` - Origin SpanOrigin `json:"origin,omitempty"` - - // mu protects concurrent writes to map fields - mu sync.RWMutex - // sample rate the span was sampled with. - sampleRate float64 - // ctx is the context where the span was started. Always non-nil. - ctx context.Context - // Dynamic Sampling context - dynamicSamplingContext DynamicSamplingContext - // parent refers to the immediate local parent span. A remote parent span is - // only referenced by setting ParentSpanID. - parent *Span - // recorder stores all spans in a transaction. Guaranteed to be non-nil. - recorder *spanRecorder - // span context, can only be set on transactions - contexts map[string]Context - // a Once instance to make sure that Finish() is only called once. - finishOnce sync.Once - // explicitSampled is a flag for configuring sampling by using `WithSpanSampled` option. - explicitSampled Sampled -} - -// TraceParentContext describes the context of a (remote) parent span. -// -// The context is normally extracted from a received "sentry-trace" header and -// used to initialize a new transaction. -// -// Note: the name might be not the best one. It was taken mostly to stay aligned -// with other SDKs, and it alludes to W3C "traceparent" header (https://www.w3.org/TR/trace-context/), -// which serves a similar purpose to "sentry-trace". We should eventually consider -// making this type internal-only and give it a better name. -type TraceParentContext struct { - TraceID TraceID - ParentSpanID SpanID - Sampled Sampled -} - -// (*) Note on maligned: -// -// We prefer readability over optimal memory layout. If we ever decide to -// reorder fields, we can use a tool: -// -// go run honnef.co/go/tools/cmd/structlayout -json . Span | go run honnef.co/go/tools/cmd/structlayout-optimize -// -// Other structs would deserve reordering as well, for example Event. - -// TODO: make Span.Tags and Span.Data opaque types (struct{unexported []slice}). -// An opaque type allows us to add methods and make it more convenient to use -// than maps, because maps require careful nil checks to use properly or rely on -// explicit initialization for every span, even when there might be no -// tags/data. For Span.Data, must gracefully handle values that cannot be -// marshaled into JSON (see transport.go:getRequestBodyFromEvent). - -// StartSpan starts a new span to describe an operation. The new span will be a -// child of the last span stored in ctx, if any. -// -// One or more options can be used to modify the span properties. Typically one -// option as a function literal is enough. Combining multiple options can be -// useful to define and reuse specific properties with named functions. -// -// Caller should call the Finish method on the span to mark its end. Finishing a -// root span sends the span and all of its children, recursively, as a -// transaction to Sentry. -func StartSpan(ctx context.Context, operation string, options ...SpanOption) *Span { - parent, hasParent := ctx.Value(spanContextKey{}).(*Span) - var span Span - span = Span{ - // defaults - Op: operation, - StartTime: time.Now(), - Sampled: SampledUndefined, - - ctx: context.WithValue(ctx, spanContextKey{}, &span), - parent: parent, - } - - _, err := rand.Read(span.SpanID[:]) - if err != nil { - panic(err) - } - - if hasParent { - span.TraceID = parent.TraceID - span.ParentSpanID = parent.SpanID - span.Origin = parent.Origin - } else { - // Only set the Source if this is a transaction - span.Source = SourceCustom - span.Origin = SpanOriginManual - - // Implementation note: - // - // While math/rand is ~2x faster than crypto/rand (exact - // difference depends on hardware / OS), crypto/rand is probably - // fast enough and a safer choice. - // - // For reference, OpenTelemetry [1] uses crypto/rand to seed - // math/rand. AFAICT this approach does not preserve the - // properties from crypto/rand that make it suitable for - // cryptography. While it might be debatable whether those - // properties are important for us here, again, we're taking the - // safer path. - // - // See [2a] & [2b] for a discussion of some of the properties we - // obtain by using crypto/rand and [3a] & [3b] for why we avoid - // math/rand. - // - // Because the math/rand seed has only 64 bits (int64), if the - // first thing we do after seeding an RNG is to read in a random - // TraceID, there are only 2^64 possible values. Compared to - // UUID v4 that have 122 random bits, there is a much greater - // chance of collision [4a] & [4b]. - // - // [1]: https://github.com/open-telemetry/opentelemetry-go/blob/958041ddf619a128/sdk/trace/trace.go#L25-L31 - // [2a]: https://security.stackexchange.com/q/120352/246345 - // [2b]: https://security.stackexchange.com/a/120365/246345 - // [3a]: https://github.com/golang/go/issues/11871#issuecomment-126333686 - // [3b]: https://github.com/golang/go/issues/11871#issuecomment-126357889 - // [4a]: https://en.wikipedia.org/wiki/Universally_unique_identifier#Collisions - // [4b]: https://www.wolframalpha.com/input/?i=sqrt%282*2%5E64*ln%281%2F%281-0.5%29%29%29 - _, err := rand.Read(span.TraceID[:]) - if err != nil { - panic(err) - } - } - - // Apply options to override defaults. - for _, option := range options { - option(&span) - } - - span.Sampled = span.sample() - - span.recorder = &spanRecorder{} - if hasParent { - span.recorder = parent.spanRecorder() - } - - span.recorder.record(&span) - - clientOptions := span.clientOptions() - if clientOptions.EnableTracing { - hub := hubFromContext(ctx) - hub.Scope().SetSpan(&span) - } - - return &span -} - -// Finish sets the span's end time, unless already set. If the span is the root -// of a span tree, Finish sends the span tree to Sentry as a transaction. -// -// The logic is executed at most once per span, so that (incorrectly) calling it twice -// never double sends to Sentry. -func (s *Span) Finish() { - s.finishOnce.Do(s.doFinish) -} - -// Context returns the context containing the span. -func (s *Span) Context() context.Context { return s.ctx } - -// StartChild starts a new child span. -// -// The call span.StartChild(operation, options...) is a shortcut for -// StartSpan(span.Context(), operation, options...). -func (s *Span) StartChild(operation string, options ...SpanOption) *Span { - return StartSpan(s.Context(), operation, options...) -} - -// SetTag sets a tag on the span. It is recommended to use SetTag instead of -// accessing the tags map directly as SetTag takes care of initializing the map -// when necessary. -func (s *Span) SetTag(name, value string) { - s.mu.Lock() - defer s.mu.Unlock() - - if s.Tags == nil { - s.Tags = make(map[string]string) - } - s.Tags[name] = value -} - -// SetData sets a data on the span. It is recommended to use SetData instead of -// accessing the data map directly as SetData takes care of initializing the map -// when necessary. -func (s *Span) SetData(name string, value interface{}) { - if value == nil { - return - } - - s.mu.Lock() - defer s.mu.Unlock() - - if s.Data == nil { - s.Data = make(map[string]interface{}) - } - s.Data[name] = value -} - -// SetContext sets a context on the span. It is recommended to use SetContext instead of -// accessing the contexts map directly as SetContext takes care of initializing the map -// when necessary. -func (s *Span) SetContext(key string, value Context) { - s.mu.Lock() - defer s.mu.Unlock() - - if s.contexts == nil { - s.contexts = make(map[string]Context) - } - s.contexts[key] = value -} - -// IsTransaction checks if the given span is a transaction. -func (s *Span) IsTransaction() bool { - return s.parent == nil -} - -// GetTransaction returns the transaction that contains this span. -// -// For transaction spans it returns itself. For spans that were created manually -// the method returns "nil". -func (s *Span) GetTransaction() *Span { - spanRecorder := s.spanRecorder() - if spanRecorder == nil { - // This probably means that the Span was created manually (not via - // StartTransaction/StartSpan or StartChild). - // Return "nil" to indicate that it's not a normal situation. - return nil - } - recorderRoot := spanRecorder.root() - if recorderRoot == nil { - // Same as above: manually created Span. - return nil - } - return recorderRoot -} - -// TODO(tracing): maybe add shortcuts to get/set transaction name. Right now the -// transaction name is in the Scope, as it has existed there historically, prior -// to tracing. -// -// See Scope.Transaction() and Scope.SetTransaction(). -// -// func (s *Span) TransactionName() string -// func (s *Span) SetTransactionName(name string) - -// ToSentryTrace returns the serialized TraceParentContext from a transaction/span. -// Use this function to propagate the TraceParentContext to a downstream SDK, -// either as the value of the "sentry-trace" HTTP header, or as an html "sentry-trace" meta tag. -func (s *Span) ToSentryTrace() string { - // TODO(tracing): add instrumentation for outgoing HTTP requests using - // ToSentryTrace. - var b strings.Builder - fmt.Fprintf(&b, "%s-%s", s.TraceID.Hex(), s.SpanID.Hex()) - switch s.Sampled { - case SampledTrue: - b.WriteString("-1") - case SampledFalse: - b.WriteString("-0") - } - return b.String() -} - -// ToTraceparent returns the W3C traceparent header value for the span. -func (s *Span) ToTraceparent() string { - traceFlags := "00" - if s.Sampled == SampledTrue { - traceFlags = "01" - } - return fmt.Sprintf("00-%s-%s-%s", s.TraceID.String(), s.SpanID.String(), traceFlags) -} - -// ToBaggage returns the serialized DynamicSamplingContext from a transaction. -// Use this function to propagate the DynamicSamplingContext to a downstream SDK, -// either as the value of the "baggage" HTTP header, or as an html "baggage" meta tag. -func (s *Span) ToBaggage() string { - t := s.GetTransaction() - if t == nil { - return "" - } - - // In case there is currently no frozen DynamicSamplingContext attached to the transaction, - // create one from the properties of the transaction. - if !s.dynamicSamplingContext.IsFrozen() { - // This will return a frozen DynamicSamplingContext. - if dsc := DynamicSamplingContextFromTransaction(t); dsc.HasEntries() { - t.dynamicSamplingContext = dsc - } - } - - return t.dynamicSamplingContext.String() -} - -// SetDynamicSamplingContext sets the given dynamic sampling context on the -// current transaction. -func (s *Span) SetDynamicSamplingContext(dsc DynamicSamplingContext) { - if s.IsTransaction() { - s.dynamicSamplingContext = dsc - } -} - -// shouldIgnoreStatusCode checks if the transaction should be ignored based on HTTP status code. -func (s *Span) shouldIgnoreStatusCode() bool { - if !s.IsTransaction() { - return false - } - - ignoreStatusCodes := s.clientOptions().TraceIgnoreStatusCodes - if len(ignoreStatusCodes) == 0 { - return false - } - - s.mu.Lock() - statusCodeData, exists := s.Data["http.response.status_code"] - s.mu.Unlock() - - if !exists { - return false - } - - statusCode, ok := statusCodeData.(int) - if !ok { - return false - } - - for _, ignoredRange := range ignoreStatusCodes { - switch len(ignoredRange) { - case 1: - // Single status code - if statusCode == ignoredRange[0] { - s.mu.Lock() - s.Sampled = SampledFalse - s.mu.Unlock() - debuglog.Printf("dropping transaction with status code %v: found in TraceIgnoreStatusCodes", statusCode) - return true - } - case 2: - // Range of status codes [min, max] - if ignoredRange[0] <= statusCode && statusCode <= ignoredRange[1] { - s.mu.Lock() - s.Sampled = SampledFalse - s.mu.Unlock() - debuglog.Printf("dropping transaction with status code %v: found in TraceIgnoreStatusCodes range [%d, %d]", statusCode, ignoredRange[0], ignoredRange[1]) - return true - } - default: - debuglog.Printf("incorrect TraceIgnoreStatusCodes format: %v", ignoredRange) - } - } - - return false -} - -// doFinish runs the actual Span.Finish() logic. -func (s *Span) doFinish() { - if s.EndTime.IsZero() { - s.EndTime = monotonicTimeSince(s.StartTime) - } - - hub := hubFromContext(s.ctx) - if !s.IsTransaction() { - if s.parent != nil { - hub.Scope().SetSpan(s.parent) - } - } - - if s.shouldIgnoreStatusCode() { - return - } - - if !s.Sampled.Bool() { - return - } - event := s.toEvent() - if event == nil { - return - } - - // TODO(tracing): add breadcrumbs - // (see https://github.com/getsentry/sentry-python/blob/f6f3525f8812f609/sentry_sdk/tracing.py#L372) - - hub.CaptureEvent(event) -} - -// sentryTracePattern matches either -// -// TRACE_ID - SPAN_ID -// [[:xdigit:]]{32}-[[:xdigit:]]{16} -// -// or -// -// TRACE_ID - SPAN_ID - SAMPLED -// [[:xdigit:]]{32}-[[:xdigit:]]{16}-[01] -var sentryTracePattern = regexp.MustCompile(`^([[:xdigit:]]{32})-([[:xdigit:]]{16})(?:-([01]))?$`) - -// updateFromSentryTrace parses a sentry-trace HTTP header (as returned by -// ToSentryTrace) and updates fields of the span. If the header cannot be -// recognized as valid, the span is left unchanged. The returned value indicates -// whether the span was updated. -func (s *Span) updateFromSentryTrace(header []byte) (updated bool) { - m := sentryTracePattern.FindSubmatch(header) - if m == nil { - // no match - return false - } - _, _ = hex.Decode(s.TraceID[:], m[1]) - _, _ = hex.Decode(s.ParentSpanID[:], m[2]) - if len(m[3]) != 0 { - switch m[3][0] { - case '0': - s.Sampled = SampledFalse - case '1': - s.Sampled = SampledTrue - } - } - return true -} - -func (s *Span) updateFromBaggage(header []byte) { - if s.IsTransaction() { - dsc, err := DynamicSamplingContextFromHeader(header) - if err != nil { - return - } - - s.dynamicSamplingContext = dsc - } -} - -func (s *Span) clientOptions() *ClientOptions { - client := hubFromContext(s.ctx).Client() - if client != nil { - return &client.options - } - return &ClientOptions{} -} - -func (s *Span) sample() Sampled { - clientOptions := s.clientOptions() - // https://develop.sentry.dev/sdk/performance/#sampling - // #1 tracing is not enabled. - if !clientOptions.EnableTracing { - debuglog.Printf("Dropping transaction: EnableTracing is set to %t", clientOptions.EnableTracing) - s.sampleRate = 0.0 - return SampledFalse - } - - // #2 explicit sampling decision via StartSpan/StartTransaction options. - if s.explicitSampled != SampledUndefined { - debuglog.Printf("Using explicit sampling decision from StartSpan/StartTransaction: %v", s.explicitSampled) - switch s.explicitSampled { - case SampledTrue: - s.sampleRate = 1.0 - case SampledFalse: - s.sampleRate = 0.0 - } - return s.explicitSampled - } - - // Variant for non-transaction spans: they inherit the parent decision. - // Note: non-transaction should always have a parent, but we check both - // conditions anyway -- the first for semantic meaning, the second to - // avoid a nil pointer dereference. - if !s.IsTransaction() && s.parent != nil { - return s.parent.Sampled - } - - // #3 use TracesSampler from ClientOptions. - sampler := clientOptions.TracesSampler - samplingContext := SamplingContext{ - Span: s, - Parent: s.parent, - } - - if sampler != nil { - tracesSamplerSampleRate := sampler.Sample(samplingContext) - s.sampleRate = tracesSamplerSampleRate - // tracesSampler can update the sample_rate on frozen DSC - if s.dynamicSamplingContext.HasEntries() { - s.dynamicSamplingContext.Entries["sample_rate"] = strconv.FormatFloat(tracesSamplerSampleRate, 'f', -1, 64) - } - if tracesSamplerSampleRate < 0.0 || tracesSamplerSampleRate > 1.0 { - debuglog.Printf("Dropping transaction: Returned TracesSampler rate is out of range [0.0, 1.0]: %f", tracesSamplerSampleRate) - return SampledFalse - } - if tracesSamplerSampleRate == 0.0 { - debuglog.Printf("Dropping transaction: Returned TracesSampler rate is: %f", tracesSamplerSampleRate) - return SampledFalse - } - - if rng.Float64() < tracesSamplerSampleRate { - return SampledTrue - } - debuglog.Printf("Dropping transaction: TracesSampler returned rate: %f", tracesSamplerSampleRate) - - return SampledFalse - } - - // #4 inherit parent decision. - if s.Sampled != SampledUndefined { - debuglog.Printf("Using sampling decision from parent: %v", s.Sampled) - switch s.Sampled { - case SampledTrue: - s.sampleRate = 1.0 - case SampledFalse: - s.sampleRate = 0.0 - } - return s.Sampled - } - - // #5 use TracesSampleRate from ClientOptions. - sampleRate := clientOptions.TracesSampleRate - s.sampleRate = sampleRate - // tracesSampleRate can update the sample_rate on frozen DSC - if s.dynamicSamplingContext.HasEntries() { - s.dynamicSamplingContext.Entries["sample_rate"] = strconv.FormatFloat(sampleRate, 'f', -1, 64) - } - if sampleRate < 0.0 || sampleRate > 1.0 { - debuglog.Printf("Dropping transaction: TracesSampleRate out of range [0.0, 1.0]: %f", sampleRate) - return SampledFalse - } - if sampleRate == 0.0 { - debuglog.Printf("Dropping transaction: TracesSampleRate rate is: %f", sampleRate) - return SampledFalse - } - - if rng.Float64() < sampleRate { - return SampledTrue - } - - return SampledFalse -} - -func (s *Span) toEvent() *Event { - s.mu.Lock() - defer s.mu.Unlock() - - if !s.IsTransaction() { - return nil // only transactions can be transformed into events - } - - children := s.recorder.children() - finished := make([]*Span, 0, len(children)) - for _, child := range children { - if child.EndTime.IsZero() { - debuglog.Printf("Dropped unfinished span: Op=%q TraceID=%s SpanID=%s", child.Op, child.TraceID, child.SpanID) - continue - } - finished = append(finished, child) - } - - // Create and attach a DynamicSamplingContext to the transaction. - // If the DynamicSamplingContext is not frozen at this point, we can assume being head of trace. - if !s.dynamicSamplingContext.IsFrozen() { - s.dynamicSamplingContext = DynamicSamplingContextFromTransaction(s) - } - - contexts := make(map[string]Context, len(s.contexts)+1) - for k, v := range s.contexts { - contexts[k] = cloneContext(v) - } - contexts["trace"] = s.traceContext().Map() - - // Make sure that the transaction source is valid - transactionSource := s.Source - if !transactionSource.isValid() { - transactionSource = SourceCustom - } - - return &Event{ - Type: transactionType, - Transaction: s.Name, - Contexts: contexts, - Tags: s.Tags, - Timestamp: s.EndTime, - StartTime: s.StartTime, - Spans: finished, - TransactionInfo: &TransactionInfo{ - Source: transactionSource, - }, - sdkMetaData: SDKMetaData{ - dsc: s.dynamicSamplingContext, - }, - } -} - -func (s *Span) traceContext() *TraceContext { - return &TraceContext{ - TraceID: s.TraceID, - SpanID: s.SpanID, - ParentSpanID: s.ParentSpanID, - Op: s.Op, - Data: s.Data, - Description: s.Description, - Status: s.Status, - } -} - -// spanRecorder stores the span tree. Guaranteed to be non-nil. -func (s *Span) spanRecorder() *spanRecorder { return s.recorder } - -// ParseTraceParentContext parses a sentry-trace header and builds a TraceParentContext from the -// parsed values. If the header was parsed correctly, the second returned argument -// ("valid") will be set to true, otherwise (e.g., empty or malformed header) it will -// be false. -func ParseTraceParentContext(header []byte) (traceParentContext TraceParentContext, valid bool) { - s := Span{} - updated := s.updateFromSentryTrace(header) - if !updated { - return TraceParentContext{}, false - } - return TraceParentContext{ - TraceID: s.TraceID, - ParentSpanID: s.ParentSpanID, - Sampled: s.Sampled, - }, true -} - -// TraceID identifies a trace. -type TraceID [16]byte - -func (id TraceID) Hex() []byte { - b := make([]byte, hex.EncodedLen(len(id))) - hex.Encode(b, id[:]) - return b -} - -func (id TraceID) String() string { - return string(id.Hex()) -} - -func (id TraceID) MarshalText() ([]byte, error) { - return id.Hex(), nil -} - -// SpanID identifies a span. -type SpanID [8]byte - -func (id SpanID) Hex() []byte { - b := make([]byte, hex.EncodedLen(len(id))) - hex.Encode(b, id[:]) - return b -} - -func (id SpanID) String() string { - return string(id.Hex()) -} - -func (id SpanID) MarshalText() ([]byte, error) { - return id.Hex(), nil -} - -// Zero values of TraceID and SpanID used for comparisons. -var ( - zeroTraceID TraceID - zeroSpanID SpanID -) - -// Contains information about how the name of the transaction was determined. -type TransactionSource string - -const ( - SourceCustom TransactionSource = "custom" - SourceURL TransactionSource = "url" - SourceRoute TransactionSource = "route" - SourceView TransactionSource = "view" - SourceComponent TransactionSource = "component" - SourceTask TransactionSource = "task" -) - -// A set of all valid transaction sources. -var allTransactionSources = map[TransactionSource]struct{}{ - SourceCustom: {}, - SourceURL: {}, - SourceRoute: {}, - SourceView: {}, - SourceComponent: {}, - SourceTask: {}, -} - -// isValid returns 'true' if the given transaction source is a valid -// source as recognized by the envelope protocol: -// https://develop.sentry.dev/sdk/event-payloads/transaction/#transaction-annotations -func (ts TransactionSource) isValid() bool { - _, found := allTransactionSources[ts] - return found -} - -// SpanStatus is the status of a span. -type SpanStatus uint8 - -// Implementation note: -// -// In Relay (ingestion), the SpanStatus type is an enum used as -// Annotated when embedded in structs, making it effectively -// Option. It means the status is either null or one of the known -// string values. -// -// In Snuba (search), the SpanStatus is stored as an uint8 and defaulted to 2 -// ("unknown") when not set. It means that Discover searches for -// `transaction.status:unknown` return both transactions/spans with status -// `null` or `"unknown"`. Searches for `transaction.status:""` return nothing. -// -// With that in mind, the Go SDK default is SpanStatusUndefined, which is -// null/omitted when serializing to JSON, but integrations may update the status -// automatically based on contextual information. - -const ( - SpanStatusUndefined SpanStatus = iota - SpanStatusOK - SpanStatusCanceled - SpanStatusUnknown - SpanStatusInvalidArgument - SpanStatusDeadlineExceeded - SpanStatusNotFound - SpanStatusAlreadyExists - SpanStatusPermissionDenied - SpanStatusResourceExhausted - SpanStatusFailedPrecondition - SpanStatusAborted - SpanStatusOutOfRange - SpanStatusUnimplemented - SpanStatusInternalError - SpanStatusUnavailable - SpanStatusDataLoss - SpanStatusUnauthenticated - maxSpanStatus -) - -var spanStatuses = [maxSpanStatus]string{ - "", - "ok", - "cancelled", // [sic] - "unknown", - "invalid_argument", - "deadline_exceeded", - "not_found", - "already_exists", - "permission_denied", - "resource_exhausted", - "failed_precondition", - "aborted", - "out_of_range", - "unimplemented", - "internal_error", - "unavailable", - "data_loss", - "unauthenticated", -} - -func (ss SpanStatus) String() string { - if ss >= maxSpanStatus { - return "" - } - return spanStatuses[ss] -} - -func (ss SpanStatus) MarshalJSON() ([]byte, error) { - s := ss.String() - if s == "" { - return []byte("null"), nil - } - return json.Marshal(s) -} - -// A TraceContext carries information about an ongoing trace and is meant to be -// stored in Event.Contexts (as *TraceContext). -type TraceContext struct { - TraceID TraceID `json:"trace_id"` - SpanID SpanID `json:"span_id"` - ParentSpanID SpanID `json:"parent_span_id,omitzero"` - Op string `json:"op,omitempty"` - Description string `json:"description,omitempty"` - Status SpanStatus `json:"status,omitempty"` - Data map[string]interface{} `json:"data,omitempty"` -} - -func (tc TraceContext) Map() map[string]interface{} { - m := map[string]interface{}{ - "trace_id": tc.TraceID, - "span_id": tc.SpanID, - } - - if tc.ParentSpanID != [8]byte{} { - m["parent_span_id"] = tc.ParentSpanID - } - - if tc.Op != "" { - m["op"] = tc.Op - } - - if tc.Description != "" { - m["description"] = tc.Description - } - - if tc.Status > 0 && tc.Status < maxSpanStatus { - m["status"] = tc.Status - } - - if len(tc.Data) > 0 { - m["data"] = tc.Data - } - - return m -} - -// Sampled signifies a sampling decision. -type Sampled int8 - -// The possible trace sampling decisions are: SampledFalse, SampledUndefined -// (default) and SampledTrue. -const ( - SampledFalse Sampled = -1 - SampledUndefined Sampled = 0 - SampledTrue Sampled = 1 -) - -func (s Sampled) String() string { - switch s { - case SampledFalse: - return "SampledFalse" - case SampledUndefined: - return "SampledUndefined" - case SampledTrue: - return "SampledTrue" - default: - return fmt.Sprintf("SampledInvalid(%d)", s) - } -} - -// Bool returns true if the sample decision is SampledTrue, false otherwise. -func (s Sampled) Bool() bool { - return s == SampledTrue -} - -// A SpanOption is a function that can modify the properties of a span. -type SpanOption func(s *Span) - -// WithTransactionName option sets the name of the current transaction. -// -// A span tree has a single transaction name, therefore using this option when -// starting a span affects the span tree as a whole, potentially overwriting a -// name set previously. -func WithTransactionName(name string) SpanOption { - return func(s *Span) { - s.Name = name - } -} - -// WithDescription sets the description of a span. -func WithDescription(description string) SpanOption { - return func(s *Span) { - s.Description = description - } -} - -// WithOpName sets the operation name for a given span. -func WithOpName(name string) SpanOption { - return func(s *Span) { - s.Op = name - } -} - -// WithTransactionSource sets the source of the transaction name. -// -// Note: if the transaction source is not a valid source (as described -// by the spec https://develop.sentry.dev/sdk/event-payloads/transaction/#transaction-annotations), -// it will be corrected to "custom" eventually, before the transaction is sent. -func WithTransactionSource(source TransactionSource) SpanOption { - return func(s *Span) { - s.Source = source - } -} - -// WithSpanSampled updates the sampling flag for a given span. -func WithSpanSampled(sampled Sampled) SpanOption { - return func(s *Span) { - s.explicitSampled = sampled - } -} - -// WithSpanOrigin sets the origin of the span. -func WithSpanOrigin(origin SpanOrigin) SpanOption { - return func(s *Span) { - s.Origin = origin - } -} - -// ContinueTrace continues a trace based on traceparent and baggage values. -// If the SDK is configured with tracing enabled, -// this function returns populated SpanOption. -// In any other cases, it populates the propagation context on the scope. -func ContinueTrace(hub *Hub, traceparent, baggage string) SpanOption { - scope := hub.Scope() - propagationContext, _ := PropagationContextFromHeaders(traceparent, baggage) - scope.SetPropagationContext(propagationContext) - - return ContinueFromHeaders(traceparent, baggage) -} - -// ContinueFromRequest returns a span option that updates the span to continue -// an existing trace. If it cannot detect an existing trace in the request, the -// span will be left unchanged. -// -// ContinueFromRequest is an alias for: -// -// ContinueFromHeaders(r.Header.Get(SentryTraceHeader), r.Header.Get(SentryBaggageHeader)). -func ContinueFromRequest(r *http.Request) SpanOption { - return ContinueFromHeaders(r.Header.Get(SentryTraceHeader), r.Header.Get(SentryBaggageHeader)) -} - -// ContinueFromHeaders returns a span option that updates the span to continue -// an existing TraceID and propagates the Dynamic Sampling context. -func ContinueFromHeaders(trace, baggage string) SpanOption { - return func(s *Span) { - if trace != "" { - s.updateFromSentryTrace([]byte(trace)) - - if baggage != "" { - s.updateFromBaggage([]byte(baggage)) - } - - // In case a sentry-trace header is present but there are no sentry-related - // values in the baggage, create an empty, frozen DynamicSamplingContext. - if !s.dynamicSamplingContext.HasEntries() { - s.dynamicSamplingContext = DynamicSamplingContext{ - Frozen: true, - } - } - } - } -} - -// ContinueFromTrace returns a span option that updates the span to continue -// an existing TraceID. -func ContinueFromTrace(trace string) SpanOption { - return func(s *Span) { - if trace == "" { - return - } - s.updateFromSentryTrace([]byte(trace)) - } -} - -// spanContextKey is used to store span values in contexts. -type spanContextKey struct{} - -// TransactionFromContext returns the root span of the current transaction. It -// returns nil if no transaction is tracked in the context. -func TransactionFromContext(ctx context.Context) *Span { - if span, ok := ctx.Value(spanContextKey{}).(*Span); ok { - return span.recorder.root() - } - return nil -} - -// SpanFromContext returns the last span stored in the context, or nil if no span -// is set on the context. -func SpanFromContext(ctx context.Context) *Span { - if span, ok := ctx.Value(spanContextKey{}).(*Span); ok { - return span - } - return nil -} - -// StartTransaction will create a transaction (root span) if there's no existing -// transaction in the context otherwise, it will return the existing transaction. -func StartTransaction(ctx context.Context, name string, options ...SpanOption) *Span { - currentTransaction, exists := ctx.Value(spanContextKey{}).(*Span) - if exists { - currentTransaction.ctx = ctx - return currentTransaction - } - - options = append(options, WithTransactionName(name)) - return StartSpan( - ctx, - "", - options..., - ) -} - -// HTTPtoSpanStatus converts an HTTP status code to a SpanStatus. -func HTTPtoSpanStatus(code int) SpanStatus { - if code < http.StatusBadRequest { - return SpanStatusOK - } - if http.StatusBadRequest <= code && code < http.StatusInternalServerError { - switch code { - case http.StatusForbidden: - return SpanStatusPermissionDenied - case http.StatusNotFound: - return SpanStatusNotFound - case http.StatusTooManyRequests: - return SpanStatusResourceExhausted - case http.StatusRequestEntityTooLarge: - return SpanStatusFailedPrecondition - case http.StatusUnauthorized: - return SpanStatusUnauthenticated - case http.StatusConflict: - return SpanStatusAlreadyExists - default: - return SpanStatusInvalidArgument - } - } - if http.StatusInternalServerError <= code && code < 600 { - switch code { - case http.StatusGatewayTimeout: - return SpanStatusDeadlineExceeded - case http.StatusNotImplemented: - return SpanStatusUnimplemented - case http.StatusServiceUnavailable: - return SpanStatusUnavailable - default: - return SpanStatusInternalError - } - } - return SpanStatusUnknown -} diff --git a/vendor/github.com/getsentry/sentry-go/transport.go b/vendor/github.com/getsentry/sentry-go/transport.go deleted file mode 100644 index 1b565750209..00000000000 --- a/vendor/github.com/getsentry/sentry-go/transport.go +++ /dev/null @@ -1,811 +0,0 @@ -package sentry - -import ( - "bytes" - "context" - "crypto/tls" - "encoding/json" - "errors" - "fmt" - "io" - "net/http" - "net/url" - "sync" - "time" - - "github.com/getsentry/sentry-go/internal/debuglog" - httpinternal "github.com/getsentry/sentry-go/internal/http" - "github.com/getsentry/sentry-go/internal/protocol" - "github.com/getsentry/sentry-go/internal/ratelimit" - "github.com/getsentry/sentry-go/internal/util" -) - -const ( - defaultBufferSize = 1000 - defaultTimeout = time.Second * 30 -) - -// Transport is used by the Client to deliver events to remote server. -type Transport interface { - Flush(timeout time.Duration) bool - FlushWithContext(ctx context.Context) bool - Configure(options ClientOptions) - SendEvent(event *Event) - Close() -} - -func getProxyConfig(options ClientOptions) func(*http.Request) (*url.URL, error) { - if options.HTTPSProxy != "" { - return func(*http.Request) (*url.URL, error) { - return url.Parse(options.HTTPSProxy) - } - } - - if options.HTTPProxy != "" { - return func(*http.Request) (*url.URL, error) { - return url.Parse(options.HTTPProxy) - } - } - - return http.ProxyFromEnvironment -} - -func getTLSConfig(options ClientOptions) *tls.Config { - if options.CaCerts != nil { - // #nosec G402 -- We should be using `MinVersion: tls.VersionTLS12`, - // but we don't want to break peoples code without the major bump. - return &tls.Config{ - RootCAs: options.CaCerts, - } - } - - return nil -} - -func getRequestBodyFromEvent(event *Event) []byte { - body, err := json.Marshal(event) - if err == nil { - return body - } - - msg := fmt.Sprintf("Could not encode original event as JSON. "+ - "Succeeded by removing Breadcrumbs, Contexts and Extra. "+ - "Please verify the data you attach to the scope. "+ - "Error: %s", err) - // Try to serialize the event, with all the contextual data that allows for interface{} stripped. - event.Breadcrumbs = nil - event.Contexts = nil - event.Extra = map[string]interface{}{ - "info": msg, - } - body, err = json.Marshal(event) - if err == nil { - debuglog.Println(msg) - return body - } - - // This should _only_ happen when Event.Exception[0].Stacktrace.Frames[0].Vars is unserializable - // Which won't ever happen, as we don't use it now (although it's the part of public interface accepted by Sentry) - // Juuust in case something, somehow goes utterly wrong. - debuglog.Println("Event couldn't be marshaled, even with stripped contextual data. Skipping delivery. " + - "Please notify the SDK owners with possibly broken payload.") - return nil -} - -func encodeAttachment(enc *json.Encoder, b io.Writer, attachment *Attachment) error { - // Attachment header - err := enc.Encode(struct { - Type string `json:"type"` - Length int `json:"length"` - Filename string `json:"filename"` - ContentType string `json:"content_type,omitempty"` - }{ - Type: "attachment", - Length: len(attachment.Payload), - Filename: attachment.Filename, - ContentType: attachment.ContentType, - }) - if err != nil { - return err - } - - // Attachment payload - if _, err = b.Write(attachment.Payload); err != nil { - return err - } - - // "Envelopes should be terminated with a trailing newline." - // - // [1]: https://develop.sentry.dev/sdk/envelopes/#envelopes - if _, err := b.Write([]byte("\n")); err != nil { - return err - } - - return nil -} - -func encodeEnvelopeItem(enc *json.Encoder, itemType string, body json.RawMessage) error { - // Item header - err := enc.Encode(struct { - Type string `json:"type"` - Length int `json:"length"` - }{ - Type: itemType, - Length: len(body), - }) - if err == nil { - // payload - err = enc.Encode(body) - } - return err -} - -func encodeEnvelopeLogs(enc *json.Encoder, count int, body json.RawMessage) error { - err := enc.Encode( - struct { - Type string `json:"type"` - ItemCount int `json:"item_count"` - ContentType string `json:"content_type"` - }{ - Type: logEvent.Type, - ItemCount: count, - ContentType: logEvent.ContentType, - }) - if err == nil { - err = enc.Encode(body) - } - return err -} - -func encodeEnvelopeMetrics(enc *json.Encoder, count int, body json.RawMessage) error { - err := enc.Encode( - struct { - Type string `json:"type"` - ItemCount int `json:"item_count"` - ContentType string `json:"content_type"` - }{ - Type: traceMetricEvent.Type, - ItemCount: count, - ContentType: traceMetricEvent.ContentType, - }) - if err == nil { - err = enc.Encode(body) - } - return err -} - -func envelopeFromBody(event *Event, dsn *Dsn, sentAt time.Time, body json.RawMessage) (*bytes.Buffer, error) { - var b bytes.Buffer - enc := json.NewEncoder(&b) - - // Construct the trace envelope header - var trace = map[string]string{} - if dsc := event.sdkMetaData.dsc; dsc.HasEntries() { - for k, v := range dsc.Entries { - trace[k] = v - } - } - - // Envelope header - err := enc.Encode(struct { - EventID EventID `json:"event_id"` - SentAt time.Time `json:"sent_at"` - Dsn string `json:"dsn"` - Sdk map[string]string `json:"sdk"` - Trace map[string]string `json:"trace,omitempty"` - }{ - EventID: event.EventID, - SentAt: sentAt, - Trace: trace, - Dsn: dsn.String(), - Sdk: map[string]string{ - "name": event.Sdk.Name, - "version": event.Sdk.Version, - }, - }) - if err != nil { - return nil, err - } - - switch event.Type { - case transactionType, checkInType: - err = encodeEnvelopeItem(enc, event.Type, body) - case logEvent.Type: - err = encodeEnvelopeLogs(enc, len(event.Logs), body) - case traceMetricEvent.Type: - err = encodeEnvelopeMetrics(enc, len(event.Metrics), body) - default: - err = encodeEnvelopeItem(enc, eventType, body) - } - - if err != nil { - return nil, err - } - - // Attachments - for _, attachment := range event.Attachments { - if err := encodeAttachment(enc, &b, attachment); err != nil { - return nil, err - } - } - - return &b, nil -} - -func getRequestFromEvent(ctx context.Context, event *Event, dsn *Dsn) (r *http.Request, err error) { - defer func() { - if r != nil { - r.Header.Set("User-Agent", fmt.Sprintf("%s/%s", event.Sdk.Name, event.Sdk.Version)) - r.Header.Set("Content-Type", "application/x-sentry-envelope") - - auth := fmt.Sprintf("Sentry sentry_version=%s, "+ - "sentry_client=%s/%s, sentry_key=%s", apiVersion, event.Sdk.Name, event.Sdk.Version, dsn.GetPublicKey()) - - // The key sentry_secret is effectively deprecated and no longer needs to be set. - // However, since it was required in older self-hosted versions, - // it should still passed through to Sentry if set. - if dsn.GetSecretKey() != "" { - auth = fmt.Sprintf("%s, sentry_secret=%s", auth, dsn.GetSecretKey()) - } - - r.Header.Set("X-Sentry-Auth", auth) - } - }() - - body := getRequestBodyFromEvent(event) - if body == nil { - return nil, errors.New("event could not be marshaled") - } - - envelope, err := envelopeFromBody(event, dsn, time.Now(), body) - if err != nil { - return nil, err - } - - if ctx == nil { - ctx = context.Background() - } - - return http.NewRequestWithContext( - ctx, - http.MethodPost, - dsn.GetAPIURL().String(), - envelope, - ) -} - -// ================================ -// HTTPTransport -// ================================ - -// A batch groups items that are processed sequentially. -type batch struct { - items chan batchItem - started chan struct{} // closed to signal items started to be worked on - done chan struct{} // closed to signal completion of all items -} - -type batchItem struct { - request *http.Request - category ratelimit.Category - eventIdentifier string -} - -// HTTPTransport is the default, non-blocking, implementation of Transport. -// -// Clients using this transport will enqueue requests in a buffer and return to -// the caller before any network communication has happened. Requests are sent -// to Sentry sequentially from a background goroutine. -type HTTPTransport struct { - dsn *Dsn - client *http.Client - transport http.RoundTripper - - // buffer is a channel of batches. Calling Flush terminates work on the - // current in-flight items and starts a new batch for subsequent events. - buffer chan batch - - startOnce sync.Once - closeOnce sync.Once - - // Size of the transport buffer. Defaults to 30. - BufferSize int - // HTTP Client request timeout. Defaults to 30 seconds. - Timeout time.Duration - - mu sync.RWMutex - limits ratelimit.Map - - // receiving signal will terminate worker. - done chan struct{} -} - -// NewHTTPTransport returns a new pre-configured instance of HTTPTransport. -func NewHTTPTransport() *HTTPTransport { - transport := HTTPTransport{ - BufferSize: defaultBufferSize, - Timeout: defaultTimeout, - done: make(chan struct{}), - } - return &transport -} - -// Configure is called by the Client itself, providing it it's own ClientOptions. -func (t *HTTPTransport) Configure(options ClientOptions) { - dsn, err := NewDsn(options.Dsn) - if err != nil { - debuglog.Printf("%v\n", err) - return - } - t.dsn = dsn - - // A buffered channel with capacity 1 works like a mutex, ensuring only one - // goroutine can access the current batch at a given time. Access is - // synchronized by reading from and writing to the channel. - t.buffer = make(chan batch, 1) - t.buffer <- batch{ - items: make(chan batchItem, t.BufferSize), - started: make(chan struct{}), - done: make(chan struct{}), - } - - if options.HTTPTransport != nil { - t.transport = options.HTTPTransport - } else { - t.transport = &http.Transport{ - Proxy: getProxyConfig(options), - TLSClientConfig: getTLSConfig(options), - } - } - - if options.HTTPClient != nil { - t.client = options.HTTPClient - } else { - t.client = &http.Client{ - Transport: t.transport, - Timeout: t.Timeout, - } - } - - t.startOnce.Do(func() { - go t.worker() - }) -} - -// SendEvent assembles a new packet out of Event and sends it to the remote server. -func (t *HTTPTransport) SendEvent(event *Event) { - t.SendEventWithContext(context.Background(), event) -} - -// SendEventWithContext assembles a new packet out of Event and sends it to the remote server. -func (t *HTTPTransport) SendEventWithContext(ctx context.Context, event *Event) { - if t.dsn == nil { - return - } - - category := event.toCategory() - - if t.disabled(category) { - return - } - - request, err := getRequestFromEvent(ctx, event, t.dsn) - if err != nil { - return - } - - // <-t.buffer is equivalent to acquiring a lock to access the current batch. - // A few lines below, t.buffer <- b releases the lock. - // - // The lock must be held during the select block below to guarantee that - // b.items is not closed while trying to send to it. Remember that sending - // on a closed channel panics. - // - // Note that the select block takes a bounded amount of CPU time because of - // the default case that is executed if sending on b.items would block. That - // is, the event is dropped if it cannot be sent immediately to the b.items - // channel (used as a queue). - b := <-t.buffer - - identifier := eventIdentifier(event) - - select { - case b.items <- batchItem{ - request: request, - category: category, - eventIdentifier: identifier, - }: - debuglog.Printf( - "Sending %s to %s project: %s", - identifier, - t.dsn.GetHost(), - t.dsn.GetProjectID(), - ) - default: - debuglog.Println("Event dropped due to transport buffer being full.") - } - - t.buffer <- b -} - -// Flush waits until any buffered events are sent to the Sentry server, blocking -// for at most the given timeout. It returns false if the timeout was reached. -// In that case, some events may not have been sent. -// -// Flush should be called before terminating the program to avoid -// unintentionally dropping events. -// -// Do not call Flush indiscriminately after every call to SendEvent. Instead, to -// have the SDK send events over the network synchronously, configure it to use -// the HTTPSyncTransport in the call to Init. -func (t *HTTPTransport) Flush(timeout time.Duration) bool { - ctx, cancel := context.WithTimeout(context.Background(), timeout) - defer cancel() - return t.FlushWithContext(ctx) -} - -// FlushWithContext works like Flush, but it accepts a context.Context instead of a timeout. -func (t *HTTPTransport) FlushWithContext(ctx context.Context) bool { - return t.flushInternal(ctx.Done()) -} - -func (t *HTTPTransport) flushInternal(timeout <-chan struct{}) bool { - // Wait until processing the current batch has started or the timeout. - // - // We must wait until the worker has seen the current batch, because it is - // the only way b.done will be closed. If we do not wait, there is a - // possible execution flow in which b.done is never closed, and the only way - // out of Flush would be waiting for the timeout, which is undesired. - var b batch - - for { - select { - case b = <-t.buffer: - select { - case <-b.started: - goto started - default: - t.buffer <- b - } - case <-timeout: - goto fail - } - } - -started: - // Signal that there won't be any more items in this batch, so that the - // worker inner loop can end. - close(b.items) - // Start a new batch for subsequent events. - t.buffer <- batch{ - items: make(chan batchItem, t.BufferSize), - started: make(chan struct{}), - done: make(chan struct{}), - } - - // Wait until the current batch is done or the timeout. - select { - case <-b.done: - debuglog.Println("Buffer flushed successfully.") - return true - case <-timeout: - goto fail - } - -fail: - debuglog.Println("Buffer flushing was canceled or timed out.") - return false -} - -// Close will terminate events sending loop. -// It useful to prevent goroutines leak in case of multiple HTTPTransport instances initiated. -// -// Close should be called after Flush and before terminating the program -// otherwise some events may be lost. -func (t *HTTPTransport) Close() { - t.closeOnce.Do(func() { - close(t.done) - }) -} - -func (t *HTTPTransport) worker() { - for b := range t.buffer { - // Signal that processing of the current batch has started. - close(b.started) - - // Return the batch to the buffer so that other goroutines can use it. - // Equivalent to releasing a lock. - t.buffer <- b - - // Process all batch items. - loop: - for { - select { - case <-t.done: - return - case item, open := <-b.items: - if !open { - break loop - } - if t.disabled(item.category) { - continue - } - - response, err := t.client.Do(item.request) - if err != nil { - debuglog.Printf("There was an issue with sending an event: %v", err) - continue - } - util.HandleHTTPResponse(response, item.eventIdentifier) - - t.mu.Lock() - if t.limits == nil { - t.limits = make(ratelimit.Map) - } - t.limits.Merge(ratelimit.FromResponse(response)) - t.mu.Unlock() - - // Drain body up to a limit and close it, allowing the - // transport to reuse TCP connections. - _, _ = io.CopyN(io.Discard, response.Body, util.MaxDrainResponseBytes) - response.Body.Close() - } - } - - // Signal that processing of the batch is done. - close(b.done) - } -} - -func (t *HTTPTransport) disabled(c ratelimit.Category) bool { - t.mu.RLock() - defer t.mu.RUnlock() - disabled := t.limits.IsRateLimited(c) - if disabled { - debuglog.Printf("Too many requests for %q, backing off till: %v", c, t.limits.Deadline(c)) - } - return disabled -} - -// ================================ -// HTTPSyncTransport -// ================================ - -// HTTPSyncTransport is a blocking implementation of Transport. -// -// Clients using this transport will send requests to Sentry sequentially and -// block until a response is returned. -// -// The blocking behavior is useful in a limited set of use cases. For example, -// use it when deploying code to a Function as a Service ("Serverless") -// platform, where any work happening in a background goroutine is not -// guaranteed to execute. -// -// For most cases, prefer HTTPTransport. -type HTTPSyncTransport struct { - dsn *Dsn - client *http.Client - transport http.RoundTripper - - mu sync.Mutex - limits ratelimit.Map - - // HTTP Client request timeout. Defaults to 30 seconds. - Timeout time.Duration -} - -// NewHTTPSyncTransport returns a new pre-configured instance of HTTPSyncTransport. -func NewHTTPSyncTransport() *HTTPSyncTransport { - transport := HTTPSyncTransport{ - Timeout: defaultTimeout, - limits: make(ratelimit.Map), - } - - return &transport -} - -// Configure is called by the Client itself, providing it it's own ClientOptions. -func (t *HTTPSyncTransport) Configure(options ClientOptions) { - dsn, err := NewDsn(options.Dsn) - if err != nil { - debuglog.Printf("%v\n", err) - return - } - t.dsn = dsn - - if options.HTTPTransport != nil { - t.transport = options.HTTPTransport - } else { - t.transport = &http.Transport{ - Proxy: getProxyConfig(options), - TLSClientConfig: getTLSConfig(options), - } - } - - if options.HTTPClient != nil { - t.client = options.HTTPClient - } else { - t.client = &http.Client{ - Transport: t.transport, - Timeout: t.Timeout, - } - } -} - -// SendEvent assembles a new packet out of Event and sends it to the remote server. -func (t *HTTPSyncTransport) SendEvent(event *Event) { - t.SendEventWithContext(context.Background(), event) -} - -func (t *HTTPSyncTransport) Close() {} - -// SendEventWithContext assembles a new packet out of Event and sends it to the remote server. -func (t *HTTPSyncTransport) SendEventWithContext(ctx context.Context, event *Event) { - if t.dsn == nil { - return - } - - if t.disabled(event.toCategory()) { - return - } - - request, err := getRequestFromEvent(ctx, event, t.dsn) - if err != nil { - return - } - - identifier := eventIdentifier(event) - debuglog.Printf( - "Sending %s to %s project: %s", - identifier, - t.dsn.GetHost(), - t.dsn.GetProjectID(), - ) - - response, err := t.client.Do(request) - if err != nil { - debuglog.Printf("There was an issue with sending an event: %v", err) - return - } - util.HandleHTTPResponse(response, identifier) - - t.mu.Lock() - if t.limits == nil { - t.limits = make(ratelimit.Map) - } - - t.limits.Merge(ratelimit.FromResponse(response)) - t.mu.Unlock() - - // Drain body up to a limit and close it, allowing the - // transport to reuse TCP connections. - _, _ = io.CopyN(io.Discard, response.Body, util.MaxDrainResponseBytes) - response.Body.Close() -} - -// Flush is a no-op for HTTPSyncTransport. It always returns true immediately. -func (t *HTTPSyncTransport) Flush(_ time.Duration) bool { - return true -} - -// FlushWithContext is a no-op for HTTPSyncTransport. It always returns true immediately. -func (t *HTTPSyncTransport) FlushWithContext(_ context.Context) bool { - return true -} - -func (t *HTTPSyncTransport) disabled(c ratelimit.Category) bool { - t.mu.Lock() - defer t.mu.Unlock() - disabled := t.limits.IsRateLimited(c) - if disabled { - debuglog.Printf("Too many requests for %q, backing off till: %v", c, t.limits.Deadline(c)) - } - return disabled -} - -// ================================ -// noopTransport -// ================================ - -// noopTransport is an implementation of Transport interface which drops all the events. -// Only used internally when an empty DSN is provided, which effectively disables the SDK. -type noopTransport struct{} - -var _ Transport = noopTransport{} - -func (noopTransport) Configure(ClientOptions) { - debuglog.Println("Sentry client initialized with an empty DSN. Using noopTransport. No events will be delivered.") -} - -func (noopTransport) SendEvent(*Event) { - debuglog.Println("Event dropped due to noopTransport usage.") -} - -func (noopTransport) Flush(time.Duration) bool { - return true -} - -func (noopTransport) FlushWithContext(context.Context) bool { - return true -} - -func (noopTransport) Close() {} - -// ================================ -// Internal Transport Adapters -// ================================ - -// newInternalAsyncTransport creates a new AsyncTransport from internal/http -// wrapped to satisfy the Transport interface. -// -// This is not yet exposed in the public API and is for internal experimentation. -func newInternalAsyncTransport() Transport { - return &internalAsyncTransportAdapter{} -} - -// internalAsyncTransportAdapter wraps the internal AsyncTransport to implement -// the root-level Transport interface. -type internalAsyncTransportAdapter struct { - transport protocol.TelemetryTransport - dsn *protocol.Dsn -} - -func (a *internalAsyncTransportAdapter) Configure(options ClientOptions) { - transportOptions := httpinternal.TransportOptions{ - Dsn: options.Dsn, - HTTPClient: options.HTTPClient, - HTTPTransport: options.HTTPTransport, - HTTPProxy: options.HTTPProxy, - HTTPSProxy: options.HTTPSProxy, - CaCerts: options.CaCerts, - } - - a.transport = httpinternal.NewAsyncTransport(transportOptions) - - if options.Dsn != "" { - dsn, err := protocol.NewDsn(options.Dsn) - if err != nil { - debuglog.Printf("Failed to parse DSN in adapter: %v\n", err) - } else { - a.dsn = dsn - } - } -} - -func (a *internalAsyncTransportAdapter) SendEvent(event *Event) { - header := &protocol.EnvelopeHeader{EventID: string(event.EventID), SentAt: time.Now(), Sdk: &protocol.SdkInfo{Name: event.Sdk.Name, Version: event.Sdk.Version}} - if a.dsn != nil { - header.Dsn = a.dsn.String() - } - if header.EventID == "" { - header.EventID = protocol.GenerateEventID() - } - envelope := protocol.NewEnvelope(header) - item, err := event.ToEnvelopeItem() - if err != nil { - debuglog.Printf("Failed to convert event to envelope item: %v", err) - return - } - envelope.AddItem(item) - - for _, attachment := range event.Attachments { - attachmentItem := protocol.NewAttachmentItem(attachment.Filename, attachment.ContentType, attachment.Payload) - envelope.AddItem(attachmentItem) - } - - if err := a.transport.SendEnvelope(envelope); err != nil { - debuglog.Printf("Error sending envelope: %v", err) - } -} - -func (a *internalAsyncTransportAdapter) Flush(timeout time.Duration) bool { - return a.transport.Flush(timeout) -} - -func (a *internalAsyncTransportAdapter) FlushWithContext(ctx context.Context) bool { - return a.transport.FlushWithContext(ctx) -} - -func (a *internalAsyncTransportAdapter) Close() { - a.transport.Close() -} diff --git a/vendor/github.com/getsentry/sentry-go/util.go b/vendor/github.com/getsentry/sentry-go/util.go deleted file mode 100644 index 298172a93b6..00000000000 --- a/vendor/github.com/getsentry/sentry-go/util.go +++ /dev/null @@ -1,132 +0,0 @@ -package sentry - -import ( - "encoding/json" - "fmt" - "os" - "runtime/debug" - "strings" - "time" - - "github.com/getsentry/sentry-go/internal/debuglog" - "github.com/getsentry/sentry-go/internal/protocol" - exec "golang.org/x/sys/execabs" -) - -func uuid() string { - return protocol.GenerateEventID() -} - -func fileExists(fileName string) bool { - _, err := os.Stat(fileName) - return err == nil -} - -// monotonicTimeSince replaces uses of time.Now() to take into account the -// monotonic clock reading stored in start, such that duration = end - start is -// unaffected by changes in the system wall clock. -func monotonicTimeSince(start time.Time) (end time.Time) { - return start.Add(time.Since(start)) -} - -// nolint: unused -func prettyPrint(data interface{}) { - dbg, _ := json.MarshalIndent(data, "", " ") - fmt.Println(string(dbg)) -} - -// defaultRelease attempts to guess a default release for the currently running -// program. -func defaultRelease() (release string) { - // Return first non-empty environment variable known to hold release info, if any. - envs := []string{ - "SENTRY_RELEASE", - "HEROKU_SLUG_COMMIT", - "SOURCE_VERSION", - "CODEBUILD_RESOLVED_SOURCE_VERSION", - "CIRCLE_SHA1", - "GAE_DEPLOYMENT_ID", - "GITHUB_SHA", // GitHub Actions - https://help.github.com/en/actions - "COMMIT_REF", // Netlify - https://docs.netlify.com/ - "VERCEL_GIT_COMMIT_SHA", // Vercel - https://vercel.com/ - "ZEIT_GITHUB_COMMIT_SHA", // Zeit (now known as Vercel) - "ZEIT_GITLAB_COMMIT_SHA", - "ZEIT_BITBUCKET_COMMIT_SHA", - } - for _, e := range envs { - if release = os.Getenv(e); release != "" { - debuglog.Printf("Using release from environment variable %s: %s", e, release) - return release - } - } - - if info, ok := debug.ReadBuildInfo(); ok { - buildInfoVcsRevision := revisionFromBuildInfo(info) - if len(buildInfoVcsRevision) > 0 { - return buildInfoVcsRevision - } - } - - // Derive a version string from Git. Example outputs: - // v1.0.1-0-g9de4 - // v2.0-8-g77df-dirty - // 4f72d7 - if _, err := exec.LookPath("git"); err == nil { - cmd := exec.Command("git", "describe", "--long", "--always", "--dirty") - b, err := cmd.Output() - if err != nil { - // Either Git is not available or the current directory is not a - // Git repository. - var s strings.Builder - fmt.Fprintf(&s, "Release detection failed: %v", err) - if err, ok := err.(*exec.ExitError); ok && len(err.Stderr) > 0 { - fmt.Fprintf(&s, ": %s", err.Stderr) - } - debuglog.Print(s.String()) - } else { - release = strings.TrimSpace(string(b)) - debuglog.Printf("Using release from Git: %s", release) - return release - } - } - - debuglog.Print("Some Sentry features will not be available. See https://docs.sentry.io/product/releases/.") - debuglog.Print("To stop seeing this message, pass a Release to sentry.Init or set the SENTRY_RELEASE environment variable.") - return "" -} - -func revisionFromBuildInfo(info *debug.BuildInfo) string { - for _, setting := range info.Settings { - if setting.Key == "vcs.revision" && setting.Value != "" { - debuglog.Printf("Using release from debug info: %s", setting.Value) - return setting.Value - } - } - - return "" -} - -func Pointer[T any](v T) *T { - return &v -} - -// eventIdentifier returns a human-readable identifier for the event to be used in log messages. -// Format: " []". -func eventIdentifier(event *Event) string { - var description string - switch event.Type { - case errorType: - description = "error" - case transactionType: - description = "transaction" - case checkInType: - description = "check-in" - case logEvent.Type: - description = fmt.Sprintf("%d log events", len(event.Logs)) - case traceMetricEvent.Type: - description = fmt.Sprintf("%d metric events", len(event.Metrics)) - default: - description = fmt.Sprintf("%s event", event.Type) - } - return fmt.Sprintf("%s [%s]", description, event.EventID) -} diff --git a/vendor/github.com/go-chi/chi/v5/.gitignore b/vendor/github.com/go-chi/chi/v5/.gitignore deleted file mode 100644 index ba22c99a99e..00000000000 --- a/vendor/github.com/go-chi/chi/v5/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -.idea -*.sw? -.vscode diff --git a/vendor/github.com/go-chi/chi/v5/CHANGELOG.md b/vendor/github.com/go-chi/chi/v5/CHANGELOG.md deleted file mode 100644 index 25b45b97430..00000000000 --- a/vendor/github.com/go-chi/chi/v5/CHANGELOG.md +++ /dev/null @@ -1,341 +0,0 @@ -# Changelog - -## v5.0.12 (2024-02-16) - -- History of changes: see https://github.com/go-chi/chi/compare/v5.0.11...v5.0.12 - - -## v5.0.11 (2023-12-19) - -- History of changes: see https://github.com/go-chi/chi/compare/v5.0.10...v5.0.11 - - -## v5.0.10 (2023-07-13) - -- Fixed small edge case in tests of v5.0.9 for older Go versions -- History of changes: see https://github.com/go-chi/chi/compare/v5.0.9...v5.0.10 - - -## v5.0.9 (2023-07-13) - -- History of changes: see https://github.com/go-chi/chi/compare/v5.0.8...v5.0.9 - - -## v5.0.8 (2022-12-07) - -- History of changes: see https://github.com/go-chi/chi/compare/v5.0.7...v5.0.8 - - -## v5.0.7 (2021-11-18) - -- History of changes: see https://github.com/go-chi/chi/compare/v5.0.6...v5.0.7 - - -## v5.0.6 (2021-11-15) - -- History of changes: see https://github.com/go-chi/chi/compare/v5.0.5...v5.0.6 - - -## v5.0.5 (2021-10-27) - -- History of changes: see https://github.com/go-chi/chi/compare/v5.0.4...v5.0.5 - - -## v5.0.4 (2021-08-29) - -- History of changes: see https://github.com/go-chi/chi/compare/v5.0.3...v5.0.4 - - -## v5.0.3 (2021-04-29) - -- History of changes: see https://github.com/go-chi/chi/compare/v5.0.2...v5.0.3 - - -## v5.0.2 (2021-03-25) - -- History of changes: see https://github.com/go-chi/chi/compare/v5.0.1...v5.0.2 - - -## v5.0.1 (2021-03-10) - -- Small improvements -- History of changes: see https://github.com/go-chi/chi/compare/v5.0.0...v5.0.1 - - -## v5.0.0 (2021-02-27) - -- chi v5, `github.com/go-chi/chi/v5` introduces the adoption of Go's SIV to adhere to the current state-of-the-tools in Go. -- chi v1.5.x did not work out as planned, as the Go tooling is too powerful and chi's adoption is too wide. - The most responsible thing to do for everyone's benefit is to just release v5 with SIV, so I present to you all, - chi v5 at `github.com/go-chi/chi/v5`. I hope someday the developer experience and ergonomics I've been seeking - will still come to fruition in some form, see https://github.com/golang/go/issues/44550 -- History of changes: see https://github.com/go-chi/chi/compare/v1.5.4...v5.0.0 - - -## v1.5.4 (2021-02-27) - -- Undo prior retraction in v1.5.3 as we prepare for v5.0.0 release -- History of changes: see https://github.com/go-chi/chi/compare/v1.5.3...v1.5.4 - - -## v1.5.3 (2021-02-21) - -- Update go.mod to go 1.16 with new retract directive marking all versions without prior go.mod support -- History of changes: see https://github.com/go-chi/chi/compare/v1.5.2...v1.5.3 - - -## v1.5.2 (2021-02-10) - -- Reverting allocation optimization as a precaution as go test -race fails. -- Minor improvements, see history below -- History of changes: see https://github.com/go-chi/chi/compare/v1.5.1...v1.5.2 - - -## v1.5.1 (2020-12-06) - -- Performance improvement: removing 1 allocation by foregoing context.WithValue, thank you @bouk for - your contribution (https://github.com/go-chi/chi/pull/555). Note: new benchmarks posted in README. -- `middleware.CleanPath`: new middleware that clean's request path of double slashes -- deprecate & remove `chi.ServerBaseContext` in favour of stdlib `http.Server#BaseContext` -- plus other tiny improvements, see full commit history below -- History of changes: see https://github.com/go-chi/chi/compare/v4.1.2...v1.5.1 - - -## v1.5.0 (2020-11-12) - now with go.mod support - -`chi` dates back to 2016 with it's original implementation as one of the first routers to adopt the newly introduced -context.Context api to the stdlib -- set out to design a router that is faster, more modular and simpler than anything -else out there -- while not introducing any custom handler types or dependencies. Today, `chi` still has zero dependencies, -and in many ways is future proofed from changes, given it's minimal nature. Between versions, chi's iterations have been very -incremental, with the architecture and api being the same today as it was originally designed in 2016. For this reason it -makes chi a pretty easy project to maintain, as well thanks to the many amazing community contributions over the years -to who all help make chi better (total of 86 contributors to date -- thanks all!). - -Chi has been a labour of love, art and engineering, with the goals to offer beautiful ergonomics, flexibility, performance -and simplicity when building HTTP services with Go. I've strived to keep the router very minimal in surface area / code size, -and always improving the code wherever possible -- and as of today the `chi` package is just 1082 lines of code (not counting -middlewares, which are all optional). As well, I don't have the exact metrics, but from my analysis and email exchanges from -companies and developers, chi is used by thousands of projects around the world -- thank you all as there is no better form of -joy for me than to have art I had started be helpful and enjoyed by others. And of course I use chi in all of my own projects too :) - -For me, the aesthetics of chi's code and usage are very important. With the introduction of Go's module support -(which I'm a big fan of), chi's past versioning scheme choice to v2, v3 and v4 would mean I'd require the import path -of "github.com/go-chi/chi/v4", leading to the lengthy discussion at https://github.com/go-chi/chi/issues/462. -Haha, to some, you may be scratching your head why I've spent > 1 year stalling to adopt "/vXX" convention in the import -path -- which isn't horrible in general -- but for chi, I'm unable to accept it as I strive for perfection in it's API design, -aesthetics and simplicity. It just doesn't feel good to me given chi's simple nature -- I do not foresee a "v5" or "v6", -and upgrading between versions in the future will also be just incremental. - -I do understand versioning is a part of the API design as well, which is why the solution for a while has been to "do nothing", -as Go supports both old and new import paths with/out go.mod. However, now that Go module support has had time to iron out kinks and -is adopted everywhere, it's time for chi to get with the times. Luckily, I've discovered a path forward that will make me happy, -while also not breaking anyone's app who adopted a prior versioning from tags in v2/v3/v4. I've made an experimental release of -v1.5.0 with go.mod silently, and tested it with new and old projects, to ensure the developer experience is preserved, and it's -largely unnoticed. Fortunately, Go's toolchain will check the tags of a repo and consider the "latest" tag the one with go.mod. -However, you can still request a specific older tag such as v4.1.2, and everything will "just work". But new users can just -`go get github.com/go-chi/chi` or `go get github.com/go-chi/chi@latest` and they will get the latest version which contains -go.mod support, which is v1.5.0+. `chi` will not change very much over the years, just like it hasn't changed much from 4 years ago. -Therefore, we will stay on v1.x from here on, starting from v1.5.0. Any breaking changes will bump a "minor" release and -backwards-compatible improvements/fixes will bump a "tiny" release. - -For existing projects who want to upgrade to the latest go.mod version, run: `go get -u github.com/go-chi/chi@v1.5.0`, -which will get you on the go.mod version line (as Go's mod cache may still remember v4.x). Brand new systems can run -`go get -u github.com/go-chi/chi` or `go get -u github.com/go-chi/chi@latest` to install chi, which will install v1.5.0+ -built with go.mod support. - -My apologies to the developers who will disagree with the decisions above, but, hope you'll try it and see it's a very -minor request which is backwards compatible and won't break your existing installations. - -Cheers all, happy coding! - - ---- - - -## v4.1.2 (2020-06-02) - -- fix that handles MethodNotAllowed with path variables, thank you @caseyhadden for your contribution -- fix to replace nested wildcards correctly in RoutePattern, thank you @@unmultimedio for your contribution -- History of changes: see https://github.com/go-chi/chi/compare/v4.1.1...v4.1.2 - - -## v4.1.1 (2020-04-16) - -- fix for issue https://github.com/go-chi/chi/issues/411 which allows for overlapping regexp - route to the correct handler through a recursive tree search, thanks to @Jahaja for the PR/fix! -- new middleware.RouteHeaders as a simple router for request headers with wildcard support -- History of changes: see https://github.com/go-chi/chi/compare/v4.1.0...v4.1.1 - - -## v4.1.0 (2020-04-1) - -- middleware.LogEntry: Write method on interface now passes the response header - and an extra interface type useful for custom logger implementations. -- middleware.WrapResponseWriter: minor fix -- middleware.Recoverer: a bit prettier -- History of changes: see https://github.com/go-chi/chi/compare/v4.0.4...v4.1.0 - -## v4.0.4 (2020-03-24) - -- middleware.Recoverer: new pretty stack trace printing (https://github.com/go-chi/chi/pull/496) -- a few minor improvements and fixes -- History of changes: see https://github.com/go-chi/chi/compare/v4.0.3...v4.0.4 - - -## v4.0.3 (2020-01-09) - -- core: fix regexp routing to include default value when param is not matched -- middleware: rewrite of middleware.Compress -- middleware: suppress http.ErrAbortHandler in middleware.Recoverer -- History of changes: see https://github.com/go-chi/chi/compare/v4.0.2...v4.0.3 - - -## v4.0.2 (2019-02-26) - -- Minor fixes -- History of changes: see https://github.com/go-chi/chi/compare/v4.0.1...v4.0.2 - - -## v4.0.1 (2019-01-21) - -- Fixes issue with compress middleware: #382 #385 -- History of changes: see https://github.com/go-chi/chi/compare/v4.0.0...v4.0.1 - - -## v4.0.0 (2019-01-10) - -- chi v4 requires Go 1.10.3+ (or Go 1.9.7+) - we have deprecated support for Go 1.7 and 1.8 -- router: respond with 404 on router with no routes (#362) -- router: additional check to ensure wildcard is at the end of a url pattern (#333) -- middleware: deprecate use of http.CloseNotifier (#347) -- middleware: fix RedirectSlashes to include query params on redirect (#334) -- History of changes: see https://github.com/go-chi/chi/compare/v3.3.4...v4.0.0 - - -## v3.3.4 (2019-01-07) - -- Minor middleware improvements. No changes to core library/router. Moving v3 into its -- own branch as a version of chi for Go 1.7, 1.8, 1.9, 1.10, 1.11 -- History of changes: see https://github.com/go-chi/chi/compare/v3.3.3...v3.3.4 - - -## v3.3.3 (2018-08-27) - -- Minor release -- See https://github.com/go-chi/chi/compare/v3.3.2...v3.3.3 - - -## v3.3.2 (2017-12-22) - -- Support to route trailing slashes on mounted sub-routers (#281) -- middleware: new `ContentCharset` to check matching charsets. Thank you - @csucu for your community contribution! - - -## v3.3.1 (2017-11-20) - -- middleware: new `AllowContentType` handler for explicit whitelist of accepted request Content-Types -- middleware: new `SetHeader` handler for short-hand middleware to set a response header key/value -- Minor bug fixes - - -## v3.3.0 (2017-10-10) - -- New chi.RegisterMethod(method) to add support for custom HTTP methods, see _examples/custom-method for usage -- Deprecated LINK and UNLINK methods from the default list, please use `chi.RegisterMethod("LINK")` and `chi.RegisterMethod("UNLINK")` in an `init()` function - - -## v3.2.1 (2017-08-31) - -- Add new `Match(rctx *Context, method, path string) bool` method to `Routes` interface - and `Mux`. Match searches the mux's routing tree for a handler that matches the method/path -- Add new `RouteMethod` to `*Context` -- Add new `Routes` pointer to `*Context` -- Add new `middleware.GetHead` to route missing HEAD requests to GET handler -- Updated benchmarks (see README) - - -## v3.1.5 (2017-08-02) - -- Setup golint and go vet for the project -- As per golint, we've redefined `func ServerBaseContext(h http.Handler, baseCtx context.Context) http.Handler` - to `func ServerBaseContext(baseCtx context.Context, h http.Handler) http.Handler` - - -## v3.1.0 (2017-07-10) - -- Fix a few minor issues after v3 release -- Move `docgen` sub-pkg to https://github.com/go-chi/docgen -- Move `render` sub-pkg to https://github.com/go-chi/render -- Add new `URLFormat` handler to chi/middleware sub-pkg to make working with url mime - suffixes easier, ie. parsing `/articles/1.json` and `/articles/1.xml`. See comments in - https://github.com/go-chi/chi/blob/master/middleware/url_format.go for example usage. - - -## v3.0.0 (2017-06-21) - -- Major update to chi library with many exciting updates, but also some *breaking changes* -- URL parameter syntax changed from `/:id` to `/{id}` for even more flexible routing, such as - `/articles/{month}-{day}-{year}-{slug}`, `/articles/{id}`, and `/articles/{id}.{ext}` on the - same router -- Support for regexp for routing patterns, in the form of `/{paramKey:regExp}` for example: - `r.Get("/articles/{name:[a-z]+}", h)` and `chi.URLParam(r, "name")` -- Add `Method` and `MethodFunc` to `chi.Router` to allow routing definitions such as - `r.Method("GET", "/", h)` which provides a cleaner interface for custom handlers like - in `_examples/custom-handler` -- Deprecating `mux#FileServer` helper function. Instead, we encourage users to create their - own using file handler with the stdlib, see `_examples/fileserver` for an example -- Add support for LINK/UNLINK http methods via `r.Method()` and `r.MethodFunc()` -- Moved the chi project to its own organization, to allow chi-related community packages to - be easily discovered and supported, at: https://github.com/go-chi -- *NOTE:* please update your import paths to `"github.com/go-chi/chi"` -- *NOTE:* chi v2 is still available at https://github.com/go-chi/chi/tree/v2 - - -## v2.1.0 (2017-03-30) - -- Minor improvements and update to the chi core library -- Introduced a brand new `chi/render` sub-package to complete the story of building - APIs to offer a pattern for managing well-defined request / response payloads. Please - check out the updated `_examples/rest` example for how it works. -- Added `MethodNotAllowed(h http.HandlerFunc)` to chi.Router interface - - -## v2.0.0 (2017-01-06) - -- After many months of v2 being in an RC state with many companies and users running it in - production, the inclusion of some improvements to the middlewares, we are very pleased to - announce v2.0.0 of chi. - - -## v2.0.0-rc1 (2016-07-26) - -- Huge update! chi v2 is a large refactor targeting Go 1.7+. As of Go 1.7, the popular - community `"net/context"` package has been included in the standard library as `"context"` and - utilized by `"net/http"` and `http.Request` to managing deadlines, cancelation signals and other - request-scoped values. We're very excited about the new context addition and are proud to - introduce chi v2, a minimal and powerful routing package for building large HTTP services, - with zero external dependencies. Chi focuses on idiomatic design and encourages the use of - stdlib HTTP handlers and middlewares. -- chi v2 deprecates its `chi.Handler` interface and requires `http.Handler` or `http.HandlerFunc` -- chi v2 stores URL routing parameters and patterns in the standard request context: `r.Context()` -- chi v2 lower-level routing context is accessible by `chi.RouteContext(r.Context()) *chi.Context`, - which provides direct access to URL routing parameters, the routing path and the matching - routing patterns. -- Users upgrading from chi v1 to v2, need to: - 1. Update the old chi.Handler signature, `func(ctx context.Context, w http.ResponseWriter, r *http.Request)` to - the standard http.Handler: `func(w http.ResponseWriter, r *http.Request)` - 2. Use `chi.URLParam(r *http.Request, paramKey string) string` - or `URLParamFromCtx(ctx context.Context, paramKey string) string` to access a url parameter value - - -## v1.0.0 (2016-07-01) - -- Released chi v1 stable https://github.com/go-chi/chi/tree/v1.0.0 for Go 1.6 and older. - - -## v0.9.0 (2016-03-31) - -- Reuse context objects via sync.Pool for zero-allocation routing [#33](https://github.com/go-chi/chi/pull/33) -- BREAKING NOTE: due to subtle API changes, previously `chi.URLParams(ctx)["id"]` used to access url parameters - has changed to: `chi.URLParam(ctx, "id")` diff --git a/vendor/github.com/go-chi/chi/v5/CONTRIBUTING.md b/vendor/github.com/go-chi/chi/v5/CONTRIBUTING.md deleted file mode 100644 index b4a6268d575..00000000000 --- a/vendor/github.com/go-chi/chi/v5/CONTRIBUTING.md +++ /dev/null @@ -1,31 +0,0 @@ -# Contributing - -## Prerequisites - -1. [Install Go][go-install]. -2. Download the sources and switch the working directory: - - ```bash - go get -u -d github.com/go-chi/chi - cd $GOPATH/src/github.com/go-chi/chi - ``` - -## Submitting a Pull Request - -A typical workflow is: - -1. [Fork the repository.][fork] -2. [Create a topic branch.][branch] -3. Add tests for your change. -4. Run `go test`. If your tests pass, return to the step 3. -5. Implement the change and ensure the steps from the previous step pass. -6. Run `goimports -w .`, to ensure the new code conforms to Go formatting guideline. -7. [Add, commit and push your changes.][git-help] -8. [Submit a pull request.][pull-req] - -[go-install]: https://golang.org/doc/install -[fork]: https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/fork-a-repo -[branch]: https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-branches -[git-help]: https://docs.github.com/en -[pull-req]: https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests - diff --git a/vendor/github.com/go-chi/chi/v5/LICENSE b/vendor/github.com/go-chi/chi/v5/LICENSE deleted file mode 100644 index d99f02ffac5..00000000000 --- a/vendor/github.com/go-chi/chi/v5/LICENSE +++ /dev/null @@ -1,20 +0,0 @@ -Copyright (c) 2015-present Peter Kieltyka (https://github.com/pkieltyka), Google Inc. - -MIT License - -Permission is hereby granted, free of charge, to any person obtaining a copy of -this software and associated documentation files (the "Software"), to deal in -the Software without restriction, including without limitation the rights to -use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of -the Software, and to permit persons to whom the Software is furnished to do so, -subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS -FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR -COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER -IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN -CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/vendor/github.com/go-chi/chi/v5/Makefile b/vendor/github.com/go-chi/chi/v5/Makefile deleted file mode 100644 index e0f18c7da21..00000000000 --- a/vendor/github.com/go-chi/chi/v5/Makefile +++ /dev/null @@ -1,22 +0,0 @@ -.PHONY: all -all: - @echo "**********************************************************" - @echo "** chi build tool **" - @echo "**********************************************************" - - -.PHONY: test -test: - go clean -testcache && $(MAKE) test-router && $(MAKE) test-middleware - -.PHONY: test-router -test-router: - go test -race -v . - -.PHONY: test-middleware -test-middleware: - go test -race -v ./middleware - -.PHONY: docs -docs: - npx docsify-cli serve ./docs diff --git a/vendor/github.com/go-chi/chi/v5/README.md b/vendor/github.com/go-chi/chi/v5/README.md deleted file mode 100644 index e668e2041d4..00000000000 --- a/vendor/github.com/go-chi/chi/v5/README.md +++ /dev/null @@ -1,572 +0,0 @@ -# chi - - -[![GoDoc Widget]][GoDoc] - -`chi` is a lightweight, idiomatic and composable router for building Go HTTP services. It's -especially good at helping you write large REST API services that are kept maintainable as your -project grows and changes. `chi` is built on the new `context` package introduced in Go 1.7 to -handle signaling, cancelation and request-scoped values across a handler chain. - -The focus of the project has been to seek out an elegant and comfortable design for writing -REST API servers, written during the development of the Pressly API service that powers our -public API service, which in turn powers all of our client-side applications. - -The key considerations of chi's design are: project structure, maintainability, standard http -handlers (stdlib-only), developer productivity, and deconstructing a large system into many small -parts. The core router `github.com/go-chi/chi` is quite small (less than 1000 LOC), but we've also -included some useful/optional subpackages: [middleware](/middleware), [render](https://github.com/go-chi/render) -and [docgen](https://github.com/go-chi/docgen). We hope you enjoy it too! - -## Install - -```sh -go get -u github.com/go-chi/chi/v5 -``` - - -## Features - -* **Lightweight** - cloc'd in ~1000 LOC for the chi router -* **Fast** - yes, see [benchmarks](#benchmarks) -* **100% compatible with net/http** - use any http or middleware pkg in the ecosystem that is also compatible with `net/http` -* **Designed for modular/composable APIs** - middlewares, inline middlewares, route groups and sub-router mounting -* **Context control** - built on new `context` package, providing value chaining, cancellations and timeouts -* **Robust** - in production at Pressly, Cloudflare, Heroku, 99Designs, and many others (see [discussion](https://github.com/go-chi/chi/issues/91)) -* **Doc generation** - `docgen` auto-generates routing documentation from your source to JSON or Markdown -* **Go.mod support** - as of v5, go.mod support (see [CHANGELOG](https://github.com/go-chi/chi/blob/master/CHANGELOG.md)) -* **No external dependencies** - plain ol' Go stdlib + net/http - - -## Examples - -See [_examples/](https://github.com/go-chi/chi/blob/master/_examples/) for a variety of examples. - - -**As easy as:** - -```go -package main - -import ( - "net/http" - - "github.com/go-chi/chi/v5" - "github.com/go-chi/chi/v5/middleware" -) - -func main() { - r := chi.NewRouter() - r.Use(middleware.Logger) - r.Get("/", func(w http.ResponseWriter, r *http.Request) { - w.Write([]byte("welcome")) - }) - http.ListenAndServe(":3000", r) -} -``` - -**REST Preview:** - -Here is a little preview of what routing looks like with chi. Also take a look at the generated routing docs -in JSON ([routes.json](https://github.com/go-chi/chi/blob/master/_examples/rest/routes.json)) and in -Markdown ([routes.md](https://github.com/go-chi/chi/blob/master/_examples/rest/routes.md)). - -I highly recommend reading the source of the [examples](https://github.com/go-chi/chi/blob/master/_examples/) listed -above, they will show you all the features of chi and serve as a good form of documentation. - -```go -import ( - //... - "context" - "github.com/go-chi/chi/v5" - "github.com/go-chi/chi/v5/middleware" -) - -func main() { - r := chi.NewRouter() - - // A good base middleware stack - r.Use(middleware.RequestID) - r.Use(middleware.ClientIPFromRemoteAddr) // pick one ClientIPFrom* based on your infra, see below - r.Use(middleware.Logger) - r.Use(middleware.Recoverer) - - // Set a timeout value on the request context (ctx), that will signal - // through ctx.Done() that the request has timed out and further - // processing should be stopped. - r.Use(middleware.Timeout(60 * time.Second)) - - r.Get("/", func(w http.ResponseWriter, r *http.Request) { - w.Write([]byte("hi")) - }) - - // RESTy routes for "articles" resource - r.Route("/articles", func(r chi.Router) { - r.With(paginate).Get("/", listArticles) // GET /articles - r.With(paginate).Get("/{month}-{day}-{year}", listArticlesByDate) // GET /articles/01-16-2017 - - r.Post("/", createArticle) // POST /articles - r.Get("/search", searchArticles) // GET /articles/search - - // Regexp url parameters: - r.Get("/{articleSlug:[a-z-]+}", getArticleBySlug) // GET /articles/home-is-toronto - - // Subrouters: - r.Route("/{articleID}", func(r chi.Router) { - r.Use(ArticleCtx) - r.Get("/", getArticle) // GET /articles/123 - r.Put("/", updateArticle) // PUT /articles/123 - r.Delete("/", deleteArticle) // DELETE /articles/123 - }) - }) - - // Mount the admin sub-router - r.Mount("/admin", adminRouter()) - - http.ListenAndServe(":3333", r) -} - -func ArticleCtx(next http.Handler) http.Handler { - return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - articleID := chi.URLParam(r, "articleID") - article, err := dbGetArticle(articleID) - if err != nil { - http.Error(w, http.StatusText(404), 404) - return - } - ctx := context.WithValue(r.Context(), "article", article) - next.ServeHTTP(w, r.WithContext(ctx)) - }) -} - -func getArticle(w http.ResponseWriter, r *http.Request) { - ctx := r.Context() - article, ok := ctx.Value("article").(*Article) - if !ok { - http.Error(w, http.StatusText(422), 422) - return - } - w.Write([]byte(fmt.Sprintf("title:%s", article.Title))) -} - -// A completely separate router for administrator routes -func adminRouter() http.Handler { - r := chi.NewRouter() - r.Use(AdminOnly) - r.Get("/", adminIndex) - r.Get("/accounts", adminListAccounts) - return r -} - -func AdminOnly(next http.Handler) http.Handler { - return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - ctx := r.Context() - perm, ok := ctx.Value("acl.permission").(YourPermissionType) - if !ok || !perm.IsAdmin() { - http.Error(w, http.StatusText(403), 403) - return - } - next.ServeHTTP(w, r) - }) -} -``` - - -## Router interface - -chi's router is based on a kind of [Patricia Radix trie](https://en.wikipedia.org/wiki/Radix_tree). -The router is fully compatible with `net/http`. - -Built on top of the tree is the `Router` interface: - -```go -// Router consisting of the core routing methods used by chi's Mux, -// using only the standard net/http. -type Router interface { - http.Handler - Routes - - // Use appends one or more middlewares onto the Router stack. - Use(middlewares ...func(http.Handler) http.Handler) - - // With adds inline middlewares for an endpoint handler. - With(middlewares ...func(http.Handler) http.Handler) Router - - // Group adds a new inline-Router along the current routing - // path, with a fresh middleware stack for the inline-Router. - Group(fn func(r Router)) Router - - // Route mounts a sub-Router along a `pattern` string. - Route(pattern string, fn func(r Router)) Router - - // Mount attaches another http.Handler along ./pattern/* - Mount(pattern string, h http.Handler) - - // Handle and HandleFunc adds routes for `pattern` that matches - // all HTTP methods. - Handle(pattern string, h http.Handler) - HandleFunc(pattern string, h http.HandlerFunc) - - // Method and MethodFunc adds routes for `pattern` that matches - // the `method` HTTP method. - Method(method, pattern string, h http.Handler) - MethodFunc(method, pattern string, h http.HandlerFunc) - - // HTTP-method routing along `pattern` - Connect(pattern string, h http.HandlerFunc) - Delete(pattern string, h http.HandlerFunc) - Get(pattern string, h http.HandlerFunc) - Head(pattern string, h http.HandlerFunc) - Options(pattern string, h http.HandlerFunc) - Patch(pattern string, h http.HandlerFunc) - Post(pattern string, h http.HandlerFunc) - Put(pattern string, h http.HandlerFunc) - Query(pattern string, h http.HandlerFunc) - Trace(pattern string, h http.HandlerFunc) - - // NotFound defines a handler to respond whenever a route could - // not be found. - NotFound(h http.HandlerFunc) - - // MethodNotAllowed defines a handler to respond whenever a method is - // not allowed. - MethodNotAllowed(h http.HandlerFunc) -} - -// Routes interface adds two methods for router traversal, which is also -// used by the github.com/go-chi/docgen package to generate documentation for Routers. -type Routes interface { - // Routes returns the routing tree in an easily traversable structure. - Routes() []Route - - // Middlewares returns the list of middlewares in use by the router. - Middlewares() Middlewares - - // Match searches the routing tree for a handler that matches - // the method/path - similar to routing a http request, but without - // executing the handler thereafter. - Match(rctx *Context, method, path string) bool -} -``` - -Each routing method accepts a URL `pattern` and chain of `handlers`. The URL pattern -supports named params (ie. `/users/{userID}`) and wildcards (ie. `/admin/*`). URL parameters -can be fetched at runtime by calling `chi.URLParam(r, "userID")` for named parameters -and `chi.URLParam(r, "*")` for a wildcard parameter. - - -### Middleware handlers - -chi's middlewares are just stdlib net/http middleware handlers. There is nothing special -about them, which means the router and all the tooling is designed to be compatible and -friendly with any middleware in the community. This offers much better extensibility and reuse -of packages and is at the heart of chi's purpose. - -Here is an example of a standard net/http middleware where we assign a context key `"user"` -the value of `"123"`. This middleware sets a hypothetical user identifier on the request -context and calls the next handler in the chain. - -```go -// HTTP middleware setting a value on the request context -func MyMiddleware(next http.Handler) http.Handler { - return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - // create new context from `r` request context, and assign key `"user"` - // to value of `"123"` - ctx := context.WithValue(r.Context(), "user", "123") - - // call the next handler in the chain, passing the response writer and - // the updated request object with the new context value. - // - // note: context.Context values are nested, so any previously set - // values will be accessible as well, and the new `"user"` key - // will be accessible from this point forward. - next.ServeHTTP(w, r.WithContext(ctx)) - }) -} -``` - - -### Request handlers - -chi uses standard net/http request handlers. This little snippet is an example of a http.Handler -func that reads a user identifier from the request context - hypothetically, identifying -the user sending an authenticated request, validated+set by a previous middleware handler. - -```go -// HTTP handler accessing data from the request context. -func MyRequestHandler(w http.ResponseWriter, r *http.Request) { - // here we read from the request context and fetch out `"user"` key set in - // the MyMiddleware example above. - user := r.Context().Value("user").(string) - - // respond to the client - w.Write([]byte(fmt.Sprintf("hi %s", user))) -} -``` - - -### URL parameters - -chi's router parses and stores URL parameters right onto the request context. Here is -an example of how to access URL params in your net/http handlers. And of course, middlewares -are able to access the same information. - -```go -// HTTP handler accessing the url routing parameters. -func MyRequestHandler(w http.ResponseWriter, r *http.Request) { - // fetch the url parameter `"userID"` from the request of a matching - // routing pattern. An example routing pattern could be: /users/{userID} - userID := chi.URLParam(r, "userID") - - // fetch `"key"` from the request context - ctx := r.Context() - key := ctx.Value("key").(string) - - // respond to the client - w.Write([]byte(fmt.Sprintf("hi %v, %v", userID, key))) -} -``` - - -## Middlewares - -chi comes equipped with an optional `middleware` package, providing a suite of standard -`net/http` middlewares. Please note, any middleware in the ecosystem that is also compatible -with `net/http` can be used with chi's mux. - -### Core middlewares - ----------------------------------------------------------------------------------------------------- -| chi/middleware Handler | description | -| :--------------------- | :---------------------------------------------------------------------- | -| [AllowContentEncoding] | Enforces a whitelist of request Content-Encoding headers | -| [AllowContentType] | Explicit whitelist of accepted request Content-Types | -| [BasicAuth] | Basic HTTP authentication | -| [Compress] | Gzip compression for clients that accept compressed responses | -| [ContentCharset] | Ensure charset for Content-Type request headers | -| [CleanPath] | Clean double slashes from request path | -| [GetHead] | Automatically route undefined HEAD requests to GET handlers | -| [Heartbeat] | Monitoring endpoint to check the servers pulse | -| [Logger] | Logs the start and end of each request with the elapsed processing time | -| [NoCache] | Sets response headers to prevent clients from caching | -| [Profiler] | Easily attach net/http/pprof to your routers | -| [ClientIPFromHeader] | Capture client IP from a trusted single-IP header (X-Real-IP, CF-Connecting-IP, ...) | -| [ClientIPFromXFF] | Capture client IP from X-Forwarded-For, skipping listed trusted CIDR prefixes | -| [ClientIPFromXFFTrustedProxies] | Capture client IP from X-Forwarded-For given a fixed number of trusted proxies | -| [ClientIPFromRemoteAddr] | Capture client IP from the TCP RemoteAddr (server directly on the public internet) | -| [RealIP] | Deprecated — vulnerable to IP spoofing; use [ClientIPFromXFF] or another ClientIPFrom\* middleware | -| [Recoverer] | Gracefully absorb panics and prints the stack trace | -| [RequestID] | Injects a request ID into the context of each request | -| [RedirectSlashes] | Redirect slashes on routing paths | -| [RouteHeaders] | Route handling for request headers | -| [SetHeader] | Short-hand middleware to set a response header key/value | -| [StripSlashes] | Strip slashes on routing paths | -| [Sunset] | Sunset set Deprecation/Sunset header to response | -| [Throttle] | Puts a ceiling on the number of concurrent requests | -| [Timeout] | Signals to the request context when the timeout deadline is reached | -| [URLFormat] | Parse extension from url and put it on request context | -| [WithValue] | Short-hand middleware to set a key/value on the request context | ----------------------------------------------------------------------------------------------------- - -[AllowContentEncoding]: https://pkg.go.dev/github.com/go-chi/chi/middleware#AllowContentEncoding -[AllowContentType]: https://pkg.go.dev/github.com/go-chi/chi/middleware#AllowContentType -[BasicAuth]: https://pkg.go.dev/github.com/go-chi/chi/middleware#BasicAuth -[Compress]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Compress -[ContentCharset]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ContentCharset -[CleanPath]: https://pkg.go.dev/github.com/go-chi/chi/middleware#CleanPath -[GetHead]: https://pkg.go.dev/github.com/go-chi/chi/middleware#GetHead -[GetReqID]: https://pkg.go.dev/github.com/go-chi/chi/middleware#GetReqID -[Heartbeat]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Heartbeat -[Logger]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Logger -[NoCache]: https://pkg.go.dev/github.com/go-chi/chi/middleware#NoCache -[Profiler]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Profiler -[ClientIPFromHeader]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ClientIPFromHeader -[ClientIPFromXFF]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ClientIPFromXFF -[ClientIPFromXFFTrustedProxies]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ClientIPFromXFFTrustedProxies -[ClientIPFromRemoteAddr]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ClientIPFromRemoteAddr -[GetClientIP]: https://pkg.go.dev/github.com/go-chi/chi/middleware#GetClientIP -[GetClientIPAddr]: https://pkg.go.dev/github.com/go-chi/chi/middleware#GetClientIPAddr -[RealIP]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RealIP -[Recoverer]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Recoverer -[RedirectSlashes]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RedirectSlashes -[RequestLogger]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RequestLogger -[RequestID]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RequestID -[RouteHeaders]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RouteHeaders -[SetHeader]: https://pkg.go.dev/github.com/go-chi/chi/middleware#SetHeader -[StripSlashes]: https://pkg.go.dev/github.com/go-chi/chi/middleware#StripSlashes -[Sunset]: https://pkg.go.dev/github.com/go-chi/chi/v5/middleware#Sunset -[Throttle]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Throttle -[ThrottleBacklog]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ThrottleBacklog -[ThrottleWithOpts]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ThrottleWithOpts -[Timeout]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Timeout -[URLFormat]: https://pkg.go.dev/github.com/go-chi/chi/middleware#URLFormat -[WithLogEntry]: https://pkg.go.dev/github.com/go-chi/chi/middleware#WithLogEntry -[WithValue]: https://pkg.go.dev/github.com/go-chi/chi/middleware#WithValue -[Compressor]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Compressor -[DefaultLogFormatter]: https://pkg.go.dev/github.com/go-chi/chi/middleware#DefaultLogFormatter -[EncoderFunc]: https://pkg.go.dev/github.com/go-chi/chi/middleware#EncoderFunc -[HeaderRoute]: https://pkg.go.dev/github.com/go-chi/chi/middleware#HeaderRoute -[HeaderRouter]: https://pkg.go.dev/github.com/go-chi/chi/middleware#HeaderRouter -[LogEntry]: https://pkg.go.dev/github.com/go-chi/chi/middleware#LogEntry -[LogFormatter]: https://pkg.go.dev/github.com/go-chi/chi/middleware#LogFormatter -[LoggerInterface]: https://pkg.go.dev/github.com/go-chi/chi/middleware#LoggerInterface -[ThrottleOpts]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ThrottleOpts -[WrapResponseWriter]: https://pkg.go.dev/github.com/go-chi/chi/middleware#WrapResponseWriter - -### Choosing a ClientIP middleware - -The legacy [RealIP] middleware is deprecated — it is vulnerable to IP spoofing -(GHSA-3fxj-6jh8-hvhx, GHSA-rjr7-jggh-pgcp, GHSA-9g5q-2w5x-hmxf) and mutates -`r.RemoteAddr`. Use one of the four `ClientIPFrom*` middlewares instead — pick -exactly one based on your network setup — and read the resulting IP with -[GetClientIP] (string) or [GetClientIPAddr] (`netip.Addr`): - -| Your setup | Use | -|---|---| -| Directly on the public internet, no proxy | `middleware.ClientIPFromRemoteAddr` | -| Behind nginx (`X-Real-IP`), Cloudflare (`CF-Connecting-IP`), Apache (`X-Client-IP`) | `middleware.ClientIPFromHeader("")` | -| Behind one or more proxies whose IP ranges you can list | `middleware.ClientIPFromXFF("10.0.0.0/8", ...)` | -| Behind a known, fixed number of proxies with dynamic IPs | `middleware.ClientIPFromXFFTrustedProxies(2)` | - -```go -r := chi.NewRouter() -r.Use(middleware.RequestID) - -// Pick exactly one. Examples for common deployments: - -// Direct internet exposure (no proxy): -// r.Use(middleware.ClientIPFromRemoteAddr) - -// Behind Cloudflare: -// r.Use(middleware.ClientIPFromHeader("CF-Connecting-IP")) - -// Behind AWS CloudFront (or any proxy fleet with known CIDRs): -r.Use(middleware.ClientIPFromXFF( - "13.32.0.0/15", // CloudFront IPv4 - "52.46.0.0/18", // CloudFront IPv4 - "2600:9000::/28", // CloudFront IPv6 -)) - -// Behind a known number of proxies with dynamic IPs: -// r.Use(middleware.ClientIPFromXFFTrustedProxies(2)) - -r.Use(middleware.Logger) -r.Use(middleware.Recoverer) - -r.Get("/", func(w http.ResponseWriter, r *http.Request) { - clientIP := middleware.GetClientIP(r.Context()) // for logs, rate-limit keys, etc. - _ = clientIP -}) -``` - -These middlewares never mutate `r.RemoteAddr`. They store a normalized -`netip.Addr` in the request context — IPv4-mapped IPv6 (`::ffff:a.b.c.d`) -is folded to plain IPv4, and IPv6 zone identifiers carried in headers are -stripped, so one logical client maps to a single canonical key for logs, -rate limits, and ACLs. - -See the per-function godoc for the full semantics of each middleware, and -[adam-p's "The perils of the 'real' client IP"](https://adam-p.ca/blog/2022/03/x-forwarded-for/) -for the underlying threat model. - -### Extra middlewares & packages - -Please see https://github.com/go-chi for additional packages. - --------------------------------------------------------------------------------------------------------------------- -| package | description | -|:---------------------------------------------------|:------------------------------------------------------------- -| [cors](https://github.com/go-chi/cors) | Cross-origin resource sharing (CORS) | -| [docgen](https://github.com/go-chi/docgen) | Print chi.Router routes at runtime | -| [jwtauth](https://github.com/go-chi/jwtauth) | JWT authentication | -| [hostrouter](https://github.com/go-chi/hostrouter) | Domain/host based request routing | -| [httplog](https://github.com/go-chi/httplog) | Small but powerful structured HTTP request logging | -| [httprate](https://github.com/go-chi/httprate) | HTTP request rate limiter | -| [httptracer](https://github.com/go-chi/httptracer) | HTTP request performance tracing library | -| [httpvcr](https://github.com/go-chi/httpvcr) | Write deterministic tests for external sources | -| [stampede](https://github.com/go-chi/stampede) | HTTP request coalescer | --------------------------------------------------------------------------------------------------------------------- - - -## context? - -`context` is a tiny pkg that provides simple interface to signal context across call stacks -and goroutines. It was originally written by [Sameer Ajmani](https://github.com/Sajmani) -and is available in stdlib since go1.7. - -Learn more at https://blog.golang.org/context - -and.. -* Docs: https://golang.org/pkg/context -* Source: https://github.com/golang/go/tree/master/src/context - - -## Benchmarks - -The benchmark suite: https://github.com/pkieltyka/go-http-routing-benchmark - -Results as of Nov 29, 2020 with Go 1.15.5 on Linux AMD 3950x - -```shell -BenchmarkChi_Param 3075895 384 ns/op 400 B/op 2 allocs/op -BenchmarkChi_Param5 2116603 566 ns/op 400 B/op 2 allocs/op -BenchmarkChi_Param20 964117 1227 ns/op 400 B/op 2 allocs/op -BenchmarkChi_ParamWrite 2863413 420 ns/op 400 B/op 2 allocs/op -BenchmarkChi_GithubStatic 3045488 395 ns/op 400 B/op 2 allocs/op -BenchmarkChi_GithubParam 2204115 540 ns/op 400 B/op 2 allocs/op -BenchmarkChi_GithubAll 10000 113811 ns/op 81203 B/op 406 allocs/op -BenchmarkChi_GPlusStatic 3337485 359 ns/op 400 B/op 2 allocs/op -BenchmarkChi_GPlusParam 2825853 423 ns/op 400 B/op 2 allocs/op -BenchmarkChi_GPlus2Params 2471697 483 ns/op 400 B/op 2 allocs/op -BenchmarkChi_GPlusAll 194220 5950 ns/op 5200 B/op 26 allocs/op -BenchmarkChi_ParseStatic 3365324 356 ns/op 400 B/op 2 allocs/op -BenchmarkChi_ParseParam 2976614 404 ns/op 400 B/op 2 allocs/op -BenchmarkChi_Parse2Params 2638084 439 ns/op 400 B/op 2 allocs/op -BenchmarkChi_ParseAll 109567 11295 ns/op 10400 B/op 52 allocs/op -BenchmarkChi_StaticAll 16846 71308 ns/op 62802 B/op 314 allocs/op -``` - -Comparison with other routers: https://gist.github.com/pkieltyka/123032f12052520aaccab752bd3e78cc - -NOTE: the allocs in the benchmark above are from the calls to http.Request's -`WithContext(context.Context)` method that clones the http.Request, sets the `Context()` -on the duplicated (alloc'd) request and returns it the new request object. This is just -how setting context on a request in Go works. - - -## Credits - -* Carl Jackson for https://github.com/zenazn/goji - * Parts of chi's thinking comes from goji, and chi's middleware package - sources from [goji](https://github.com/zenazn/goji/tree/master/web/middleware). - * Please see goji's [LICENSE](https://github.com/zenazn/goji/blob/master/LICENSE) (MIT) -* Armon Dadgar for https://github.com/armon/go-radix -* Contributions: [@VojtechVitek](https://github.com/VojtechVitek) - -We'll be more than happy to see [your contributions](./CONTRIBUTING.md)! - - -## Beyond REST - -chi is just a http router that lets you decompose request handling into many smaller layers. -Many companies use chi to write REST services for their public APIs. But, REST is just a convention -for managing state via HTTP, and there's a lot of other pieces required to write a complete client-server -system or network of microservices. - -Looking beyond REST, I also recommend some newer works in the field: -* [webrpc](https://github.com/webrpc/webrpc) - Web-focused RPC client+server framework with code-gen -* [gRPC](https://github.com/grpc/grpc-go) - Google's RPC framework via protobufs -* [graphql](https://github.com/99designs/gqlgen) - Declarative query language -* [NATS](https://nats.io) - lightweight pub-sub - - -## License - -Copyright (c) 2015-present [Peter Kieltyka](https://github.com/pkieltyka) - -Licensed under [MIT License](./LICENSE) - -[GoDoc]: https://pkg.go.dev/github.com/go-chi/chi/v5 -[GoDoc Widget]: https://godoc.org/github.com/go-chi/chi?status.svg -[Travis]: https://travis-ci.org/go-chi/chi -[Travis Widget]: https://travis-ci.org/go-chi/chi.svg?branch=master diff --git a/vendor/github.com/go-chi/chi/v5/SECURITY.md b/vendor/github.com/go-chi/chi/v5/SECURITY.md deleted file mode 100644 index 7e937f87f30..00000000000 --- a/vendor/github.com/go-chi/chi/v5/SECURITY.md +++ /dev/null @@ -1,5 +0,0 @@ -# Reporting Security Issues - -We appreciate your efforts to responsibly disclose your findings, and will make every effort to acknowledge your contributions. - -To report a security issue, please use the GitHub Security Advisory ["Report a Vulnerability"](https://github.com/go-chi/chi/security/advisories/new) tab. diff --git a/vendor/github.com/go-chi/chi/v5/chain.go b/vendor/github.com/go-chi/chi/v5/chain.go deleted file mode 100644 index a2278414f40..00000000000 --- a/vendor/github.com/go-chi/chi/v5/chain.go +++ /dev/null @@ -1,49 +0,0 @@ -package chi - -import "net/http" - -// Chain returns a Middlewares type from a slice of middleware handlers. -func Chain(middlewares ...func(http.Handler) http.Handler) Middlewares { - return Middlewares(middlewares) -} - -// Handler builds and returns a http.Handler from the chain of middlewares, -// with `h http.Handler` as the final handler. -func (mws Middlewares) Handler(h http.Handler) http.Handler { - return &ChainHandler{h, chain(mws, h), mws} -} - -// HandlerFunc builds and returns a http.Handler from the chain of middlewares, -// with `h http.Handler` as the final handler. -func (mws Middlewares) HandlerFunc(h http.HandlerFunc) http.Handler { - return &ChainHandler{h, chain(mws, h), mws} -} - -// ChainHandler is a http.Handler with support for handler composition and -// execution. -type ChainHandler struct { - Endpoint http.Handler - chain http.Handler - Middlewares Middlewares -} - -func (c *ChainHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { - c.chain.ServeHTTP(w, r) -} - -// chain builds a http.Handler composed of an inline middleware stack and endpoint -// handler in the order they are passed. -func chain(middlewares []func(http.Handler) http.Handler, endpoint http.Handler) http.Handler { - // Return ahead of time if there aren't any middlewares for the chain - if len(middlewares) == 0 { - return endpoint - } - - // Wrap the end handler with the middleware chain - h := middlewares[len(middlewares)-1](endpoint) - for i := len(middlewares) - 2; i >= 0; i-- { - h = middlewares[i](h) - } - - return h -} diff --git a/vendor/github.com/go-chi/chi/v5/chi.go b/vendor/github.com/go-chi/chi/v5/chi.go deleted file mode 100644 index cb129e3054c..00000000000 --- a/vendor/github.com/go-chi/chi/v5/chi.go +++ /dev/null @@ -1,138 +0,0 @@ -// Package chi is a small, idiomatic and composable router for building HTTP services. -// -// chi supports the four most recent major versions of Go. -// -// Example: -// -// package main -// -// import ( -// "net/http" -// -// "github.com/go-chi/chi/v5" -// "github.com/go-chi/chi/v5/middleware" -// ) -// -// func main() { -// r := chi.NewRouter() -// r.Use(middleware.Logger) -// r.Use(middleware.Recoverer) -// -// r.Get("/", func(w http.ResponseWriter, r *http.Request) { -// w.Write([]byte("root.")) -// }) -// -// http.ListenAndServe(":3333", r) -// } -// -// See github.com/go-chi/chi/_examples/ for more in-depth examples. -// -// URL patterns allow for easy matching of path components in HTTP -// requests. The matching components can then be accessed using -// chi.URLParam(). All patterns must begin with a slash. -// -// A simple named placeholder {name} matches any sequence of characters -// up to the next / or the end of the URL. Trailing slashes on paths must -// be handled explicitly. -// -// A placeholder with a name followed by a colon allows a regular -// expression match, for example {number:\\d+}. The regular expression -// syntax is Go's normal regexp RE2 syntax, except that / will never be -// matched. An anonymous regexp pattern is allowed, using an empty string -// before the colon in the placeholder, such as {:\\d+} -// -// The special placeholder of asterisk matches the rest of the requested -// URL. Any trailing characters in the pattern are ignored. This is the only -// placeholder which will match / characters. -// -// Examples: -// -// "/user/{name}" matches "/user/jsmith" but not "/user/jsmith/info" or "/user/jsmith/" -// "/user/{name}/info" matches "/user/jsmith/info" -// "/page/*" matches "/page/intro/latest" -// "/page/{other}/latest" also matches "/page/intro/latest" -// "/date/{yyyy:\\d\\d\\d\\d}/{mm:\\d\\d}/{dd:\\d\\d}" matches "/date/2017/04/01" -package chi - -import "net/http" - -// NewRouter returns a new Mux object that implements the Router interface. -func NewRouter() *Mux { - return NewMux() -} - -// Router consisting of the core routing methods used by chi's Mux, -// using only the standard net/http. -type Router interface { - http.Handler - Routes - - // Use appends one or more middlewares onto the Router stack. - Use(middlewares ...func(http.Handler) http.Handler) - - // With adds inline middlewares for an endpoint handler. - With(middlewares ...func(http.Handler) http.Handler) Router - - // Group adds a new inline-Router along the current routing - // path, with a fresh middleware stack for the inline-Router. - Group(fn func(r Router)) Router - - // Route mounts a sub-Router along a `pattern` string. - Route(pattern string, fn func(r Router)) Router - - // Mount attaches another http.Handler along ./pattern/* - Mount(pattern string, h http.Handler) - - // Handle and HandleFunc adds routes for `pattern` that matches - // all HTTP methods. - Handle(pattern string, h http.Handler) - HandleFunc(pattern string, h http.HandlerFunc) - - // Method and MethodFunc adds routes for `pattern` that matches - // the `method` HTTP method. - Method(method, pattern string, h http.Handler) - MethodFunc(method, pattern string, h http.HandlerFunc) - - // HTTP-method routing along `pattern` - Connect(pattern string, h http.HandlerFunc) - Delete(pattern string, h http.HandlerFunc) - Get(pattern string, h http.HandlerFunc) - Head(pattern string, h http.HandlerFunc) - Options(pattern string, h http.HandlerFunc) - Patch(pattern string, h http.HandlerFunc) - Post(pattern string, h http.HandlerFunc) - Put(pattern string, h http.HandlerFunc) - Query(pattern string, h http.HandlerFunc) - Trace(pattern string, h http.HandlerFunc) - - // NotFound defines a handler to respond whenever a route could - // not be found. - NotFound(h http.HandlerFunc) - - // MethodNotAllowed defines a handler to respond whenever a method is - // not allowed. - MethodNotAllowed(h http.HandlerFunc) -} - -// Routes interface adds two methods for router traversal, which is also -// used by the `docgen` subpackage to generation documentation for Routers. -type Routes interface { - // Routes returns the routing tree in an easily traversable structure. - Routes() []Route - - // Middlewares returns the list of middlewares in use by the router. - Middlewares() Middlewares - - // Match searches the routing tree for a handler that matches - // the method/path - similar to routing a http request, but without - // executing the handler thereafter. - Match(rctx *Context, method, path string) bool - - // Find searches the routing tree for the pattern that matches - // the method/path. - Find(rctx *Context, method, path string) string -} - -// Middlewares type is a slice of standard middleware handlers with methods -// to compose middleware chains and http.Handler's. -type Middlewares []func(http.Handler) http.Handler diff --git a/vendor/github.com/go-chi/chi/v5/context.go b/vendor/github.com/go-chi/chi/v5/context.go deleted file mode 100644 index 82220730e99..00000000000 --- a/vendor/github.com/go-chi/chi/v5/context.go +++ /dev/null @@ -1,166 +0,0 @@ -package chi - -import ( - "context" - "net/http" - "strings" -) - -// URLParam returns the url parameter from a http.Request object. -func URLParam(r *http.Request, key string) string { - if rctx := RouteContext(r.Context()); rctx != nil { - return rctx.URLParam(key) - } - return "" -} - -// URLParamFromCtx returns the url parameter from a http.Request Context. -func URLParamFromCtx(ctx context.Context, key string) string { - if rctx := RouteContext(ctx); rctx != nil { - return rctx.URLParam(key) - } - return "" -} - -// RouteContext returns chi's routing Context object from a -// http.Request Context. -func RouteContext(ctx context.Context) *Context { - val, _ := ctx.Value(RouteCtxKey).(*Context) - return val -} - -// NewRouteContext returns a new routing Context object. -func NewRouteContext() *Context { - return &Context{} -} - -var ( - // RouteCtxKey is the context.Context key to store the request context. - RouteCtxKey = &contextKey{"RouteContext"} -) - -// Context is the default routing context set on the root node of a -// request context to track route patterns, URL parameters and -// an optional routing path. -type Context struct { - Routes Routes - - // parentCtx is the parent of this one, for using Context as a - // context.Context directly. This is an optimization that saves - // 1 allocation. - parentCtx context.Context - - // Routing path/method override used during the route search. - // See Mux#routeHTTP method. - RoutePath string - RouteMethod string - - // URLParams are the stack of routeParams captured during the - // routing lifecycle across a stack of sub-routers. - URLParams RouteParams - - // Route parameters matched for the current sub-router. It is - // intentionally unexported so it can't be tampered. - routeParams RouteParams - - // The endpoint routing pattern that matched the request URI path - // or `RoutePath` of the current sub-router. This value will update - // during the lifecycle of a request passing through a stack of - // sub-routers. - routePattern string - - // Routing pattern stack throughout the lifecycle of the request, - // across all connected routers. It is a record of all matching - // patterns across a stack of sub-routers. - RoutePatterns []string - - methodsAllowed []methodTyp // allowed methods in case of a 405 - methodNotAllowed bool -} - -// Reset a routing context to its initial state. -func (x *Context) Reset() { - x.Routes = nil - x.RoutePath = "" - x.RouteMethod = "" - x.RoutePatterns = x.RoutePatterns[:0] - x.URLParams.Keys = x.URLParams.Keys[:0] - x.URLParams.Values = x.URLParams.Values[:0] - - x.routePattern = "" - x.routeParams.Keys = x.routeParams.Keys[:0] - x.routeParams.Values = x.routeParams.Values[:0] - x.methodNotAllowed = false - x.methodsAllowed = x.methodsAllowed[:0] - x.parentCtx = nil -} - -// URLParam returns the corresponding URL parameter value from the request -// routing context. -func (x *Context) URLParam(key string) string { - for k := len(x.URLParams.Keys) - 1; k >= 0; k-- { - if x.URLParams.Keys[k] == key { - return x.URLParams.Values[k] - } - } - return "" -} - -// RoutePattern builds the routing pattern string for the particular -// request, at the particular point during routing. This means, the value -// will change throughout the execution of a request in a router. That is -// why it's advised to only use this value after calling the next handler. -// -// For example, -// -// func Instrument(next http.Handler) http.Handler { -// return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { -// next.ServeHTTP(w, r) -// routePattern := chi.RouteContext(r.Context()).RoutePattern() -// measure(w, r, routePattern) -// }) -// } -func (x *Context) RoutePattern() string { - if x == nil { - return "" - } - routePattern := strings.Join(x.RoutePatterns, "") - routePattern = replaceWildcards(routePattern) - if routePattern != "/" { - routePattern = strings.TrimSuffix(routePattern, "//") - routePattern = strings.TrimSuffix(routePattern, "/") - } - return routePattern -} - -// replaceWildcards takes a route pattern and replaces all occurrences of -// "/*/" with "/". It iteratively runs until no wildcards remain to -// correctly handle consecutive wildcards. -func replaceWildcards(p string) string { - for strings.Contains(p, "/*/") { - p = strings.ReplaceAll(p, "/*/", "/") - } - return p -} - -// RouteParams is a structure to track URL routing parameters efficiently. -type RouteParams struct { - Keys, Values []string -} - -// Add will append a URL parameter to the end of the route param -func (s *RouteParams) Add(key, value string) { - s.Keys = append(s.Keys, key) - s.Values = append(s.Values, value) -} - -// contextKey is a value for use with context.WithValue. It's used as -// a pointer so it fits in an interface{} without allocation. This technique -// for defining context keys was copied from Go 1.7's new use of context in net/http. -type contextKey struct { - name string -} - -func (k *contextKey) String() string { - return "chi context value " + k.name -} diff --git a/vendor/github.com/go-chi/chi/v5/mux.go b/vendor/github.com/go-chi/chi/v5/mux.go deleted file mode 100644 index 37cd50043f4..00000000000 --- a/vendor/github.com/go-chi/chi/v5/mux.go +++ /dev/null @@ -1,532 +0,0 @@ -package chi - -import ( - "context" - "fmt" - "net/http" - "strings" - "sync" -) - -var _ Router = &Mux{} - -// Mux is a simple HTTP route multiplexer that parses a request path, -// records any URL params, and executes an end handler. It implements -// the http.Handler interface and is friendly with the standard library. -// -// Mux is designed to be fast, minimal and offer a powerful API for building -// modular and composable HTTP services with a large set of handlers. It's -// particularly useful for writing large REST API services that break a handler -// into many smaller parts composed of middlewares and end handlers. -type Mux struct { - // The computed mux handler made of the chained middleware stack and - // the tree router - handler http.Handler - - // The radix trie router - tree *node - - // Custom method not allowed handler - methodNotAllowedHandler http.HandlerFunc - - // A reference to the parent mux used by subrouters when mounting - // to a parent mux - parent *Mux - - // Routing context pool - pool *sync.Pool - - // Custom route not found handler - notFoundHandler http.HandlerFunc - - // The middleware stack - middlewares []func(http.Handler) http.Handler - - // Controls the behaviour of middleware chain generation when a mux - // is registered as an inline group inside another mux. - inline bool -} - -// NewMux returns a newly initialized Mux object that implements the Router -// interface. -func NewMux() *Mux { - mux := &Mux{tree: &node{}, pool: &sync.Pool{}} - mux.pool.New = func() interface{} { - return NewRouteContext() - } - return mux -} - -// ServeHTTP is the single method of the http.Handler interface that makes -// Mux interoperable with the standard library. It uses a sync.Pool to get and -// reuse routing contexts for each request. -func (mx *Mux) ServeHTTP(w http.ResponseWriter, r *http.Request) { - // Ensure the mux has some routes defined on the mux - if mx.handler == nil { - mx.NotFoundHandler().ServeHTTP(w, r) - return - } - - // Check if a routing context already exists from a parent router. - rctx, _ := r.Context().Value(RouteCtxKey).(*Context) - if rctx != nil { - mx.handler.ServeHTTP(w, r) - return - } - - // Fetch a RouteContext object from the sync pool, and call the computed - // mx.handler that is comprised of mx.middlewares + mx.routeHTTP. - // Once the request is finished, reset the routing context and put it back - // into the pool for reuse from another request. - rctx = mx.pool.Get().(*Context) - rctx.Reset() - rctx.Routes = mx - rctx.parentCtx = r.Context() - - // NOTE: r.WithContext() causes 2 allocations and context.WithValue() causes 1 allocation - r = r.WithContext(context.WithValue(r.Context(), RouteCtxKey, rctx)) - - // Serve the request and once its done, put the request context back in the sync pool - mx.handler.ServeHTTP(w, r) - mx.pool.Put(rctx) -} - -// Use appends a middleware handler to the Mux middleware stack. -// -// The middleware stack for any Mux will execute before searching for a matching -// route to a specific handler, which provides opportunity to respond early, -// change the course of the request execution, or set request-scoped values for -// the next http.Handler. -func (mx *Mux) Use(middlewares ...func(http.Handler) http.Handler) { - if mx.handler != nil { - panic("chi: all middlewares must be defined before routes on a mux") - } - mx.middlewares = append(mx.middlewares, middlewares...) -} - -// Handle adds the route `pattern` that matches any http method to -// execute the `handler` http.Handler. -func (mx *Mux) Handle(pattern string, handler http.Handler) { - if i := strings.IndexAny(pattern, " \t"); i >= 0 { - method, rest := pattern[:i], strings.TrimLeft(pattern[i+1:], " \t") - mx.Method(method, rest, handler) - return - } - - mx.handle(mALL, pattern, handler) -} - -// HandleFunc adds the route `pattern` that matches any http method to -// execute the `handlerFn` http.HandlerFunc. -func (mx *Mux) HandleFunc(pattern string, handlerFn http.HandlerFunc) { - mx.Handle(pattern, handlerFn) -} - -// Method adds the route `pattern` that matches `method` http method to -// execute the `handler` http.Handler. -func (mx *Mux) Method(method, pattern string, handler http.Handler) { - m, ok := methodMap[strings.ToUpper(method)] - if !ok { - panic(fmt.Sprintf("chi: '%s' http method is not supported.", method)) - } - mx.handle(m, pattern, handler) -} - -// MethodFunc adds the route `pattern` that matches `method` http method to -// execute the `handlerFn` http.HandlerFunc. -func (mx *Mux) MethodFunc(method, pattern string, handlerFn http.HandlerFunc) { - mx.Method(method, pattern, handlerFn) -} - -// Connect adds the route `pattern` that matches a CONNECT http method to -// execute the `handlerFn` http.HandlerFunc. -func (mx *Mux) Connect(pattern string, handlerFn http.HandlerFunc) { - mx.handle(mCONNECT, pattern, handlerFn) -} - -// Delete adds the route `pattern` that matches a DELETE http method to -// execute the `handlerFn` http.HandlerFunc. -func (mx *Mux) Delete(pattern string, handlerFn http.HandlerFunc) { - mx.handle(mDELETE, pattern, handlerFn) -} - -// Get adds the route `pattern` that matches a GET http method to -// execute the `handlerFn` http.HandlerFunc. -func (mx *Mux) Get(pattern string, handlerFn http.HandlerFunc) { - mx.handle(mGET, pattern, handlerFn) -} - -// Head adds the route `pattern` that matches a HEAD http method to -// execute the `handlerFn` http.HandlerFunc. -func (mx *Mux) Head(pattern string, handlerFn http.HandlerFunc) { - mx.handle(mHEAD, pattern, handlerFn) -} - -// Options adds the route `pattern` that matches an OPTIONS http method to -// execute the `handlerFn` http.HandlerFunc. -func (mx *Mux) Options(pattern string, handlerFn http.HandlerFunc) { - mx.handle(mOPTIONS, pattern, handlerFn) -} - -// Patch adds the route `pattern` that matches a PATCH http method to -// execute the `handlerFn` http.HandlerFunc. -func (mx *Mux) Patch(pattern string, handlerFn http.HandlerFunc) { - mx.handle(mPATCH, pattern, handlerFn) -} - -// Post adds the route `pattern` that matches a POST http method to -// execute the `handlerFn` http.HandlerFunc. -func (mx *Mux) Post(pattern string, handlerFn http.HandlerFunc) { - mx.handle(mPOST, pattern, handlerFn) -} - -// Put adds the route `pattern` that matches a PUT http method to -// execute the `handlerFn` http.HandlerFunc. -func (mx *Mux) Put(pattern string, handlerFn http.HandlerFunc) { - mx.handle(mPUT, pattern, handlerFn) -} - -// Query adds the route `pattern` that matches a QUERY http method to -// execute the `handlerFn` http.HandlerFunc. -func (mx *Mux) Query(pattern string, handlerFn http.HandlerFunc) { - mx.handle(mQUERY, pattern, handlerFn) -} - -// Trace adds the route `pattern` that matches a TRACE http method to -// execute the `handlerFn` http.HandlerFunc. -func (mx *Mux) Trace(pattern string, handlerFn http.HandlerFunc) { - mx.handle(mTRACE, pattern, handlerFn) -} - -// NotFound sets a custom http.HandlerFunc for routing paths that could -// not be found. The default 404 handler is `http.NotFound`. -func (mx *Mux) NotFound(handlerFn http.HandlerFunc) { - // Build NotFound handler chain - m := mx - hFn := handlerFn - if mx.inline && mx.parent != nil { - m = mx.parent - hFn = Chain(mx.middlewares...).HandlerFunc(hFn).ServeHTTP - } - - // Update the notFoundHandler from this point forward - m.notFoundHandler = hFn - m.updateSubRoutes(func(subMux *Mux) { - if subMux.notFoundHandler == nil { - subMux.NotFound(hFn) - } - }) -} - -// MethodNotAllowed sets a custom http.HandlerFunc for routing paths where the -// method is unresolved. The default handler returns a 405 with an empty body. -func (mx *Mux) MethodNotAllowed(handlerFn http.HandlerFunc) { - // Build MethodNotAllowed handler chain - m := mx - hFn := handlerFn - if mx.inline && mx.parent != nil { - m = mx.parent - hFn = Chain(mx.middlewares...).HandlerFunc(hFn).ServeHTTP - } - - // Update the methodNotAllowedHandler from this point forward - m.methodNotAllowedHandler = hFn - m.updateSubRoutes(func(subMux *Mux) { - if subMux.methodNotAllowedHandler == nil { - subMux.MethodNotAllowed(hFn) - } - }) -} - -// With adds inline middlewares for an endpoint handler. -func (mx *Mux) With(middlewares ...func(http.Handler) http.Handler) Router { - // Similarly as in handle(), we must build the mux handler once additional - // middleware registration isn't allowed for this stack, like now. - if !mx.inline && mx.handler == nil { - mx.updateRouteHandler() - } - - // Copy middlewares from parent inline muxs - var mws Middlewares - if mx.inline { - mws = make(Middlewares, len(mx.middlewares)) - copy(mws, mx.middlewares) - } - mws = append(mws, middlewares...) - - im := &Mux{ - pool: mx.pool, inline: true, parent: mx, tree: mx.tree, middlewares: mws, - notFoundHandler: mx.notFoundHandler, methodNotAllowedHandler: mx.methodNotAllowedHandler, - } - - return im -} - -// Group creates a new inline-Mux with a copy of middleware stack. It's useful -// for a group of handlers along the same routing path that use an additional -// set of middlewares. See _examples/. -func (mx *Mux) Group(fn func(r Router)) Router { - im := mx.With() - if fn != nil { - fn(im) - } - return im -} - -// Route creates a new Mux and mounts it along the `pattern` as a subrouter. -// Effectively, this is a short-hand call to Mount. See _examples/. -func (mx *Mux) Route(pattern string, fn func(r Router)) Router { - if fn == nil { - panic(fmt.Sprintf("chi: attempting to Route() a nil subrouter on '%s'", pattern)) - } - subRouter := NewRouter() - fn(subRouter) - mx.Mount(pattern, subRouter) - return subRouter -} - -// Mount attaches another http.Handler or chi Router as a subrouter along a routing -// path. It's very useful to split up a large API as many independent routers and -// compose them as a single service using Mount. See _examples/. -// -// Note that Mount() simply sets a wildcard along the `pattern` that will continue -// routing at the `handler`, which in most cases is another chi.Router. As a result, -// if you define two Mount() routes on the exact same pattern the mount will panic. -func (mx *Mux) Mount(pattern string, handler http.Handler) { - if handler == nil { - panic(fmt.Sprintf("chi: attempting to Mount() a nil handler on '%s'", pattern)) - } - - // Provide runtime safety for ensuring a pattern isn't mounted on an existing - // routing pattern. - if mx.tree.findPattern(pattern+"*") || mx.tree.findPattern(pattern+"/*") { - panic(fmt.Sprintf("chi: attempting to Mount() a handler on an existing path, '%s'", pattern)) - } - - // Assign sub-Router's with the parent not found & method not allowed handler if not specified. - subr, ok := handler.(*Mux) - if ok && subr.notFoundHandler == nil && mx.notFoundHandler != nil { - subr.NotFound(mx.notFoundHandler) - } - if ok && subr.methodNotAllowedHandler == nil && mx.methodNotAllowedHandler != nil { - subr.MethodNotAllowed(mx.methodNotAllowedHandler) - } - - mountHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - rctx := RouteContext(r.Context()) - - // shift the url path past the previous subrouter - rctx.RoutePath = mx.nextRoutePath(rctx) - - // reset the wildcard URLParam which connects the subrouter - n := len(rctx.URLParams.Keys) - 1 - if n >= 0 && rctx.URLParams.Keys[n] == "*" && len(rctx.URLParams.Values) > n { - rctx.URLParams.Values[n] = "" - } - - handler.ServeHTTP(w, r) - }) - - if pattern == "" || pattern[len(pattern)-1] != '/' { - mx.handle(mALL|mSTUB, pattern, mountHandler) - mx.handle(mALL|mSTUB, pattern+"/", mountHandler) - pattern += "/" - } - - method := mALL - subroutes, _ := handler.(Routes) - if subroutes != nil { - method |= mSTUB - } - n := mx.handle(method, pattern+"*", mountHandler) - - if subroutes != nil { - n.subroutes = subroutes - } -} - -// Routes returns a slice of routing information from the tree, -// useful for traversing available routes of a router. -func (mx *Mux) Routes() []Route { - return mx.tree.routes() -} - -// Middlewares returns a slice of middleware handler functions. -func (mx *Mux) Middlewares() Middlewares { - return mx.middlewares -} - -// Match searches the routing tree for a handler that matches the method/path. -// It's similar to routing a http request, but without executing the handler -// thereafter. -// -// Note: the *Context state is updated during execution, so manage -// the state carefully or make a NewRouteContext(). -func (mx *Mux) Match(rctx *Context, method, path string) bool { - return mx.Find(rctx, method, path) != "" -} - -// Find searches the routing tree for the pattern that matches -// the method/path. -// -// Note: the *Context state is updated during execution, so manage -// the state carefully or make a NewRouteContext(). -func (mx *Mux) Find(rctx *Context, method, path string) string { - m, ok := methodMap[method] - if !ok { - return "" - } - - node, _, _ := mx.tree.FindRoute(rctx, m, path) - pattern := rctx.routePattern - - if node != nil { - if node.subroutes == nil { - e := node.endpoints[m] - return e.pattern - } - - rctx.RoutePath = mx.nextRoutePath(rctx) - subPattern := node.subroutes.Find(rctx, method, rctx.RoutePath) - if subPattern == "" { - return "" - } - - pattern = strings.TrimSuffix(pattern, "/*") - pattern += subPattern - } - - return pattern -} - -// NotFoundHandler returns the default Mux 404 responder whenever a route -// cannot be found. -func (mx *Mux) NotFoundHandler() http.HandlerFunc { - if mx.notFoundHandler != nil { - return mx.notFoundHandler - } - return http.NotFound -} - -// MethodNotAllowedHandler returns the default Mux 405 responder whenever -// a method cannot be resolved for a route. -func (mx *Mux) MethodNotAllowedHandler(methodsAllowed ...methodTyp) http.HandlerFunc { - if mx.methodNotAllowedHandler != nil { - return mx.methodNotAllowedHandler - } - return methodNotAllowedHandler(methodsAllowed...) -} - -// handle registers a http.Handler in the routing tree for a particular http method -// and routing pattern. -func (mx *Mux) handle(method methodTyp, pattern string, handler http.Handler) *node { - if len(pattern) == 0 || pattern[0] != '/' { - panic(fmt.Sprintf("chi: routing pattern must begin with '/' in '%s'", pattern)) - } - - // Build the computed routing handler for this routing pattern. - if !mx.inline && mx.handler == nil { - mx.updateRouteHandler() - } - - // Build endpoint handler with inline middlewares for the route - var h http.Handler - if mx.inline { - mx.handler = http.HandlerFunc(mx.routeHTTP) - h = Chain(mx.middlewares...).Handler(handler) - } else { - h = handler - } - - // Add the endpoint to the tree and return the node - return mx.tree.InsertRoute(method, pattern, h) -} - -// routeHTTP routes a http.Request through the Mux routing tree to serve -// the matching handler for a particular http method. -func (mx *Mux) routeHTTP(w http.ResponseWriter, r *http.Request) { - // Grab the route context object - rctx := r.Context().Value(RouteCtxKey).(*Context) - - // The request routing path - routePath := rctx.RoutePath - if routePath == "" { - if r.URL.RawPath != "" { - routePath = r.URL.RawPath - } else { - routePath = r.URL.Path - } - if routePath == "" { - routePath = "/" - } - } - - // Check if method is supported by chi - if rctx.RouteMethod == "" { - rctx.RouteMethod = r.Method - } - method, ok := methodMap[rctx.RouteMethod] - if !ok { - mx.MethodNotAllowedHandler().ServeHTTP(w, r) - return - } - - // Find the route - if _, _, h := mx.tree.FindRoute(rctx, method, routePath); h != nil { - // Set http.Request path values from our request context - for i, key := range rctx.URLParams.Keys { - value := rctx.URLParams.Values[i] - r.SetPathValue(key, value) - } - r.Pattern = rctx.RoutePattern() - - h.ServeHTTP(w, r) - return - } - if rctx.methodNotAllowed { - mx.MethodNotAllowedHandler(rctx.methodsAllowed...).ServeHTTP(w, r) - } else { - mx.NotFoundHandler().ServeHTTP(w, r) - } -} - -func (mx *Mux) nextRoutePath(rctx *Context) string { - routePath := "/" - nx := len(rctx.routeParams.Keys) - 1 // index of last param in list - if nx >= 0 && rctx.routeParams.Keys[nx] == "*" && len(rctx.routeParams.Values) > nx { - routePath = "/" + rctx.routeParams.Values[nx] - } - return routePath -} - -// Recursively update data on child routers. -func (mx *Mux) updateSubRoutes(fn func(subMux *Mux)) { - for _, r := range mx.tree.routes() { - subMux, ok := r.SubRoutes.(*Mux) - if !ok { - continue - } - fn(subMux) - } -} - -// updateRouteHandler builds the single mux handler that is a chain of the middleware -// stack, as defined by calls to Use(), and the tree router (Mux) itself. After this -// point, no other middlewares can be registered on this Mux's stack. But you can still -// compose additional middlewares via Group()'s or using a chained middleware handler. -func (mx *Mux) updateRouteHandler() { - mx.handler = chain(mx.middlewares, http.HandlerFunc(mx.routeHTTP)) -} - -// methodNotAllowedHandler is a helper function to respond with a 405, -// method not allowed. It sets the Allow header with the list of allowed -// methods for the route. -func methodNotAllowedHandler(methodsAllowed ...methodTyp) func(w http.ResponseWriter, r *http.Request) { - return func(w http.ResponseWriter, r *http.Request) { - for _, m := range methodsAllowed { - w.Header().Add("Allow", reverseMethodMap[m]) - } - w.WriteHeader(405) - w.Write(nil) - } -} diff --git a/vendor/github.com/go-chi/chi/v5/tree.go b/vendor/github.com/go-chi/chi/v5/tree.go deleted file mode 100644 index 74ff43db16e..00000000000 --- a/vendor/github.com/go-chi/chi/v5/tree.go +++ /dev/null @@ -1,885 +0,0 @@ -package chi - -// Radix tree implementation below is a based on the original work by -// Armon Dadgar in https://github.com/armon/go-radix/blob/master/radix.go -// (MIT licensed). It's been heavily modified for use as a HTTP routing tree. - -import ( - "fmt" - "net/http" - "regexp" - "slices" - "sort" - "strconv" - "strings" -) - -type methodTyp uint - -const ( - mSTUB methodTyp = 1 << iota - mCONNECT - mDELETE - mGET - mHEAD - mOPTIONS - mPATCH - mPOST - mPUT - mQUERY - mTRACE -) - -var mALL = mCONNECT | mDELETE | mGET | mHEAD | - mOPTIONS | mPATCH | mPOST | mPUT | mQUERY | mTRACE - -// methodQuery is the HTTP QUERY method (RFC 10008), a safe, idempotent -// method that conveys a request body. It is defined here until net/http -// provides an equivalent constant, at which point this is a 1-1 swap. -const methodQuery = "QUERY" - -var methodMap = map[string]methodTyp{ - http.MethodConnect: mCONNECT, - http.MethodDelete: mDELETE, - http.MethodGet: mGET, - http.MethodHead: mHEAD, - http.MethodOptions: mOPTIONS, - http.MethodPatch: mPATCH, - http.MethodPost: mPOST, - http.MethodPut: mPUT, - methodQuery: mQUERY, - http.MethodTrace: mTRACE, -} - -var reverseMethodMap = map[methodTyp]string{ - mCONNECT: http.MethodConnect, - mDELETE: http.MethodDelete, - mGET: http.MethodGet, - mHEAD: http.MethodHead, - mOPTIONS: http.MethodOptions, - mPATCH: http.MethodPatch, - mPOST: http.MethodPost, - mPUT: http.MethodPut, - mQUERY: methodQuery, - mTRACE: http.MethodTrace, -} - -// RegisterMethod adds support for custom HTTP method handlers, available -// via Router#Method and Router#MethodFunc -func RegisterMethod(method string) { - if method == "" { - return - } - method = strings.ToUpper(method) - if _, ok := methodMap[method]; ok { - return - } - n := len(methodMap) - if n > strconv.IntSize-2 { - panic(fmt.Sprintf("chi: max number of methods reached (%d)", strconv.IntSize)) - } - mt := methodTyp(2 << n) - methodMap[method] = mt - reverseMethodMap[mt] = method - mALL |= mt -} - -type nodeTyp uint8 - -const ( - ntStatic nodeTyp = iota // /home - ntRegexp // /{id:[0-9]+} - ntParam // /{user} - ntCatchAll // /api/v1/* -) - -type node struct { - // subroutes on the leaf node - subroutes Routes - - // regexp matcher for regexp nodes - rex *regexp.Regexp - - // HTTP handler endpoints on the leaf node - endpoints endpoints - - // prefix is the common prefix we ignore - prefix string - - // child nodes should be stored in-order for iteration, - // in groups of the node type. - children [ntCatchAll + 1]nodes - - // first byte of the child prefix - tail byte - - // node type: static, regexp, param, catchAll - typ nodeTyp - - // first byte of the prefix - label byte -} - -// endpoints is a mapping of http method constants to handlers -// for a given route. -type endpoints map[methodTyp]*endpoint - -type endpoint struct { - // endpoint handler - handler http.Handler - - // pattern is the routing pattern for handler nodes - pattern string - - // parameter keys recorded on handler nodes - paramKeys []string -} - -func (s endpoints) Value(method methodTyp) *endpoint { - mh, ok := s[method] - if !ok { - mh = &endpoint{} - s[method] = mh - } - return mh -} - -func (n *node) InsertRoute(method methodTyp, pattern string, handler http.Handler) *node { - var parent *node - search := pattern - - for { - // Handle key exhaustion - if len(search) == 0 { - // Insert or update the node's leaf handler - n.setEndpoint(method, handler, pattern) - return n - } - - // We're going to be searching for a wild node next, - // in this case, we need to get the tail - var label = search[0] - var segTail byte - var segEndIdx int - var segTyp nodeTyp - var segRexpat string - if label == '{' || label == '*' { - segTyp, _, segRexpat, segTail, _, segEndIdx = patNextSegment(search) - } - - var prefix string - if segTyp == ntRegexp { - prefix = segRexpat - } - - // Look for the edge to attach to - parent = n - n = n.getEdge(segTyp, label, segTail, prefix) - - // No edge, create one - if n == nil { - child := &node{label: label, tail: segTail, prefix: search} - hn := parent.addChild(child, search) - hn.setEndpoint(method, handler, pattern) - - return hn - } - - // Found an edge to match the pattern - - if n.typ > ntStatic { - // We found a param node, trim the param from the search path and continue. - // This param/wild pattern segment would already be on the tree from a previous - // call to addChild when creating a new node. - search = search[segEndIdx:] - continue - } - - // Static nodes fall below here. - // Determine longest prefix of the search key on match. - commonPrefix := longestPrefix(search, n.prefix) - if commonPrefix == len(n.prefix) { - // the common prefix is as long as the current node's prefix we're attempting to insert. - // keep the search going. - search = search[commonPrefix:] - continue - } - - // Split the node - child := &node{ - typ: ntStatic, - prefix: search[:commonPrefix], - } - parent.replaceChild(search[0], segTail, child) - - // Restore the existing node - n.label = n.prefix[commonPrefix] - n.prefix = n.prefix[commonPrefix:] - child.addChild(n, n.prefix) - - // If the new key is a subset, set the method/handler on this node and finish. - search = search[commonPrefix:] - if len(search) == 0 { - child.setEndpoint(method, handler, pattern) - return child - } - - // Create a new edge for the node - subchild := &node{ - typ: ntStatic, - label: search[0], - prefix: search, - } - hn := child.addChild(subchild, search) - hn.setEndpoint(method, handler, pattern) - return hn - } -} - -// addChild appends the new `child` node to the tree using the `pattern` as the trie key. -// For a URL router like chi's, we split the static, param, regexp and wildcard segments -// into different nodes. In addition, addChild will recursively call itself until every -// pattern segment is added to the url pattern tree as individual nodes, depending on type. -func (n *node) addChild(child *node, prefix string) *node { - search := prefix - - // handler leaf node added to the tree is the child. - // this may be overridden later down the flow - hn := child - - // Parse next segment - segTyp, _, segRexpat, segTail, segStartIdx, segEndIdx := patNextSegment(search) - - // Add child depending on next up segment - switch segTyp { - - case ntStatic: - // Search prefix is all static (that is, has no params in path) - // noop - - default: - // Search prefix contains a param, regexp or wildcard - - if segTyp == ntRegexp { - rex, err := regexp.Compile(segRexpat) - if err != nil { - panic(fmt.Sprintf("chi: invalid regexp pattern '%s' in route param", segRexpat)) - } - child.prefix = segRexpat - child.rex = rex - } - - if segStartIdx == 0 { - // Route starts with a param - child.typ = segTyp - - if segTyp == ntCatchAll { - segStartIdx = -1 - } else { - segStartIdx = segEndIdx - } - if segStartIdx < 0 { - segStartIdx = len(search) - } - child.tail = segTail // for params, we set the tail - - if segStartIdx != len(search) { - // add static edge for the remaining part, split the end. - // its not possible to have adjacent param nodes, so its certainly - // going to be a static node next. - - search = search[segStartIdx:] // advance search position - - nn := &node{ - typ: ntStatic, - label: search[0], - prefix: search, - } - hn = child.addChild(nn, search) - } - - } else if segStartIdx > 0 { - // Route has some param - - // starts with a static segment - child.typ = ntStatic - child.prefix = search[:segStartIdx] - child.rex = nil - - // add the param edge node - search = search[segStartIdx:] - - nn := &node{ - typ: segTyp, - label: search[0], - tail: segTail, - } - hn = child.addChild(nn, search) - - } - } - - n.children[child.typ] = append(n.children[child.typ], child) - n.children[child.typ].Sort() - return hn -} - -func (n *node) replaceChild(label, tail byte, child *node) { - for i := 0; i < len(n.children[child.typ]); i++ { - if n.children[child.typ][i].label == label && n.children[child.typ][i].tail == tail { - n.children[child.typ][i] = child - n.children[child.typ][i].label = label - n.children[child.typ][i].tail = tail - return - } - } - panic("chi: replacing missing child") -} - -func (n *node) getEdge(ntyp nodeTyp, label, tail byte, prefix string) *node { - nds := n.children[ntyp] - for i := range nds { - if nds[i].label == label && nds[i].tail == tail { - if ntyp == ntRegexp && nds[i].prefix != prefix { - continue - } - return nds[i] - } - } - return nil -} - -func (n *node) setEndpoint(method methodTyp, handler http.Handler, pattern string) { - // Set the handler for the method type on the node - if n.endpoints == nil { - n.endpoints = make(endpoints) - } - - paramKeys := patParamKeys(pattern) - - if method&mSTUB == mSTUB { - n.endpoints.Value(mSTUB).handler = handler - } - if method&mALL == mALL { - h := n.endpoints.Value(mALL) - h.handler = handler - h.pattern = pattern - h.paramKeys = paramKeys - for _, m := range methodMap { - h := n.endpoints.Value(m) - h.handler = handler - h.pattern = pattern - h.paramKeys = paramKeys - } - } else { - h := n.endpoints.Value(method) - h.handler = handler - h.pattern = pattern - h.paramKeys = paramKeys - } -} - -func (n *node) FindRoute(rctx *Context, method methodTyp, path string) (*node, endpoints, http.Handler) { - // Reset the context routing pattern and params - rctx.routePattern = "" - rctx.routeParams.Keys = rctx.routeParams.Keys[:0] - rctx.routeParams.Values = rctx.routeParams.Values[:0] - - // Find the routing handlers for the path - rn := n.findRoute(rctx, method, path) - if rn == nil { - return nil, nil, nil - } - - // Record the routing params in the request lifecycle - rctx.URLParams.Keys = append(rctx.URLParams.Keys, rctx.routeParams.Keys...) - rctx.URLParams.Values = append(rctx.URLParams.Values, rctx.routeParams.Values...) - - // Record the routing pattern in the request lifecycle - if rn.endpoints[method].pattern != "" { - rctx.routePattern = rn.endpoints[method].pattern - rctx.RoutePatterns = append(rctx.RoutePatterns, rctx.routePattern) - } - - return rn, rn.endpoints, rn.endpoints[method].handler -} - -// Recursive edge traversal by checking all nodeTyp groups along the way. -// It's like searching through a multi-dimensional radix trie. -func (n *node) findRoute(rctx *Context, method methodTyp, path string) *node { - nn := n - search := path - - for t, nds := range nn.children { - ntyp := nodeTyp(t) - if len(nds) == 0 { - continue - } - - var xn *node - xsearch := search - - var label byte - if search != "" { - label = search[0] - } - - switch ntyp { - case ntStatic: - xn = nds.findEdge(label) - if xn == nil || !strings.HasPrefix(xsearch, xn.prefix) { - continue - } - xsearch = xsearch[len(xn.prefix):] - - case ntParam, ntRegexp: - // short-circuit and return no matching route for empty param values - if xsearch == "" { - continue - } - - // serially loop through each node grouped by the tail delimiter - for _, xn = range nds { - // label for param nodes is the delimiter byte - p := strings.IndexByte(xsearch, xn.tail) - - if p < 0 { - if xn.tail == '/' { - p = len(xsearch) - } else { - continue - } - } else if ntyp == ntRegexp && p == 0 { - continue - } - - if ntyp == ntRegexp && xn.rex != nil { - if !xn.rex.MatchString(xsearch[:p]) { - continue - } - } else if strings.IndexByte(xsearch[:p], '/') != -1 { - // avoid a match across path segments - continue - } - - prevlen := len(rctx.routeParams.Values) - rctx.routeParams.Values = append(rctx.routeParams.Values, xsearch[:p]) - xsearch = xsearch[p:] - - if len(xsearch) == 0 { - if xn.isLeaf() { - h := xn.endpoints[method] - if h != nil && h.handler != nil { - rctx.routeParams.Keys = append(rctx.routeParams.Keys, h.paramKeys...) - return xn - } - - for endpoints := range xn.endpoints { - if endpoints == mALL || endpoints == mSTUB { - continue - } - rctx.methodsAllowed = append(rctx.methodsAllowed, endpoints) - } - - // flag that the routing context found a route, but not a corresponding - // supported method - rctx.methodNotAllowed = true - } - } - - // recursively find the next node on this branch - fin := xn.findRoute(rctx, method, xsearch) - if fin != nil { - return fin - } - - // not found on this branch, reset vars - rctx.routeParams.Values = rctx.routeParams.Values[:prevlen] - xsearch = search - } - - rctx.routeParams.Values = append(rctx.routeParams.Values, "") - - default: - // catch-all nodes - rctx.routeParams.Values = append(rctx.routeParams.Values, search) - xn = nds[0] - xsearch = "" - } - - if xn == nil { - continue - } - - // did we find it yet? - if len(xsearch) == 0 { - if xn.isLeaf() { - h := xn.endpoints[method] - if h != nil && h.handler != nil { - rctx.routeParams.Keys = append(rctx.routeParams.Keys, h.paramKeys...) - return xn - } - - for endpoints := range xn.endpoints { - if endpoints == mALL || endpoints == mSTUB { - continue - } - rctx.methodsAllowed = append(rctx.methodsAllowed, endpoints) - } - - // flag that the routing context found a route, but not a corresponding - // supported method - rctx.methodNotAllowed = true - } - } - - // recursively find the next node.. - fin := xn.findRoute(rctx, method, xsearch) - if fin != nil { - return fin - } - - // Did not find final handler, let's remove the param here if it was set - if xn.typ > ntStatic { - if len(rctx.routeParams.Values) > 0 { - rctx.routeParams.Values = rctx.routeParams.Values[:len(rctx.routeParams.Values)-1] - } - } - - } - - return nil -} - -func (n *node) findEdge(ntyp nodeTyp, label byte) *node { - nds := n.children[ntyp] - num := len(nds) - idx := 0 - - switch ntyp { - case ntStatic, ntParam, ntRegexp: - i, j := 0, num-1 - for i <= j { - idx = i + (j-i)/2 - if label > nds[idx].label { - i = idx + 1 - } else if label < nds[idx].label { - j = idx - 1 - } else { - i = num // breaks cond - } - } - if nds[idx].label != label { - return nil - } - return nds[idx] - - default: // catch all - return nds[idx] - } -} - -func (n *node) isLeaf() bool { - return n.endpoints != nil -} - -func (n *node) findPattern(pattern string) bool { - nn := n - for _, nds := range nn.children { - if len(nds) == 0 { - continue - } - - n = nn.findEdge(nds[0].typ, pattern[0]) - if n == nil { - continue - } - - var idx int - var xpattern string - - switch n.typ { - case ntStatic: - idx = longestPrefix(pattern, n.prefix) - if idx < len(n.prefix) { - continue - } - - case ntParam, ntRegexp: - idx = strings.IndexByte(pattern, '}') + 1 - - case ntCatchAll: - idx = longestPrefix(pattern, "*") - - default: - panic("chi: unknown node type") - } - - xpattern = pattern[idx:] - if len(xpattern) == 0 { - return true - } - - return n.findPattern(xpattern) - } - return false -} - -func (n *node) routes() []Route { - rts := []Route{} - - n.walk(func(eps endpoints, subroutes Routes) bool { - if eps[mSTUB] != nil && eps[mSTUB].handler != nil && subroutes == nil { - return false - } - - // Group methodHandlers by unique patterns - pats := make(map[string]endpoints) - - for mt, h := range eps { - if h.pattern == "" { - continue - } - p, ok := pats[h.pattern] - if !ok { - p = endpoints{} - pats[h.pattern] = p - } - p[mt] = h - } - - for p, mh := range pats { - hs := make(map[string]http.Handler) - if mh[mALL] != nil && mh[mALL].handler != nil { - hs["*"] = mh[mALL].handler - } - - for mt, h := range mh { - if h.handler == nil { - continue - } - if m, ok := reverseMethodMap[mt]; ok { - hs[m] = h.handler - } - } - - rt := Route{subroutes, hs, p} - rts = append(rts, rt) - } - - return false - }) - - return rts -} - -func (n *node) walk(fn func(eps endpoints, subroutes Routes) bool) bool { - // Visit the leaf values if any - if (n.endpoints != nil || n.subroutes != nil) && fn(n.endpoints, n.subroutes) { - return true - } - - // Recurse on the children - for _, ns := range n.children { - for _, cn := range ns { - if cn.walk(fn) { - return true - } - } - } - return false -} - -// patNextSegment returns the next segment details from a pattern: -// node type, param key, regexp string, param tail byte, param starting index, param ending index -func patNextSegment(pattern string) (nodeTyp, string, string, byte, int, int) { - ps := strings.Index(pattern, "{") - ws := strings.Index(pattern, "*") - - if ps < 0 && ws < 0 { - return ntStatic, "", "", 0, 0, len(pattern) // we return the entire thing - } - - // Sanity check - if ps >= 0 && ws >= 0 && ws < ps { - panic("chi: wildcard '*' must be the last pattern in a route, otherwise use a '{param}'") - } - - var tail byte = '/' // Default endpoint tail to / byte - - if ps >= 0 { - // Param/Regexp pattern is next - nt := ntParam - - // Read to closing } taking into account opens and closes in curl count (cc) - cc := 0 - pe := ps - for i, c := range pattern[ps:] { - if c == '{' { - cc++ - } else if c == '}' { - cc-- - if cc == 0 { - pe = ps + i - break - } - } - } - if pe == ps { - panic("chi: route param closing delimiter '}' is missing") - } - - key := pattern[ps+1 : pe] - pe++ // set end to next position - - if pe < len(pattern) { - tail = pattern[pe] - } - - key, rexpat, isRegexp := strings.Cut(key, ":") - if isRegexp { - nt = ntRegexp - } - - if len(rexpat) > 0 { - if rexpat[0] != '^' { - rexpat = "^" + rexpat - } - if rexpat[len(rexpat)-1] != '$' { - rexpat += "$" - } - } - - return nt, key, rexpat, tail, ps, pe - } - - // Wildcard pattern as finale - if ws < len(pattern)-1 { - panic("chi: wildcard '*' must be the last value in a route. trim trailing text or use a '{param}' instead") - } - return ntCatchAll, "*", "", 0, ws, len(pattern) -} - -func patParamKeys(pattern string) []string { - pat := pattern - paramKeys := []string{} - for { - ptyp, paramKey, _, _, _, e := patNextSegment(pat) - if ptyp == ntStatic { - return paramKeys - } - for i := 0; i < len(paramKeys); i++ { - if paramKeys[i] == paramKey { - panic(fmt.Sprintf("chi: routing pattern '%s' contains duplicate param key, '%s'", pattern, paramKey)) - } - } - paramKeys = append(paramKeys, paramKey) - pat = pat[e:] - } -} - -// longestPrefix finds the length of the shared prefix of two strings -func longestPrefix(k1, k2 string) (i int) { - for i = 0; i < min(len(k1), len(k2)); i++ { - if k1[i] != k2[i] { - break - } - } - return -} - -type nodes []*node - -// Sort the list of nodes by label -func (ns nodes) Sort() { sort.Sort(ns); ns.tailSort() } -func (ns nodes) Len() int { return len(ns) } -func (ns nodes) Swap(i, j int) { ns[i], ns[j] = ns[j], ns[i] } -func (ns nodes) Less(i, j int) bool { return ns[i].label < ns[j].label } - -// tailSort pushes nodes with '/' as the tail to the end of the list for param nodes. -// The list order determines the traversal order. -func (ns nodes) tailSort() { - for i := len(ns) - 1; i >= 0; i-- { - if ns[i].typ > ntStatic && ns[i].tail == '/' { - ns.Swap(i, len(ns)-1) - return - } - } -} - -func (ns nodes) findEdge(label byte) *node { - num := len(ns) - idx := 0 - i, j := 0, num-1 - for i <= j { - idx = i + (j-i)/2 - if label > ns[idx].label { - i = idx + 1 - } else if label < ns[idx].label { - j = idx - 1 - } else { - i = num // breaks cond - } - } - if ns[idx].label != label { - return nil - } - return ns[idx] -} - -// Route describes the details of a routing handler. -// Handlers map key is an HTTP method -type Route struct { - SubRoutes Routes - Handlers map[string]http.Handler - Pattern string -} - -// WalkFunc is the type of the function called for each method and route visited by Walk. -type WalkFunc func(method string, route string, handler http.Handler, middlewares ...func(http.Handler) http.Handler) error - -// Walk walks any router tree that implements Routes interface. -func Walk(r Routes, walkFn WalkFunc) error { - return walk(r, walkFn, "") -} - -func walk(r Routes, walkFn WalkFunc, parentRoute string, parentMw ...func(http.Handler) http.Handler) error { - for _, route := range r.Routes() { - mws := slices.Concat(parentMw, r.Middlewares()) - - if route.SubRoutes != nil { - if handler, ok := route.Handlers["*"]; ok { - if chain, ok := handler.(*ChainHandler); ok { - mws = append(mws, chain.Middlewares...) - } - } - - if err := walk(route.SubRoutes, walkFn, parentRoute+route.Pattern, mws...); err != nil { - return err - } - continue - } - - for method, handler := range route.Handlers { - if method == "*" { - // Ignore a "catchAll" method, since we pass down all the specific methods for each route. - continue - } - - fullRoute := parentRoute + route.Pattern - fullRoute = strings.ReplaceAll(fullRoute, "/*/", "/") - - if chain, ok := handler.(*ChainHandler); ok { - if err := walkFn(method, fullRoute, chain.Endpoint, append(mws, chain.Middlewares...)...); err != nil { - return err - } - } else { - if err := walkFn(method, fullRoute, handler, mws...); err != nil { - return err - } - } - } - } - - return nil -} diff --git a/vendor/github.com/go-chi/cors/LICENSE b/vendor/github.com/go-chi/cors/LICENSE deleted file mode 100644 index aee6182f9ac..00000000000 --- a/vendor/github.com/go-chi/cors/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -Copyright (c) 2014 Olivier Poitrey -Copyright (c) 2016-Present https://github.com/go-chi authors - -MIT License - -Permission is hereby granted, free of charge, to any person obtaining a copy of -this software and associated documentation files (the "Software"), to deal in -the Software without restriction, including without limitation the rights to -use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of -the Software, and to permit persons to whom the Software is furnished to do so, -subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS -FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR -COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER -IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN -CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/vendor/github.com/go-chi/cors/README.md b/vendor/github.com/go-chi/cors/README.md deleted file mode 100644 index b41686b6aff..00000000000 --- a/vendor/github.com/go-chi/cors/README.md +++ /dev/null @@ -1,39 +0,0 @@ -# CORS net/http middleware - -[go-chi/cors](https://github.com/go-chi/cors) is a fork of [github.com/rs/cors](https://github.com/rs/cors) that -provides a `net/http` compatible middleware for performing preflight CORS checks on the server side. These headers -are required for using the browser native [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API). - -This middleware is designed to be used as a top-level middleware on the [chi](https://github.com/go-chi/chi) router. -Applying with within a `r.Group()` or using `With()` will not work without routes matching `OPTIONS` added. - -## Usage - -```go -func main() { - r := chi.NewRouter() - - // Basic CORS - // for more ideas, see: https://developer.github.com/v3/#cross-origin-resource-sharing - r.Use(cors.Handler(cors.Options{ - // AllowedOrigins: []string{"https://foo.com"}, // Use this to allow specific origin hosts - AllowedOrigins: []string{"https://*", "http://*"}, - // AllowOriginFunc: func(r *http.Request, origin string) bool { return true }, - AllowedMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"}, - AllowedHeaders: []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token"}, - ExposedHeaders: []string{"Link"}, - AllowCredentials: false, - MaxAge: 300, // Maximum value not ignored by any of major browsers - })) - - r.Get("/", func(w http.ResponseWriter, r *http.Request) { - w.Write([]byte("welcome")) - }) - - http.ListenAndServe(":3000", r) -} -``` - -## Credits - -All credit for the original work of this middleware goes out to [github.com/rs](github.com/rs). diff --git a/vendor/github.com/go-chi/cors/cors.go b/vendor/github.com/go-chi/cors/cors.go deleted file mode 100644 index 8df81636e3b..00000000000 --- a/vendor/github.com/go-chi/cors/cors.go +++ /dev/null @@ -1,400 +0,0 @@ -// cors package is net/http handler to handle CORS related requests -// as defined by http://www.w3.org/TR/cors/ -// -// You can configure it by passing an option struct to cors.New: -// -// c := cors.New(cors.Options{ -// AllowedOrigins: []string{"foo.com"}, -// AllowedMethods: []string{"GET", "POST", "DELETE"}, -// AllowCredentials: true, -// }) -// -// Then insert the handler in the chain: -// -// handler = c.Handler(handler) -// -// See Options documentation for more options. -// -// The resulting handler is a standard net/http handler. -package cors - -import ( - "log" - "net/http" - "os" - "strconv" - "strings" -) - -// Options is a configuration container to setup the CORS middleware. -type Options struct { - // AllowedOrigins is a list of origins a cross-domain request can be executed from. - // If the special "*" value is present in the list, all origins will be allowed. - // An origin may contain a wildcard (*) to replace 0 or more characters - // (i.e.: http://*.domain.com). Usage of wildcards implies a small performance penalty. - // Only one wildcard can be used per origin. - // Default value is ["*"] - AllowedOrigins []string - - // AllowOriginFunc is a custom function to validate the origin. It takes the origin - // as argument and returns true if allowed or false otherwise. If this option is - // set, the content of AllowedOrigins is ignored. - AllowOriginFunc func(r *http.Request, origin string) bool - - // AllowedMethods is a list of methods the client is allowed to use with - // cross-domain requests. Default value is simple methods (HEAD, GET and POST). - AllowedMethods []string - - // AllowedHeaders is list of non simple headers the client is allowed to use with - // cross-domain requests. - // If the special "*" value is present in the list, all headers will be allowed. - // Default value is [] but "Origin" is always appended to the list. - AllowedHeaders []string - - // ExposedHeaders indicates which headers are safe to expose to the API of a CORS - // API specification - ExposedHeaders []string - - // AllowCredentials indicates whether the request can include user credentials like - // cookies, HTTP authentication or client side SSL certificates. - AllowCredentials bool - - // MaxAge indicates how long (in seconds) the results of a preflight request - // can be cached - MaxAge int - - // OptionsPassthrough instructs preflight to let other potential next handlers to - // process the OPTIONS method. Turn this on if your application handles OPTIONS. - OptionsPassthrough bool - - // Debugging flag adds additional output to debug server side CORS issues - Debug bool -} - -// Logger generic interface for logger -type Logger interface { - Printf(string, ...interface{}) -} - -// Cors http handler -type Cors struct { - // Debug logger - Log Logger - - // Normalized list of plain allowed origins - allowedOrigins []string - - // List of allowed origins containing wildcards - allowedWOrigins []wildcard - - // Optional origin validator function - allowOriginFunc func(r *http.Request, origin string) bool - - // Normalized list of allowed headers - allowedHeaders []string - - // Normalized list of allowed methods - allowedMethods []string - - // Normalized list of exposed headers - exposedHeaders []string - maxAge int - - // Set to true when allowed origins contains a "*" - allowedOriginsAll bool - - // Set to true when allowed headers contains a "*" - allowedHeadersAll bool - - allowCredentials bool - optionPassthrough bool -} - -// New creates a new Cors handler with the provided options. -func New(options Options) *Cors { - c := &Cors{ - exposedHeaders: convert(options.ExposedHeaders, http.CanonicalHeaderKey), - allowOriginFunc: options.AllowOriginFunc, - allowCredentials: options.AllowCredentials, - maxAge: options.MaxAge, - optionPassthrough: options.OptionsPassthrough, - } - if options.Debug && c.Log == nil { - c.Log = log.New(os.Stdout, "[cors] ", log.LstdFlags) - } - - // Normalize options - // Note: for origins and methods matching, the spec requires a case-sensitive matching. - // As it may error prone, we chose to ignore the spec here. - - // Allowed Origins - if len(options.AllowedOrigins) == 0 { - if options.AllowOriginFunc == nil { - // Default is all origins - c.allowedOriginsAll = true - } - } else { - c.allowedOrigins = []string{} - c.allowedWOrigins = []wildcard{} - for _, origin := range options.AllowedOrigins { - // Normalize - origin = strings.ToLower(origin) - if origin == "*" { - // If "*" is present in the list, turn the whole list into a match all - c.allowedOriginsAll = true - c.allowedOrigins = nil - c.allowedWOrigins = nil - break - } else if i := strings.IndexByte(origin, '*'); i >= 0 { - // Split the origin in two: start and end string without the * - w := wildcard{origin[0:i], origin[i+1:]} - c.allowedWOrigins = append(c.allowedWOrigins, w) - } else { - c.allowedOrigins = append(c.allowedOrigins, origin) - } - } - } - - // Allowed Headers - if len(options.AllowedHeaders) == 0 { - // Use sensible defaults - c.allowedHeaders = []string{"Origin", "Accept", "Content-Type"} - } else { - // Origin is always appended as some browsers will always request for this header at preflight - c.allowedHeaders = convert(append(options.AllowedHeaders, "Origin"), http.CanonicalHeaderKey) - for _, h := range options.AllowedHeaders { - if h == "*" { - c.allowedHeadersAll = true - c.allowedHeaders = nil - break - } - } - } - - // Allowed Methods - if len(options.AllowedMethods) == 0 { - // Default is spec's "simple" methods - c.allowedMethods = []string{http.MethodGet, http.MethodPost, http.MethodHead} - } else { - c.allowedMethods = convert(options.AllowedMethods, strings.ToUpper) - } - - return c -} - -// Handler creates a new Cors handler with passed options. -func Handler(options Options) func(next http.Handler) http.Handler { - c := New(options) - return c.Handler -} - -// AllowAll create a new Cors handler with permissive configuration allowing all -// origins with all standard methods with any header and credentials. -func AllowAll() *Cors { - return New(Options{ - AllowedOrigins: []string{"*"}, - AllowedMethods: []string{ - http.MethodHead, - http.MethodGet, - http.MethodPost, - http.MethodPut, - http.MethodPatch, - http.MethodDelete, - }, - AllowedHeaders: []string{"*"}, - AllowCredentials: false, - }) -} - -// Handler apply the CORS specification on the request, and add relevant CORS headers -// as necessary. -func (c *Cors) Handler(next http.Handler) http.Handler { - return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - if r.Method == http.MethodOptions && r.Header.Get("Access-Control-Request-Method") != "" { - c.logf("Handler: Preflight request") - c.handlePreflight(w, r) - // Preflight requests are standalone and should stop the chain as some other - // middleware may not handle OPTIONS requests correctly. One typical example - // is authentication middleware ; OPTIONS requests won't carry authentication - // headers (see #1) - if c.optionPassthrough { - next.ServeHTTP(w, r) - } else { - w.WriteHeader(http.StatusOK) - } - } else { - c.logf("Handler: Actual request") - c.handleActualRequest(w, r) - next.ServeHTTP(w, r) - } - }) -} - -// handlePreflight handles pre-flight CORS requests -func (c *Cors) handlePreflight(w http.ResponseWriter, r *http.Request) { - headers := w.Header() - origin := r.Header.Get("Origin") - - if r.Method != http.MethodOptions { - c.logf("Preflight aborted: %s!=OPTIONS", r.Method) - return - } - // Always set Vary headers - // see https://github.com/rs/cors/issues/10, - // https://github.com/rs/cors/commit/dbdca4d95feaa7511a46e6f1efb3b3aa505bc43f#commitcomment-12352001 - headers.Add("Vary", "Origin") - headers.Add("Vary", "Access-Control-Request-Method") - headers.Add("Vary", "Access-Control-Request-Headers") - - if origin == "" { - c.logf("Preflight aborted: empty origin") - return - } - if !c.isOriginAllowed(r, origin) { - c.logf("Preflight aborted: origin '%s' not allowed", origin) - return - } - - reqMethod := r.Header.Get("Access-Control-Request-Method") - if !c.isMethodAllowed(reqMethod) { - c.logf("Preflight aborted: method '%s' not allowed", reqMethod) - return - } - reqHeaders := parseHeaderList(r.Header.Get("Access-Control-Request-Headers")) - if !c.areHeadersAllowed(reqHeaders) { - c.logf("Preflight aborted: headers '%v' not allowed", reqHeaders) - return - } - if c.allowedOriginsAll { - headers.Set("Access-Control-Allow-Origin", "*") - } else { - headers.Set("Access-Control-Allow-Origin", origin) - } - // Spec says: Since the list of methods can be unbounded, simply returning the method indicated - // by Access-Control-Request-Method (if supported) can be enough - headers.Set("Access-Control-Allow-Methods", strings.ToUpper(reqMethod)) - if len(reqHeaders) > 0 { - - // Spec says: Since the list of headers can be unbounded, simply returning supported headers - // from Access-Control-Request-Headers can be enough - headers.Set("Access-Control-Allow-Headers", strings.Join(reqHeaders, ", ")) - } - if c.allowCredentials { - headers.Set("Access-Control-Allow-Credentials", "true") - } - if c.maxAge > 0 { - headers.Set("Access-Control-Max-Age", strconv.Itoa(c.maxAge)) - } - c.logf("Preflight response headers: %v", headers) -} - -// handleActualRequest handles simple cross-origin requests, actual request or redirects -func (c *Cors) handleActualRequest(w http.ResponseWriter, r *http.Request) { - headers := w.Header() - origin := r.Header.Get("Origin") - - // Always set Vary, see https://github.com/rs/cors/issues/10 - headers.Add("Vary", "Origin") - if origin == "" { - c.logf("Actual request no headers added: missing origin") - return - } - if !c.isOriginAllowed(r, origin) { - c.logf("Actual request no headers added: origin '%s' not allowed", origin) - return - } - - // Note that spec does define a way to specifically disallow a simple method like GET or - // POST. Access-Control-Allow-Methods is only used for pre-flight requests and the - // spec doesn't instruct to check the allowed methods for simple cross-origin requests. - // We think it's a nice feature to be able to have control on those methods though. - if !c.isMethodAllowed(r.Method) { - c.logf("Actual request no headers added: method '%s' not allowed", r.Method) - - return - } - if c.allowedOriginsAll { - headers.Set("Access-Control-Allow-Origin", "*") - } else { - headers.Set("Access-Control-Allow-Origin", origin) - } - if len(c.exposedHeaders) > 0 { - headers.Set("Access-Control-Expose-Headers", strings.Join(c.exposedHeaders, ", ")) - } - if c.allowCredentials { - headers.Set("Access-Control-Allow-Credentials", "true") - } - c.logf("Actual response added headers: %v", headers) -} - -// convenience method. checks if a logger is set. -func (c *Cors) logf(format string, a ...interface{}) { - if c.Log != nil { - c.Log.Printf(format, a...) - } -} - -// isOriginAllowed checks if a given origin is allowed to perform cross-domain requests -// on the endpoint -func (c *Cors) isOriginAllowed(r *http.Request, origin string) bool { - if c.allowOriginFunc != nil { - return c.allowOriginFunc(r, origin) - } - if c.allowedOriginsAll { - return true - } - origin = strings.ToLower(origin) - for _, o := range c.allowedOrigins { - if o == origin { - return true - } - } - for _, w := range c.allowedWOrigins { - if w.match(origin) { - return true - } - } - return false -} - -// isMethodAllowed checks if a given method can be used as part of a cross-domain request -// on the endpoint -func (c *Cors) isMethodAllowed(method string) bool { - if len(c.allowedMethods) == 0 { - // If no method allowed, always return false, even for preflight request - return false - } - method = strings.ToUpper(method) - if method == http.MethodOptions { - // Always allow preflight requests - return true - } - for _, m := range c.allowedMethods { - if m == method { - return true - } - } - return false -} - -// areHeadersAllowed checks if a given list of headers are allowed to used within -// a cross-domain request. -func (c *Cors) areHeadersAllowed(requestedHeaders []string) bool { - if c.allowedHeadersAll || len(requestedHeaders) == 0 { - return true - } - for _, header := range requestedHeaders { - header = http.CanonicalHeaderKey(header) - found := false - for _, h := range c.allowedHeaders { - if h == header { - found = true - break - } - } - if !found { - return false - } - } - return true -} diff --git a/vendor/github.com/go-chi/cors/utils.go b/vendor/github.com/go-chi/cors/utils.go deleted file mode 100644 index 3fe5a5aeeb6..00000000000 --- a/vendor/github.com/go-chi/cors/utils.go +++ /dev/null @@ -1,70 +0,0 @@ -package cors - -import "strings" - -const toLower = 'a' - 'A' - -type converter func(string) string - -type wildcard struct { - prefix string - suffix string -} - -func (w wildcard) match(s string) bool { - return len(s) >= len(w.prefix+w.suffix) && strings.HasPrefix(s, w.prefix) && strings.HasSuffix(s, w.suffix) -} - -// convert converts a list of string using the passed converter function -func convert(s []string, c converter) []string { - out := []string{} - for _, i := range s { - out = append(out, c(i)) - } - return out -} - -// parseHeaderList tokenize + normalize a string containing a list of headers -func parseHeaderList(headerList string) []string { - l := len(headerList) - h := make([]byte, 0, l) - upper := true - // Estimate the number headers in order to allocate the right splice size - t := 0 - for i := 0; i < l; i++ { - if headerList[i] == ',' { - t++ - } - } - headers := make([]string, 0, t) - for i := 0; i < l; i++ { - b := headerList[i] - if b >= 'a' && b <= 'z' { - if upper { - h = append(h, b-toLower) - } else { - h = append(h, b) - } - } else if b >= 'A' && b <= 'Z' { - if !upper { - h = append(h, b+toLower) - } else { - h = append(h, b) - } - } else if b == '-' || b == '_' || b == '.' || (b >= '0' && b <= '9') { - h = append(h, b) - } - - if b == ' ' || b == ',' || i == l-1 { - if len(h) > 0 { - // Flush the found header - headers = append(headers, string(h)) - h = h[:0] - upper = true - } - } else { - upper = b == '-' - } - } - return headers -} diff --git a/vendor/github.com/go-jose/go-jose/v4/.gitignore b/vendor/github.com/go-jose/go-jose/v4/.gitignore deleted file mode 100644 index eb29ebaefd8..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -jose-util/jose-util -jose-util.t.err \ No newline at end of file diff --git a/vendor/github.com/go-jose/go-jose/v4/.golangci.yml b/vendor/github.com/go-jose/go-jose/v4/.golangci.yml deleted file mode 100644 index 2a577a8f95b..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/.golangci.yml +++ /dev/null @@ -1,53 +0,0 @@ -# https://github.com/golangci/golangci-lint - -run: - skip-files: - - doc_test.go - modules-download-mode: readonly - -linters: - enable-all: true - disable: - - gochecknoglobals - - goconst - - lll - - maligned - - nakedret - - scopelint - - unparam - - funlen # added in 1.18 (requires go-jose changes before it can be enabled) - -linters-settings: - gocyclo: - min-complexity: 35 - -issues: - exclude-rules: - - text: "don't use ALL_CAPS in Go names" - linters: - - golint - - text: "hardcoded credentials" - linters: - - gosec - - text: "weak cryptographic primitive" - linters: - - gosec - - path: json/ - linters: - - dupl - - errcheck - - gocritic - - gocyclo - - golint - - govet - - ineffassign - - staticcheck - - structcheck - - stylecheck - - unused - - path: _test\.go - linters: - - scopelint - - path: jwk.go - linters: - - gocyclo diff --git a/vendor/github.com/go-jose/go-jose/v4/.travis.yml b/vendor/github.com/go-jose/go-jose/v4/.travis.yml deleted file mode 100644 index 48de631b003..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/.travis.yml +++ /dev/null @@ -1,33 +0,0 @@ -language: go - -matrix: - fast_finish: true - allow_failures: - - go: tip - -go: - - "1.13.x" - - "1.14.x" - - tip - -before_script: - - export PATH=$HOME/.local/bin:$PATH - -before_install: - - go get -u github.com/mattn/goveralls github.com/wadey/gocovmerge - - curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | sh -s -- -b $(go env GOPATH)/bin v1.18.0 - - pip install cram --user - -script: - - go test -v -covermode=count -coverprofile=profile.cov . - - go test -v -covermode=count -coverprofile=cryptosigner/profile.cov ./cryptosigner - - go test -v -covermode=count -coverprofile=cipher/profile.cov ./cipher - - go test -v -covermode=count -coverprofile=jwt/profile.cov ./jwt - - go test -v ./json # no coverage for forked encoding/json package - - golangci-lint run - - cd jose-util && go build && PATH=$PWD:$PATH cram -v jose-util.t # cram tests jose-util - - cd .. - -after_success: - - gocovmerge *.cov */*.cov > merged.coverprofile - - goveralls -coverprofile merged.coverprofile -service=travis-ci diff --git a/vendor/github.com/go-jose/go-jose/v4/CONTRIBUTING.md b/vendor/github.com/go-jose/go-jose/v4/CONTRIBUTING.md deleted file mode 100644 index 4b4805add65..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/CONTRIBUTING.md +++ /dev/null @@ -1,9 +0,0 @@ -# Contributing - -If you would like to contribute code to go-jose you can do so through GitHub by -forking the repository and sending a pull request. - -When submitting code, please make every effort to follow existing conventions -and style in order to keep the code as readable as possible. Please also make -sure all tests pass by running `go test`, and format your code with `go fmt`. -We also recommend using `golint` and `errcheck`. diff --git a/vendor/github.com/go-jose/go-jose/v4/LICENSE b/vendor/github.com/go-jose/go-jose/v4/LICENSE deleted file mode 100644 index d6456956733..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/LICENSE +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - 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. diff --git a/vendor/github.com/go-jose/go-jose/v4/README.md b/vendor/github.com/go-jose/go-jose/v4/README.md deleted file mode 100644 index 55c5509176b..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/README.md +++ /dev/null @@ -1,108 +0,0 @@ -# Go JOSE - -[![godoc](https://pkg.go.dev/badge/github.com/go-jose/go-jose/v4.svg)](https://pkg.go.dev/github.com/go-jose/go-jose/v4) -[![godoc](https://pkg.go.dev/badge/github.com/go-jose/go-jose/v4/jwt.svg)](https://pkg.go.dev/github.com/go-jose/go-jose/v4/jwt) -[![license](https://img.shields.io/badge/license-apache_2.0-blue.svg?style=flat)](https://raw.githubusercontent.com/go-jose/go-jose/master/LICENSE) - -Package jose aims to provide an implementation of the Javascript Object Signing -and Encryption set of standards. This includes support for JSON Web Encryption, -JSON Web Signature, and JSON Web Token standards. - -## Overview - -The implementation follows the -[JSON Web Encryption](https://dx.doi.org/10.17487/RFC7516) (RFC 7516), -[JSON Web Signature](https://dx.doi.org/10.17487/RFC7515) (RFC 7515), and -[JSON Web Token](https://dx.doi.org/10.17487/RFC7519) (RFC 7519) specifications. -Tables of supported algorithms are shown below. The library supports both -the compact and JWS/JWE JSON Serialization formats, and has optional support for -multiple recipients. It also comes with a small command-line utility -([`jose-util`](https://pkg.go.dev/github.com/go-jose/go-jose/jose-util)) -for dealing with JOSE messages in a shell. - -**Note**: We use a forked version of the `encoding/json` package from the Go -standard library which uses case-sensitive matching for member names (instead -of [case-insensitive matching](https://www.ietf.org/mail-archive/web/json/current/msg03763.html)). -This is to avoid differences in interpretation of messages between go-jose and -libraries in other languages. - -### Versions - -The forthcoming Version 5 will be released with several breaking API changes, -and will require Golang's `encoding/json/v2`, which is currently requires -Go 1.25 built with GOEXPERIMENT=jsonv2. - -Version 4 is the current stable version: - - import "github.com/go-jose/go-jose/v4" - -It supports at least the current and previous Golang release. Currently it -requires Golang 1.24. - -Version 3 is only receiving critical security updates. Migration to Version 4 is recommended. - -Versions 1 and 2 are obsolete, but can be found in the old repository, [square/go-jose](https://github.com/square/go-jose). - -### Supported algorithms - -See below for a table of supported algorithms. Algorithm identifiers match -the names in the [JSON Web Algorithms](https://dx.doi.org/10.17487/RFC7518) -standard where possible. The Godoc reference has a list of constants. - -| Key encryption | Algorithm identifier(s) | -|:-----------------------|:-----------------------------------------------| -| RSA-PKCS#1v1.5 | RSA1_5 | -| RSA-OAEP | RSA-OAEP, RSA-OAEP-256 | -| AES key wrap | A128KW, A192KW, A256KW | -| AES-GCM key wrap | A128GCMKW, A192GCMKW, A256GCMKW | -| ECDH-ES + AES key wrap | ECDH-ES+A128KW, ECDH-ES+A192KW, ECDH-ES+A256KW | -| ECDH-ES (direct) | ECDH-ES1 | -| Direct encryption | dir1 | - -1. Not supported in multi-recipient mode - -| Signing / MAC | Algorithm identifier(s) | -|:------------------|:------------------------| -| RSASSA-PKCS#1v1.5 | RS256, RS384, RS512 | -| RSASSA-PSS | PS256, PS384, PS512 | -| HMAC | HS256, HS384, HS512 | -| ECDSA | ES256, ES384, ES512 | -| Ed25519 | EdDSA2 | - -2. Only available in version 2 of the package - -| Content encryption | Algorithm identifier(s) | -|:-------------------|:--------------------------------------------| -| AES-CBC+HMAC | A128CBC-HS256, A192CBC-HS384, A256CBC-HS512 | -| AES-GCM | A128GCM, A192GCM, A256GCM | - -| Compression | Algorithm identifiers(s) | -|:-------------------|--------------------------| -| DEFLATE (RFC 1951) | DEF | - -### Supported key types - -See below for a table of supported key types. These are understood by the -library, and can be passed to corresponding functions such as `NewEncrypter` or -`NewSigner`. Each of these keys can also be wrapped in a JWK if desired, which -allows attaching a key id. - -| Algorithm(s) | Corresponding types | -|:------------------|--------------------------------------------------------------------------------------------------------------------------------------| -| RSA | *[rsa.PublicKey](https://pkg.go.dev/crypto/rsa/#PublicKey), *[rsa.PrivateKey](https://pkg.go.dev/crypto/rsa/#PrivateKey) | -| ECDH, ECDSA | *[ecdsa.PublicKey](https://pkg.go.dev/crypto/ecdsa/#PublicKey), *[ecdsa.PrivateKey](https://pkg.go.dev/crypto/ecdsa/#PrivateKey) | -| EdDSA1 | [ed25519.PublicKey](https://pkg.go.dev/crypto/ed25519#PublicKey), [ed25519.PrivateKey](https://pkg.go.dev/crypto/ed25519#PrivateKey) | -| AES, HMAC | []byte | - -1. Only available in version 2 or later of the package - -## Examples - -[![godoc](https://pkg.go.dev/badge/github.com/go-jose/go-jose/v4.svg)](https://pkg.go.dev/github.com/go-jose/go-jose/v4) -[![godoc](https://pkg.go.dev/badge/github.com/go-jose/go-jose/v4/jwt.svg)](https://pkg.go.dev/github.com/go-jose/go-jose/v4/jwt) - -Examples can be found in the Godoc -reference for this package. The -[`jose-util`](https://github.com/go-jose/go-jose/tree/main/jose-util) -subdirectory also contains a small command-line utility which might be useful -as an example as well. diff --git a/vendor/github.com/go-jose/go-jose/v4/SECURITY.md b/vendor/github.com/go-jose/go-jose/v4/SECURITY.md deleted file mode 100644 index 2f18a75a822..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/SECURITY.md +++ /dev/null @@ -1,13 +0,0 @@ -# Security Policy -This document explains how to contact the Let's Encrypt security team to report security vulnerabilities. - -## Supported Versions -| Version | Supported | -| ------- | ----------| -| >= v3 | ✓ | -| v2 | ✗ | -| v1 | ✗ | - -## Reporting a vulnerability - -Please see [https://letsencrypt.org/contact/#security](https://letsencrypt.org/contact/#security) for the email address to report a vulnerability. Ensure that the subject line for your report contains the word `vulnerability` and is descriptive. Your email should be acknowledged within 24 hours. If you do not receive a response within 24 hours, please follow-up again with another email. diff --git a/vendor/github.com/go-jose/go-jose/v4/asymmetric.go b/vendor/github.com/go-jose/go-jose/v4/asymmetric.go deleted file mode 100644 index 7784cd4584e..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/asymmetric.go +++ /dev/null @@ -1,603 +0,0 @@ -/*- - * Copyright 2014 Square 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 jose - -import ( - "crypto" - "crypto/aes" - "crypto/ecdsa" - "crypto/ed25519" - "crypto/rand" - "crypto/rsa" - "crypto/sha1" - "crypto/sha256" - "errors" - "fmt" - "math/big" - - josecipher "github.com/go-jose/go-jose/v4/cipher" - "github.com/go-jose/go-jose/v4/json" -) - -// A generic RSA-based encrypter/verifier -type rsaEncrypterVerifier struct { - publicKey *rsa.PublicKey -} - -// A generic RSA-based decrypter/signer -type rsaDecrypterSigner struct { - privateKey *rsa.PrivateKey -} - -// A generic EC-based encrypter/verifier -type ecEncrypterVerifier struct { - publicKey *ecdsa.PublicKey -} - -type edEncrypterVerifier struct { - publicKey ed25519.PublicKey -} - -// A key generator for ECDH-ES -type ecKeyGenerator struct { - size int - algID string - publicKey *ecdsa.PublicKey -} - -// A generic EC-based decrypter/signer -type ecDecrypterSigner struct { - privateKey *ecdsa.PrivateKey -} - -type edDecrypterSigner struct { - privateKey ed25519.PrivateKey -} - -// newRSARecipient creates recipientKeyInfo based on the given key. -func newRSARecipient(keyAlg KeyAlgorithm, publicKey *rsa.PublicKey) (recipientKeyInfo, error) { - // Verify that key management algorithm is supported by this encrypter - switch keyAlg { - case RSA1_5, RSA_OAEP, RSA_OAEP_256: - default: - return recipientKeyInfo{}, ErrUnsupportedAlgorithm - } - - if publicKey == nil { - return recipientKeyInfo{}, errors.New("invalid public key") - } - - return recipientKeyInfo{ - keyAlg: keyAlg, - keyEncrypter: &rsaEncrypterVerifier{ - publicKey: publicKey, - }, - }, nil -} - -// newRSASigner creates a recipientSigInfo based on the given key. -func newRSASigner(sigAlg SignatureAlgorithm, privateKey *rsa.PrivateKey) (recipientSigInfo, error) { - // Verify that key management algorithm is supported by this encrypter - switch sigAlg { - case RS256, RS384, RS512, PS256, PS384, PS512: - default: - return recipientSigInfo{}, ErrUnsupportedAlgorithm - } - - if privateKey == nil { - return recipientSigInfo{}, errors.New("invalid private key") - } - - return recipientSigInfo{ - sigAlg: sigAlg, - publicKey: staticPublicKey(&JSONWebKey{ - Key: privateKey.Public(), - }), - signer: &rsaDecrypterSigner{ - privateKey: privateKey, - }, - }, nil -} - -func newEd25519Signer(sigAlg SignatureAlgorithm, privateKey ed25519.PrivateKey) (recipientSigInfo, error) { - if sigAlg != EdDSA { - return recipientSigInfo{}, ErrUnsupportedAlgorithm - } - - if privateKey == nil { - return recipientSigInfo{}, errors.New("invalid private key") - } - return recipientSigInfo{ - sigAlg: sigAlg, - publicKey: staticPublicKey(&JSONWebKey{ - Key: privateKey.Public(), - }), - signer: &edDecrypterSigner{ - privateKey: privateKey, - }, - }, nil -} - -// newECDHRecipient creates recipientKeyInfo based on the given key. -func newECDHRecipient(keyAlg KeyAlgorithm, publicKey *ecdsa.PublicKey) (recipientKeyInfo, error) { - // Verify that key management algorithm is supported by this encrypter - switch keyAlg { - case ECDH_ES, ECDH_ES_A128KW, ECDH_ES_A192KW, ECDH_ES_A256KW: - default: - return recipientKeyInfo{}, ErrUnsupportedAlgorithm - } - - if publicKey == nil || !publicKey.Curve.IsOnCurve(publicKey.X, publicKey.Y) { - return recipientKeyInfo{}, errors.New("invalid public key") - } - - return recipientKeyInfo{ - keyAlg: keyAlg, - keyEncrypter: &ecEncrypterVerifier{ - publicKey: publicKey, - }, - }, nil -} - -// newECDSASigner creates a recipientSigInfo based on the given key. -func newECDSASigner(sigAlg SignatureAlgorithm, privateKey *ecdsa.PrivateKey) (recipientSigInfo, error) { - // Verify that key management algorithm is supported by this encrypter - switch sigAlg { - case ES256, ES384, ES512: - default: - return recipientSigInfo{}, ErrUnsupportedAlgorithm - } - - if privateKey == nil { - return recipientSigInfo{}, errors.New("invalid private key") - } - - return recipientSigInfo{ - sigAlg: sigAlg, - publicKey: staticPublicKey(&JSONWebKey{ - Key: privateKey.Public(), - }), - signer: &ecDecrypterSigner{ - privateKey: privateKey, - }, - }, nil -} - -// Encrypt the given payload and update the object. -func (ctx rsaEncrypterVerifier) encryptKey(cek []byte, alg KeyAlgorithm) (recipientInfo, error) { - encryptedKey, err := ctx.encrypt(cek, alg) - if err != nil { - return recipientInfo{}, err - } - - return recipientInfo{ - encryptedKey: encryptedKey, - header: &rawHeader{}, - }, nil -} - -// Encrypt the given payload. Based on the key encryption algorithm, -// this will either use RSA-PKCS1v1.5 or RSA-OAEP (with SHA-1 or SHA-256). -func (ctx rsaEncrypterVerifier) encrypt(cek []byte, alg KeyAlgorithm) ([]byte, error) { - switch alg { - case RSA1_5: - return rsa.EncryptPKCS1v15(RandReader, ctx.publicKey, cek) - case RSA_OAEP: - return rsa.EncryptOAEP(sha1.New(), RandReader, ctx.publicKey, cek, []byte{}) - case RSA_OAEP_256: - return rsa.EncryptOAEP(sha256.New(), RandReader, ctx.publicKey, cek, []byte{}) - } - - return nil, ErrUnsupportedAlgorithm -} - -// Decrypt the given payload and return the content encryption key. -func (ctx rsaDecrypterSigner) decryptKey(headers rawHeader, recipient *recipientInfo, generator keyGenerator) ([]byte, error) { - return ctx.decrypt(recipient.encryptedKey, headers.getAlgorithm(), generator) -} - -// Decrypt the given payload. Based on the key encryption algorithm, -// this will either use RSA-PKCS1v1.5 or RSA-OAEP (with SHA-1 or SHA-256). -func (ctx rsaDecrypterSigner) decrypt(jek []byte, alg KeyAlgorithm, generator keyGenerator) ([]byte, error) { - // Note: The random reader on decrypt operations is only used for blinding, - // so stubbing is meanlingless (hence the direct use of rand.Reader). - switch alg { - case RSA1_5: - defer func() { - // DecryptPKCS1v15SessionKey sometimes panics on an invalid payload - // because of an index out of bounds error, which we want to ignore. - // This has been fixed in Go 1.3.1 (released 2014/08/13), the recover() - // only exists for preventing crashes with unpatched versions. - // See: https://groups.google.com/forum/#!topic/golang-dev/7ihX6Y6kx9k - // See: https://code.google.com/p/go/source/detail?r=58ee390ff31602edb66af41ed10901ec95904d33 - _ = recover() - }() - - // Perform some input validation. - keyBytes := ctx.privateKey.PublicKey.N.BitLen() / 8 - if keyBytes != len(jek) { - // Input size is incorrect, the encrypted payload should always match - // the size of the public modulus (e.g. using a 2048 bit key will - // produce 256 bytes of output). Reject this since it's invalid input. - return nil, ErrCryptoFailure - } - - cek, _, err := generator.genKey() - if err != nil { - return nil, ErrCryptoFailure - } - - // When decrypting an RSA-PKCS1v1.5 payload, we must take precautions to - // prevent chosen-ciphertext attacks as described in RFC 3218, "Preventing - // the Million Message Attack on Cryptographic Message Syntax". We are - // therefore deliberately ignoring errors here. - _ = rsa.DecryptPKCS1v15SessionKey(rand.Reader, ctx.privateKey, jek, cek) - - return cek, nil - case RSA_OAEP: - // Use rand.Reader for RSA blinding - return rsa.DecryptOAEP(sha1.New(), rand.Reader, ctx.privateKey, jek, []byte{}) - case RSA_OAEP_256: - // Use rand.Reader for RSA blinding - return rsa.DecryptOAEP(sha256.New(), rand.Reader, ctx.privateKey, jek, []byte{}) - } - - return nil, ErrUnsupportedAlgorithm -} - -// Sign the given payload -func (ctx rsaDecrypterSigner) signPayload(payload []byte, alg SignatureAlgorithm) (Signature, error) { - var hash crypto.Hash - - switch alg { - case RS256, PS256: - hash = crypto.SHA256 - case RS384, PS384: - hash = crypto.SHA384 - case RS512, PS512: - hash = crypto.SHA512 - default: - return Signature{}, ErrUnsupportedAlgorithm - } - - hasher := hash.New() - - // According to documentation, Write() on hash never fails - _, _ = hasher.Write(payload) - hashed := hasher.Sum(nil) - - var out []byte - var err error - - switch alg { - case RS256, RS384, RS512: - // TODO(https://github.com/go-jose/go-jose/issues/40): As of go1.20, the - // random parameter is legacy and ignored, and it can be nil. - // https://cs.opensource.google/go/go/+/refs/tags/go1.20:src/crypto/rsa/pkcs1v15.go;l=263;bpv=0;bpt=1 - out, err = rsa.SignPKCS1v15(RandReader, ctx.privateKey, hash, hashed) - case PS256, PS384, PS512: - out, err = rsa.SignPSS(RandReader, ctx.privateKey, hash, hashed, &rsa.PSSOptions{ - SaltLength: rsa.PSSSaltLengthEqualsHash, - }) - } - - if err != nil { - return Signature{}, err - } - - return Signature{ - Signature: out, - protected: &rawHeader{}, - }, nil -} - -// Verify the given payload -func (ctx rsaEncrypterVerifier) verifyPayload(payload []byte, signature []byte, alg SignatureAlgorithm) error { - var hash crypto.Hash - - switch alg { - case RS256, PS256: - hash = crypto.SHA256 - case RS384, PS384: - hash = crypto.SHA384 - case RS512, PS512: - hash = crypto.SHA512 - default: - return ErrUnsupportedAlgorithm - } - - hasher := hash.New() - - // According to documentation, Write() on hash never fails - _, _ = hasher.Write(payload) - hashed := hasher.Sum(nil) - - switch alg { - case RS256, RS384, RS512: - return rsa.VerifyPKCS1v15(ctx.publicKey, hash, hashed, signature) - case PS256, PS384, PS512: - return rsa.VerifyPSS(ctx.publicKey, hash, hashed, signature, nil) - } - - return ErrUnsupportedAlgorithm -} - -// Encrypt the given payload and update the object. -func (ctx ecEncrypterVerifier) encryptKey(cek []byte, alg KeyAlgorithm) (recipientInfo, error) { - switch alg { - case ECDH_ES: - // ECDH-ES mode doesn't wrap a key, the shared secret is used directly as the key. - return recipientInfo{ - header: &rawHeader{}, - }, nil - case ECDH_ES_A128KW, ECDH_ES_A192KW, ECDH_ES_A256KW: - default: - return recipientInfo{}, ErrUnsupportedAlgorithm - } - - generator := ecKeyGenerator{ - algID: string(alg), - publicKey: ctx.publicKey, - } - - switch alg { - case ECDH_ES_A128KW: - generator.size = 16 - case ECDH_ES_A192KW: - generator.size = 24 - case ECDH_ES_A256KW: - generator.size = 32 - } - - kek, header, err := generator.genKey() - if err != nil { - return recipientInfo{}, err - } - - block, err := aes.NewCipher(kek) - if err != nil { - return recipientInfo{}, err - } - - jek, err := josecipher.KeyWrap(block, cek) - if err != nil { - return recipientInfo{}, err - } - - return recipientInfo{ - encryptedKey: jek, - header: &header, - }, nil -} - -// Get key size for EC key generator -func (ctx ecKeyGenerator) keySize() int { - return ctx.size -} - -// Get a content encryption key for ECDH-ES -func (ctx ecKeyGenerator) genKey() ([]byte, rawHeader, error) { - priv, err := ecdsa.GenerateKey(ctx.publicKey.Curve, RandReader) - if err != nil { - return nil, rawHeader{}, err - } - - out := josecipher.DeriveECDHES(ctx.algID, []byte{}, []byte{}, priv, ctx.publicKey, ctx.size) - - b, err := json.Marshal(&JSONWebKey{ - Key: &priv.PublicKey, - }) - if err != nil { - return nil, nil, err - } - - headers := rawHeader{ - headerEPK: makeRawMessage(b), - } - - return out, headers, nil -} - -// Decrypt the given payload and return the content encryption key. -func (ctx ecDecrypterSigner) decryptKey(headers rawHeader, recipient *recipientInfo, generator keyGenerator) ([]byte, error) { - if recipient == nil { - return nil, errors.New("go-jose/go-jose: missing recipient") - } - epk, err := headers.getEPK() - if err != nil { - return nil, errors.New("go-jose/go-jose: invalid epk header") - } - if epk == nil { - return nil, errors.New("go-jose/go-jose: missing epk header") - } - - publicKey, ok := epk.Key.(*ecdsa.PublicKey) - if publicKey == nil || !ok { - return nil, errors.New("go-jose/go-jose: invalid epk header") - } - - if !ctx.privateKey.Curve.IsOnCurve(publicKey.X, publicKey.Y) { - return nil, errors.New("go-jose/go-jose: invalid public key in epk header") - } - - apuData, err := headers.getAPU() - if err != nil { - return nil, errors.New("go-jose/go-jose: invalid apu header") - } - apvData, err := headers.getAPV() - if err != nil { - return nil, errors.New("go-jose/go-jose: invalid apv header") - } - - deriveKey := func(algID string, size int) []byte { - return josecipher.DeriveECDHES(algID, apuData.bytes(), apvData.bytes(), ctx.privateKey, publicKey, size) - } - - var keySize int - - algorithm := headers.getAlgorithm() - switch algorithm { - case ECDH_ES: - // ECDH-ES uses direct key agreement, no key unwrapping necessary. - return deriveKey(string(headers.getEncryption()), generator.keySize()), nil - case ECDH_ES_A128KW: - keySize = 16 - case ECDH_ES_A192KW: - keySize = 24 - case ECDH_ES_A256KW: - keySize = 32 - default: - return nil, ErrUnsupportedAlgorithm - } - - encryptedKey := recipient.encryptedKey - if len(encryptedKey) == 0 { - return nil, errors.New("go-jose/go-jose: missing JWE Encrypted Key") - } - - key := deriveKey(string(algorithm), keySize) - block, err := aes.NewCipher(key) - if err != nil { - return nil, err - } - - return josecipher.KeyUnwrap(block, encryptedKey) -} - -func (ctx edDecrypterSigner) signPayload(payload []byte, alg SignatureAlgorithm) (Signature, error) { - if alg != EdDSA { - return Signature{}, ErrUnsupportedAlgorithm - } - - sig, err := ctx.privateKey.Sign(RandReader, payload, crypto.Hash(0)) - if err != nil { - return Signature{}, err - } - - return Signature{ - Signature: sig, - protected: &rawHeader{}, - }, nil -} - -func (ctx edEncrypterVerifier) verifyPayload(payload []byte, signature []byte, alg SignatureAlgorithm) error { - if alg != EdDSA { - return ErrUnsupportedAlgorithm - } - ok := ed25519.Verify(ctx.publicKey, payload, signature) - if !ok { - return errors.New("go-jose/go-jose: ed25519 signature failed to verify") - } - return nil -} - -// Sign the given payload -func (ctx ecDecrypterSigner) signPayload(payload []byte, alg SignatureAlgorithm) (Signature, error) { - var expectedBitSize int - var hash crypto.Hash - - switch alg { - case ES256: - expectedBitSize = 256 - hash = crypto.SHA256 - case ES384: - expectedBitSize = 384 - hash = crypto.SHA384 - case ES512: - expectedBitSize = 521 - hash = crypto.SHA512 - } - - curveBits := ctx.privateKey.Curve.Params().BitSize - if expectedBitSize != curveBits { - return Signature{}, fmt.Errorf("go-jose/go-jose: expected %d bit key, got %d bits instead", expectedBitSize, curveBits) - } - - hasher := hash.New() - - // According to documentation, Write() on hash never fails - _, _ = hasher.Write(payload) - hashed := hasher.Sum(nil) - - r, s, err := ecdsa.Sign(RandReader, ctx.privateKey, hashed) - if err != nil { - return Signature{}, err - } - - keyBytes := curveBits / 8 - if curveBits%8 > 0 { - keyBytes++ - } - - // We serialize the outputs (r and s) into big-endian byte arrays and pad - // them with zeros on the left to make sure the sizes work out. Both arrays - // must be keyBytes long, and the output must be 2*keyBytes long. - rBytes := r.Bytes() - rBytesPadded := make([]byte, keyBytes) - copy(rBytesPadded[keyBytes-len(rBytes):], rBytes) - - sBytes := s.Bytes() - sBytesPadded := make([]byte, keyBytes) - copy(sBytesPadded[keyBytes-len(sBytes):], sBytes) - - out := append(rBytesPadded, sBytesPadded...) - - return Signature{ - Signature: out, - protected: &rawHeader{}, - }, nil -} - -// Verify the given payload -func (ctx ecEncrypterVerifier) verifyPayload(payload []byte, signature []byte, alg SignatureAlgorithm) error { - var keySize int - var hash crypto.Hash - - switch alg { - case ES256: - keySize = 32 - hash = crypto.SHA256 - case ES384: - keySize = 48 - hash = crypto.SHA384 - case ES512: - keySize = 66 - hash = crypto.SHA512 - default: - return ErrUnsupportedAlgorithm - } - - if len(signature) != 2*keySize { - return fmt.Errorf("go-jose/go-jose: invalid signature size, have %d bytes, wanted %d", len(signature), 2*keySize) - } - - hasher := hash.New() - - // According to documentation, Write() on hash never fails - _, _ = hasher.Write(payload) - hashed := hasher.Sum(nil) - - r := big.NewInt(0).SetBytes(signature[:keySize]) - s := big.NewInt(0).SetBytes(signature[keySize:]) - - match := ecdsa.Verify(ctx.publicKey, hashed, r, s) - if !match { - return errors.New("go-jose/go-jose: ecdsa signature failed to verify") - } - - return nil -} diff --git a/vendor/github.com/go-jose/go-jose/v4/cipher/cbc_hmac.go b/vendor/github.com/go-jose/go-jose/v4/cipher/cbc_hmac.go deleted file mode 100644 index af029cec0ba..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/cipher/cbc_hmac.go +++ /dev/null @@ -1,196 +0,0 @@ -/*- - * Copyright 2014 Square 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 josecipher - -import ( - "bytes" - "crypto/cipher" - "crypto/hmac" - "crypto/sha256" - "crypto/sha512" - "crypto/subtle" - "encoding/binary" - "errors" - "hash" -) - -const ( - nonceBytes = 16 -) - -// NewCBCHMAC instantiates a new AEAD based on CBC+HMAC. -func NewCBCHMAC(key []byte, newBlockCipher func([]byte) (cipher.Block, error)) (cipher.AEAD, error) { - keySize := len(key) / 2 - integrityKey := key[:keySize] - encryptionKey := key[keySize:] - - blockCipher, err := newBlockCipher(encryptionKey) - if err != nil { - return nil, err - } - - var hash func() hash.Hash - switch keySize { - case 16: - hash = sha256.New - case 24: - hash = sha512.New384 - case 32: - hash = sha512.New - } - - return &cbcAEAD{ - hash: hash, - blockCipher: blockCipher, - authtagBytes: keySize, - integrityKey: integrityKey, - }, nil -} - -// An AEAD based on CBC+HMAC -type cbcAEAD struct { - hash func() hash.Hash - authtagBytes int - integrityKey []byte - blockCipher cipher.Block -} - -func (ctx *cbcAEAD) NonceSize() int { - return nonceBytes -} - -func (ctx *cbcAEAD) Overhead() int { - // Maximum overhead is block size (for padding) plus auth tag length, where - // the length of the auth tag is equivalent to the key size. - return ctx.blockCipher.BlockSize() + ctx.authtagBytes -} - -// Seal encrypts and authenticates the plaintext. -func (ctx *cbcAEAD) Seal(dst, nonce, plaintext, data []byte) []byte { - // Output buffer -- must take care not to mangle plaintext input. - ciphertext := make([]byte, uint64(len(plaintext))+uint64(ctx.Overhead()))[:len(plaintext)] - copy(ciphertext, plaintext) - ciphertext = padBuffer(ciphertext, ctx.blockCipher.BlockSize()) - - cbc := cipher.NewCBCEncrypter(ctx.blockCipher, nonce) - - cbc.CryptBlocks(ciphertext, ciphertext) - authtag := ctx.computeAuthTag(data, nonce, ciphertext) - - ret, out := resize(dst, uint64(len(dst))+uint64(len(ciphertext))+uint64(len(authtag))) - copy(out, ciphertext) - copy(out[len(ciphertext):], authtag) - - return ret -} - -// Open decrypts and authenticates the ciphertext. -func (ctx *cbcAEAD) Open(dst, nonce, ciphertext, data []byte) ([]byte, error) { - if len(ciphertext) < ctx.authtagBytes { - return nil, errors.New("go-jose/go-jose: invalid ciphertext (too short)") - } - - offset := len(ciphertext) - ctx.authtagBytes - expectedTag := ctx.computeAuthTag(data, nonce, ciphertext[:offset]) - match := subtle.ConstantTimeCompare(expectedTag, ciphertext[offset:]) - if match != 1 { - return nil, errors.New("go-jose/go-jose: invalid ciphertext (auth tag mismatch)") - } - - cbc := cipher.NewCBCDecrypter(ctx.blockCipher, nonce) - - // Make copy of ciphertext buffer, don't want to modify in place - buffer := append([]byte{}, ciphertext[:offset]...) - - if len(buffer)%ctx.blockCipher.BlockSize() > 0 { - return nil, errors.New("go-jose/go-jose: invalid ciphertext (invalid length)") - } - - cbc.CryptBlocks(buffer, buffer) - - // Remove padding - plaintext, err := unpadBuffer(buffer, ctx.blockCipher.BlockSize()) - if err != nil { - return nil, err - } - - ret, out := resize(dst, uint64(len(dst))+uint64(len(plaintext))) - copy(out, plaintext) - - return ret, nil -} - -// Compute an authentication tag -func (ctx *cbcAEAD) computeAuthTag(aad, nonce, ciphertext []byte) []byte { - buffer := make([]byte, uint64(len(aad))+uint64(len(nonce))+uint64(len(ciphertext))+8) - n := 0 - n += copy(buffer, aad) - n += copy(buffer[n:], nonce) - n += copy(buffer[n:], ciphertext) - binary.BigEndian.PutUint64(buffer[n:], uint64(len(aad))*8) - - // According to documentation, Write() on hash.Hash never fails. - hmac := hmac.New(ctx.hash, ctx.integrityKey) - _, _ = hmac.Write(buffer) - - return hmac.Sum(nil)[:ctx.authtagBytes] -} - -// resize ensures that the given slice has a capacity of at least n bytes. -// If the capacity of the slice is less than n, a new slice is allocated -// and the existing data will be copied. -func resize(in []byte, n uint64) (head, tail []byte) { - if uint64(cap(in)) >= n { - head = in[:n] - } else { - head = make([]byte, n) - copy(head, in) - } - - tail = head[len(in):] - return -} - -// Apply padding -func padBuffer(buffer []byte, blockSize int) []byte { - missing := blockSize - (len(buffer) % blockSize) - ret, out := resize(buffer, uint64(len(buffer))+uint64(missing)) - padding := bytes.Repeat([]byte{byte(missing)}, missing) - copy(out, padding) - return ret -} - -// Remove padding -func unpadBuffer(buffer []byte, blockSize int) ([]byte, error) { - if len(buffer)%blockSize != 0 { - return nil, errors.New("go-jose/go-jose: invalid padding") - } - - last := buffer[len(buffer)-1] - count := int(last) - - if count == 0 || count > blockSize || count > len(buffer) { - return nil, errors.New("go-jose/go-jose: invalid padding") - } - - padding := bytes.Repeat([]byte{last}, count) - if !bytes.HasSuffix(buffer, padding) { - return nil, errors.New("go-jose/go-jose: invalid padding") - } - - return buffer[:len(buffer)-count], nil -} diff --git a/vendor/github.com/go-jose/go-jose/v4/cipher/concat_kdf.go b/vendor/github.com/go-jose/go-jose/v4/cipher/concat_kdf.go deleted file mode 100644 index f62c3bdba5d..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/cipher/concat_kdf.go +++ /dev/null @@ -1,75 +0,0 @@ -/*- - * Copyright 2014 Square 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 josecipher - -import ( - "crypto" - "encoding/binary" - "hash" - "io" -) - -type concatKDF struct { - z, info []byte - i uint32 - cache []byte - hasher hash.Hash -} - -// NewConcatKDF builds a KDF reader based on the given inputs. -func NewConcatKDF(hash crypto.Hash, z, algID, ptyUInfo, ptyVInfo, supPubInfo, supPrivInfo []byte) io.Reader { - buffer := make([]byte, uint64(len(algID))+uint64(len(ptyUInfo))+uint64(len(ptyVInfo))+uint64(len(supPubInfo))+uint64(len(supPrivInfo))) - n := 0 - n += copy(buffer, algID) - n += copy(buffer[n:], ptyUInfo) - n += copy(buffer[n:], ptyVInfo) - n += copy(buffer[n:], supPubInfo) - copy(buffer[n:], supPrivInfo) - - hasher := hash.New() - - return &concatKDF{ - z: z, - info: buffer, - hasher: hasher, - cache: []byte{}, - i: 1, - } -} - -func (ctx *concatKDF) Read(out []byte) (int, error) { - copied := copy(out, ctx.cache) - ctx.cache = ctx.cache[copied:] - - for copied < len(out) { - ctx.hasher.Reset() - - // Write on a hash.Hash never fails - _ = binary.Write(ctx.hasher, binary.BigEndian, ctx.i) - _, _ = ctx.hasher.Write(ctx.z) - _, _ = ctx.hasher.Write(ctx.info) - - hash := ctx.hasher.Sum(nil) - chunkCopied := copy(out[copied:], hash) - copied += chunkCopied - ctx.cache = hash[chunkCopied:] - - ctx.i++ - } - - return copied, nil -} diff --git a/vendor/github.com/go-jose/go-jose/v4/cipher/ecdh_es.go b/vendor/github.com/go-jose/go-jose/v4/cipher/ecdh_es.go deleted file mode 100644 index 093c646740b..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/cipher/ecdh_es.go +++ /dev/null @@ -1,86 +0,0 @@ -/*- - * Copyright 2014 Square 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 josecipher - -import ( - "bytes" - "crypto" - "crypto/ecdsa" - "crypto/elliptic" - "encoding/binary" -) - -// DeriveECDHES derives a shared encryption key using ECDH/ConcatKDF as described in JWE/JWA. -// It is an error to call this function with a private/public key that are not on the same -// curve. Callers must ensure that the keys are valid before calling this function. Output -// size may be at most 1<<16 bytes (64 KiB). -func DeriveECDHES(alg string, apuData, apvData []byte, priv *ecdsa.PrivateKey, pub *ecdsa.PublicKey, size int) []byte { - if size > 1<<16 { - panic("ECDH-ES output size too large, must be less than or equal to 1<<16") - } - - // algId, partyUInfo, partyVInfo inputs must be prefixed with the length - algID := lengthPrefixed([]byte(alg)) - ptyUInfo := lengthPrefixed(apuData) - ptyVInfo := lengthPrefixed(apvData) - - // suppPubInfo is the encoded length of the output size in bits - supPubInfo := make([]byte, 4) - binary.BigEndian.PutUint32(supPubInfo, uint32(size)*8) - - if !priv.PublicKey.Curve.IsOnCurve(pub.X, pub.Y) { - panic("public key not on same curve as private key") - } - - z, _ := priv.Curve.ScalarMult(pub.X, pub.Y, priv.D.Bytes()) - zBytes := z.Bytes() - - // Note that calling z.Bytes() on a big.Int may strip leading zero bytes from - // the returned byte array. This can lead to a problem where zBytes will be - // shorter than expected which breaks the key derivation. Therefore we must pad - // to the full length of the expected coordinate here before calling the KDF. - octSize := dSize(priv.Curve) - if len(zBytes) != octSize { - zBytes = append(bytes.Repeat([]byte{0}, octSize-len(zBytes)), zBytes...) - } - - reader := NewConcatKDF(crypto.SHA256, zBytes, algID, ptyUInfo, ptyVInfo, supPubInfo, []byte{}) - key := make([]byte, size) - - // Read on the KDF will never fail - _, _ = reader.Read(key) - - return key -} - -// dSize returns the size in octets for a coordinate on a elliptic curve. -func dSize(curve elliptic.Curve) int { - order := curve.Params().P - bitLen := order.BitLen() - size := bitLen / 8 - if bitLen%8 != 0 { - size++ - } - return size -} - -func lengthPrefixed(data []byte) []byte { - out := make([]byte, len(data)+4) - binary.BigEndian.PutUint32(out, uint32(len(data))) - copy(out[4:], data) - return out -} diff --git a/vendor/github.com/go-jose/go-jose/v4/cipher/key_wrap.go b/vendor/github.com/go-jose/go-jose/v4/cipher/key_wrap.go deleted file mode 100644 index a2f86e3db95..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/cipher/key_wrap.go +++ /dev/null @@ -1,117 +0,0 @@ -/*- - * Copyright 2014 Square 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 josecipher - -import ( - "crypto/cipher" - "crypto/subtle" - "encoding/binary" - "errors" -) - -var defaultIV = []byte{0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6} - -// KeyWrap implements NIST key wrapping; it wraps a content encryption key (cek) with the given block cipher. -func KeyWrap(block cipher.Block, cek []byte) ([]byte, error) { - if len(cek)%8 != 0 { - return nil, errors.New("go-jose/go-jose: key wrap input must be 8 byte blocks") - } - - n := len(cek) / 8 - r := make([][]byte, n) - - for i := range r { - r[i] = make([]byte, 8) - copy(r[i], cek[i*8:]) - } - - buffer := make([]byte, 16) - tBytes := make([]byte, 8) - copy(buffer, defaultIV) - - for t := 0; t < 6*n; t++ { - copy(buffer[8:], r[t%n]) - - block.Encrypt(buffer, buffer) - - binary.BigEndian.PutUint64(tBytes, uint64(t+1)) - - for i := 0; i < 8; i++ { - buffer[i] ^= tBytes[i] - } - copy(r[t%n], buffer[8:]) - } - - out := make([]byte, (n+1)*8) - copy(out, buffer[:8]) - for i := range r { - copy(out[(i+1)*8:], r[i]) - } - - return out, nil -} - -// KeyUnwrap implements NIST key unwrapping; it unwraps a content encryption key (cek) with the given block cipher. -// -// https://datatracker.ietf.org/doc/html/rfc7518#section-4.4 -// https://datatracker.ietf.org/doc/html/rfc7518#section-4.6 -// https://datatracker.ietf.org/doc/html/rfc7518#section-4.8 -func KeyUnwrap(block cipher.Block, ciphertext []byte) ([]byte, error) { - n := (len(ciphertext) / 8) - 1 - if n <= 0 { - return nil, errors.New("go-jose/go-jose: JWE Encrypted Key too short") - } - - if len(ciphertext)%8 != 0 { - return nil, errors.New("go-jose/go-jose: key wrap input must be 8 byte blocks") - } - - r := make([][]byte, n) - - for i := range r { - r[i] = make([]byte, 8) - copy(r[i], ciphertext[(i+1)*8:]) - } - - buffer := make([]byte, 16) - tBytes := make([]byte, 8) - copy(buffer[:8], ciphertext[:8]) - - for t := 6*n - 1; t >= 0; t-- { - binary.BigEndian.PutUint64(tBytes, uint64(t+1)) - - for i := 0; i < 8; i++ { - buffer[i] ^= tBytes[i] - } - copy(buffer[8:], r[t%n]) - - block.Decrypt(buffer, buffer) - - copy(r[t%n], buffer[8:]) - } - - if subtle.ConstantTimeCompare(buffer[:8], defaultIV) == 0 { - return nil, errors.New("go-jose/go-jose: failed to unwrap key") - } - - out := make([]byte, n*8) - for i := range r { - copy(out[i*8:], r[i]) - } - - return out, nil -} diff --git a/vendor/github.com/go-jose/go-jose/v4/crypter.go b/vendor/github.com/go-jose/go-jose/v4/crypter.go deleted file mode 100644 index 31290fc8715..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/crypter.go +++ /dev/null @@ -1,595 +0,0 @@ -/*- - * Copyright 2014 Square 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 jose - -import ( - "crypto/ecdsa" - "crypto/rsa" - "errors" - "fmt" - - "github.com/go-jose/go-jose/v4/json" -) - -// Encrypter represents an encrypter which produces an encrypted JWE object. -type Encrypter interface { - Encrypt(plaintext []byte) (*JSONWebEncryption, error) - EncryptWithAuthData(plaintext []byte, aad []byte) (*JSONWebEncryption, error) - Options() EncrypterOptions -} - -// A generic content cipher -type contentCipher interface { - keySize() int - encrypt(cek []byte, aad, plaintext []byte) (*aeadParts, error) - decrypt(cek []byte, aad []byte, parts *aeadParts) ([]byte, error) -} - -// A key generator (for generating/getting a CEK) -type keyGenerator interface { - keySize() int - genKey() ([]byte, rawHeader, error) -} - -// A generic key encrypter -type keyEncrypter interface { - encryptKey(cek []byte, alg KeyAlgorithm) (recipientInfo, error) // Encrypt a key -} - -// A generic key decrypter -type keyDecrypter interface { - decryptKey(headers rawHeader, recipient *recipientInfo, generator keyGenerator) ([]byte, error) // Decrypt a key -} - -// A generic encrypter based on the given key encrypter and content cipher. -type genericEncrypter struct { - contentAlg ContentEncryption - compressionAlg CompressionAlgorithm - cipher contentCipher - recipients []recipientKeyInfo - keyGenerator keyGenerator - extraHeaders map[HeaderKey]interface{} -} - -type recipientKeyInfo struct { - keyID string - keyAlg KeyAlgorithm - keyEncrypter keyEncrypter -} - -// EncrypterOptions represents options that can be set on new encrypters. -type EncrypterOptions struct { - Compression CompressionAlgorithm - - // Optional map of name/value pairs to be inserted into the protected - // header of a JWS object. Some specifications which make use of - // JWS require additional values here. - // - // Values will be serialized by [json.Marshal] and must be valid inputs to - // that function. - // - // [json.Marshal]: https://pkg.go.dev/encoding/json#Marshal - ExtraHeaders map[HeaderKey]interface{} -} - -// WithHeader adds an arbitrary value to the ExtraHeaders map, initializing it -// if necessary, and returns the updated EncrypterOptions. -// -// The v parameter will be serialized by [json.Marshal] and must be a valid -// input to that function. -// -// [json.Marshal]: https://pkg.go.dev/encoding/json#Marshal -func (eo *EncrypterOptions) WithHeader(k HeaderKey, v interface{}) *EncrypterOptions { - if eo.ExtraHeaders == nil { - eo.ExtraHeaders = map[HeaderKey]interface{}{} - } - eo.ExtraHeaders[k] = v - return eo -} - -// WithContentType adds a content type ("cty") header and returns the updated -// EncrypterOptions. -func (eo *EncrypterOptions) WithContentType(contentType ContentType) *EncrypterOptions { - return eo.WithHeader(HeaderContentType, contentType) -} - -// WithType adds a type ("typ") header and returns the updated EncrypterOptions. -func (eo *EncrypterOptions) WithType(typ ContentType) *EncrypterOptions { - return eo.WithHeader(HeaderType, typ) -} - -// Recipient represents an algorithm/key to encrypt messages to. -// -// PBES2Count and PBES2Salt correspond with the "p2c" and "p2s" headers used -// on the password-based encryption algorithms PBES2-HS256+A128KW, -// PBES2-HS384+A192KW, and PBES2-HS512+A256KW. If they are not provided a safe -// default of 100000 will be used for the count and a 128-bit random salt will -// be generated. -type Recipient struct { - Algorithm KeyAlgorithm - // Key must have one of these types: - // - ed25519.PublicKey - // - *ecdsa.PublicKey - // - *rsa.PublicKey - // - *JSONWebKey - // - JSONWebKey - // - []byte (a symmetric key) - // - Any type that satisfies the OpaqueKeyEncrypter interface - // - // The type of Key must match the value of Algorithm. - Key interface{} - KeyID string - PBES2Count int - PBES2Salt []byte -} - -// NewEncrypter creates an appropriate encrypter based on the key type -func NewEncrypter(enc ContentEncryption, rcpt Recipient, opts *EncrypterOptions) (Encrypter, error) { - encrypter := &genericEncrypter{ - contentAlg: enc, - recipients: []recipientKeyInfo{}, - cipher: getContentCipher(enc), - } - if opts != nil { - encrypter.compressionAlg = opts.Compression - encrypter.extraHeaders = opts.ExtraHeaders - } - - if encrypter.cipher == nil { - return nil, ErrUnsupportedAlgorithm - } - - var keyID string - var rawKey interface{} - switch encryptionKey := rcpt.Key.(type) { - case JSONWebKey: - keyID, rawKey = encryptionKey.KeyID, encryptionKey.Key - case *JSONWebKey: - keyID, rawKey = encryptionKey.KeyID, encryptionKey.Key - case OpaqueKeyEncrypter: - keyID, rawKey = encryptionKey.KeyID(), encryptionKey - default: - rawKey = encryptionKey - } - - switch rcpt.Algorithm { - case DIRECT: - // Direct encryption mode must be treated differently - keyBytes, ok := rawKey.([]byte) - if !ok { - return nil, ErrUnsupportedKeyType - } - if encrypter.cipher.keySize() != len(keyBytes) { - return nil, ErrInvalidKeySize - } - encrypter.keyGenerator = staticKeyGenerator{ - key: keyBytes, - } - recipientInfo, _ := newSymmetricRecipient(rcpt.Algorithm, keyBytes) - recipientInfo.keyID = keyID - if rcpt.KeyID != "" { - recipientInfo.keyID = rcpt.KeyID - } - encrypter.recipients = []recipientKeyInfo{recipientInfo} - return encrypter, nil - case ECDH_ES: - // ECDH-ES (w/o key wrapping) is similar to DIRECT mode - keyDSA, ok := rawKey.(*ecdsa.PublicKey) - if !ok { - return nil, ErrUnsupportedKeyType - } - encrypter.keyGenerator = ecKeyGenerator{ - size: encrypter.cipher.keySize(), - algID: string(enc), - publicKey: keyDSA, - } - recipientInfo, _ := newECDHRecipient(rcpt.Algorithm, keyDSA) - recipientInfo.keyID = keyID - if rcpt.KeyID != "" { - recipientInfo.keyID = rcpt.KeyID - } - encrypter.recipients = []recipientKeyInfo{recipientInfo} - return encrypter, nil - default: - // Can just add a standard recipient - encrypter.keyGenerator = randomKeyGenerator{ - size: encrypter.cipher.keySize(), - } - err := encrypter.addRecipient(rcpt) - return encrypter, err - } -} - -// NewMultiEncrypter creates a multi-encrypter based on the given parameters -func NewMultiEncrypter(enc ContentEncryption, rcpts []Recipient, opts *EncrypterOptions) (Encrypter, error) { - cipher := getContentCipher(enc) - - if cipher == nil { - return nil, ErrUnsupportedAlgorithm - } - if len(rcpts) == 0 { - return nil, fmt.Errorf("go-jose/go-jose: recipients is nil or empty") - } - - encrypter := &genericEncrypter{ - contentAlg: enc, - recipients: []recipientKeyInfo{}, - cipher: cipher, - keyGenerator: randomKeyGenerator{ - size: cipher.keySize(), - }, - } - - if opts != nil { - encrypter.compressionAlg = opts.Compression - encrypter.extraHeaders = opts.ExtraHeaders - } - - for _, recipient := range rcpts { - err := encrypter.addRecipient(recipient) - if err != nil { - return nil, err - } - } - - return encrypter, nil -} - -func (ctx *genericEncrypter) addRecipient(recipient Recipient) (err error) { - var recipientInfo recipientKeyInfo - - switch recipient.Algorithm { - case DIRECT, ECDH_ES: - return fmt.Errorf("go-jose/go-jose: key algorithm '%s' not supported in multi-recipient mode", recipient.Algorithm) - } - - recipientInfo, err = makeJWERecipient(recipient.Algorithm, recipient.Key) - if recipient.KeyID != "" { - recipientInfo.keyID = recipient.KeyID - } - - switch recipient.Algorithm { - case PBES2_HS256_A128KW, PBES2_HS384_A192KW, PBES2_HS512_A256KW: - if sr, ok := recipientInfo.keyEncrypter.(*symmetricKeyCipher); ok { - sr.p2c = recipient.PBES2Count - sr.p2s = recipient.PBES2Salt - } - } - - if err == nil { - ctx.recipients = append(ctx.recipients, recipientInfo) - } - return err -} - -func makeJWERecipient(alg KeyAlgorithm, encryptionKey interface{}) (recipientKeyInfo, error) { - switch encryptionKey := encryptionKey.(type) { - case *rsa.PublicKey: - return newRSARecipient(alg, encryptionKey) - case *ecdsa.PublicKey: - return newECDHRecipient(alg, encryptionKey) - case []byte: - return newSymmetricRecipient(alg, encryptionKey) - case string: - return newSymmetricRecipient(alg, []byte(encryptionKey)) - case JSONWebKey: - recipient, err := makeJWERecipient(alg, encryptionKey.Key) - recipient.keyID = encryptionKey.KeyID - return recipient, err - case *JSONWebKey: - recipient, err := makeJWERecipient(alg, encryptionKey.Key) - recipient.keyID = encryptionKey.KeyID - return recipient, err - case OpaqueKeyEncrypter: - return newOpaqueKeyEncrypter(alg, encryptionKey) - } - return recipientKeyInfo{}, ErrUnsupportedKeyType -} - -// newDecrypter creates an appropriate decrypter based on the key type -func newDecrypter(decryptionKey interface{}) (keyDecrypter, error) { - switch decryptionKey := decryptionKey.(type) { - case *rsa.PrivateKey: - return &rsaDecrypterSigner{ - privateKey: decryptionKey, - }, nil - case *ecdsa.PrivateKey: - return &ecDecrypterSigner{ - privateKey: decryptionKey, - }, nil - case []byte: - return &symmetricKeyCipher{ - key: decryptionKey, - }, nil - case string: - return &symmetricKeyCipher{ - key: []byte(decryptionKey), - }, nil - case JSONWebKey: - return newDecrypter(decryptionKey.Key) - case *JSONWebKey: - return newDecrypter(decryptionKey.Key) - case OpaqueKeyDecrypter: - return &opaqueKeyDecrypter{decrypter: decryptionKey}, nil - default: - return nil, ErrUnsupportedKeyType - } -} - -// Implementation of encrypt method producing a JWE object. -func (ctx *genericEncrypter) Encrypt(plaintext []byte) (*JSONWebEncryption, error) { - return ctx.EncryptWithAuthData(plaintext, nil) -} - -// Implementation of encrypt method producing a JWE object. -func (ctx *genericEncrypter) EncryptWithAuthData(plaintext, aad []byte) (*JSONWebEncryption, error) { - obj := &JSONWebEncryption{} - obj.aad = aad - - obj.protected = &rawHeader{} - err := obj.protected.set(headerEncryption, ctx.contentAlg) - if err != nil { - return nil, err - } - - obj.recipients = make([]recipientInfo, len(ctx.recipients)) - - if len(ctx.recipients) == 0 { - return nil, fmt.Errorf("go-jose/go-jose: no recipients to encrypt to") - } - - cek, headers, err := ctx.keyGenerator.genKey() - if err != nil { - return nil, err - } - - obj.protected.merge(&headers) - - for i, info := range ctx.recipients { - recipient, err := info.keyEncrypter.encryptKey(cek, info.keyAlg) - if err != nil { - return nil, err - } - - err = recipient.header.set(headerAlgorithm, info.keyAlg) - if err != nil { - return nil, err - } - - if info.keyID != "" { - err = recipient.header.set(headerKeyID, info.keyID) - if err != nil { - return nil, err - } - } - obj.recipients[i] = recipient - } - - if len(ctx.recipients) == 1 { - // Move per-recipient headers into main protected header if there's - // only a single recipient. - obj.protected.merge(obj.recipients[0].header) - obj.recipients[0].header = nil - } - - if ctx.compressionAlg != NONE { - plaintext, err = compress(ctx.compressionAlg, plaintext) - if err != nil { - return nil, err - } - - err = obj.protected.set(headerCompression, ctx.compressionAlg) - if err != nil { - return nil, err - } - } - - for k, v := range ctx.extraHeaders { - b, err := json.Marshal(v) - if err != nil { - return nil, err - } - (*obj.protected)[k] = makeRawMessage(b) - } - - authData := obj.computeAuthData() - parts, err := ctx.cipher.encrypt(cek, authData, plaintext) - if err != nil { - return nil, err - } - - obj.iv = parts.iv - obj.ciphertext = parts.ciphertext - obj.tag = parts.tag - - return obj, nil -} - -func (ctx *genericEncrypter) Options() EncrypterOptions { - return EncrypterOptions{ - Compression: ctx.compressionAlg, - ExtraHeaders: ctx.extraHeaders, - } -} - -// Decrypt and validate the object and return the plaintext. This -// function does not support multi-recipient. If you desire multi-recipient -// decryption use DecryptMulti instead. -// -// The decryptionKey argument must contain a private or symmetric key -// and must have one of these types: -// - *ecdsa.PrivateKey -// - *rsa.PrivateKey -// - *JSONWebKey -// - JSONWebKey -// - *JSONWebKeySet -// - JSONWebKeySet -// - []byte (a symmetric key) -// - string (a symmetric key) -// - Any type that satisfies the OpaqueKeyDecrypter interface. -// -// Note that ed25519 is only available for signatures, not encryption, so is -// not an option here. -// -// Automatically decompresses plaintext, but returns an error if the decompressed -// data would be >250kB or >10x the size of the compressed data, whichever is larger. -func (obj JSONWebEncryption) Decrypt(decryptionKey interface{}) ([]byte, error) { - headers := obj.mergedHeaders(nil) - - if len(obj.recipients) > 1 { - return nil, errors.New("go-jose/go-jose: too many recipients in payload; expecting only one") - } - - err := headers.checkNoCritical() - if err != nil { - return nil, err - } - - key, err := tryJWKS(decryptionKey, obj.Header) - if err != nil { - return nil, err - } - decrypter, err := newDecrypter(key) - if err != nil { - return nil, err - } - - cipher := getContentCipher(headers.getEncryption()) - if cipher == nil { - return nil, fmt.Errorf("go-jose/go-jose: unsupported enc value '%s'", string(headers.getEncryption())) - } - - generator := randomKeyGenerator{ - size: cipher.keySize(), - } - - parts := &aeadParts{ - iv: obj.iv, - ciphertext: obj.ciphertext, - tag: obj.tag, - } - - authData := obj.computeAuthData() - - var plaintext []byte - recipient := obj.recipients[0] - recipientHeaders := obj.mergedHeaders(&recipient) - - cek, err := decrypter.decryptKey(recipientHeaders, &recipient, generator) - if err == nil { - // Found a valid CEK -- let's try to decrypt. - plaintext, err = cipher.decrypt(cek, authData, parts) - } - - if plaintext == nil { - return nil, ErrCryptoFailure - } - - // The "zip" header parameter may only be present in the protected header. - if comp := obj.protected.getCompression(); comp != "" { - plaintext, err = decompress(comp, plaintext) - if err != nil { - return nil, fmt.Errorf("go-jose/go-jose: failed to decompress plaintext: %v", err) - } - } - - return plaintext, nil -} - -// DecryptMulti decrypts and validates the object and returns the plaintexts, -// with support for multiple recipients. It returns the index of the recipient -// for which the decryption was successful, the merged headers for that recipient, -// and the plaintext. -// -// The decryptionKey argument must have one of the types allowed for the -// decryptionKey argument of Decrypt(). -// -// Automatically decompresses plaintext, but returns an error if the decompressed -// data would be >250kB or >3x the size of the compressed data, whichever is larger. -func (obj JSONWebEncryption) DecryptMulti(decryptionKey interface{}) (int, Header, []byte, error) { - globalHeaders := obj.mergedHeaders(nil) - - err := globalHeaders.checkNoCritical() - if err != nil { - return -1, Header{}, nil, err - } - - key, err := tryJWKS(decryptionKey, obj.Header) - if err != nil { - return -1, Header{}, nil, err - } - decrypter, err := newDecrypter(key) - if err != nil { - return -1, Header{}, nil, err - } - - encryption := globalHeaders.getEncryption() - cipher := getContentCipher(encryption) - if cipher == nil { - return -1, Header{}, nil, fmt.Errorf("go-jose/go-jose: unsupported enc value '%s'", string(encryption)) - } - - generator := randomKeyGenerator{ - size: cipher.keySize(), - } - - parts := &aeadParts{ - iv: obj.iv, - ciphertext: obj.ciphertext, - tag: obj.tag, - } - - authData := obj.computeAuthData() - - index := -1 - var plaintext []byte - var headers rawHeader - - for i, recipient := range obj.recipients { - recipientHeaders := obj.mergedHeaders(&recipient) - - cek, err := decrypter.decryptKey(recipientHeaders, &recipient, generator) - if err == nil { - // Found a valid CEK -- let's try to decrypt. - plaintext, err = cipher.decrypt(cek, authData, parts) - if err == nil { - index = i - headers = recipientHeaders - break - } - } - } - - if plaintext == nil { - return -1, Header{}, nil, ErrCryptoFailure - } - - // The "zip" header parameter may only be present in the protected header. - if comp := obj.protected.getCompression(); comp != "" { - plaintext, err = decompress(comp, plaintext) - if err != nil { - return -1, Header{}, nil, fmt.Errorf("go-jose/go-jose: failed to decompress plaintext: %v", err) - } - } - - sanitized, err := headers.sanitized() - if err != nil { - return -1, Header{}, nil, fmt.Errorf("go-jose/go-jose: failed to sanitize header: %v", err) - } - - return index, sanitized, plaintext, err -} diff --git a/vendor/github.com/go-jose/go-jose/v4/doc.go b/vendor/github.com/go-jose/go-jose/v4/doc.go deleted file mode 100644 index 0ad40ca085f..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/doc.go +++ /dev/null @@ -1,25 +0,0 @@ -/*- - * Copyright 2014 Square 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 jose aims to provide an implementation of the Javascript Object Signing -and Encryption set of standards. It implements encryption and signing based on -the JSON Web Encryption and JSON Web Signature standards, with optional JSON Web -Token support available in a sub-package. The library supports both the compact -and JWS/JWE JSON Serialization formats, and has optional support for multiple -recipients. -*/ -package jose diff --git a/vendor/github.com/go-jose/go-jose/v4/encoding.go b/vendor/github.com/go-jose/go-jose/v4/encoding.go deleted file mode 100644 index 4f6e0d4a5cf..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/encoding.go +++ /dev/null @@ -1,228 +0,0 @@ -/*- - * Copyright 2014 Square 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 jose - -import ( - "bytes" - "compress/flate" - "encoding/base64" - "encoding/binary" - "fmt" - "io" - "math/big" - "strings" - "unicode" - - "github.com/go-jose/go-jose/v4/json" -) - -// Helper function to serialize known-good objects. -// Precondition: value is not a nil pointer. -func mustSerializeJSON(value interface{}) []byte { - out, err := json.Marshal(value) - if err != nil { - panic(err) - } - // We never want to serialize the top-level value "null," since it's not a - // valid JOSE message. But if a caller passes in a nil pointer to this method, - // MarshalJSON will happily serialize it as the top-level value "null". If - // that value is then embedded in another operation, for instance by being - // base64-encoded and fed as input to a signing algorithm - // (https://github.com/go-jose/go-jose/issues/22), the result will be - // incorrect. Because this method is intended for known-good objects, and a nil - // pointer is not a known-good object, we are free to panic in this case. - // Note: It's not possible to directly check whether the data pointed at by an - // interface is a nil pointer, so we do this hacky workaround. - // https://groups.google.com/forum/#!topic/golang-nuts/wnH302gBa4I - if string(out) == "null" { - panic("Tried to serialize a nil pointer.") - } - return out -} - -// Strip all newlines and whitespace -func stripWhitespace(data string) string { - buf := strings.Builder{} - buf.Grow(len(data)) - for _, r := range data { - if !unicode.IsSpace(r) { - buf.WriteRune(r) - } - } - return buf.String() -} - -// Perform compression based on algorithm -func compress(algorithm CompressionAlgorithm, input []byte) ([]byte, error) { - switch algorithm { - case DEFLATE: - return deflate(input) - default: - return nil, ErrUnsupportedAlgorithm - } -} - -// Perform decompression based on algorithm -func decompress(algorithm CompressionAlgorithm, input []byte) ([]byte, error) { - switch algorithm { - case DEFLATE: - return inflate(input) - default: - return nil, ErrUnsupportedAlgorithm - } -} - -// deflate compresses the input. -func deflate(input []byte) ([]byte, error) { - output := new(bytes.Buffer) - - // Writing to byte buffer, err is always nil - writer, _ := flate.NewWriter(output, 1) - _, _ = io.Copy(writer, bytes.NewBuffer(input)) - - err := writer.Close() - return output.Bytes(), err -} - -// inflate decompresses the input. -// -// Errors if the decompressed data would be >250kB or >10x the size of the -// compressed data, whichever is larger. -func inflate(input []byte) ([]byte, error) { - output := new(bytes.Buffer) - reader := flate.NewReader(bytes.NewBuffer(input)) - - maxCompressedSize := max(250_000, 10*int64(len(input))) - - limit := maxCompressedSize + 1 - n, err := io.CopyN(output, reader, limit) - if err != nil && err != io.EOF { - return nil, err - } - if n == limit { - return nil, fmt.Errorf("uncompressed data would be too large (>%d bytes)", maxCompressedSize) - } - - err = reader.Close() - return output.Bytes(), err -} - -// byteBuffer represents a slice of bytes that can be serialized to url-safe base64. -type byteBuffer struct { - data []byte -} - -func newBuffer(data []byte) *byteBuffer { - if data == nil { - return nil - } - return &byteBuffer{ - data: data, - } -} - -func newFixedSizeBuffer(data []byte, length int) *byteBuffer { - if len(data) > length { - panic("go-jose/go-jose: invalid call to newFixedSizeBuffer (len(data) > length)") - } - pad := make([]byte, length-len(data)) - return newBuffer(append(pad, data...)) -} - -func newBufferFromInt(num uint64) *byteBuffer { - data := make([]byte, 8) - binary.BigEndian.PutUint64(data, num) - return newBuffer(bytes.TrimLeft(data, "\x00")) -} - -func (b *byteBuffer) MarshalJSON() ([]byte, error) { - return json.Marshal(b.base64()) -} - -func (b *byteBuffer) UnmarshalJSON(data []byte) error { - var encoded string - err := json.Unmarshal(data, &encoded) - if err != nil { - return err - } - - if encoded == "" { - return nil - } - - decoded, err := base64.RawURLEncoding.DecodeString(encoded) - if err != nil { - return err - } - - *b = *newBuffer(decoded) - - return nil -} - -func (b *byteBuffer) base64() string { - return base64.RawURLEncoding.EncodeToString(b.data) -} - -func (b *byteBuffer) bytes() []byte { - // Handling nil here allows us to transparently handle nil slices when serializing. - if b == nil { - return nil - } - return b.data -} - -func (b byteBuffer) bigInt() *big.Int { - return new(big.Int).SetBytes(b.data) -} - -func (b byteBuffer) toInt() int { - return int(b.bigInt().Int64()) -} - -func base64EncodeLen(sl []byte) int { - return base64.RawURLEncoding.EncodedLen(len(sl)) -} - -func base64JoinWithDots(inputs ...[]byte) string { - if len(inputs) == 0 { - return "" - } - - // Count of dots. - totalCount := len(inputs) - 1 - - for _, input := range inputs { - totalCount += base64EncodeLen(input) - } - - out := make([]byte, totalCount) - startEncode := 0 - for i, input := range inputs { - base64.RawURLEncoding.Encode(out[startEncode:], input) - - if i == len(inputs)-1 { - continue - } - - startEncode += base64EncodeLen(input) - out[startEncode] = '.' - startEncode++ - } - - return string(out) -} diff --git a/vendor/github.com/go-jose/go-jose/v4/json/LICENSE b/vendor/github.com/go-jose/go-jose/v4/json/LICENSE deleted file mode 100644 index 74487567632..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/json/LICENSE +++ /dev/null @@ -1,27 +0,0 @@ -Copyright (c) 2012 The Go Authors. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - * Redistributions of source code must retain the above copyright -notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above -copyright notice, this list of conditions and the following disclaimer -in the documentation and/or other materials provided with the -distribution. - * Neither the name of Google Inc. nor the names of its -contributors may be used to endorse or promote products derived from -this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/go-jose/go-jose/v4/json/README.md b/vendor/github.com/go-jose/go-jose/v4/json/README.md deleted file mode 100644 index 86de5e5581f..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/json/README.md +++ /dev/null @@ -1,13 +0,0 @@ -# Safe JSON - -This repository contains a fork of the `encoding/json` package from Go 1.6. - -The following changes were made: - -* Object deserialization uses case-sensitive member name matching instead of - [case-insensitive matching](https://www.ietf.org/mail-archive/web/json/current/msg03763.html). - This is to avoid differences in the interpretation of JOSE messages between - go-jose and libraries written in other languages. -* When deserializing a JSON object, we check for duplicate keys and reject the - input whenever we detect a duplicate. Rather than trying to work with malformed - data, we prefer to reject it right away. diff --git a/vendor/github.com/go-jose/go-jose/v4/json/decode.go b/vendor/github.com/go-jose/go-jose/v4/json/decode.go deleted file mode 100644 index 50634dd8478..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/json/decode.go +++ /dev/null @@ -1,1216 +0,0 @@ -// Copyright 2010 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. - -// Represents JSON data structure using native Go types: booleans, floats, -// strings, arrays, and maps. - -package json - -import ( - "bytes" - "encoding" - "encoding/base64" - "errors" - "fmt" - "math" - "reflect" - "runtime" - "strconv" - "unicode" - "unicode/utf16" - "unicode/utf8" -) - -// Unmarshal parses the JSON-encoded data and stores the result -// in the value pointed to by v. -// -// Unmarshal uses the inverse of the encodings that -// Marshal uses, allocating maps, slices, and pointers as necessary, -// with the following additional rules: -// -// To unmarshal JSON into a pointer, Unmarshal first handles the case of -// the JSON being the JSON literal null. In that case, Unmarshal sets -// the pointer to nil. Otherwise, Unmarshal unmarshals the JSON into -// the value pointed at by the pointer. If the pointer is nil, Unmarshal -// allocates a new value for it to point to. -// -// To unmarshal JSON into a struct, Unmarshal matches incoming object -// keys to the keys used by Marshal (either the struct field name or its tag), -// preferring an exact match but also accepting a case-insensitive match. -// Unmarshal will only set exported fields of the struct. -// -// To unmarshal JSON into an interface value, -// Unmarshal stores one of these in the interface value: -// -// bool, for JSON booleans -// float64, for JSON numbers -// string, for JSON strings -// []interface{}, for JSON arrays -// map[string]interface{}, for JSON objects -// nil for JSON null -// -// To unmarshal a JSON array into a slice, Unmarshal resets the slice length -// to zero and then appends each element to the slice. -// As a special case, to unmarshal an empty JSON array into a slice, -// Unmarshal replaces the slice with a new empty slice. -// -// To unmarshal a JSON array into a Go array, Unmarshal decodes -// JSON array elements into corresponding Go array elements. -// If the Go array is smaller than the JSON array, -// the additional JSON array elements are discarded. -// If the JSON array is smaller than the Go array, -// the additional Go array elements are set to zero values. -// -// To unmarshal a JSON object into a string-keyed map, Unmarshal first -// establishes a map to use, If the map is nil, Unmarshal allocates a new map. -// Otherwise Unmarshal reuses the existing map, keeping existing entries. -// Unmarshal then stores key-value pairs from the JSON object into the map. -// -// If a JSON value is not appropriate for a given target type, -// or if a JSON number overflows the target type, Unmarshal -// skips that field and completes the unmarshaling as best it can. -// If no more serious errors are encountered, Unmarshal returns -// an UnmarshalTypeError describing the earliest such error. -// -// The JSON null value unmarshals into an interface, map, pointer, or slice -// by setting that Go value to nil. Because null is often used in JSON to mean -// “not present,” unmarshaling a JSON null into any other Go type has no effect -// on the value and produces no error. -// -// When unmarshaling quoted strings, invalid UTF-8 or -// invalid UTF-16 surrogate pairs are not treated as an error. -// Instead, they are replaced by the Unicode replacement -// character U+FFFD. -func Unmarshal(data []byte, v interface{}) error { - // Check for well-formedness. - // Avoids filling out half a data structure - // before discovering a JSON syntax error. - var d decodeState - err := checkValid(data, &d.scan) - if err != nil { - return err - } - - d.init(data) - return d.unmarshal(v) -} - -// Unmarshaler is the interface implemented by objects -// that can unmarshal a JSON description of themselves. -// The input can be assumed to be a valid encoding of -// a JSON value. UnmarshalJSON must copy the JSON data -// if it wishes to retain the data after returning. -type Unmarshaler interface { - UnmarshalJSON([]byte) error -} - -// An UnmarshalTypeError describes a JSON value that was -// not appropriate for a value of a specific Go type. -type UnmarshalTypeError struct { - Value string // description of JSON value - "bool", "array", "number -5" - Type reflect.Type // type of Go value it could not be assigned to - Offset int64 // error occurred after reading Offset bytes -} - -func (e *UnmarshalTypeError) Error() string { - return "json: cannot unmarshal " + e.Value + " into Go value of type " + e.Type.String() -} - -// An UnmarshalFieldError describes a JSON object key that -// led to an unexported (and therefore unwritable) struct field. -// (No longer used; kept for compatibility.) -type UnmarshalFieldError struct { - Key string - Type reflect.Type - Field reflect.StructField -} - -func (e *UnmarshalFieldError) Error() string { - return "json: cannot unmarshal object key " + strconv.Quote(e.Key) + " into unexported field " + e.Field.Name + " of type " + e.Type.String() -} - -// An InvalidUnmarshalError describes an invalid argument passed to Unmarshal. -// (The argument to Unmarshal must be a non-nil pointer.) -type InvalidUnmarshalError struct { - Type reflect.Type -} - -func (e *InvalidUnmarshalError) Error() string { - if e.Type == nil { - return "json: Unmarshal(nil)" - } - - if e.Type.Kind() != reflect.Ptr { - return "json: Unmarshal(non-pointer " + e.Type.String() + ")" - } - return "json: Unmarshal(nil " + e.Type.String() + ")" -} - -func (d *decodeState) unmarshal(v interface{}) (err error) { - defer func() { - if r := recover(); r != nil { - if _, ok := r.(runtime.Error); ok { - panic(r) - } - err = r.(error) - } - }() - - rv := reflect.ValueOf(v) - if rv.Kind() != reflect.Ptr || rv.IsNil() { - return &InvalidUnmarshalError{reflect.TypeOf(v)} - } - - d.scan.reset() - // We decode rv not rv.Elem because the Unmarshaler interface - // test must be applied at the top level of the value. - d.value(rv) - return d.savedError -} - -// A Number represents a JSON number literal. -type Number string - -// String returns the literal text of the number. -func (n Number) String() string { return string(n) } - -// Float64 returns the number as a float64. -func (n Number) Float64() (float64, error) { - return strconv.ParseFloat(string(n), 64) -} - -// Int64 returns the number as an int64. -func (n Number) Int64() (int64, error) { - return strconv.ParseInt(string(n), 10, 64) -} - -// isValidNumber reports whether s is a valid JSON number literal. -func isValidNumber(s string) bool { - // This function implements the JSON numbers grammar. - // See https://tools.ietf.org/html/rfc7159#section-6 - // and http://json.org/number.gif - - if s == "" { - return false - } - - // Optional - - if s[0] == '-' { - s = s[1:] - if s == "" { - return false - } - } - - // Digits - switch { - default: - return false - - case s[0] == '0': - s = s[1:] - - case '1' <= s[0] && s[0] <= '9': - s = s[1:] - for len(s) > 0 && '0' <= s[0] && s[0] <= '9' { - s = s[1:] - } - } - - // . followed by 1 or more digits. - if len(s) >= 2 && s[0] == '.' && '0' <= s[1] && s[1] <= '9' { - s = s[2:] - for len(s) > 0 && '0' <= s[0] && s[0] <= '9' { - s = s[1:] - } - } - - // e or E followed by an optional - or + and - // 1 or more digits. - if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') { - s = s[1:] - if s[0] == '+' || s[0] == '-' { - s = s[1:] - if s == "" { - return false - } - } - for len(s) > 0 && '0' <= s[0] && s[0] <= '9' { - s = s[1:] - } - } - - // Make sure we are at the end. - return s == "" -} - -type NumberUnmarshalType int - -const ( - // unmarshal a JSON number into an interface{} as a float64 - UnmarshalFloat NumberUnmarshalType = iota - // unmarshal a JSON number into an interface{} as a `json.Number` - UnmarshalJSONNumber - // unmarshal a JSON number into an interface{} as a int64 - // if value is an integer otherwise float64 - UnmarshalIntOrFloat -) - -// decodeState represents the state while decoding a JSON value. -type decodeState struct { - data []byte - off int // read offset in data - scan scanner - nextscan scanner // for calls to nextValue - savedError error - numberType NumberUnmarshalType -} - -// errPhase is used for errors that should not happen unless -// there is a bug in the JSON decoder or something is editing -// the data slice while the decoder executes. -var errPhase = errors.New("JSON decoder out of sync - data changing underfoot?") - -func (d *decodeState) init(data []byte) *decodeState { - d.data = data - d.off = 0 - d.savedError = nil - return d -} - -// error aborts the decoding by panicking with err. -func (d *decodeState) error(err error) { - panic(err) -} - -// saveError saves the first err it is called with, -// for reporting at the end of the unmarshal. -func (d *decodeState) saveError(err error) { - if d.savedError == nil { - d.savedError = err - } -} - -// next cuts off and returns the next full JSON value in d.data[d.off:]. -// The next value is known to be an object or array, not a literal. -func (d *decodeState) next() []byte { - c := d.data[d.off] - item, rest, err := nextValue(d.data[d.off:], &d.nextscan) - if err != nil { - d.error(err) - } - d.off = len(d.data) - len(rest) - - // Our scanner has seen the opening brace/bracket - // and thinks we're still in the middle of the object. - // invent a closing brace/bracket to get it out. - if c == '{' { - d.scan.step(&d.scan, '}') - } else { - d.scan.step(&d.scan, ']') - } - - return item -} - -// scanWhile processes bytes in d.data[d.off:] until it -// receives a scan code not equal to op. -// It updates d.off and returns the new scan code. -func (d *decodeState) scanWhile(op int) int { - var newOp int - for { - if d.off >= len(d.data) { - newOp = d.scan.eof() - d.off = len(d.data) + 1 // mark processed EOF with len+1 - } else { - c := d.data[d.off] - d.off++ - newOp = d.scan.step(&d.scan, c) - } - if newOp != op { - break - } - } - return newOp -} - -// value decodes a JSON value from d.data[d.off:] into the value. -// it updates d.off to point past the decoded value. -func (d *decodeState) value(v reflect.Value) { - if !v.IsValid() { - _, rest, err := nextValue(d.data[d.off:], &d.nextscan) - if err != nil { - d.error(err) - } - d.off = len(d.data) - len(rest) - - // d.scan thinks we're still at the beginning of the item. - // Feed in an empty string - the shortest, simplest value - - // so that it knows we got to the end of the value. - if d.scan.redo { - // rewind. - d.scan.redo = false - d.scan.step = stateBeginValue - } - d.scan.step(&d.scan, '"') - d.scan.step(&d.scan, '"') - - n := len(d.scan.parseState) - if n > 0 && d.scan.parseState[n-1] == parseObjectKey { - // d.scan thinks we just read an object key; finish the object - d.scan.step(&d.scan, ':') - d.scan.step(&d.scan, '"') - d.scan.step(&d.scan, '"') - d.scan.step(&d.scan, '}') - } - - return - } - - switch op := d.scanWhile(scanSkipSpace); op { - default: - d.error(errPhase) - - case scanBeginArray: - d.array(v) - - case scanBeginObject: - d.object(v) - - case scanBeginLiteral: - d.literal(v) - } -} - -type unquotedValue struct{} - -// valueQuoted is like value but decodes a -// quoted string literal or literal null into an interface value. -// If it finds anything other than a quoted string literal or null, -// valueQuoted returns unquotedValue{}. -func (d *decodeState) valueQuoted() interface{} { - switch op := d.scanWhile(scanSkipSpace); op { - default: - d.error(errPhase) - - case scanBeginArray: - d.array(reflect.Value{}) - - case scanBeginObject: - d.object(reflect.Value{}) - - case scanBeginLiteral: - switch v := d.literalInterface().(type) { - case nil, string: - return v - } - } - return unquotedValue{} -} - -// indirect walks down v allocating pointers as needed, -// until it gets to a non-pointer. -// if it encounters an Unmarshaler, indirect stops and returns that. -// if decodingNull is true, indirect stops at the last pointer so it can be set to nil. -func (d *decodeState) indirect(v reflect.Value, decodingNull bool) (Unmarshaler, encoding.TextUnmarshaler, reflect.Value) { - // If v is a named type and is addressable, - // start with its address, so that if the type has pointer methods, - // we find them. - if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() { - v = v.Addr() - } - for { - // Load value from interface, but only if the result will be - // usefully addressable. - if v.Kind() == reflect.Interface && !v.IsNil() { - e := v.Elem() - if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) { - v = e - continue - } - } - - if v.Kind() != reflect.Ptr { - break - } - - if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() { - break - } - if v.IsNil() { - v.Set(reflect.New(v.Type().Elem())) - } - if v.Type().NumMethod() > 0 { - if u, ok := v.Interface().(Unmarshaler); ok { - return u, nil, reflect.Value{} - } - if u, ok := v.Interface().(encoding.TextUnmarshaler); ok { - return nil, u, reflect.Value{} - } - } - v = v.Elem() - } - return nil, nil, v -} - -// array consumes an array from d.data[d.off-1:], decoding into the value v. -// the first byte of the array ('[') has been read already. -func (d *decodeState) array(v reflect.Value) { - // Check for unmarshaler. - u, ut, pv := d.indirect(v, false) - if u != nil { - d.off-- - err := u.UnmarshalJSON(d.next()) - if err != nil { - d.error(err) - } - return - } - if ut != nil { - d.saveError(&UnmarshalTypeError{"array", v.Type(), int64(d.off)}) - d.off-- - d.next() - return - } - - v = pv - - // Check type of target. - switch v.Kind() { - case reflect.Interface: - if v.NumMethod() == 0 { - // Decoding into nil interface? Switch to non-reflect code. - v.Set(reflect.ValueOf(d.arrayInterface())) - return - } - // Otherwise it's invalid. - fallthrough - default: - d.saveError(&UnmarshalTypeError{"array", v.Type(), int64(d.off)}) - d.off-- - d.next() - return - case reflect.Array: - case reflect.Slice: - break - } - - i := 0 - for { - // Look ahead for ] - can only happen on first iteration. - op := d.scanWhile(scanSkipSpace) - if op == scanEndArray { - break - } - - // Back up so d.value can have the byte we just read. - d.off-- - d.scan.undo(op) - - // Get element of array, growing if necessary. - if v.Kind() == reflect.Slice { - // Grow slice if necessary - if i >= v.Cap() { - newcap := v.Cap() + v.Cap()/2 - if newcap < 4 { - newcap = 4 - } - newv := reflect.MakeSlice(v.Type(), v.Len(), newcap) - reflect.Copy(newv, v) - v.Set(newv) - } - if i >= v.Len() { - v.SetLen(i + 1) - } - } - - if i < v.Len() { - // Decode into element. - d.value(v.Index(i)) - } else { - // Ran out of fixed array: skip. - d.value(reflect.Value{}) - } - i++ - - // Next token must be , or ]. - op = d.scanWhile(scanSkipSpace) - if op == scanEndArray { - break - } - if op != scanArrayValue { - d.error(errPhase) - } - } - - if i < v.Len() { - if v.Kind() == reflect.Array { - // Array. Zero the rest. - z := reflect.Zero(v.Type().Elem()) - for ; i < v.Len(); i++ { - v.Index(i).Set(z) - } - } else { - v.SetLen(i) - } - } - if i == 0 && v.Kind() == reflect.Slice { - v.Set(reflect.MakeSlice(v.Type(), 0, 0)) - } -} - -var nullLiteral = []byte("null") - -// object consumes an object from d.data[d.off-1:], decoding into the value v. -// the first byte ('{') of the object has been read already. -func (d *decodeState) object(v reflect.Value) { - // Check for unmarshaler. - u, ut, pv := d.indirect(v, false) - if u != nil { - d.off-- - err := u.UnmarshalJSON(d.next()) - if err != nil { - d.error(err) - } - return - } - if ut != nil { - d.saveError(&UnmarshalTypeError{"object", v.Type(), int64(d.off)}) - d.off-- - d.next() // skip over { } in input - return - } - v = pv - - // Decoding into nil interface? Switch to non-reflect code. - if v.Kind() == reflect.Interface && v.NumMethod() == 0 { - v.Set(reflect.ValueOf(d.objectInterface())) - return - } - - // Check type of target: struct or map[string]T - switch v.Kind() { - case reflect.Map: - // map must have string kind - t := v.Type() - if t.Key().Kind() != reflect.String { - d.saveError(&UnmarshalTypeError{"object", v.Type(), int64(d.off)}) - d.off-- - d.next() // skip over { } in input - return - } - if v.IsNil() { - v.Set(reflect.MakeMap(t)) - } - case reflect.Struct: - - default: - d.saveError(&UnmarshalTypeError{"object", v.Type(), int64(d.off)}) - d.off-- - d.next() // skip over { } in input - return - } - - var mapElem reflect.Value - keys := map[string]bool{} - - for { - // Read opening " of string key or closing }. - op := d.scanWhile(scanSkipSpace) - if op == scanEndObject { - // closing } - can only happen on first iteration. - break - } - if op != scanBeginLiteral { - d.error(errPhase) - } - - // Read key. - start := d.off - 1 - op = d.scanWhile(scanContinue) - item := d.data[start : d.off-1] - key, ok := unquote(item) - if !ok { - d.error(errPhase) - } - - // Check for duplicate keys. - _, ok = keys[key] - if !ok { - keys[key] = true - } else { - d.error(fmt.Errorf("json: duplicate key '%s' in object", key)) - } - - // Figure out field corresponding to key. - var subv reflect.Value - destring := false // whether the value is wrapped in a string to be decoded first - - if v.Kind() == reflect.Map { - elemType := v.Type().Elem() - if !mapElem.IsValid() { - mapElem = reflect.New(elemType).Elem() - } else { - mapElem.Set(reflect.Zero(elemType)) - } - subv = mapElem - } else { - var f *field - fields := cachedTypeFields(v.Type()) - for i := range fields { - ff := &fields[i] - if bytes.Equal(ff.nameBytes, []byte(key)) { - f = ff - break - } - } - if f != nil { - subv = v - destring = f.quoted - for _, i := range f.index { - if subv.Kind() == reflect.Ptr { - if subv.IsNil() { - subv.Set(reflect.New(subv.Type().Elem())) - } - subv = subv.Elem() - } - subv = subv.Field(i) - } - } - } - - // Read : before value. - if op == scanSkipSpace { - op = d.scanWhile(scanSkipSpace) - } - if op != scanObjectKey { - d.error(errPhase) - } - - // Read value. - if destring { - switch qv := d.valueQuoted().(type) { - case nil: - d.literalStore(nullLiteral, subv, false) - case string: - d.literalStore([]byte(qv), subv, true) - default: - d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", subv.Type())) - } - } else { - d.value(subv) - } - - // Write value back to map; - // if using struct, subv points into struct already. - if v.Kind() == reflect.Map { - kv := reflect.ValueOf(key).Convert(v.Type().Key()) - v.SetMapIndex(kv, subv) - } - - // Next token must be , or }. - op = d.scanWhile(scanSkipSpace) - if op == scanEndObject { - break - } - if op != scanObjectValue { - d.error(errPhase) - } - } -} - -// literal consumes a literal from d.data[d.off-1:], decoding into the value v. -// The first byte of the literal has been read already -// (that's how the caller knows it's a literal). -func (d *decodeState) literal(v reflect.Value) { - // All bytes inside literal return scanContinue op code. - start := d.off - 1 - op := d.scanWhile(scanContinue) - - // Scan read one byte too far; back up. - d.off-- - d.scan.undo(op) - - d.literalStore(d.data[start:d.off], v, false) -} - -// convertNumber converts the number literal s to a float64, int64 or a Number -// depending on d.numberDecodeType. -func (d *decodeState) convertNumber(s string) (interface{}, error) { - switch d.numberType { - - case UnmarshalJSONNumber: - return Number(s), nil - case UnmarshalIntOrFloat: - v, err := strconv.ParseInt(s, 10, 64) - if err == nil { - return v, nil - } - - // tries to parse integer number in scientific notation - f, err := strconv.ParseFloat(s, 64) - if err != nil { - return nil, &UnmarshalTypeError{"number " + s, reflect.TypeOf(0.0), int64(d.off)} - } - - // if it has no decimal value use int64 - if fi, fd := math.Modf(f); fd == 0.0 { - return int64(fi), nil - } - return f, nil - default: - f, err := strconv.ParseFloat(s, 64) - if err != nil { - return nil, &UnmarshalTypeError{"number " + s, reflect.TypeOf(0.0), int64(d.off)} - } - return f, nil - } - -} - -var numberType = reflect.TypeOf(Number("")) - -// literalStore decodes a literal stored in item into v. -// -// fromQuoted indicates whether this literal came from unwrapping a -// string from the ",string" struct tag option. this is used only to -// produce more helpful error messages. -func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool) { - // Check for unmarshaler. - if len(item) == 0 { - //Empty string given - d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())) - return - } - wantptr := item[0] == 'n' // null - u, ut, pv := d.indirect(v, wantptr) - if u != nil { - err := u.UnmarshalJSON(item) - if err != nil { - d.error(err) - } - return - } - if ut != nil { - if item[0] != '"' { - if fromQuoted { - d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())) - } else { - d.saveError(&UnmarshalTypeError{"string", v.Type(), int64(d.off)}) - } - return - } - s, ok := unquoteBytes(item) - if !ok { - if fromQuoted { - d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())) - } else { - d.error(errPhase) - } - } - err := ut.UnmarshalText(s) - if err != nil { - d.error(err) - } - return - } - - v = pv - - switch c := item[0]; c { - case 'n': // null - switch v.Kind() { - case reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice: - v.Set(reflect.Zero(v.Type())) - // otherwise, ignore null for primitives/string - } - case 't', 'f': // true, false - value := c == 't' - switch v.Kind() { - default: - if fromQuoted { - d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())) - } else { - d.saveError(&UnmarshalTypeError{"bool", v.Type(), int64(d.off)}) - } - case reflect.Bool: - v.SetBool(value) - case reflect.Interface: - if v.NumMethod() == 0 { - v.Set(reflect.ValueOf(value)) - } else { - d.saveError(&UnmarshalTypeError{"bool", v.Type(), int64(d.off)}) - } - } - - case '"': // string - s, ok := unquoteBytes(item) - if !ok { - if fromQuoted { - d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())) - } else { - d.error(errPhase) - } - } - switch v.Kind() { - default: - d.saveError(&UnmarshalTypeError{"string", v.Type(), int64(d.off)}) - case reflect.Slice: - if v.Type().Elem().Kind() != reflect.Uint8 { - d.saveError(&UnmarshalTypeError{"string", v.Type(), int64(d.off)}) - break - } - b := make([]byte, base64.StdEncoding.DecodedLen(len(s))) - n, err := base64.StdEncoding.Decode(b, s) - if err != nil { - d.saveError(err) - break - } - v.SetBytes(b[:n]) - case reflect.String: - v.SetString(string(s)) - case reflect.Interface: - if v.NumMethod() == 0 { - v.Set(reflect.ValueOf(string(s))) - } else { - d.saveError(&UnmarshalTypeError{"string", v.Type(), int64(d.off)}) - } - } - - default: // number - if c != '-' && (c < '0' || c > '9') { - if fromQuoted { - d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())) - } else { - d.error(errPhase) - } - } - s := string(item) - switch v.Kind() { - default: - if v.Kind() == reflect.String && v.Type() == numberType { - v.SetString(s) - if !isValidNumber(s) { - d.error(fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", item)) - } - break - } - if fromQuoted { - d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())) - } else { - d.error(&UnmarshalTypeError{"number", v.Type(), int64(d.off)}) - } - case reflect.Interface: - n, err := d.convertNumber(s) - if err != nil { - d.saveError(err) - break - } - if v.NumMethod() != 0 { - d.saveError(&UnmarshalTypeError{"number", v.Type(), int64(d.off)}) - break - } - v.Set(reflect.ValueOf(n)) - - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - n, err := strconv.ParseInt(s, 10, 64) - if err != nil || v.OverflowInt(n) { - d.saveError(&UnmarshalTypeError{"number " + s, v.Type(), int64(d.off)}) - break - } - v.SetInt(n) - - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: - n, err := strconv.ParseUint(s, 10, 64) - if err != nil || v.OverflowUint(n) { - d.saveError(&UnmarshalTypeError{"number " + s, v.Type(), int64(d.off)}) - break - } - v.SetUint(n) - - case reflect.Float32, reflect.Float64: - n, err := strconv.ParseFloat(s, v.Type().Bits()) - if err != nil || v.OverflowFloat(n) { - d.saveError(&UnmarshalTypeError{"number " + s, v.Type(), int64(d.off)}) - break - } - v.SetFloat(n) - } - } -} - -// The xxxInterface routines build up a value to be stored -// in an empty interface. They are not strictly necessary, -// but they avoid the weight of reflection in this common case. - -// valueInterface is like value but returns interface{} -func (d *decodeState) valueInterface() interface{} { - switch d.scanWhile(scanSkipSpace) { - default: - d.error(errPhase) - panic("unreachable") - case scanBeginArray: - return d.arrayInterface() - case scanBeginObject: - return d.objectInterface() - case scanBeginLiteral: - return d.literalInterface() - } -} - -// arrayInterface is like array but returns []interface{}. -func (d *decodeState) arrayInterface() []interface{} { - var v = make([]interface{}, 0) - for { - // Look ahead for ] - can only happen on first iteration. - op := d.scanWhile(scanSkipSpace) - if op == scanEndArray { - break - } - - // Back up so d.value can have the byte we just read. - d.off-- - d.scan.undo(op) - - v = append(v, d.valueInterface()) - - // Next token must be , or ]. - op = d.scanWhile(scanSkipSpace) - if op == scanEndArray { - break - } - if op != scanArrayValue { - d.error(errPhase) - } - } - return v -} - -// objectInterface is like object but returns map[string]interface{}. -func (d *decodeState) objectInterface() map[string]interface{} { - m := make(map[string]interface{}) - keys := map[string]bool{} - - for { - // Read opening " of string key or closing }. - op := d.scanWhile(scanSkipSpace) - if op == scanEndObject { - // closing } - can only happen on first iteration. - break - } - if op != scanBeginLiteral { - d.error(errPhase) - } - - // Read string key. - start := d.off - 1 - op = d.scanWhile(scanContinue) - item := d.data[start : d.off-1] - key, ok := unquote(item) - if !ok { - d.error(errPhase) - } - - // Check for duplicate keys. - _, ok = keys[key] - if !ok { - keys[key] = true - } else { - d.error(fmt.Errorf("json: duplicate key '%s' in object", key)) - } - - // Read : before value. - if op == scanSkipSpace { - op = d.scanWhile(scanSkipSpace) - } - if op != scanObjectKey { - d.error(errPhase) - } - - // Read value. - m[key] = d.valueInterface() - - // Next token must be , or }. - op = d.scanWhile(scanSkipSpace) - if op == scanEndObject { - break - } - if op != scanObjectValue { - d.error(errPhase) - } - } - return m -} - -// literalInterface is like literal but returns an interface value. -func (d *decodeState) literalInterface() interface{} { - // All bytes inside literal return scanContinue op code. - start := d.off - 1 - op := d.scanWhile(scanContinue) - - // Scan read one byte too far; back up. - d.off-- - d.scan.undo(op) - item := d.data[start:d.off] - - switch c := item[0]; c { - case 'n': // null - return nil - - case 't', 'f': // true, false - return c == 't' - - case '"': // string - s, ok := unquote(item) - if !ok { - d.error(errPhase) - } - return s - - default: // number - if c != '-' && (c < '0' || c > '9') { - d.error(errPhase) - } - n, err := d.convertNumber(string(item)) - if err != nil { - d.saveError(err) - } - return n - } -} - -// getu4 decodes \uXXXX from the beginning of s, returning the hex value, -// or it returns -1. -func getu4(s []byte) rune { - if len(s) < 6 || s[0] != '\\' || s[1] != 'u' { - return -1 - } - r, err := strconv.ParseUint(string(s[2:6]), 16, 64) - if err != nil { - return -1 - } - return rune(r) -} - -// unquote converts a quoted JSON string literal s into an actual string t. -// The rules are different than for Go, so cannot use strconv.Unquote. -func unquote(s []byte) (t string, ok bool) { - s, ok = unquoteBytes(s) - t = string(s) - return -} - -func unquoteBytes(s []byte) (t []byte, ok bool) { - if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' { - return - } - s = s[1 : len(s)-1] - - // Check for unusual characters. If there are none, - // then no unquoting is needed, so return a slice of the - // original bytes. - r := 0 - for r < len(s) { - c := s[r] - if c == '\\' || c == '"' || c < ' ' { - break - } - if c < utf8.RuneSelf { - r++ - continue - } - rr, size := utf8.DecodeRune(s[r:]) - if rr == utf8.RuneError && size == 1 { - break - } - r += size - } - if r == len(s) { - return s, true - } - - b := make([]byte, len(s)+2*utf8.UTFMax) - w := copy(b, s[0:r]) - for r < len(s) { - // Out of room? Can only happen if s is full of - // malformed UTF-8 and we're replacing each - // byte with RuneError. - if w >= len(b)-2*utf8.UTFMax { - nb := make([]byte, (len(b)+utf8.UTFMax)*2) - copy(nb, b[0:w]) - b = nb - } - switch c := s[r]; { - case c == '\\': - r++ - if r >= len(s) { - return - } - switch s[r] { - default: - return - case '"', '\\', '/', '\'': - b[w] = s[r] - r++ - w++ - case 'b': - b[w] = '\b' - r++ - w++ - case 'f': - b[w] = '\f' - r++ - w++ - case 'n': - b[w] = '\n' - r++ - w++ - case 'r': - b[w] = '\r' - r++ - w++ - case 't': - b[w] = '\t' - r++ - w++ - case 'u': - r-- - rr := getu4(s[r:]) - if rr < 0 { - return - } - r += 6 - if utf16.IsSurrogate(rr) { - rr1 := getu4(s[r:]) - if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar { - // A valid pair; consume. - r += 6 - w += utf8.EncodeRune(b[w:], dec) - break - } - // Invalid surrogate; fall back to replacement rune. - rr = unicode.ReplacementChar - } - w += utf8.EncodeRune(b[w:], rr) - } - - // Quote, control characters are invalid. - case c == '"', c < ' ': - return - - // ASCII - case c < utf8.RuneSelf: - b[w] = c - r++ - w++ - - // Coerce to well-formed UTF-8. - default: - rr, size := utf8.DecodeRune(s[r:]) - r += size - w += utf8.EncodeRune(b[w:], rr) - } - } - return b[0:w], true -} diff --git a/vendor/github.com/go-jose/go-jose/v4/json/encode.go b/vendor/github.com/go-jose/go-jose/v4/json/encode.go deleted file mode 100644 index 98de68ce1e9..00000000000 --- a/vendor/github.com/go-jose/go-jose/v4/json/encode.go +++ /dev/null @@ -1,1197 +0,0 @@ -// Copyright 2010 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 json implements encoding and decoding of JSON objects as defined in -// RFC 4627. The mapping between JSON objects and Go values is described -// in the documentation for the Marshal and Unmarshal functions. -// -// See "JSON and Go" for an introduction to this package: -// https://golang.org/doc/articles/json_and_go.html -package json - -import ( - "bytes" - "encoding" - "encoding/base64" - "fmt" - "math" - "reflect" - "runtime" - "sort" - "strconv" - "strings" - "sync" - "unicode" - "unicode/utf8" -) - -// Marshal returns the JSON encoding of v. -// -// Marshal traverses the value v recursively. -// If an encountered value implements the Marshaler interface -// and is not a nil pointer, Marshal calls its MarshalJSON method -// to produce JSON. If no MarshalJSON method is present but the -// value implements encoding.TextMarshaler instead, Marshal calls -// its MarshalText method. -// The nil pointer exception is not strictly necessary -// but mimics a similar, necessary exception in the behavior of -// UnmarshalJSON. -// -// Otherwise, Marshal uses the following type-dependent default encodings: -// -// Boolean values encode as JSON booleans. -// -// Floating point, integer, and Number values encode as JSON numbers. -// -// String values encode as JSON strings coerced to valid UTF-8, -// replacing invalid bytes with the Unicode replacement rune. -// The angle brackets "<" and ">" are escaped to "\u003c" and "\u003e" -// to keep some browsers from misinterpreting JSON output as HTML. -// Ampersand "&" is also escaped to "\u0026" for the same reason. -// -// Array and slice values encode as JSON arrays, except that -// []byte encodes as a base64-encoded string, and a nil slice -// encodes as the null JSON object. -// -// Struct values encode as JSON objects. Each exported struct field -// becomes a member of the object unless -// - the field's tag is "-", or -// - the field is empty and its tag specifies the "omitempty" option. -// -// The empty values are false, 0, any -// nil pointer or interface value, and any array, slice, map, or string of -// length zero. The object's default key string is the struct field name -// but can be specified in the struct field's tag value. The "json" key in -// the struct field's tag value is the key name, followed by an optional comma -// and options. Examples: -// -// // Field is ignored by this package. -// Field int `json:"-"` -// -// // Field appears in JSON as key "myName". -// Field int `json:"myName"` -// -// // Field appears in JSON as key "myName" and -// // the field is omitted from the object if its value is empty, -// // as defined above. -// Field int `json:"myName,omitempty"` -// -// // Field appears in JSON as key "Field" (the default), but -// // the field is skipped if empty. -// // Note the leading comma. -// Field int `json:",omitempty"` -// -// The "string" option signals that a field is stored as JSON inside a -// JSON-encoded string. It applies only to fields of string, floating point, -// integer, or boolean types. This extra level of encoding is sometimes used -// when communicating with JavaScript programs: -// -// Int64String int64 `json:",string"` -// -// The key name will be used if it's a non-empty string consisting of -// only Unicode letters, digits, dollar signs, percent signs, hyphens, -// underscores and slashes. -// -// Anonymous struct fields are usually marshaled as if their inner exported fields -// were fields in the outer struct, subject to the usual Go visibility rules amended -// as described in the next paragraph. -// An anonymous struct field with a name given in its JSON tag is treated as -// having that name, rather than being anonymous. -// An anonymous struct field of interface type is treated the same as having -// that type as its name, rather than being anonymous. -// -// The Go visibility rules for struct fields are amended for JSON when -// deciding which field to marshal or unmarshal. If there are -// multiple fields at the same level, and that level is the least -// nested (and would therefore be the nesting level selected by the -// usual Go rules), the following extra rules apply: -// -// 1) Of those fields, if any are JSON-tagged, only tagged fields are considered, -// even if there are multiple untagged fields that would otherwise conflict. -// 2) If there is exactly one field (tagged or not according to the first rule), that is selected. -// 3) Otherwise there are multiple fields, and all are ignored; no error occurs. -// -// Handling of anonymous struct fields is new in Go 1.1. -// Prior to Go 1.1, anonymous struct fields were ignored. To force ignoring of -// an anonymous struct field in both current and earlier versions, give the field -// a JSON tag of "-". -// -// Map values encode as JSON objects. -// The map's key type must be string; the map keys are used as JSON object -// keys, subject to the UTF-8 coercion described for string values above. -// -// Pointer values encode as the value pointed to. -// A nil pointer encodes as the null JSON object. -// -// Interface values encode as the value contained in the interface. -// A nil interface value encodes as the null JSON object. -// -// Channel, complex, and function values cannot be encoded in JSON. -// Attempting to encode such a value causes Marshal to return -// an UnsupportedTypeError. -// -// JSON cannot represent cyclic data structures and Marshal does not -// handle them. Passing cyclic structures to Marshal will result in -// an infinite recursion. -func Marshal(v interface{}) ([]byte, error) { - e := &encodeState{} - err := e.marshal(v) - if err != nil { - return nil, err - } - return e.Bytes(), nil -} - -// MarshalIndent is like Marshal but applies Indent to format the output. -func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) { - b, err := Marshal(v) - if err != nil { - return nil, err - } - var buf bytes.Buffer - err = Indent(&buf, b, prefix, indent) - if err != nil { - return nil, err - } - return buf.Bytes(), nil -} - -// HTMLEscape appends to dst the JSON-encoded src with <, >, &, U+2028 and U+2029 -// characters inside string literals changed to \u003c, \u003e, \u0026, \u2028, \u2029 -// so that the JSON will be safe to embed inside HTML