/ as a fallback.
+ f, err = os.Open("/proc/self/task/" + strconv.Itoa(unix.Gettid()) + "/mountinfo")
+ if os.IsNotExist(err) {
+ // If /proc/self/task/... failed, it means that our active pid
+ // namespace doesn't match the pid namespace of the /proc mount. In
+ // this case we just have to make do with /proc/self, since there
+ // is no other way of figuring out our tid in a parent pid
+ // namespace on pre-3.17 kernels.
+ f, err = os.Open("/proc/self/mountinfo")
+ }
+ }
if err != nil {
return nil, err
}
@@ -158,10 +194,10 @@ func PidMountInfo(pid int) ([]*Info, error) {
// A few specific characters in mountinfo path entries (root and mountpoint)
// are escaped using a backslash followed by a character's ascii code in octal.
//
-// space -- as \040
-// tab (aka \t) -- as \011
-// newline (aka \n) -- as \012
-// backslash (aka \\) -- as \134
+// space -- as \040
+// tab (aka \t) -- as \011
+// newline (aka \n) -- as \012
+// backslash (aka \\) -- as \134
//
// This function converts path from mountinfo back, i.e. it unescapes the above sequences.
func unescape(path string) (string, error) {
diff --git a/vendor/golang.org/x/crypto/LICENSE b/vendor/golang.org/x/crypto/LICENSE
index 6a66aea5ea..2a7cf70da6 100644
--- a/vendor/golang.org/x/crypto/LICENSE
+++ b/vendor/golang.org/x/crypto/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
+Copyright 2009 The Go Authors.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
@@ -10,7 +10,7 @@ notice, this list of conditions and the following disclaimer.
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
+ * Neither the name of Google LLC nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
diff --git a/vendor/golang.org/x/crypto/acme/http.go b/vendor/golang.org/x/crypto/acme/http.go
index 58836e5d30..d92ff232fe 100644
--- a/vendor/golang.org/x/crypto/acme/http.go
+++ b/vendor/golang.org/x/crypto/acme/http.go
@@ -15,6 +15,7 @@ import (
"io"
"math/big"
"net/http"
+ "runtime/debug"
"strconv"
"strings"
"time"
@@ -271,9 +272,27 @@ func (c *Client) httpClient() *http.Client {
}
// packageVersion is the version of the module that contains this package, for
-// sending as part of the User-Agent header. It's set in version_go112.go.
+// sending as part of the User-Agent header.
var packageVersion string
+func init() {
+ // Set packageVersion if the binary was built in modules mode and x/crypto
+ // was not replaced with a different module.
+ info, ok := debug.ReadBuildInfo()
+ if !ok {
+ return
+ }
+ for _, m := range info.Deps {
+ if m.Path != "golang.org/x/crypto" {
+ continue
+ }
+ if m.Replace == nil {
+ packageVersion = m.Version
+ }
+ break
+ }
+}
+
// userAgent returns the User-Agent header value. It includes the package name,
// the module version (if available), and the c.UserAgent value (if set).
func (c *Client) userAgent() string {
diff --git a/vendor/golang.org/x/crypto/acme/version_go112.go b/vendor/golang.org/x/crypto/acme/version_go112.go
deleted file mode 100644
index cc5fab604b..0000000000
--- a/vendor/golang.org/x/crypto/acme/version_go112.go
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2019 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 go1.12
-
-package acme
-
-import "runtime/debug"
-
-func init() {
- // Set packageVersion if the binary was built in modules mode and x/crypto
- // was not replaced with a different module.
- info, ok := debug.ReadBuildInfo()
- if !ok {
- return
- }
- for _, m := range info.Deps {
- if m.Path != "golang.org/x/crypto" {
- continue
- }
- if m.Replace == nil {
- packageVersion = m.Version
- }
- break
- }
-}
diff --git a/vendor/golang.org/x/crypto/cryptobyte/asn1/asn1.go b/vendor/golang.org/x/crypto/cryptobyte/asn1/asn1.go
index cda8e3edfd..90ef6a241d 100644
--- a/vendor/golang.org/x/crypto/cryptobyte/asn1/asn1.go
+++ b/vendor/golang.org/x/crypto/cryptobyte/asn1/asn1.go
@@ -4,7 +4,7 @@
// Package asn1 contains supporting types for parsing and building ASN.1
// messages with the cryptobyte package.
-package asn1 // import "golang.org/x/crypto/cryptobyte/asn1"
+package asn1
// Tag represents an ASN.1 identifier octet, consisting of a tag number
// (indicating a type) and class (such as context-specific or constructed).
diff --git a/vendor/golang.org/x/crypto/cryptobyte/string.go b/vendor/golang.org/x/crypto/cryptobyte/string.go
index 10692a8a31..4b0f8097f9 100644
--- a/vendor/golang.org/x/crypto/cryptobyte/string.go
+++ b/vendor/golang.org/x/crypto/cryptobyte/string.go
@@ -15,7 +15,7 @@
//
// See the documentation and examples for the Builder and String types to get
// started.
-package cryptobyte // import "golang.org/x/crypto/cryptobyte"
+package cryptobyte
// String represents a string of bytes. It provides methods for parsing
// fixed-length and length-prefixed values from it.
diff --git a/vendor/golang.org/x/crypto/hkdf/hkdf.go b/vendor/golang.org/x/crypto/hkdf/hkdf.go
index f4ded5fee2..3bee66294e 100644
--- a/vendor/golang.org/x/crypto/hkdf/hkdf.go
+++ b/vendor/golang.org/x/crypto/hkdf/hkdf.go
@@ -8,7 +8,7 @@
// HKDF is a cryptographic key derivation function (KDF) with the goal of
// expanding limited input keying material into one or more cryptographically
// strong secret keys.
-package hkdf // import "golang.org/x/crypto/hkdf"
+package hkdf
import (
"crypto/hmac"
diff --git a/vendor/golang.org/x/crypto/internal/poly1305/mac_noasm.go b/vendor/golang.org/x/crypto/internal/poly1305/mac_noasm.go
index 333da285b3..bd896bdc76 100644
--- a/vendor/golang.org/x/crypto/internal/poly1305/mac_noasm.go
+++ b/vendor/golang.org/x/crypto/internal/poly1305/mac_noasm.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-//go:build (!amd64 && !ppc64le && !s390x) || !gc || purego
+//go:build (!amd64 && !ppc64le && !ppc64 && !s390x) || !gc || purego
package poly1305
diff --git a/vendor/golang.org/x/crypto/internal/poly1305/sum_amd64.s b/vendor/golang.org/x/crypto/internal/poly1305/sum_amd64.s
index e0d3c64756..133757384b 100644
--- a/vendor/golang.org/x/crypto/internal/poly1305/sum_amd64.s
+++ b/vendor/golang.org/x/crypto/internal/poly1305/sum_amd64.s
@@ -1,108 +1,93 @@
-// 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.
+// Code generated by command: go run sum_amd64_asm.go -out ../sum_amd64.s -pkg poly1305. DO NOT EDIT.
//go:build gc && !purego
-#include "textflag.h"
-
-#define POLY1305_ADD(msg, h0, h1, h2) \
- ADDQ 0(msg), h0; \
- ADCQ 8(msg), h1; \
- ADCQ $1, h2; \
- LEAQ 16(msg), msg
-
-#define POLY1305_MUL(h0, h1, h2, r0, r1, t0, t1, t2, t3) \
- MOVQ r0, AX; \
- MULQ h0; \
- MOVQ AX, t0; \
- MOVQ DX, t1; \
- MOVQ r0, AX; \
- MULQ h1; \
- ADDQ AX, t1; \
- ADCQ $0, DX; \
- MOVQ r0, t2; \
- IMULQ h2, t2; \
- ADDQ DX, t2; \
- \
- MOVQ r1, AX; \
- MULQ h0; \
- ADDQ AX, t1; \
- ADCQ $0, DX; \
- MOVQ DX, h0; \
- MOVQ r1, t3; \
- IMULQ h2, t3; \
- MOVQ r1, AX; \
- MULQ h1; \
- ADDQ AX, t2; \
- ADCQ DX, t3; \
- ADDQ h0, t2; \
- ADCQ $0, t3; \
- \
- MOVQ t0, h0; \
- MOVQ t1, h1; \
- MOVQ t2, h2; \
- ANDQ $3, h2; \
- MOVQ t2, t0; \
- ANDQ $0xFFFFFFFFFFFFFFFC, t0; \
- ADDQ t0, h0; \
- ADCQ t3, h1; \
- ADCQ $0, h2; \
- SHRQ $2, t3, t2; \
- SHRQ $2, t3; \
- ADDQ t2, h0; \
- ADCQ t3, h1; \
- ADCQ $0, h2
-
-// func update(state *[7]uint64, msg []byte)
+// func update(state *macState, msg []byte)
TEXT ·update(SB), $0-32
MOVQ state+0(FP), DI
MOVQ msg_base+8(FP), SI
MOVQ msg_len+16(FP), R15
-
- MOVQ 0(DI), R8 // h0
- MOVQ 8(DI), R9 // h1
- MOVQ 16(DI), R10 // h2
- MOVQ 24(DI), R11 // r0
- MOVQ 32(DI), R12 // r1
-
- CMPQ R15, $16
+ MOVQ (DI), R8
+ MOVQ 8(DI), R9
+ MOVQ 16(DI), R10
+ MOVQ 24(DI), R11
+ MOVQ 32(DI), R12
+ CMPQ R15, $0x10
JB bytes_between_0_and_15
loop:
- POLY1305_ADD(SI, R8, R9, R10)
+ ADDQ (SI), R8
+ ADCQ 8(SI), R9
+ ADCQ $0x01, R10
+ LEAQ 16(SI), SI
multiply:
- POLY1305_MUL(R8, R9, R10, R11, R12, BX, CX, R13, R14)
- SUBQ $16, R15
- CMPQ R15, $16
- JAE loop
+ MOVQ R11, AX
+ MULQ R8
+ MOVQ AX, BX
+ MOVQ DX, CX
+ MOVQ R11, AX
+ MULQ R9
+ ADDQ AX, CX
+ ADCQ $0x00, DX
+ MOVQ R11, R13
+ IMULQ R10, R13
+ ADDQ DX, R13
+ MOVQ R12, AX
+ MULQ R8
+ ADDQ AX, CX
+ ADCQ $0x00, DX
+ MOVQ DX, R8
+ MOVQ R12, R14
+ IMULQ R10, R14
+ MOVQ R12, AX
+ MULQ R9
+ ADDQ AX, R13
+ ADCQ DX, R14
+ ADDQ R8, R13
+ ADCQ $0x00, R14
+ MOVQ BX, R8
+ MOVQ CX, R9
+ MOVQ R13, R10
+ ANDQ $0x03, R10
+ MOVQ R13, BX
+ ANDQ $-4, BX
+ ADDQ BX, R8
+ ADCQ R14, R9
+ ADCQ $0x00, R10
+ SHRQ $0x02, R14, R13
+ SHRQ $0x02, R14
+ ADDQ R13, R8
+ ADCQ R14, R9
+ ADCQ $0x00, R10
+ SUBQ $0x10, R15
+ CMPQ R15, $0x10
+ JAE loop
bytes_between_0_and_15:
TESTQ R15, R15
JZ done
- MOVQ $1, BX
+ MOVQ $0x00000001, BX
XORQ CX, CX
XORQ R13, R13
ADDQ R15, SI
flush_buffer:
- SHLQ $8, BX, CX
- SHLQ $8, BX
+ SHLQ $0x08, BX, CX
+ SHLQ $0x08, BX
MOVB -1(SI), R13
XORQ R13, BX
DECQ SI
DECQ R15
JNZ flush_buffer
-
ADDQ BX, R8
ADCQ CX, R9
- ADCQ $0, R10
- MOVQ $16, R15
+ ADCQ $0x00, R10
+ MOVQ $0x00000010, R15
JMP multiply
done:
- MOVQ R8, 0(DI)
+ MOVQ R8, (DI)
MOVQ R9, 8(DI)
MOVQ R10, 16(DI)
RET
diff --git a/vendor/golang.org/x/crypto/internal/poly1305/sum_ppc64le.go b/vendor/golang.org/x/crypto/internal/poly1305/sum_ppc64x.go
similarity index 95%
rename from vendor/golang.org/x/crypto/internal/poly1305/sum_ppc64le.go
rename to vendor/golang.org/x/crypto/internal/poly1305/sum_ppc64x.go
index 4aec4874b5..1a1679aaad 100644
--- a/vendor/golang.org/x/crypto/internal/poly1305/sum_ppc64le.go
+++ b/vendor/golang.org/x/crypto/internal/poly1305/sum_ppc64x.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-//go:build gc && !purego
+//go:build gc && !purego && (ppc64 || ppc64le)
package poly1305
diff --git a/vendor/golang.org/x/crypto/internal/poly1305/sum_ppc64le.s b/vendor/golang.org/x/crypto/internal/poly1305/sum_ppc64x.s
similarity index 89%
rename from vendor/golang.org/x/crypto/internal/poly1305/sum_ppc64le.s
rename to vendor/golang.org/x/crypto/internal/poly1305/sum_ppc64x.s
index b3c1699bff..6899a1dabc 100644
--- a/vendor/golang.org/x/crypto/internal/poly1305/sum_ppc64le.s
+++ b/vendor/golang.org/x/crypto/internal/poly1305/sum_ppc64x.s
@@ -2,15 +2,25 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-//go:build gc && !purego
+//go:build gc && !purego && (ppc64 || ppc64le)
#include "textflag.h"
// This was ported from the amd64 implementation.
+#ifdef GOARCH_ppc64le
+#define LE_MOVD MOVD
+#define LE_MOVWZ MOVWZ
+#define LE_MOVHZ MOVHZ
+#else
+#define LE_MOVD MOVDBR
+#define LE_MOVWZ MOVWBR
+#define LE_MOVHZ MOVHBR
+#endif
+
#define POLY1305_ADD(msg, h0, h1, h2, t0, t1, t2) \
- MOVD (msg), t0; \
- MOVD 8(msg), t1; \
+ LE_MOVD (msg)( R0), t0; \
+ LE_MOVD (msg)(R24), t1; \
MOVD $1, t2; \
ADDC t0, h0, h0; \
ADDE t1, h1, h1; \
@@ -50,10 +60,6 @@
ADDE t3, h1, h1; \
ADDZE h2
-DATA ·poly1305Mask<>+0x00(SB)/8, $0x0FFFFFFC0FFFFFFF
-DATA ·poly1305Mask<>+0x08(SB)/8, $0x0FFFFFFC0FFFFFFC
-GLOBL ·poly1305Mask<>(SB), RODATA, $16
-
// func update(state *[7]uint64, msg []byte)
TEXT ·update(SB), $0-32
MOVD state+0(FP), R3
@@ -66,6 +72,8 @@ TEXT ·update(SB), $0-32
MOVD 24(R3), R11 // r0
MOVD 32(R3), R12 // r1
+ MOVD $8, R24
+
CMP R5, $16
BLT bytes_between_0_and_15
@@ -94,7 +102,7 @@ flush_buffer:
// Greater than 8 -- load the rightmost remaining bytes in msg
// and put into R17 (h1)
- MOVD (R4)(R21), R17
+ LE_MOVD (R4)(R21), R17
MOVD $16, R22
// Find the offset to those bytes
@@ -118,7 +126,7 @@ just1:
BLT less8
// Exactly 8
- MOVD (R4), R16
+ LE_MOVD (R4), R16
CMP R17, $0
@@ -133,7 +141,7 @@ less8:
MOVD $0, R22 // shift count
CMP R5, $4
BLT less4
- MOVWZ (R4), R16
+ LE_MOVWZ (R4), R16
ADD $4, R4
ADD $-4, R5
MOVD $32, R22
@@ -141,7 +149,7 @@ less8:
less4:
CMP R5, $2
BLT less2
- MOVHZ (R4), R21
+ LE_MOVHZ (R4), R21
SLD R22, R21, R21
OR R16, R21, R16
ADD $16, R22
diff --git a/vendor/golang.org/x/crypto/nacl/secretbox/secretbox.go b/vendor/golang.org/x/crypto/nacl/secretbox/secretbox.go
index f3c3242a04..1fe600ad03 100644
--- a/vendor/golang.org/x/crypto/nacl/secretbox/secretbox.go
+++ b/vendor/golang.org/x/crypto/nacl/secretbox/secretbox.go
@@ -32,7 +32,7 @@ chunk size.
This package is interoperable with NaCl: https://nacl.cr.yp.to/secretbox.html.
*/
-package secretbox // import "golang.org/x/crypto/nacl/secretbox"
+package secretbox
import (
"golang.org/x/crypto/internal/alias"
diff --git a/vendor/golang.org/x/crypto/salsa20/salsa/hsalsa20.go b/vendor/golang.org/x/crypto/salsa20/salsa/hsalsa20.go
index 3fd05b2751..3685b34458 100644
--- a/vendor/golang.org/x/crypto/salsa20/salsa/hsalsa20.go
+++ b/vendor/golang.org/x/crypto/salsa20/salsa/hsalsa20.go
@@ -3,7 +3,7 @@
// license that can be found in the LICENSE file.
// Package salsa provides low-level access to functions in the Salsa family.
-package salsa // import "golang.org/x/crypto/salsa20/salsa"
+package salsa
import "math/bits"
diff --git a/vendor/golang.org/x/crypto/salsa20/salsa/salsa20_amd64.s b/vendor/golang.org/x/crypto/salsa20/salsa/salsa20_amd64.s
index fcce0234b6..3883e0ec22 100644
--- a/vendor/golang.org/x/crypto/salsa20/salsa/salsa20_amd64.s
+++ b/vendor/golang.org/x/crypto/salsa20/salsa/salsa20_amd64.s
@@ -1,880 +1,880 @@
-// 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.
+// Code generated by command: go run salsa20_amd64_asm.go -out ../salsa20_amd64.s -pkg salsa. DO NOT EDIT.
//go:build amd64 && !purego && gc
-// This code was translated into a form compatible with 6a from the public
-// domain sources in SUPERCOP: https://bench.cr.yp.to/supercop.html
+// func salsa2020XORKeyStream(out *byte, in *byte, n uint64, nonce *byte, key *byte)
+// Requires: SSE2
+TEXT ·salsa2020XORKeyStream(SB), $456-40
+ // This needs up to 64 bytes at 360(R12); hence the non-obvious frame size.
+ MOVQ out+0(FP), DI
+ MOVQ in+8(FP), SI
+ MOVQ n+16(FP), DX
+ MOVQ nonce+24(FP), CX
+ MOVQ key+32(FP), R8
+ MOVQ SP, R12
+ ADDQ $0x1f, R12
+ ANDQ $-32, R12
+ MOVQ DX, R9
+ MOVQ CX, DX
+ MOVQ R8, R10
+ CMPQ R9, $0x00
+ JBE DONE
+ MOVL 20(R10), CX
+ MOVL (R10), R8
+ MOVL (DX), AX
+ MOVL 16(R10), R11
+ MOVL CX, (R12)
+ MOVL R8, 4(R12)
+ MOVL AX, 8(R12)
+ MOVL R11, 12(R12)
+ MOVL 8(DX), CX
+ MOVL 24(R10), R8
+ MOVL 4(R10), AX
+ MOVL 4(DX), R11
+ MOVL CX, 16(R12)
+ MOVL R8, 20(R12)
+ MOVL AX, 24(R12)
+ MOVL R11, 28(R12)
+ MOVL 12(DX), CX
+ MOVL 12(R10), DX
+ MOVL 28(R10), R8
+ MOVL 8(R10), AX
+ MOVL DX, 32(R12)
+ MOVL CX, 36(R12)
+ MOVL R8, 40(R12)
+ MOVL AX, 44(R12)
+ MOVQ $0x61707865, DX
+ MOVQ $0x3320646e, CX
+ MOVQ $0x79622d32, R8
+ MOVQ $0x6b206574, AX
+ MOVL DX, 48(R12)
+ MOVL CX, 52(R12)
+ MOVL R8, 56(R12)
+ MOVL AX, 60(R12)
+ CMPQ R9, $0x00000100
+ JB BYTESBETWEEN1AND255
+ MOVOA 48(R12), X0
+ PSHUFL $0x55, X0, X1
+ PSHUFL $0xaa, X0, X2
+ PSHUFL $0xff, X0, X3
+ PSHUFL $0x00, X0, X0
+ MOVOA X1, 64(R12)
+ MOVOA X2, 80(R12)
+ MOVOA X3, 96(R12)
+ MOVOA X0, 112(R12)
+ MOVOA (R12), X0
+ PSHUFL $0xaa, X0, X1
+ PSHUFL $0xff, X0, X2
+ PSHUFL $0x00, X0, X3
+ PSHUFL $0x55, X0, X0
+ MOVOA X1, 128(R12)
+ MOVOA X2, 144(R12)
+ MOVOA X3, 160(R12)
+ MOVOA X0, 176(R12)
+ MOVOA 16(R12), X0
+ PSHUFL $0xff, X0, X1
+ PSHUFL $0x55, X0, X2
+ PSHUFL $0xaa, X0, X0
+ MOVOA X1, 192(R12)
+ MOVOA X2, 208(R12)
+ MOVOA X0, 224(R12)
+ MOVOA 32(R12), X0
+ PSHUFL $0x00, X0, X1
+ PSHUFL $0xaa, X0, X2
+ PSHUFL $0xff, X0, X0
+ MOVOA X1, 240(R12)
+ MOVOA X2, 256(R12)
+ MOVOA X0, 272(R12)
-// func salsa2020XORKeyStream(out, in *byte, n uint64, nonce, key *byte)
-// This needs up to 64 bytes at 360(R12); hence the non-obvious frame size.
-TEXT ·salsa2020XORKeyStream(SB),0,$456-40 // frame = 424 + 32 byte alignment
- MOVQ out+0(FP),DI
- MOVQ in+8(FP),SI
- MOVQ n+16(FP),DX
- MOVQ nonce+24(FP),CX
- MOVQ key+32(FP),R8
+BYTESATLEAST256:
+ MOVL 16(R12), DX
+ MOVL 36(R12), CX
+ MOVL DX, 288(R12)
+ MOVL CX, 304(R12)
+ SHLQ $0x20, CX
+ ADDQ CX, DX
+ ADDQ $0x01, DX
+ MOVQ DX, CX
+ SHRQ $0x20, CX
+ MOVL DX, 292(R12)
+ MOVL CX, 308(R12)
+ ADDQ $0x01, DX
+ MOVQ DX, CX
+ SHRQ $0x20, CX
+ MOVL DX, 296(R12)
+ MOVL CX, 312(R12)
+ ADDQ $0x01, DX
+ MOVQ DX, CX
+ SHRQ $0x20, CX
+ MOVL DX, 300(R12)
+ MOVL CX, 316(R12)
+ ADDQ $0x01, DX
+ MOVQ DX, CX
+ SHRQ $0x20, CX
+ MOVL DX, 16(R12)
+ MOVL CX, 36(R12)
+ MOVQ R9, 352(R12)
+ MOVQ $0x00000014, DX
+ MOVOA 64(R12), X0
+ MOVOA 80(R12), X1
+ MOVOA 96(R12), X2
+ MOVOA 256(R12), X3
+ MOVOA 272(R12), X4
+ MOVOA 128(R12), X5
+ MOVOA 144(R12), X6
+ MOVOA 176(R12), X7
+ MOVOA 192(R12), X8
+ MOVOA 208(R12), X9
+ MOVOA 224(R12), X10
+ MOVOA 304(R12), X11
+ MOVOA 112(R12), X12
+ MOVOA 160(R12), X13
+ MOVOA 240(R12), X14
+ MOVOA 288(R12), X15
- MOVQ SP,R12
- ADDQ $31, R12
- ANDQ $~31, R12
+MAINLOOP1:
+ MOVOA X1, 320(R12)
+ MOVOA X2, 336(R12)
+ MOVOA X13, X1
+ PADDL X12, X1
+ MOVOA X1, X2
+ PSLLL $0x07, X1
+ PXOR X1, X14
+ PSRLL $0x19, X2
+ PXOR X2, X14
+ MOVOA X7, X1
+ PADDL X0, X1
+ MOVOA X1, X2
+ PSLLL $0x07, X1
+ PXOR X1, X11
+ PSRLL $0x19, X2
+ PXOR X2, X11
+ MOVOA X12, X1
+ PADDL X14, X1
+ MOVOA X1, X2
+ PSLLL $0x09, X1
+ PXOR X1, X15
+ PSRLL $0x17, X2
+ PXOR X2, X15
+ MOVOA X0, X1
+ PADDL X11, X1
+ MOVOA X1, X2
+ PSLLL $0x09, X1
+ PXOR X1, X9
+ PSRLL $0x17, X2
+ PXOR X2, X9
+ MOVOA X14, X1
+ PADDL X15, X1
+ MOVOA X1, X2
+ PSLLL $0x0d, X1
+ PXOR X1, X13
+ PSRLL $0x13, X2
+ PXOR X2, X13
+ MOVOA X11, X1
+ PADDL X9, X1
+ MOVOA X1, X2
+ PSLLL $0x0d, X1
+ PXOR X1, X7
+ PSRLL $0x13, X2
+ PXOR X2, X7
+ MOVOA X15, X1
+ PADDL X13, X1
+ MOVOA X1, X2
+ PSLLL $0x12, X1
+ PXOR X1, X12
+ PSRLL $0x0e, X2
+ PXOR X2, X12
+ MOVOA 320(R12), X1
+ MOVOA X12, 320(R12)
+ MOVOA X9, X2
+ PADDL X7, X2
+ MOVOA X2, X12
+ PSLLL $0x12, X2
+ PXOR X2, X0
+ PSRLL $0x0e, X12
+ PXOR X12, X0
+ MOVOA X5, X2
+ PADDL X1, X2
+ MOVOA X2, X12
+ PSLLL $0x07, X2
+ PXOR X2, X3
+ PSRLL $0x19, X12
+ PXOR X12, X3
+ MOVOA 336(R12), X2
+ MOVOA X0, 336(R12)
+ MOVOA X6, X0
+ PADDL X2, X0
+ MOVOA X0, X12
+ PSLLL $0x07, X0
+ PXOR X0, X4
+ PSRLL $0x19, X12
+ PXOR X12, X4
+ MOVOA X1, X0
+ PADDL X3, X0
+ MOVOA X0, X12
+ PSLLL $0x09, X0
+ PXOR X0, X10
+ PSRLL $0x17, X12
+ PXOR X12, X10
+ MOVOA X2, X0
+ PADDL X4, X0
+ MOVOA X0, X12
+ PSLLL $0x09, X0
+ PXOR X0, X8
+ PSRLL $0x17, X12
+ PXOR X12, X8
+ MOVOA X3, X0
+ PADDL X10, X0
+ MOVOA X0, X12
+ PSLLL $0x0d, X0
+ PXOR X0, X5
+ PSRLL $0x13, X12
+ PXOR X12, X5
+ MOVOA X4, X0
+ PADDL X8, X0
+ MOVOA X0, X12
+ PSLLL $0x0d, X0
+ PXOR X0, X6
+ PSRLL $0x13, X12
+ PXOR X12, X6
+ MOVOA X10, X0
+ PADDL X5, X0
+ MOVOA X0, X12
+ PSLLL $0x12, X0
+ PXOR X0, X1
+ PSRLL $0x0e, X12
+ PXOR X12, X1
+ MOVOA 320(R12), X0
+ MOVOA X1, 320(R12)
+ MOVOA X4, X1
+ PADDL X0, X1
+ MOVOA X1, X12
+ PSLLL $0x07, X1
+ PXOR X1, X7
+ PSRLL $0x19, X12
+ PXOR X12, X7
+ MOVOA X8, X1
+ PADDL X6, X1
+ MOVOA X1, X12
+ PSLLL $0x12, X1
+ PXOR X1, X2
+ PSRLL $0x0e, X12
+ PXOR X12, X2
+ MOVOA 336(R12), X12
+ MOVOA X2, 336(R12)
+ MOVOA X14, X1
+ PADDL X12, X1
+ MOVOA X1, X2
+ PSLLL $0x07, X1
+ PXOR X1, X5
+ PSRLL $0x19, X2
+ PXOR X2, X5
+ MOVOA X0, X1
+ PADDL X7, X1
+ MOVOA X1, X2
+ PSLLL $0x09, X1
+ PXOR X1, X10
+ PSRLL $0x17, X2
+ PXOR X2, X10
+ MOVOA X12, X1
+ PADDL X5, X1
+ MOVOA X1, X2
+ PSLLL $0x09, X1
+ PXOR X1, X8
+ PSRLL $0x17, X2
+ PXOR X2, X8
+ MOVOA X7, X1
+ PADDL X10, X1
+ MOVOA X1, X2
+ PSLLL $0x0d, X1
+ PXOR X1, X4
+ PSRLL $0x13, X2
+ PXOR X2, X4
+ MOVOA X5, X1
+ PADDL X8, X1
+ MOVOA X1, X2
+ PSLLL $0x0d, X1
+ PXOR X1, X14
+ PSRLL $0x13, X2
+ PXOR X2, X14
+ MOVOA X10, X1
+ PADDL X4, X1
+ MOVOA X1, X2
+ PSLLL $0x12, X1
+ PXOR X1, X0
+ PSRLL $0x0e, X2
+ PXOR X2, X0
+ MOVOA 320(R12), X1
+ MOVOA X0, 320(R12)
+ MOVOA X8, X0
+ PADDL X14, X0
+ MOVOA X0, X2
+ PSLLL $0x12, X0
+ PXOR X0, X12
+ PSRLL $0x0e, X2
+ PXOR X2, X12
+ MOVOA X11, X0
+ PADDL X1, X0
+ MOVOA X0, X2
+ PSLLL $0x07, X0
+ PXOR X0, X6
+ PSRLL $0x19, X2
+ PXOR X2, X6
+ MOVOA 336(R12), X2
+ MOVOA X12, 336(R12)
+ MOVOA X3, X0
+ PADDL X2, X0
+ MOVOA X0, X12
+ PSLLL $0x07, X0
+ PXOR X0, X13
+ PSRLL $0x19, X12
+ PXOR X12, X13
+ MOVOA X1, X0
+ PADDL X6, X0
+ MOVOA X0, X12
+ PSLLL $0x09, X0
+ PXOR X0, X15
+ PSRLL $0x17, X12
+ PXOR X12, X15
+ MOVOA X2, X0
+ PADDL X13, X0
+ MOVOA X0, X12
+ PSLLL $0x09, X0
+ PXOR X0, X9
+ PSRLL $0x17, X12
+ PXOR X12, X9
+ MOVOA X6, X0
+ PADDL X15, X0
+ MOVOA X0, X12
+ PSLLL $0x0d, X0
+ PXOR X0, X11
+ PSRLL $0x13, X12
+ PXOR X12, X11
+ MOVOA X13, X0
+ PADDL X9, X0
+ MOVOA X0, X12
+ PSLLL $0x0d, X0
+ PXOR X0, X3
+ PSRLL $0x13, X12
+ PXOR X12, X3
+ MOVOA X15, X0
+ PADDL X11, X0
+ MOVOA X0, X12
+ PSLLL $0x12, X0
+ PXOR X0, X1
+ PSRLL $0x0e, X12
+ PXOR X12, X1
+ MOVOA X9, X0
+ PADDL X3, X0
+ MOVOA X0, X12
+ PSLLL $0x12, X0
+ PXOR X0, X2
+ PSRLL $0x0e, X12
+ PXOR X12, X2
+ MOVOA 320(R12), X12
+ MOVOA 336(R12), X0
+ SUBQ $0x02, DX
+ JA MAINLOOP1
+ PADDL 112(R12), X12
+ PADDL 176(R12), X7
+ PADDL 224(R12), X10
+ PADDL 272(R12), X4
+ MOVD X12, DX
+ MOVD X7, CX
+ MOVD X10, R8
+ MOVD X4, R9
+ PSHUFL $0x39, X12, X12
+ PSHUFL $0x39, X7, X7
+ PSHUFL $0x39, X10, X10
+ PSHUFL $0x39, X4, X4
+ XORL (SI), DX
+ XORL 4(SI), CX
+ XORL 8(SI), R8
+ XORL 12(SI), R9
+ MOVL DX, (DI)
+ MOVL CX, 4(DI)
+ MOVL R8, 8(DI)
+ MOVL R9, 12(DI)
+ MOVD X12, DX
+ MOVD X7, CX
+ MOVD X10, R8
+ MOVD X4, R9
+ PSHUFL $0x39, X12, X12
+ PSHUFL $0x39, X7, X7
+ PSHUFL $0x39, X10, X10
+ PSHUFL $0x39, X4, X4
+ XORL 64(SI), DX
+ XORL 68(SI), CX
+ XORL 72(SI), R8
+ XORL 76(SI), R9
+ MOVL DX, 64(DI)
+ MOVL CX, 68(DI)
+ MOVL R8, 72(DI)
+ MOVL R9, 76(DI)
+ MOVD X12, DX
+ MOVD X7, CX
+ MOVD X10, R8
+ MOVD X4, R9
+ PSHUFL $0x39, X12, X12
+ PSHUFL $0x39, X7, X7
+ PSHUFL $0x39, X10, X10
+ PSHUFL $0x39, X4, X4
+ XORL 128(SI), DX
+ XORL 132(SI), CX
+ XORL 136(SI), R8
+ XORL 140(SI), R9
+ MOVL DX, 128(DI)
+ MOVL CX, 132(DI)
+ MOVL R8, 136(DI)
+ MOVL R9, 140(DI)
+ MOVD X12, DX
+ MOVD X7, CX
+ MOVD X10, R8
+ MOVD X4, R9
+ XORL 192(SI), DX
+ XORL 196(SI), CX
+ XORL 200(SI), R8
+ XORL 204(SI), R9
+ MOVL DX, 192(DI)
+ MOVL CX, 196(DI)
+ MOVL R8, 200(DI)
+ MOVL R9, 204(DI)
+ PADDL 240(R12), X14
+ PADDL 64(R12), X0
+ PADDL 128(R12), X5
+ PADDL 192(R12), X8
+ MOVD X14, DX
+ MOVD X0, CX
+ MOVD X5, R8
+ MOVD X8, R9
+ PSHUFL $0x39, X14, X14
+ PSHUFL $0x39, X0, X0
+ PSHUFL $0x39, X5, X5
+ PSHUFL $0x39, X8, X8
+ XORL 16(SI), DX
+ XORL 20(SI), CX
+ XORL 24(SI), R8
+ XORL 28(SI), R9
+ MOVL DX, 16(DI)
+ MOVL CX, 20(DI)
+ MOVL R8, 24(DI)
+ MOVL R9, 28(DI)
+ MOVD X14, DX
+ MOVD X0, CX
+ MOVD X5, R8
+ MOVD X8, R9
+ PSHUFL $0x39, X14, X14
+ PSHUFL $0x39, X0, X0
+ PSHUFL $0x39, X5, X5
+ PSHUFL $0x39, X8, X8
+ XORL 80(SI), DX
+ XORL 84(SI), CX
+ XORL 88(SI), R8
+ XORL 92(SI), R9
+ MOVL DX, 80(DI)
+ MOVL CX, 84(DI)
+ MOVL R8, 88(DI)
+ MOVL R9, 92(DI)
+ MOVD X14, DX
+ MOVD X0, CX
+ MOVD X5, R8
+ MOVD X8, R9
+ PSHUFL $0x39, X14, X14
+ PSHUFL $0x39, X0, X0
+ PSHUFL $0x39, X5, X5
+ PSHUFL $0x39, X8, X8
+ XORL 144(SI), DX
+ XORL 148(SI), CX
+ XORL 152(SI), R8
+ XORL 156(SI), R9
+ MOVL DX, 144(DI)
+ MOVL CX, 148(DI)
+ MOVL R8, 152(DI)
+ MOVL R9, 156(DI)
+ MOVD X14, DX
+ MOVD X0, CX
+ MOVD X5, R8
+ MOVD X8, R9
+ XORL 208(SI), DX
+ XORL 212(SI), CX
+ XORL 216(SI), R8
+ XORL 220(SI), R9
+ MOVL DX, 208(DI)
+ MOVL CX, 212(DI)
+ MOVL R8, 216(DI)
+ MOVL R9, 220(DI)
+ PADDL 288(R12), X15
+ PADDL 304(R12), X11
+ PADDL 80(R12), X1
+ PADDL 144(R12), X6
+ MOVD X15, DX
+ MOVD X11, CX
+ MOVD X1, R8
+ MOVD X6, R9
+ PSHUFL $0x39, X15, X15
+ PSHUFL $0x39, X11, X11
+ PSHUFL $0x39, X1, X1
+ PSHUFL $0x39, X6, X6
+ XORL 32(SI), DX
+ XORL 36(SI), CX
+ XORL 40(SI), R8
+ XORL 44(SI), R9
+ MOVL DX, 32(DI)
+ MOVL CX, 36(DI)
+ MOVL R8, 40(DI)
+ MOVL R9, 44(DI)
+ MOVD X15, DX
+ MOVD X11, CX
+ MOVD X1, R8
+ MOVD X6, R9
+ PSHUFL $0x39, X15, X15
+ PSHUFL $0x39, X11, X11
+ PSHUFL $0x39, X1, X1
+ PSHUFL $0x39, X6, X6
+ XORL 96(SI), DX
+ XORL 100(SI), CX
+ XORL 104(SI), R8
+ XORL 108(SI), R9
+ MOVL DX, 96(DI)
+ MOVL CX, 100(DI)
+ MOVL R8, 104(DI)
+ MOVL R9, 108(DI)
+ MOVD X15, DX
+ MOVD X11, CX
+ MOVD X1, R8
+ MOVD X6, R9
+ PSHUFL $0x39, X15, X15
+ PSHUFL $0x39, X11, X11
+ PSHUFL $0x39, X1, X1
+ PSHUFL $0x39, X6, X6
+ XORL 160(SI), DX
+ XORL 164(SI), CX
+ XORL 168(SI), R8
+ XORL 172(SI), R9
+ MOVL DX, 160(DI)
+ MOVL CX, 164(DI)
+ MOVL R8, 168(DI)
+ MOVL R9, 172(DI)
+ MOVD X15, DX
+ MOVD X11, CX
+ MOVD X1, R8
+ MOVD X6, R9
+ XORL 224(SI), DX
+ XORL 228(SI), CX
+ XORL 232(SI), R8
+ XORL 236(SI), R9
+ MOVL DX, 224(DI)
+ MOVL CX, 228(DI)
+ MOVL R8, 232(DI)
+ MOVL R9, 236(DI)
+ PADDL 160(R12), X13
+ PADDL 208(R12), X9
+ PADDL 256(R12), X3
+ PADDL 96(R12), X2
+ MOVD X13, DX
+ MOVD X9, CX
+ MOVD X3, R8
+ MOVD X2, R9
+ PSHUFL $0x39, X13, X13
+ PSHUFL $0x39, X9, X9
+ PSHUFL $0x39, X3, X3
+ PSHUFL $0x39, X2, X2
+ XORL 48(SI), DX
+ XORL 52(SI), CX
+ XORL 56(SI), R8
+ XORL 60(SI), R9
+ MOVL DX, 48(DI)
+ MOVL CX, 52(DI)
+ MOVL R8, 56(DI)
+ MOVL R9, 60(DI)
+ MOVD X13, DX
+ MOVD X9, CX
+ MOVD X3, R8
+ MOVD X2, R9
+ PSHUFL $0x39, X13, X13
+ PSHUFL $0x39, X9, X9
+ PSHUFL $0x39, X3, X3
+ PSHUFL $0x39, X2, X2
+ XORL 112(SI), DX
+ XORL 116(SI), CX
+ XORL 120(SI), R8
+ XORL 124(SI), R9
+ MOVL DX, 112(DI)
+ MOVL CX, 116(DI)
+ MOVL R8, 120(DI)
+ MOVL R9, 124(DI)
+ MOVD X13, DX
+ MOVD X9, CX
+ MOVD X3, R8
+ MOVD X2, R9
+ PSHUFL $0x39, X13, X13
+ PSHUFL $0x39, X9, X9
+ PSHUFL $0x39, X3, X3
+ PSHUFL $0x39, X2, X2
+ XORL 176(SI), DX
+ XORL 180(SI), CX
+ XORL 184(SI), R8
+ XORL 188(SI), R9
+ MOVL DX, 176(DI)
+ MOVL CX, 180(DI)
+ MOVL R8, 184(DI)
+ MOVL R9, 188(DI)
+ MOVD X13, DX
+ MOVD X9, CX
+ MOVD X3, R8
+ MOVD X2, R9
+ XORL 240(SI), DX
+ XORL 244(SI), CX
+ XORL 248(SI), R8
+ XORL 252(SI), R9
+ MOVL DX, 240(DI)
+ MOVL CX, 244(DI)
+ MOVL R8, 248(DI)
+ MOVL R9, 252(DI)
+ MOVQ 352(R12), R9
+ SUBQ $0x00000100, R9
+ ADDQ $0x00000100, SI
+ ADDQ $0x00000100, DI
+ CMPQ R9, $0x00000100
+ JAE BYTESATLEAST256
+ CMPQ R9, $0x00
+ JBE DONE
- MOVQ DX,R9
- MOVQ CX,DX
- MOVQ R8,R10
- CMPQ R9,$0
- JBE DONE
- START:
- MOVL 20(R10),CX
- MOVL 0(R10),R8
- MOVL 0(DX),AX
- MOVL 16(R10),R11
- MOVL CX,0(R12)
- MOVL R8, 4 (R12)
- MOVL AX, 8 (R12)
- MOVL R11, 12 (R12)
- MOVL 8(DX),CX
- MOVL 24(R10),R8
- MOVL 4(R10),AX
- MOVL 4(DX),R11
- MOVL CX,16(R12)
- MOVL R8, 20 (R12)
- MOVL AX, 24 (R12)
- MOVL R11, 28 (R12)
- MOVL 12(DX),CX
- MOVL 12(R10),DX
- MOVL 28(R10),R8
- MOVL 8(R10),AX
- MOVL DX,32(R12)
- MOVL CX, 36 (R12)
- MOVL R8, 40 (R12)
- MOVL AX, 44 (R12)
- MOVQ $1634760805,DX
- MOVQ $857760878,CX
- MOVQ $2036477234,R8
- MOVQ $1797285236,AX
- MOVL DX,48(R12)
- MOVL CX, 52 (R12)
- MOVL R8, 56 (R12)
- MOVL AX, 60 (R12)
- CMPQ R9,$256
- JB BYTESBETWEEN1AND255
- MOVOA 48(R12),X0
- PSHUFL $0X55,X0,X1
- PSHUFL $0XAA,X0,X2
- PSHUFL $0XFF,X0,X3
- PSHUFL $0X00,X0,X0
- MOVOA X1,64(R12)
- MOVOA X2,80(R12)
- MOVOA X3,96(R12)
- MOVOA X0,112(R12)
- MOVOA 0(R12),X0
- PSHUFL $0XAA,X0,X1
- PSHUFL $0XFF,X0,X2
- PSHUFL $0X00,X0,X3
- PSHUFL $0X55,X0,X0
- MOVOA X1,128(R12)
- MOVOA X2,144(R12)
- MOVOA X3,160(R12)
- MOVOA X0,176(R12)
- MOVOA 16(R12),X0
- PSHUFL $0XFF,X0,X1
- PSHUFL $0X55,X0,X2
- PSHUFL $0XAA,X0,X0
- MOVOA X1,192(R12)
- MOVOA X2,208(R12)
- MOVOA X0,224(R12)
- MOVOA 32(R12),X0
- PSHUFL $0X00,X0,X1
- PSHUFL $0XAA,X0,X2
- PSHUFL $0XFF,X0,X0
- MOVOA X1,240(R12)
- MOVOA X2,256(R12)
- MOVOA X0,272(R12)
- BYTESATLEAST256:
- MOVL 16(R12),DX
- MOVL 36 (R12),CX
- MOVL DX,288(R12)
- MOVL CX,304(R12)
- SHLQ $32,CX
- ADDQ CX,DX
- ADDQ $1,DX
- MOVQ DX,CX
- SHRQ $32,CX
- MOVL DX, 292 (R12)
- MOVL CX, 308 (R12)
- ADDQ $1,DX
- MOVQ DX,CX
- SHRQ $32,CX
- MOVL DX, 296 (R12)
- MOVL CX, 312 (R12)
- ADDQ $1,DX
- MOVQ DX,CX
- SHRQ $32,CX
- MOVL DX, 300 (R12)
- MOVL CX, 316 (R12)
- ADDQ $1,DX
- MOVQ DX,CX
- SHRQ $32,CX
- MOVL DX,16(R12)
- MOVL CX, 36 (R12)
- MOVQ R9,352(R12)
- MOVQ $20,DX
- MOVOA 64(R12),X0
- MOVOA 80(R12),X1
- MOVOA 96(R12),X2
- MOVOA 256(R12),X3
- MOVOA 272(R12),X4
- MOVOA 128(R12),X5
- MOVOA 144(R12),X6
- MOVOA 176(R12),X7
- MOVOA 192(R12),X8
- MOVOA 208(R12),X9
- MOVOA 224(R12),X10
- MOVOA 304(R12),X11
- MOVOA 112(R12),X12
- MOVOA 160(R12),X13
- MOVOA 240(R12),X14
- MOVOA 288(R12),X15
- MAINLOOP1:
- MOVOA X1,320(R12)
- MOVOA X2,336(R12)
- MOVOA X13,X1
- PADDL X12,X1
- MOVOA X1,X2
- PSLLL $7,X1
- PXOR X1,X14
- PSRLL $25,X2
- PXOR X2,X14
- MOVOA X7,X1
- PADDL X0,X1
- MOVOA X1,X2
- PSLLL $7,X1
- PXOR X1,X11
- PSRLL $25,X2
- PXOR X2,X11
- MOVOA X12,X1
- PADDL X14,X1
- MOVOA X1,X2
- PSLLL $9,X1
- PXOR X1,X15
- PSRLL $23,X2
- PXOR X2,X15
- MOVOA X0,X1
- PADDL X11,X1
- MOVOA X1,X2
- PSLLL $9,X1
- PXOR X1,X9
- PSRLL $23,X2
- PXOR X2,X9
- MOVOA X14,X1
- PADDL X15,X1
- MOVOA X1,X2
- PSLLL $13,X1
- PXOR X1,X13
- PSRLL $19,X2
- PXOR X2,X13
- MOVOA X11,X1
- PADDL X9,X1
- MOVOA X1,X2
- PSLLL $13,X1
- PXOR X1,X7
- PSRLL $19,X2
- PXOR X2,X7
- MOVOA X15,X1
- PADDL X13,X1
- MOVOA X1,X2
- PSLLL $18,X1
- PXOR X1,X12
- PSRLL $14,X2
- PXOR X2,X12
- MOVOA 320(R12),X1
- MOVOA X12,320(R12)
- MOVOA X9,X2
- PADDL X7,X2
- MOVOA X2,X12
- PSLLL $18,X2
- PXOR X2,X0
- PSRLL $14,X12
- PXOR X12,X0
- MOVOA X5,X2
- PADDL X1,X2
- MOVOA X2,X12
- PSLLL $7,X2
- PXOR X2,X3
- PSRLL $25,X12
- PXOR X12,X3
- MOVOA 336(R12),X2
- MOVOA X0,336(R12)
- MOVOA X6,X0
- PADDL X2,X0
- MOVOA X0,X12
- PSLLL $7,X0
- PXOR X0,X4
- PSRLL $25,X12
- PXOR X12,X4
- MOVOA X1,X0
- PADDL X3,X0
- MOVOA X0,X12
- PSLLL $9,X0
- PXOR X0,X10
- PSRLL $23,X12
- PXOR X12,X10
- MOVOA X2,X0
- PADDL X4,X0
- MOVOA X0,X12
- PSLLL $9,X0
- PXOR X0,X8
- PSRLL $23,X12
- PXOR X12,X8
- MOVOA X3,X0
- PADDL X10,X0
- MOVOA X0,X12
- PSLLL $13,X0
- PXOR X0,X5
- PSRLL $19,X12
- PXOR X12,X5
- MOVOA X4,X0
- PADDL X8,X0
- MOVOA X0,X12
- PSLLL $13,X0
- PXOR X0,X6
- PSRLL $19,X12
- PXOR X12,X6
- MOVOA X10,X0
- PADDL X5,X0
- MOVOA X0,X12
- PSLLL $18,X0
- PXOR X0,X1
- PSRLL $14,X12
- PXOR X12,X1
- MOVOA 320(R12),X0
- MOVOA X1,320(R12)
- MOVOA X4,X1
- PADDL X0,X1
- MOVOA X1,X12
- PSLLL $7,X1
- PXOR X1,X7
- PSRLL $25,X12
- PXOR X12,X7
- MOVOA X8,X1
- PADDL X6,X1
- MOVOA X1,X12
- PSLLL $18,X1
- PXOR X1,X2
- PSRLL $14,X12
- PXOR X12,X2
- MOVOA 336(R12),X12
- MOVOA X2,336(R12)
- MOVOA X14,X1
- PADDL X12,X1
- MOVOA X1,X2
- PSLLL $7,X1
- PXOR X1,X5
- PSRLL $25,X2
- PXOR X2,X5
- MOVOA X0,X1
- PADDL X7,X1
- MOVOA X1,X2
- PSLLL $9,X1
- PXOR X1,X10
- PSRLL $23,X2
- PXOR X2,X10
- MOVOA X12,X1
- PADDL X5,X1
- MOVOA X1,X2
- PSLLL $9,X1
- PXOR X1,X8
- PSRLL $23,X2
- PXOR X2,X8
- MOVOA X7,X1
- PADDL X10,X1
- MOVOA X1,X2
- PSLLL $13,X1
- PXOR X1,X4
- PSRLL $19,X2
- PXOR X2,X4
- MOVOA X5,X1
- PADDL X8,X1
- MOVOA X1,X2
- PSLLL $13,X1
- PXOR X1,X14
- PSRLL $19,X2
- PXOR X2,X14
- MOVOA X10,X1
- PADDL X4,X1
- MOVOA X1,X2
- PSLLL $18,X1
- PXOR X1,X0
- PSRLL $14,X2
- PXOR X2,X0
- MOVOA 320(R12),X1
- MOVOA X0,320(R12)
- MOVOA X8,X0
- PADDL X14,X0
- MOVOA X0,X2
- PSLLL $18,X0
- PXOR X0,X12
- PSRLL $14,X2
- PXOR X2,X12
- MOVOA X11,X0
- PADDL X1,X0
- MOVOA X0,X2
- PSLLL $7,X0
- PXOR X0,X6
- PSRLL $25,X2
- PXOR X2,X6
- MOVOA 336(R12),X2
- MOVOA X12,336(R12)
- MOVOA X3,X0
- PADDL X2,X0
- MOVOA X0,X12
- PSLLL $7,X0
- PXOR X0,X13
- PSRLL $25,X12
- PXOR X12,X13
- MOVOA X1,X0
- PADDL X6,X0
- MOVOA X0,X12
- PSLLL $9,X0
- PXOR X0,X15
- PSRLL $23,X12
- PXOR X12,X15
- MOVOA X2,X0
- PADDL X13,X0
- MOVOA X0,X12
- PSLLL $9,X0
- PXOR X0,X9
- PSRLL $23,X12
- PXOR X12,X9
- MOVOA X6,X0
- PADDL X15,X0
- MOVOA X0,X12
- PSLLL $13,X0
- PXOR X0,X11
- PSRLL $19,X12
- PXOR X12,X11
- MOVOA X13,X0
- PADDL X9,X0
- MOVOA X0,X12
- PSLLL $13,X0
- PXOR X0,X3
- PSRLL $19,X12
- PXOR X12,X3
- MOVOA X15,X0
- PADDL X11,X0
- MOVOA X0,X12
- PSLLL $18,X0
- PXOR X0,X1
- PSRLL $14,X12
- PXOR X12,X1
- MOVOA X9,X0
- PADDL X3,X0
- MOVOA X0,X12
- PSLLL $18,X0
- PXOR X0,X2
- PSRLL $14,X12
- PXOR X12,X2
- MOVOA 320(R12),X12
- MOVOA 336(R12),X0
- SUBQ $2,DX
- JA MAINLOOP1
- PADDL 112(R12),X12
- PADDL 176(R12),X7
- PADDL 224(R12),X10
- PADDL 272(R12),X4
- MOVD X12,DX
- MOVD X7,CX
- MOVD X10,R8
- MOVD X4,R9
- PSHUFL $0X39,X12,X12
- PSHUFL $0X39,X7,X7
- PSHUFL $0X39,X10,X10
- PSHUFL $0X39,X4,X4
- XORL 0(SI),DX
- XORL 4(SI),CX
- XORL 8(SI),R8
- XORL 12(SI),R9
- MOVL DX,0(DI)
- MOVL CX,4(DI)
- MOVL R8,8(DI)
- MOVL R9,12(DI)
- MOVD X12,DX
- MOVD X7,CX
- MOVD X10,R8
- MOVD X4,R9
- PSHUFL $0X39,X12,X12
- PSHUFL $0X39,X7,X7
- PSHUFL $0X39,X10,X10
- PSHUFL $0X39,X4,X4
- XORL 64(SI),DX
- XORL 68(SI),CX
- XORL 72(SI),R8
- XORL 76(SI),R9
- MOVL DX,64(DI)
- MOVL CX,68(DI)
- MOVL R8,72(DI)
- MOVL R9,76(DI)
- MOVD X12,DX
- MOVD X7,CX
- MOVD X10,R8
- MOVD X4,R9
- PSHUFL $0X39,X12,X12
- PSHUFL $0X39,X7,X7
- PSHUFL $0X39,X10,X10
- PSHUFL $0X39,X4,X4
- XORL 128(SI),DX
- XORL 132(SI),CX
- XORL 136(SI),R8
- XORL 140(SI),R9
- MOVL DX,128(DI)
- MOVL CX,132(DI)
- MOVL R8,136(DI)
- MOVL R9,140(DI)
- MOVD X12,DX
- MOVD X7,CX
- MOVD X10,R8
- MOVD X4,R9
- XORL 192(SI),DX
- XORL 196(SI),CX
- XORL 200(SI),R8
- XORL 204(SI),R9
- MOVL DX,192(DI)
- MOVL CX,196(DI)
- MOVL R8,200(DI)
- MOVL R9,204(DI)
- PADDL 240(R12),X14
- PADDL 64(R12),X0
- PADDL 128(R12),X5
- PADDL 192(R12),X8
- MOVD X14,DX
- MOVD X0,CX
- MOVD X5,R8
- MOVD X8,R9
- PSHUFL $0X39,X14,X14
- PSHUFL $0X39,X0,X0
- PSHUFL $0X39,X5,X5
- PSHUFL $0X39,X8,X8
- XORL 16(SI),DX
- XORL 20(SI),CX
- XORL 24(SI),R8
- XORL 28(SI),R9
- MOVL DX,16(DI)
- MOVL CX,20(DI)
- MOVL R8,24(DI)
- MOVL R9,28(DI)
- MOVD X14,DX
- MOVD X0,CX
- MOVD X5,R8
- MOVD X8,R9
- PSHUFL $0X39,X14,X14
- PSHUFL $0X39,X0,X0
- PSHUFL $0X39,X5,X5
- PSHUFL $0X39,X8,X8
- XORL 80(SI),DX
- XORL 84(SI),CX
- XORL 88(SI),R8
- XORL 92(SI),R9
- MOVL DX,80(DI)
- MOVL CX,84(DI)
- MOVL R8,88(DI)
- MOVL R9,92(DI)
- MOVD X14,DX
- MOVD X0,CX
- MOVD X5,R8
- MOVD X8,R9
- PSHUFL $0X39,X14,X14
- PSHUFL $0X39,X0,X0
- PSHUFL $0X39,X5,X5
- PSHUFL $0X39,X8,X8
- XORL 144(SI),DX
- XORL 148(SI),CX
- XORL 152(SI),R8
- XORL 156(SI),R9
- MOVL DX,144(DI)
- MOVL CX,148(DI)
- MOVL R8,152(DI)
- MOVL R9,156(DI)
- MOVD X14,DX
- MOVD X0,CX
- MOVD X5,R8
- MOVD X8,R9
- XORL 208(SI),DX
- XORL 212(SI),CX
- XORL 216(SI),R8
- XORL 220(SI),R9
- MOVL DX,208(DI)
- MOVL CX,212(DI)
- MOVL R8,216(DI)
- MOVL R9,220(DI)
- PADDL 288(R12),X15
- PADDL 304(R12),X11
- PADDL 80(R12),X1
- PADDL 144(R12),X6
- MOVD X15,DX
- MOVD X11,CX
- MOVD X1,R8
- MOVD X6,R9
- PSHUFL $0X39,X15,X15
- PSHUFL $0X39,X11,X11
- PSHUFL $0X39,X1,X1
- PSHUFL $0X39,X6,X6
- XORL 32(SI),DX
- XORL 36(SI),CX
- XORL 40(SI),R8
- XORL 44(SI),R9
- MOVL DX,32(DI)
- MOVL CX,36(DI)
- MOVL R8,40(DI)
- MOVL R9,44(DI)
- MOVD X15,DX
- MOVD X11,CX
- MOVD X1,R8
- MOVD X6,R9
- PSHUFL $0X39,X15,X15
- PSHUFL $0X39,X11,X11
- PSHUFL $0X39,X1,X1
- PSHUFL $0X39,X6,X6
- XORL 96(SI),DX
- XORL 100(SI),CX
- XORL 104(SI),R8
- XORL 108(SI),R9
- MOVL DX,96(DI)
- MOVL CX,100(DI)
- MOVL R8,104(DI)
- MOVL R9,108(DI)
- MOVD X15,DX
- MOVD X11,CX
- MOVD X1,R8
- MOVD X6,R9
- PSHUFL $0X39,X15,X15
- PSHUFL $0X39,X11,X11
- PSHUFL $0X39,X1,X1
- PSHUFL $0X39,X6,X6
- XORL 160(SI),DX
- XORL 164(SI),CX
- XORL 168(SI),R8
- XORL 172(SI),R9
- MOVL DX,160(DI)
- MOVL CX,164(DI)
- MOVL R8,168(DI)
- MOVL R9,172(DI)
- MOVD X15,DX
- MOVD X11,CX
- MOVD X1,R8
- MOVD X6,R9
- XORL 224(SI),DX
- XORL 228(SI),CX
- XORL 232(SI),R8
- XORL 236(SI),R9
- MOVL DX,224(DI)
- MOVL CX,228(DI)
- MOVL R8,232(DI)
- MOVL R9,236(DI)
- PADDL 160(R12),X13
- PADDL 208(R12),X9
- PADDL 256(R12),X3
- PADDL 96(R12),X2
- MOVD X13,DX
- MOVD X9,CX
- MOVD X3,R8
- MOVD X2,R9
- PSHUFL $0X39,X13,X13
- PSHUFL $0X39,X9,X9
- PSHUFL $0X39,X3,X3
- PSHUFL $0X39,X2,X2
- XORL 48(SI),DX
- XORL 52(SI),CX
- XORL 56(SI),R8
- XORL 60(SI),R9
- MOVL DX,48(DI)
- MOVL CX,52(DI)
- MOVL R8,56(DI)
- MOVL R9,60(DI)
- MOVD X13,DX
- MOVD X9,CX
- MOVD X3,R8
- MOVD X2,R9
- PSHUFL $0X39,X13,X13
- PSHUFL $0X39,X9,X9
- PSHUFL $0X39,X3,X3
- PSHUFL $0X39,X2,X2
- XORL 112(SI),DX
- XORL 116(SI),CX
- XORL 120(SI),R8
- XORL 124(SI),R9
- MOVL DX,112(DI)
- MOVL CX,116(DI)
- MOVL R8,120(DI)
- MOVL R9,124(DI)
- MOVD X13,DX
- MOVD X9,CX
- MOVD X3,R8
- MOVD X2,R9
- PSHUFL $0X39,X13,X13
- PSHUFL $0X39,X9,X9
- PSHUFL $0X39,X3,X3
- PSHUFL $0X39,X2,X2
- XORL 176(SI),DX
- XORL 180(SI),CX
- XORL 184(SI),R8
- XORL 188(SI),R9
- MOVL DX,176(DI)
- MOVL CX,180(DI)
- MOVL R8,184(DI)
- MOVL R9,188(DI)
- MOVD X13,DX
- MOVD X9,CX
- MOVD X3,R8
- MOVD X2,R9
- XORL 240(SI),DX
- XORL 244(SI),CX
- XORL 248(SI),R8
- XORL 252(SI),R9
- MOVL DX,240(DI)
- MOVL CX,244(DI)
- MOVL R8,248(DI)
- MOVL R9,252(DI)
- MOVQ 352(R12),R9
- SUBQ $256,R9
- ADDQ $256,SI
- ADDQ $256,DI
- CMPQ R9,$256
- JAE BYTESATLEAST256
- CMPQ R9,$0
- JBE DONE
- BYTESBETWEEN1AND255:
- CMPQ R9,$64
- JAE NOCOPY
- MOVQ DI,DX
- LEAQ 360(R12),DI
- MOVQ R9,CX
+BYTESBETWEEN1AND255:
+ CMPQ R9, $0x40
+ JAE NOCOPY
+ MOVQ DI, DX
+ LEAQ 360(R12), DI
+ MOVQ R9, CX
REP; MOVSB
- LEAQ 360(R12),DI
- LEAQ 360(R12),SI
- NOCOPY:
- MOVQ R9,352(R12)
- MOVOA 48(R12),X0
- MOVOA 0(R12),X1
- MOVOA 16(R12),X2
- MOVOA 32(R12),X3
- MOVOA X1,X4
- MOVQ $20,CX
- MAINLOOP2:
- PADDL X0,X4
- MOVOA X0,X5
- MOVOA X4,X6
- PSLLL $7,X4
- PSRLL $25,X6
- PXOR X4,X3
- PXOR X6,X3
- PADDL X3,X5
- MOVOA X3,X4
- MOVOA X5,X6
- PSLLL $9,X5
- PSRLL $23,X6
- PXOR X5,X2
- PSHUFL $0X93,X3,X3
- PXOR X6,X2
- PADDL X2,X4
- MOVOA X2,X5
- MOVOA X4,X6
- PSLLL $13,X4
- PSRLL $19,X6
- PXOR X4,X1
- PSHUFL $0X4E,X2,X2
- PXOR X6,X1
- PADDL X1,X5
- MOVOA X3,X4
- MOVOA X5,X6
- PSLLL $18,X5
- PSRLL $14,X6
- PXOR X5,X0
- PSHUFL $0X39,X1,X1
- PXOR X6,X0
- PADDL X0,X4
- MOVOA X0,X5
- MOVOA X4,X6
- PSLLL $7,X4
- PSRLL $25,X6
- PXOR X4,X1
- PXOR X6,X1
- PADDL X1,X5
- MOVOA X1,X4
- MOVOA X5,X6
- PSLLL $9,X5
- PSRLL $23,X6
- PXOR X5,X2
- PSHUFL $0X93,X1,X1
- PXOR X6,X2
- PADDL X2,X4
- MOVOA X2,X5
- MOVOA X4,X6
- PSLLL $13,X4
- PSRLL $19,X6
- PXOR X4,X3
- PSHUFL $0X4E,X2,X2
- PXOR X6,X3
- PADDL X3,X5
- MOVOA X1,X4
- MOVOA X5,X6
- PSLLL $18,X5
- PSRLL $14,X6
- PXOR X5,X0
- PSHUFL $0X39,X3,X3
- PXOR X6,X0
- PADDL X0,X4
- MOVOA X0,X5
- MOVOA X4,X6
- PSLLL $7,X4
- PSRLL $25,X6
- PXOR X4,X3
- PXOR X6,X3
- PADDL X3,X5
- MOVOA X3,X4
- MOVOA X5,X6
- PSLLL $9,X5
- PSRLL $23,X6
- PXOR X5,X2
- PSHUFL $0X93,X3,X3
- PXOR X6,X2
- PADDL X2,X4
- MOVOA X2,X5
- MOVOA X4,X6
- PSLLL $13,X4
- PSRLL $19,X6
- PXOR X4,X1
- PSHUFL $0X4E,X2,X2
- PXOR X6,X1
- PADDL X1,X5
- MOVOA X3,X4
- MOVOA X5,X6
- PSLLL $18,X5
- PSRLL $14,X6
- PXOR X5,X0
- PSHUFL $0X39,X1,X1
- PXOR X6,X0
- PADDL X0,X4
- MOVOA X0,X5
- MOVOA X4,X6
- PSLLL $7,X4
- PSRLL $25,X6
- PXOR X4,X1
- PXOR X6,X1
- PADDL X1,X5
- MOVOA X1,X4
- MOVOA X5,X6
- PSLLL $9,X5
- PSRLL $23,X6
- PXOR X5,X2
- PSHUFL $0X93,X1,X1
- PXOR X6,X2
- PADDL X2,X4
- MOVOA X2,X5
- MOVOA X4,X6
- PSLLL $13,X4
- PSRLL $19,X6
- PXOR X4,X3
- PSHUFL $0X4E,X2,X2
- PXOR X6,X3
- SUBQ $4,CX
- PADDL X3,X5
- MOVOA X1,X4
- MOVOA X5,X6
- PSLLL $18,X5
- PXOR X7,X7
- PSRLL $14,X6
- PXOR X5,X0
- PSHUFL $0X39,X3,X3
- PXOR X6,X0
- JA MAINLOOP2
- PADDL 48(R12),X0
- PADDL 0(R12),X1
- PADDL 16(R12),X2
- PADDL 32(R12),X3
- MOVD X0,CX
- MOVD X1,R8
- MOVD X2,R9
- MOVD X3,AX
- PSHUFL $0X39,X0,X0
- PSHUFL $0X39,X1,X1
- PSHUFL $0X39,X2,X2
- PSHUFL $0X39,X3,X3
- XORL 0(SI),CX
- XORL 48(SI),R8
- XORL 32(SI),R9
- XORL 16(SI),AX
- MOVL CX,0(DI)
- MOVL R8,48(DI)
- MOVL R9,32(DI)
- MOVL AX,16(DI)
- MOVD X0,CX
- MOVD X1,R8
- MOVD X2,R9
- MOVD X3,AX
- PSHUFL $0X39,X0,X0
- PSHUFL $0X39,X1,X1
- PSHUFL $0X39,X2,X2
- PSHUFL $0X39,X3,X3
- XORL 20(SI),CX
- XORL 4(SI),R8
- XORL 52(SI),R9
- XORL 36(SI),AX
- MOVL CX,20(DI)
- MOVL R8,4(DI)
- MOVL R9,52(DI)
- MOVL AX,36(DI)
- MOVD X0,CX
- MOVD X1,R8
- MOVD X2,R9
- MOVD X3,AX
- PSHUFL $0X39,X0,X0
- PSHUFL $0X39,X1,X1
- PSHUFL $0X39,X2,X2
- PSHUFL $0X39,X3,X3
- XORL 40(SI),CX
- XORL 24(SI),R8
- XORL 8(SI),R9
- XORL 56(SI),AX
- MOVL CX,40(DI)
- MOVL R8,24(DI)
- MOVL R9,8(DI)
- MOVL AX,56(DI)
- MOVD X0,CX
- MOVD X1,R8
- MOVD X2,R9
- MOVD X3,AX
- XORL 60(SI),CX
- XORL 44(SI),R8
- XORL 28(SI),R9
- XORL 12(SI),AX
- MOVL CX,60(DI)
- MOVL R8,44(DI)
- MOVL R9,28(DI)
- MOVL AX,12(DI)
- MOVQ 352(R12),R9
- MOVL 16(R12),CX
- MOVL 36 (R12),R8
- ADDQ $1,CX
- SHLQ $32,R8
- ADDQ R8,CX
- MOVQ CX,R8
- SHRQ $32,R8
- MOVL CX,16(R12)
- MOVL R8, 36 (R12)
- CMPQ R9,$64
- JA BYTESATLEAST65
- JAE BYTESATLEAST64
- MOVQ DI,SI
- MOVQ DX,DI
- MOVQ R9,CX
+ LEAQ 360(R12), DI
+ LEAQ 360(R12), SI
+
+NOCOPY:
+ MOVQ R9, 352(R12)
+ MOVOA 48(R12), X0
+ MOVOA (R12), X1
+ MOVOA 16(R12), X2
+ MOVOA 32(R12), X3
+ MOVOA X1, X4
+ MOVQ $0x00000014, CX
+
+MAINLOOP2:
+ PADDL X0, X4
+ MOVOA X0, X5
+ MOVOA X4, X6
+ PSLLL $0x07, X4
+ PSRLL $0x19, X6
+ PXOR X4, X3
+ PXOR X6, X3
+ PADDL X3, X5
+ MOVOA X3, X4
+ MOVOA X5, X6
+ PSLLL $0x09, X5
+ PSRLL $0x17, X6
+ PXOR X5, X2
+ PSHUFL $0x93, X3, X3
+ PXOR X6, X2
+ PADDL X2, X4
+ MOVOA X2, X5
+ MOVOA X4, X6
+ PSLLL $0x0d, X4
+ PSRLL $0x13, X6
+ PXOR X4, X1
+ PSHUFL $0x4e, X2, X2
+ PXOR X6, X1
+ PADDL X1, X5
+ MOVOA X3, X4
+ MOVOA X5, X6
+ PSLLL $0x12, X5
+ PSRLL $0x0e, X6
+ PXOR X5, X0
+ PSHUFL $0x39, X1, X1
+ PXOR X6, X0
+ PADDL X0, X4
+ MOVOA X0, X5
+ MOVOA X4, X6
+ PSLLL $0x07, X4
+ PSRLL $0x19, X6
+ PXOR X4, X1
+ PXOR X6, X1
+ PADDL X1, X5
+ MOVOA X1, X4
+ MOVOA X5, X6
+ PSLLL $0x09, X5
+ PSRLL $0x17, X6
+ PXOR X5, X2
+ PSHUFL $0x93, X1, X1
+ PXOR X6, X2
+ PADDL X2, X4
+ MOVOA X2, X5
+ MOVOA X4, X6
+ PSLLL $0x0d, X4
+ PSRLL $0x13, X6
+ PXOR X4, X3
+ PSHUFL $0x4e, X2, X2
+ PXOR X6, X3
+ PADDL X3, X5
+ MOVOA X1, X4
+ MOVOA X5, X6
+ PSLLL $0x12, X5
+ PSRLL $0x0e, X6
+ PXOR X5, X0
+ PSHUFL $0x39, X3, X3
+ PXOR X6, X0
+ PADDL X0, X4
+ MOVOA X0, X5
+ MOVOA X4, X6
+ PSLLL $0x07, X4
+ PSRLL $0x19, X6
+ PXOR X4, X3
+ PXOR X6, X3
+ PADDL X3, X5
+ MOVOA X3, X4
+ MOVOA X5, X6
+ PSLLL $0x09, X5
+ PSRLL $0x17, X6
+ PXOR X5, X2
+ PSHUFL $0x93, X3, X3
+ PXOR X6, X2
+ PADDL X2, X4
+ MOVOA X2, X5
+ MOVOA X4, X6
+ PSLLL $0x0d, X4
+ PSRLL $0x13, X6
+ PXOR X4, X1
+ PSHUFL $0x4e, X2, X2
+ PXOR X6, X1
+ PADDL X1, X5
+ MOVOA X3, X4
+ MOVOA X5, X6
+ PSLLL $0x12, X5
+ PSRLL $0x0e, X6
+ PXOR X5, X0
+ PSHUFL $0x39, X1, X1
+ PXOR X6, X0
+ PADDL X0, X4
+ MOVOA X0, X5
+ MOVOA X4, X6
+ PSLLL $0x07, X4
+ PSRLL $0x19, X6
+ PXOR X4, X1
+ PXOR X6, X1
+ PADDL X1, X5
+ MOVOA X1, X4
+ MOVOA X5, X6
+ PSLLL $0x09, X5
+ PSRLL $0x17, X6
+ PXOR X5, X2
+ PSHUFL $0x93, X1, X1
+ PXOR X6, X2
+ PADDL X2, X4
+ MOVOA X2, X5
+ MOVOA X4, X6
+ PSLLL $0x0d, X4
+ PSRLL $0x13, X6
+ PXOR X4, X3
+ PSHUFL $0x4e, X2, X2
+ PXOR X6, X3
+ SUBQ $0x04, CX
+ PADDL X3, X5
+ MOVOA X1, X4
+ MOVOA X5, X6
+ PSLLL $0x12, X5
+ PXOR X7, X7
+ PSRLL $0x0e, X6
+ PXOR X5, X0
+ PSHUFL $0x39, X3, X3
+ PXOR X6, X0
+ JA MAINLOOP2
+ PADDL 48(R12), X0
+ PADDL (R12), X1
+ PADDL 16(R12), X2
+ PADDL 32(R12), X3
+ MOVD X0, CX
+ MOVD X1, R8
+ MOVD X2, R9
+ MOVD X3, AX
+ PSHUFL $0x39, X0, X0
+ PSHUFL $0x39, X1, X1
+ PSHUFL $0x39, X2, X2
+ PSHUFL $0x39, X3, X3
+ XORL (SI), CX
+ XORL 48(SI), R8
+ XORL 32(SI), R9
+ XORL 16(SI), AX
+ MOVL CX, (DI)
+ MOVL R8, 48(DI)
+ MOVL R9, 32(DI)
+ MOVL AX, 16(DI)
+ MOVD X0, CX
+ MOVD X1, R8
+ MOVD X2, R9
+ MOVD X3, AX
+ PSHUFL $0x39, X0, X0
+ PSHUFL $0x39, X1, X1
+ PSHUFL $0x39, X2, X2
+ PSHUFL $0x39, X3, X3
+ XORL 20(SI), CX
+ XORL 4(SI), R8
+ XORL 52(SI), R9
+ XORL 36(SI), AX
+ MOVL CX, 20(DI)
+ MOVL R8, 4(DI)
+ MOVL R9, 52(DI)
+ MOVL AX, 36(DI)
+ MOVD X0, CX
+ MOVD X1, R8
+ MOVD X2, R9
+ MOVD X3, AX
+ PSHUFL $0x39, X0, X0
+ PSHUFL $0x39, X1, X1
+ PSHUFL $0x39, X2, X2
+ PSHUFL $0x39, X3, X3
+ XORL 40(SI), CX
+ XORL 24(SI), R8
+ XORL 8(SI), R9
+ XORL 56(SI), AX
+ MOVL CX, 40(DI)
+ MOVL R8, 24(DI)
+ MOVL R9, 8(DI)
+ MOVL AX, 56(DI)
+ MOVD X0, CX
+ MOVD X1, R8
+ MOVD X2, R9
+ MOVD X3, AX
+ XORL 60(SI), CX
+ XORL 44(SI), R8
+ XORL 28(SI), R9
+ XORL 12(SI), AX
+ MOVL CX, 60(DI)
+ MOVL R8, 44(DI)
+ MOVL R9, 28(DI)
+ MOVL AX, 12(DI)
+ MOVQ 352(R12), R9
+ MOVL 16(R12), CX
+ MOVL 36(R12), R8
+ ADDQ $0x01, CX
+ SHLQ $0x20, R8
+ ADDQ R8, CX
+ MOVQ CX, R8
+ SHRQ $0x20, R8
+ MOVL CX, 16(R12)
+ MOVL R8, 36(R12)
+ CMPQ R9, $0x40
+ JA BYTESATLEAST65
+ JAE BYTESATLEAST64
+ MOVQ DI, SI
+ MOVQ DX, DI
+ MOVQ R9, CX
REP; MOVSB
- BYTESATLEAST64:
- DONE:
+
+BYTESATLEAST64:
+DONE:
RET
- BYTESATLEAST65:
- SUBQ $64,R9
- ADDQ $64,DI
- ADDQ $64,SI
- JMP BYTESBETWEEN1AND255
+
+BYTESATLEAST65:
+ SUBQ $0x40, R9
+ ADDQ $0x40, DI
+ ADDQ $0x40, SI
+ JMP BYTESBETWEEN1AND255
diff --git a/vendor/golang.org/x/exp/LICENSE b/vendor/golang.org/x/exp/LICENSE
index 6a66aea5ea..2a7cf70da6 100644
--- a/vendor/golang.org/x/exp/LICENSE
+++ b/vendor/golang.org/x/exp/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
+Copyright 2009 The Go Authors.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
@@ -10,7 +10,7 @@ notice, this list of conditions and the following disclaimer.
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
+ * Neither the name of Google LLC nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
diff --git a/vendor/golang.org/x/exp/slices/cmp.go b/vendor/golang.org/x/exp/slices/cmp.go
new file mode 100644
index 0000000000..fbf1934a06
--- /dev/null
+++ b/vendor/golang.org/x/exp/slices/cmp.go
@@ -0,0 +1,44 @@
+// 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.
+
+package slices
+
+import "golang.org/x/exp/constraints"
+
+// min is a version of the predeclared function from the Go 1.21 release.
+func min[T constraints.Ordered](a, b T) T {
+ if a < b || isNaN(a) {
+ return a
+ }
+ return b
+}
+
+// max is a version of the predeclared function from the Go 1.21 release.
+func max[T constraints.Ordered](a, b T) T {
+ if a > b || isNaN(a) {
+ return a
+ }
+ return b
+}
+
+// cmpLess is a copy of cmp.Less from the Go 1.21 release.
+func cmpLess[T constraints.Ordered](x, y T) bool {
+ return (isNaN(x) && !isNaN(y)) || x < y
+}
+
+// cmpCompare is a copy of cmp.Compare from the Go 1.21 release.
+func cmpCompare[T constraints.Ordered](x, y T) int {
+ xNaN := isNaN(x)
+ yNaN := isNaN(y)
+ if xNaN && yNaN {
+ return 0
+ }
+ if xNaN || x < y {
+ return -1
+ }
+ if yNaN || x > y {
+ return +1
+ }
+ return 0
+}
diff --git a/vendor/golang.org/x/exp/slices/slices.go b/vendor/golang.org/x/exp/slices/slices.go
index a17b3cf691..46ceac3439 100644
--- a/vendor/golang.org/x/exp/slices/slices.go
+++ b/vendor/golang.org/x/exp/slices/slices.go
@@ -3,23 +3,20 @@
// license that can be found in the LICENSE file.
// Package slices defines various functions useful with slices of any type.
-// Unless otherwise specified, these functions all apply to the elements
-// of a slice at index 0 <= i < len(s).
-//
-// Note that the less function in IsSortedFunc, SortFunc, SortStableFunc requires a
-// strict weak ordering (https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings),
-// or the sorting may fail to sort correctly. A common case is when sorting slices of
-// floating-point numbers containing NaN values.
package slices
-import "golang.org/x/exp/constraints"
+import (
+ "unsafe"
+
+ "golang.org/x/exp/constraints"
+)
// Equal reports whether two slices are equal: the same length and all
// elements equal. If the lengths are different, Equal returns false.
// Otherwise, the elements are compared in increasing index order, and the
// comparison stops at the first unequal pair.
// Floating point NaNs are not considered equal.
-func Equal[E comparable](s1, s2 []E) bool {
+func Equal[S ~[]E, E comparable](s1, s2 S) bool {
if len(s1) != len(s2) {
return false
}
@@ -31,12 +28,12 @@ func Equal[E comparable](s1, s2 []E) bool {
return true
}
-// EqualFunc reports whether two slices are equal using a comparison
+// EqualFunc reports whether two slices are equal using an equality
// function on each pair of elements. If the lengths are different,
// EqualFunc returns false. Otherwise, the elements are compared in
// increasing index order, and the comparison stops at the first index
// for which eq returns false.
-func EqualFunc[E1, E2 any](s1 []E1, s2 []E2, eq func(E1, E2) bool) bool {
+func EqualFunc[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, eq func(E1, E2) bool) bool {
if len(s1) != len(s2) {
return false
}
@@ -49,45 +46,37 @@ func EqualFunc[E1, E2 any](s1 []E1, s2 []E2, eq func(E1, E2) bool) bool {
return true
}
-// Compare compares the elements of s1 and s2.
-// The elements are compared sequentially, starting at index 0,
+// Compare compares the elements of s1 and s2, using [cmp.Compare] on each pair
+// of elements. The elements are compared sequentially, starting at index 0,
// until one element is not equal to the other.
// The result of comparing the first non-matching elements is returned.
// If both slices are equal until one of them ends, the shorter slice is
// considered less than the longer one.
// The result is 0 if s1 == s2, -1 if s1 < s2, and +1 if s1 > s2.
-// Comparisons involving floating point NaNs are ignored.
-func Compare[E constraints.Ordered](s1, s2 []E) int {
- s2len := len(s2)
+func Compare[S ~[]E, E constraints.Ordered](s1, s2 S) int {
for i, v1 := range s1 {
- if i >= s2len {
+ if i >= len(s2) {
return +1
}
v2 := s2[i]
- switch {
- case v1 < v2:
- return -1
- case v1 > v2:
- return +1
+ if c := cmpCompare(v1, v2); c != 0 {
+ return c
}
}
- if len(s1) < s2len {
+ if len(s1) < len(s2) {
return -1
}
return 0
}
-// CompareFunc is like Compare but uses a comparison function
-// on each pair of elements. The elements are compared in increasing
-// index order, and the comparisons stop after the first time cmp
-// returns non-zero.
+// CompareFunc is like [Compare] but uses a custom comparison function on each
+// pair of elements.
// The result is the first non-zero result of cmp; if cmp always
// returns 0 the result is 0 if len(s1) == len(s2), -1 if len(s1) < len(s2),
// and +1 if len(s1) > len(s2).
-func CompareFunc[E1, E2 any](s1 []E1, s2 []E2, cmp func(E1, E2) int) int {
- s2len := len(s2)
+func CompareFunc[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, cmp func(E1, E2) int) int {
for i, v1 := range s1 {
- if i >= s2len {
+ if i >= len(s2) {
return +1
}
v2 := s2[i]
@@ -95,7 +84,7 @@ func CompareFunc[E1, E2 any](s1 []E1, s2 []E2, cmp func(E1, E2) int) int {
return c
}
}
- if len(s1) < s2len {
+ if len(s1) < len(s2) {
return -1
}
return 0
@@ -103,9 +92,9 @@ func CompareFunc[E1, E2 any](s1 []E1, s2 []E2, cmp func(E1, E2) int) int {
// Index returns the index of the first occurrence of v in s,
// or -1 if not present.
-func Index[E comparable](s []E, v E) int {
- for i, vs := range s {
- if v == vs {
+func Index[S ~[]E, E comparable](s S, v E) int {
+ for i := range s {
+ if v == s[i] {
return i
}
}
@@ -114,9 +103,9 @@ func Index[E comparable](s []E, v E) int {
// IndexFunc returns the first index i satisfying f(s[i]),
// or -1 if none do.
-func IndexFunc[E any](s []E, f func(E) bool) int {
- for i, v := range s {
- if f(v) {
+func IndexFunc[S ~[]E, E any](s S, f func(E) bool) int {
+ for i := range s {
+ if f(s[i]) {
return i
}
}
@@ -124,42 +113,237 @@ func IndexFunc[E any](s []E, f func(E) bool) int {
}
// Contains reports whether v is present in s.
-func Contains[E comparable](s []E, v E) bool {
+func Contains[S ~[]E, E comparable](s S, v E) bool {
return Index(s, v) >= 0
}
+// ContainsFunc reports whether at least one
+// element e of s satisfies f(e).
+func ContainsFunc[S ~[]E, E any](s S, f func(E) bool) bool {
+ return IndexFunc(s, f) >= 0
+}
+
// Insert inserts the values v... into s at index i,
// returning the modified slice.
-// In the returned slice r, r[i] == v[0].
+// The elements at s[i:] are shifted up to make room.
+// In the returned slice r, r[i] == v[0],
+// and r[i+len(v)] == value originally at r[i].
// Insert panics if i is out of range.
// This function is O(len(s) + len(v)).
func Insert[S ~[]E, E any](s S, i int, v ...E) S {
- tot := len(s) + len(v)
- if tot <= cap(s) {
- s2 := s[:tot]
- copy(s2[i+len(v):], s[i:])
+ m := len(v)
+ if m == 0 {
+ return s
+ }
+ n := len(s)
+ if i == n {
+ return append(s, v...)
+ }
+ if n+m > cap(s) {
+ // Use append rather than make so that we bump the size of
+ // the slice up to the next storage class.
+ // This is what Grow does but we don't call Grow because
+ // that might copy the values twice.
+ s2 := append(s[:i], make(S, n+m-i)...)
copy(s2[i:], v)
+ copy(s2[i+m:], s[i:])
return s2
}
- s2 := make(S, tot)
- copy(s2, s[:i])
- copy(s2[i:], v)
- copy(s2[i+len(v):], s[i:])
- return s2
+ s = s[:n+m]
+
+ // before:
+ // s: aaaaaaaabbbbccccccccdddd
+ // ^ ^ ^ ^
+ // i i+m n n+m
+ // after:
+ // s: aaaaaaaavvvvbbbbcccccccc
+ // ^ ^ ^ ^
+ // i i+m n n+m
+ //
+ // a are the values that don't move in s.
+ // v are the values copied in from v.
+ // b and c are the values from s that are shifted up in index.
+ // d are the values that get overwritten, never to be seen again.
+
+ if !overlaps(v, s[i+m:]) {
+ // Easy case - v does not overlap either the c or d regions.
+ // (It might be in some of a or b, or elsewhere entirely.)
+ // The data we copy up doesn't write to v at all, so just do it.
+
+ copy(s[i+m:], s[i:])
+
+ // Now we have
+ // s: aaaaaaaabbbbbbbbcccccccc
+ // ^ ^ ^ ^
+ // i i+m n n+m
+ // Note the b values are duplicated.
+
+ copy(s[i:], v)
+
+ // Now we have
+ // s: aaaaaaaavvvvbbbbcccccccc
+ // ^ ^ ^ ^
+ // i i+m n n+m
+ // That's the result we want.
+ return s
+ }
+
+ // The hard case - v overlaps c or d. We can't just shift up
+ // the data because we'd move or clobber the values we're trying
+ // to insert.
+ // So instead, write v on top of d, then rotate.
+ copy(s[n:], v)
+
+ // Now we have
+ // s: aaaaaaaabbbbccccccccvvvv
+ // ^ ^ ^ ^
+ // i i+m n n+m
+
+ rotateRight(s[i:], m)
+
+ // Now we have
+ // s: aaaaaaaavvvvbbbbcccccccc
+ // ^ ^ ^ ^
+ // i i+m n n+m
+ // That's the result we want.
+ return s
+}
+
+// clearSlice sets all elements up to the length of s to the zero value of E.
+// We may use the builtin clear func instead, and remove clearSlice, when upgrading
+// to Go 1.21+.
+func clearSlice[S ~[]E, E any](s S) {
+ var zero E
+ for i := range s {
+ s[i] = zero
+ }
}
// Delete removes the elements s[i:j] from s, returning the modified slice.
-// Delete panics if s[i:j] is not a valid slice of s.
-// Delete modifies the contents of the slice s; it does not create a new slice.
-// Delete is O(len(s)-j), so if many items must be deleted, it is better to
+// Delete panics if j > len(s) or s[i:j] is not a valid slice of s.
+// Delete is O(len(s)-i), so if many items must be deleted, it is better to
// make a single call deleting them all together than to delete one at a time.
-// Delete might not modify the elements s[len(s)-(j-i):len(s)]. If those
-// elements contain pointers you might consider zeroing those elements so that
-// objects they reference can be garbage collected.
+// Delete zeroes the elements s[len(s)-(j-i):len(s)].
func Delete[S ~[]E, E any](s S, i, j int) S {
- _ = s[i:j] // bounds check
+ _ = s[i:j:len(s)] // bounds check
+
+ if i == j {
+ return s
+ }
+
+ oldlen := len(s)
+ s = append(s[:i], s[j:]...)
+ clearSlice(s[len(s):oldlen]) // zero/nil out the obsolete elements, for GC
+ return s
+}
+
+// DeleteFunc removes any elements from s for which del returns true,
+// returning the modified slice.
+// DeleteFunc zeroes the elements between the new length and the original length.
+func DeleteFunc[S ~[]E, E any](s S, del func(E) bool) S {
+ i := IndexFunc(s, del)
+ if i == -1 {
+ return s
+ }
+ // Don't start copying elements until we find one to delete.
+ for j := i + 1; j < len(s); j++ {
+ if v := s[j]; !del(v) {
+ s[i] = v
+ i++
+ }
+ }
+ clearSlice(s[i:]) // zero/nil out the obsolete elements, for GC
+ return s[:i]
+}
+
+// Replace replaces the elements s[i:j] by the given v, and returns the
+// modified slice. Replace panics if s[i:j] is not a valid slice of s.
+// When len(v) < (j-i), Replace zeroes the elements between the new length and the original length.
+func Replace[S ~[]E, E any](s S, i, j int, v ...E) S {
+ _ = s[i:j] // verify that i:j is a valid subslice
+
+ if i == j {
+ return Insert(s, i, v...)
+ }
+ if j == len(s) {
+ return append(s[:i], v...)
+ }
+
+ tot := len(s[:i]) + len(v) + len(s[j:])
+ if tot > cap(s) {
+ // Too big to fit, allocate and copy over.
+ s2 := append(s[:i], make(S, tot-i)...) // See Insert
+ copy(s2[i:], v)
+ copy(s2[i+len(v):], s[j:])
+ return s2
+ }
+
+ r := s[:tot]
+
+ if i+len(v) <= j {
+ // Easy, as v fits in the deleted portion.
+ copy(r[i:], v)
+ if i+len(v) != j {
+ copy(r[i+len(v):], s[j:])
+ }
+ clearSlice(s[tot:]) // zero/nil out the obsolete elements, for GC
+ return r
+ }
+
+ // We are expanding (v is bigger than j-i).
+ // The situation is something like this:
+ // (example has i=4,j=8,len(s)=16,len(v)=6)
+ // s: aaaaxxxxbbbbbbbbyy
+ // ^ ^ ^ ^
+ // i j len(s) tot
+ // a: prefix of s
+ // x: deleted range
+ // b: more of s
+ // y: area to expand into
+
+ if !overlaps(r[i+len(v):], v) {
+ // Easy, as v is not clobbered by the first copy.
+ copy(r[i+len(v):], s[j:])
+ copy(r[i:], v)
+ return r
+ }
+
+ // This is a situation where we don't have a single place to which
+ // we can copy v. Parts of it need to go to two different places.
+ // We want to copy the prefix of v into y and the suffix into x, then
+ // rotate |y| spots to the right.
+ //
+ // v[2:] v[:2]
+ // | |
+ // s: aaaavvvvbbbbbbbbvv
+ // ^ ^ ^ ^
+ // i j len(s) tot
+ //
+ // If either of those two destinations don't alias v, then we're good.
+ y := len(v) - (j - i) // length of y portion
- return append(s[:i], s[j:]...)
+ if !overlaps(r[i:j], v) {
+ copy(r[i:j], v[y:])
+ copy(r[len(s):], v[:y])
+ rotateRight(r[i:], y)
+ return r
+ }
+ if !overlaps(r[len(s):], v) {
+ copy(r[len(s):], v[:y])
+ copy(r[i:j], v[y:])
+ rotateRight(r[i:], y)
+ return r
+ }
+
+ // Now we know that v overlaps both x and y.
+ // That means that the entirety of b is *inside* v.
+ // So we don't need to preserve b at all; instead we
+ // can copy v first, then copy the b part of v out of
+ // v to the right destination.
+ k := startIdx(v, s[j:])
+ copy(r[i:], v)
+ copy(r[i+len(v):], r[i+k:])
+ return r
}
// Clone returns a copy of the slice.
@@ -174,50 +358,158 @@ func Clone[S ~[]E, E any](s S) S {
// Compact replaces consecutive runs of equal elements with a single copy.
// This is like the uniq command found on Unix.
-// Compact modifies the contents of the slice s; it does not create a new slice.
+// Compact modifies the contents of the slice s and returns the modified slice,
+// which may have a smaller length.
+// Compact zeroes the elements between the new length and the original length.
func Compact[S ~[]E, E comparable](s S) S {
- if len(s) == 0 {
+ if len(s) < 2 {
return s
}
i := 1
- last := s[0]
- for _, v := range s[1:] {
- if v != last {
- s[i] = v
+ for k := 1; k < len(s); k++ {
+ if s[k] != s[k-1] {
+ if i != k {
+ s[i] = s[k]
+ }
i++
- last = v
}
}
+ clearSlice(s[i:]) // zero/nil out the obsolete elements, for GC
return s[:i]
}
-// CompactFunc is like Compact but uses a comparison function.
+// CompactFunc is like [Compact] but uses an equality function to compare elements.
+// For runs of elements that compare equal, CompactFunc keeps the first one.
+// CompactFunc zeroes the elements between the new length and the original length.
func CompactFunc[S ~[]E, E any](s S, eq func(E, E) bool) S {
- if len(s) == 0 {
+ if len(s) < 2 {
return s
}
i := 1
- last := s[0]
- for _, v := range s[1:] {
- if !eq(v, last) {
- s[i] = v
+ for k := 1; k < len(s); k++ {
+ if !eq(s[k], s[k-1]) {
+ if i != k {
+ s[i] = s[k]
+ }
i++
- last = v
}
}
+ clearSlice(s[i:]) // zero/nil out the obsolete elements, for GC
return s[:i]
}
// Grow increases the slice's capacity, if necessary, to guarantee space for
// another n elements. After Grow(n), at least n elements can be appended
-// to the slice without another allocation. Grow may modify elements of the
-// slice between the length and the capacity. If n is negative or too large to
+// to the slice without another allocation. If n is negative or too large to
// allocate the memory, Grow panics.
func Grow[S ~[]E, E any](s S, n int) S {
- return append(s, make(S, n)...)[:len(s)]
+ if n < 0 {
+ panic("cannot be negative")
+ }
+ if n -= cap(s) - len(s); n > 0 {
+ // TODO(https://go.dev/issue/53888): Make using []E instead of S
+ // to workaround a compiler bug where the runtime.growslice optimization
+ // does not take effect. Revert when the compiler is fixed.
+ s = append([]E(s)[:cap(s)], make([]E, n)...)[:len(s)]
+ }
+ return s
}
// Clip removes unused capacity from the slice, returning s[:len(s):len(s)].
func Clip[S ~[]E, E any](s S) S {
return s[:len(s):len(s)]
}
+
+// Rotation algorithm explanation:
+//
+// rotate left by 2
+// start with
+// 0123456789
+// split up like this
+// 01 234567 89
+// swap first 2 and last 2
+// 89 234567 01
+// join first parts
+// 89234567 01
+// recursively rotate first left part by 2
+// 23456789 01
+// join at the end
+// 2345678901
+//
+// rotate left by 8
+// start with
+// 0123456789
+// split up like this
+// 01 234567 89
+// swap first 2 and last 2
+// 89 234567 01
+// join last parts
+// 89 23456701
+// recursively rotate second part left by 6
+// 89 01234567
+// join at the end
+// 8901234567
+
+// TODO: There are other rotate algorithms.
+// This algorithm has the desirable property that it moves each element exactly twice.
+// The triple-reverse algorithm is simpler and more cache friendly, but takes more writes.
+// The follow-cycles algorithm can be 1-write but it is not very cache friendly.
+
+// rotateLeft rotates b left by n spaces.
+// s_final[i] = s_orig[i+r], wrapping around.
+func rotateLeft[E any](s []E, r int) {
+ for r != 0 && r != len(s) {
+ if r*2 <= len(s) {
+ swap(s[:r], s[len(s)-r:])
+ s = s[:len(s)-r]
+ } else {
+ swap(s[:len(s)-r], s[r:])
+ s, r = s[len(s)-r:], r*2-len(s)
+ }
+ }
+}
+func rotateRight[E any](s []E, r int) {
+ rotateLeft(s, len(s)-r)
+}
+
+// swap swaps the contents of x and y. x and y must be equal length and disjoint.
+func swap[E any](x, y []E) {
+ for i := 0; i < len(x); i++ {
+ x[i], y[i] = y[i], x[i]
+ }
+}
+
+// overlaps reports whether the memory ranges a[0:len(a)] and b[0:len(b)] overlap.
+func overlaps[E any](a, b []E) bool {
+ if len(a) == 0 || len(b) == 0 {
+ return false
+ }
+ elemSize := unsafe.Sizeof(a[0])
+ if elemSize == 0 {
+ return false
+ }
+ // TODO: use a runtime/unsafe facility once one becomes available. See issue 12445.
+ // Also see crypto/internal/alias/alias.go:AnyOverlap
+ return uintptr(unsafe.Pointer(&a[0])) <= uintptr(unsafe.Pointer(&b[len(b)-1]))+(elemSize-1) &&
+ uintptr(unsafe.Pointer(&b[0])) <= uintptr(unsafe.Pointer(&a[len(a)-1]))+(elemSize-1)
+}
+
+// startIdx returns the index in haystack where the needle starts.
+// prerequisite: the needle must be aliased entirely inside the haystack.
+func startIdx[E any](haystack, needle []E) int {
+ p := &needle[0]
+ for i := range haystack {
+ if p == &haystack[i] {
+ return i
+ }
+ }
+ // TODO: what if the overlap is by a non-integral number of Es?
+ panic("needle not found")
+}
+
+// Reverse reverses the elements of the slice in place.
+func Reverse[S ~[]E, E any](s S) {
+ for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
+ s[i], s[j] = s[j], s[i]
+ }
+}
diff --git a/vendor/golang.org/x/exp/slices/sort.go b/vendor/golang.org/x/exp/slices/sort.go
index c22e74bd10..f58bbc7ba4 100644
--- a/vendor/golang.org/x/exp/slices/sort.go
+++ b/vendor/golang.org/x/exp/slices/sort.go
@@ -2,6 +2,8 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
+//go:generate go run $GOROOT/src/sort/gen_sort_variants.go -exp
+
package slices
import (
@@ -11,97 +13,159 @@ import (
)
// Sort sorts a slice of any ordered type in ascending order.
-// Sort may fail to sort correctly when sorting slices of floating-point
-// numbers containing Not-a-number (NaN) values.
-// Use slices.SortFunc(x, func(a, b float64) bool {return a < b || (math.IsNaN(a) && !math.IsNaN(b))})
-// instead if the input may contain NaNs.
-func Sort[E constraints.Ordered](x []E) {
+// When sorting floating-point numbers, NaNs are ordered before other values.
+func Sort[S ~[]E, E constraints.Ordered](x S) {
n := len(x)
pdqsortOrdered(x, 0, n, bits.Len(uint(n)))
}
-// SortFunc sorts the slice x in ascending order as determined by the less function.
-// This sort is not guaranteed to be stable.
+// SortFunc sorts the slice x in ascending order as determined by the cmp
+// function. This sort is not guaranteed to be stable.
+// cmp(a, b) should return a negative number when a < b, a positive number when
+// a > b and zero when a == b or when a is not comparable to b in the sense
+// of the formal definition of Strict Weak Ordering.
//
-// SortFunc requires that less is a strict weak ordering.
+// SortFunc requires that cmp is a strict weak ordering.
// See https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings.
-func SortFunc[E any](x []E, less func(a, b E) bool) {
+// To indicate 'uncomparable', return 0 from the function.
+func SortFunc[S ~[]E, E any](x S, cmp func(a, b E) int) {
n := len(x)
- pdqsortLessFunc(x, 0, n, bits.Len(uint(n)), less)
+ pdqsortCmpFunc(x, 0, n, bits.Len(uint(n)), cmp)
}
-// SortStable sorts the slice x while keeping the original order of equal
-// elements, using less to compare elements.
-func SortStableFunc[E any](x []E, less func(a, b E) bool) {
- stableLessFunc(x, len(x), less)
+// SortStableFunc sorts the slice x while keeping the original order of equal
+// elements, using cmp to compare elements in the same way as [SortFunc].
+func SortStableFunc[S ~[]E, E any](x S, cmp func(a, b E) int) {
+ stableCmpFunc(x, len(x), cmp)
}
// IsSorted reports whether x is sorted in ascending order.
-func IsSorted[E constraints.Ordered](x []E) bool {
+func IsSorted[S ~[]E, E constraints.Ordered](x S) bool {
for i := len(x) - 1; i > 0; i-- {
- if x[i] < x[i-1] {
+ if cmpLess(x[i], x[i-1]) {
return false
}
}
return true
}
-// IsSortedFunc reports whether x is sorted in ascending order, with less as the
-// comparison function.
-func IsSortedFunc[E any](x []E, less func(a, b E) bool) bool {
+// IsSortedFunc reports whether x is sorted in ascending order, with cmp as the
+// comparison function as defined by [SortFunc].
+func IsSortedFunc[S ~[]E, E any](x S, cmp func(a, b E) int) bool {
for i := len(x) - 1; i > 0; i-- {
- if less(x[i], x[i-1]) {
+ if cmp(x[i], x[i-1]) < 0 {
return false
}
}
return true
}
+// Min returns the minimal value in x. It panics if x is empty.
+// For floating-point numbers, Min propagates NaNs (any NaN value in x
+// forces the output to be NaN).
+func Min[S ~[]E, E constraints.Ordered](x S) E {
+ if len(x) < 1 {
+ panic("slices.Min: empty list")
+ }
+ m := x[0]
+ for i := 1; i < len(x); i++ {
+ m = min(m, x[i])
+ }
+ return m
+}
+
+// MinFunc returns the minimal value in x, using cmp to compare elements.
+// It panics if x is empty. If there is more than one minimal element
+// according to the cmp function, MinFunc returns the first one.
+func MinFunc[S ~[]E, E any](x S, cmp func(a, b E) int) E {
+ if len(x) < 1 {
+ panic("slices.MinFunc: empty list")
+ }
+ m := x[0]
+ for i := 1; i < len(x); i++ {
+ if cmp(x[i], m) < 0 {
+ m = x[i]
+ }
+ }
+ return m
+}
+
+// Max returns the maximal value in x. It panics if x is empty.
+// For floating-point E, Max propagates NaNs (any NaN value in x
+// forces the output to be NaN).
+func Max[S ~[]E, E constraints.Ordered](x S) E {
+ if len(x) < 1 {
+ panic("slices.Max: empty list")
+ }
+ m := x[0]
+ for i := 1; i < len(x); i++ {
+ m = max(m, x[i])
+ }
+ return m
+}
+
+// MaxFunc returns the maximal value in x, using cmp to compare elements.
+// It panics if x is empty. If there is more than one maximal element
+// according to the cmp function, MaxFunc returns the first one.
+func MaxFunc[S ~[]E, E any](x S, cmp func(a, b E) int) E {
+ if len(x) < 1 {
+ panic("slices.MaxFunc: empty list")
+ }
+ m := x[0]
+ for i := 1; i < len(x); i++ {
+ if cmp(x[i], m) > 0 {
+ m = x[i]
+ }
+ }
+ return m
+}
+
// BinarySearch searches for target in a sorted slice and returns the position
// where target is found, or the position where target would appear in the
// sort order; it also returns a bool saying whether the target is really found
// in the slice. The slice must be sorted in increasing order.
-func BinarySearch[E constraints.Ordered](x []E, target E) (int, bool) {
- // search returns the leftmost position where f returns true, or len(x) if f
- // returns false for all x. This is the insertion position for target in x,
- // and could point to an element that's either == target or not.
- pos := search(len(x), func(i int) bool { return x[i] >= target })
- if pos >= len(x) || x[pos] != target {
- return pos, false
- } else {
- return pos, true
- }
-}
-
-// BinarySearchFunc works like BinarySearch, but uses a custom comparison
-// function. The slice must be sorted in increasing order, where "increasing" is
-// defined by cmp. cmp(a, b) is expected to return an integer comparing the two
-// parameters: 0 if a == b, a negative number if a < b and a positive number if
-// a > b.
-func BinarySearchFunc[E any](x []E, target E, cmp func(E, E) int) (int, bool) {
- pos := search(len(x), func(i int) bool { return cmp(x[i], target) >= 0 })
- if pos >= len(x) || cmp(x[pos], target) != 0 {
- return pos, false
- } else {
- return pos, true
+func BinarySearch[S ~[]E, E constraints.Ordered](x S, target E) (int, bool) {
+ // Inlining is faster than calling BinarySearchFunc with a lambda.
+ n := len(x)
+ // Define x[-1] < target and x[n] >= target.
+ // Invariant: x[i-1] < target, x[j] >= target.
+ i, j := 0, n
+ for i < j {
+ h := int(uint(i+j) >> 1) // avoid overflow when computing h
+ // i ≤ h < j
+ if cmpLess(x[h], target) {
+ i = h + 1 // preserves x[i-1] < target
+ } else {
+ j = h // preserves x[j] >= target
+ }
}
+ // i == j, x[i-1] < target, and x[j] (= x[i]) >= target => answer is i.
+ return i, i < n && (x[i] == target || (isNaN(x[i]) && isNaN(target)))
}
-func search(n int, f func(int) bool) int {
- // Define f(-1) == false and f(n) == true.
- // Invariant: f(i-1) == false, f(j) == true.
+// BinarySearchFunc works like [BinarySearch], but uses a custom comparison
+// function. The slice must be sorted in increasing order, where "increasing"
+// is defined by cmp. cmp should return 0 if the slice element matches
+// the target, a negative number if the slice element precedes the target,
+// or a positive number if the slice element follows the target.
+// cmp must implement the same ordering as the slice, such that if
+// cmp(a, t) < 0 and cmp(b, t) >= 0, then a must precede b in the slice.
+func BinarySearchFunc[S ~[]E, E, T any](x S, target T, cmp func(E, T) int) (int, bool) {
+ n := len(x)
+ // Define cmp(x[-1], target) < 0 and cmp(x[n], target) >= 0 .
+ // Invariant: cmp(x[i - 1], target) < 0, cmp(x[j], target) >= 0.
i, j := 0, n
for i < j {
h := int(uint(i+j) >> 1) // avoid overflow when computing h
// i ≤ h < j
- if !f(h) {
- i = h + 1 // preserves f(i-1) == false
+ if cmp(x[h], target) < 0 {
+ i = h + 1 // preserves cmp(x[i - 1], target) < 0
} else {
- j = h // preserves f(j) == true
+ j = h // preserves cmp(x[j], target) >= 0
}
}
- // i == j, f(i-1) == false, and f(j) (= f(i)) == true => answer is i.
- return i
+ // i == j, cmp(x[i-1], target) < 0, and cmp(x[j], target) (= cmp(x[i], target)) >= 0 => answer is i.
+ return i, i < n && cmp(x[i], target) == 0
}
type sortedHint int // hint for pdqsort when choosing the pivot
@@ -125,3 +189,9 @@ func (r *xorshift) Next() uint64 {
func nextPowerOfTwo(length int) uint {
return 1 << bits.Len(uint(length))
}
+
+// isNaN reports whether x is a NaN without requiring the math package.
+// This will always return false if T is not floating-point.
+func isNaN[T constraints.Ordered](x T) bool {
+ return x != x
+}
diff --git a/vendor/golang.org/x/exp/slices/zsortfunc.go b/vendor/golang.org/x/exp/slices/zsortanyfunc.go
similarity index 64%
rename from vendor/golang.org/x/exp/slices/zsortfunc.go
rename to vendor/golang.org/x/exp/slices/zsortanyfunc.go
index 2a632476c5..06f2c7a248 100644
--- a/vendor/golang.org/x/exp/slices/zsortfunc.go
+++ b/vendor/golang.org/x/exp/slices/zsortanyfunc.go
@@ -6,28 +6,28 @@
package slices
-// insertionSortLessFunc sorts data[a:b] using insertion sort.
-func insertionSortLessFunc[E any](data []E, a, b int, less func(a, b E) bool) {
+// insertionSortCmpFunc sorts data[a:b] using insertion sort.
+func insertionSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
for i := a + 1; i < b; i++ {
- for j := i; j > a && less(data[j], data[j-1]); j-- {
+ for j := i; j > a && (cmp(data[j], data[j-1]) < 0); j-- {
data[j], data[j-1] = data[j-1], data[j]
}
}
}
-// siftDownLessFunc implements the heap property on data[lo:hi].
+// siftDownCmpFunc implements the heap property on data[lo:hi].
// first is an offset into the array where the root of the heap lies.
-func siftDownLessFunc[E any](data []E, lo, hi, first int, less func(a, b E) bool) {
+func siftDownCmpFunc[E any](data []E, lo, hi, first int, cmp func(a, b E) int) {
root := lo
for {
child := 2*root + 1
if child >= hi {
break
}
- if child+1 < hi && less(data[first+child], data[first+child+1]) {
+ if child+1 < hi && (cmp(data[first+child], data[first+child+1]) < 0) {
child++
}
- if !less(data[first+root], data[first+child]) {
+ if !(cmp(data[first+root], data[first+child]) < 0) {
return
}
data[first+root], data[first+child] = data[first+child], data[first+root]
@@ -35,30 +35,30 @@ func siftDownLessFunc[E any](data []E, lo, hi, first int, less func(a, b E) bool
}
}
-func heapSortLessFunc[E any](data []E, a, b int, less func(a, b E) bool) {
+func heapSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
first := a
lo := 0
hi := b - a
// Build heap with greatest element at top.
for i := (hi - 1) / 2; i >= 0; i-- {
- siftDownLessFunc(data, i, hi, first, less)
+ siftDownCmpFunc(data, i, hi, first, cmp)
}
// Pop elements, largest first, into end of data.
for i := hi - 1; i >= 0; i-- {
data[first], data[first+i] = data[first+i], data[first]
- siftDownLessFunc(data, lo, i, first, less)
+ siftDownCmpFunc(data, lo, i, first, cmp)
}
}
-// pdqsortLessFunc sorts data[a:b].
+// pdqsortCmpFunc sorts data[a:b].
// The algorithm based on pattern-defeating quicksort(pdqsort), but without the optimizations from BlockQuicksort.
// pdqsort paper: https://arxiv.org/pdf/2106.05123.pdf
// C++ implementation: https://github.com/orlp/pdqsort
// Rust implementation: https://docs.rs/pdqsort/latest/pdqsort/
// limit is the number of allowed bad (very unbalanced) pivots before falling back to heapsort.
-func pdqsortLessFunc[E any](data []E, a, b, limit int, less func(a, b E) bool) {
+func pdqsortCmpFunc[E any](data []E, a, b, limit int, cmp func(a, b E) int) {
const maxInsertion = 12
var (
@@ -70,25 +70,25 @@ func pdqsortLessFunc[E any](data []E, a, b, limit int, less func(a, b E) bool) {
length := b - a
if length <= maxInsertion {
- insertionSortLessFunc(data, a, b, less)
+ insertionSortCmpFunc(data, a, b, cmp)
return
}
// Fall back to heapsort if too many bad choices were made.
if limit == 0 {
- heapSortLessFunc(data, a, b, less)
+ heapSortCmpFunc(data, a, b, cmp)
return
}
// If the last partitioning was imbalanced, we need to breaking patterns.
if !wasBalanced {
- breakPatternsLessFunc(data, a, b, less)
+ breakPatternsCmpFunc(data, a, b, cmp)
limit--
}
- pivot, hint := choosePivotLessFunc(data, a, b, less)
+ pivot, hint := choosePivotCmpFunc(data, a, b, cmp)
if hint == decreasingHint {
- reverseRangeLessFunc(data, a, b, less)
+ reverseRangeCmpFunc(data, a, b, cmp)
// The chosen pivot was pivot-a elements after the start of the array.
// After reversing it is pivot-a elements before the end of the array.
// The idea came from Rust's implementation.
@@ -98,48 +98,48 @@ func pdqsortLessFunc[E any](data []E, a, b, limit int, less func(a, b E) bool) {
// The slice is likely already sorted.
if wasBalanced && wasPartitioned && hint == increasingHint {
- if partialInsertionSortLessFunc(data, a, b, less) {
+ if partialInsertionSortCmpFunc(data, a, b, cmp) {
return
}
}
// Probably the slice contains many duplicate elements, partition the slice into
// elements equal to and elements greater than the pivot.
- if a > 0 && !less(data[a-1], data[pivot]) {
- mid := partitionEqualLessFunc(data, a, b, pivot, less)
+ if a > 0 && !(cmp(data[a-1], data[pivot]) < 0) {
+ mid := partitionEqualCmpFunc(data, a, b, pivot, cmp)
a = mid
continue
}
- mid, alreadyPartitioned := partitionLessFunc(data, a, b, pivot, less)
+ mid, alreadyPartitioned := partitionCmpFunc(data, a, b, pivot, cmp)
wasPartitioned = alreadyPartitioned
leftLen, rightLen := mid-a, b-mid
balanceThreshold := length / 8
if leftLen < rightLen {
wasBalanced = leftLen >= balanceThreshold
- pdqsortLessFunc(data, a, mid, limit, less)
+ pdqsortCmpFunc(data, a, mid, limit, cmp)
a = mid + 1
} else {
wasBalanced = rightLen >= balanceThreshold
- pdqsortLessFunc(data, mid+1, b, limit, less)
+ pdqsortCmpFunc(data, mid+1, b, limit, cmp)
b = mid
}
}
}
-// partitionLessFunc does one quicksort partition.
+// partitionCmpFunc does one quicksort partition.
// Let p = data[pivot]
// Moves elements in data[a:b] around, so that data[i]=p for inewpivot.
// On return, data[newpivot] = p
-func partitionLessFunc[E any](data []E, a, b, pivot int, less func(a, b E) bool) (newpivot int, alreadyPartitioned bool) {
+func partitionCmpFunc[E any](data []E, a, b, pivot int, cmp func(a, b E) int) (newpivot int, alreadyPartitioned bool) {
data[a], data[pivot] = data[pivot], data[a]
i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
- for i <= j && less(data[i], data[a]) {
+ for i <= j && (cmp(data[i], data[a]) < 0) {
i++
}
- for i <= j && !less(data[j], data[a]) {
+ for i <= j && !(cmp(data[j], data[a]) < 0) {
j--
}
if i > j {
@@ -151,10 +151,10 @@ func partitionLessFunc[E any](data []E, a, b, pivot int, less func(a, b E) bool)
j--
for {
- for i <= j && less(data[i], data[a]) {
+ for i <= j && (cmp(data[i], data[a]) < 0) {
i++
}
- for i <= j && !less(data[j], data[a]) {
+ for i <= j && !(cmp(data[j], data[a]) < 0) {
j--
}
if i > j {
@@ -168,17 +168,17 @@ func partitionLessFunc[E any](data []E, a, b, pivot int, less func(a, b E) bool)
return j, false
}
-// partitionEqualLessFunc partitions data[a:b] into elements equal to data[pivot] followed by elements greater than data[pivot].
+// partitionEqualCmpFunc partitions data[a:b] into elements equal to data[pivot] followed by elements greater than data[pivot].
// It assumed that data[a:b] does not contain elements smaller than the data[pivot].
-func partitionEqualLessFunc[E any](data []E, a, b, pivot int, less func(a, b E) bool) (newpivot int) {
+func partitionEqualCmpFunc[E any](data []E, a, b, pivot int, cmp func(a, b E) int) (newpivot int) {
data[a], data[pivot] = data[pivot], data[a]
i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
for {
- for i <= j && !less(data[a], data[i]) {
+ for i <= j && !(cmp(data[a], data[i]) < 0) {
i++
}
- for i <= j && less(data[a], data[j]) {
+ for i <= j && (cmp(data[a], data[j]) < 0) {
j--
}
if i > j {
@@ -191,15 +191,15 @@ func partitionEqualLessFunc[E any](data []E, a, b, pivot int, less func(a, b E)
return i
}
-// partialInsertionSortLessFunc partially sorts a slice, returns true if the slice is sorted at the end.
-func partialInsertionSortLessFunc[E any](data []E, a, b int, less func(a, b E) bool) bool {
+// partialInsertionSortCmpFunc partially sorts a slice, returns true if the slice is sorted at the end.
+func partialInsertionSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) bool {
const (
maxSteps = 5 // maximum number of adjacent out-of-order pairs that will get shifted
shortestShifting = 50 // don't shift any elements on short arrays
)
i := a + 1
for j := 0; j < maxSteps; j++ {
- for i < b && !less(data[i], data[i-1]) {
+ for i < b && !(cmp(data[i], data[i-1]) < 0) {
i++
}
@@ -216,7 +216,7 @@ func partialInsertionSortLessFunc[E any](data []E, a, b int, less func(a, b E) b
// Shift the smaller one to the left.
if i-a >= 2 {
for j := i - 1; j >= 1; j-- {
- if !less(data[j], data[j-1]) {
+ if !(cmp(data[j], data[j-1]) < 0) {
break
}
data[j], data[j-1] = data[j-1], data[j]
@@ -225,7 +225,7 @@ func partialInsertionSortLessFunc[E any](data []E, a, b int, less func(a, b E) b
// Shift the greater one to the right.
if b-i >= 2 {
for j := i + 1; j < b; j++ {
- if !less(data[j], data[j-1]) {
+ if !(cmp(data[j], data[j-1]) < 0) {
break
}
data[j], data[j-1] = data[j-1], data[j]
@@ -235,9 +235,9 @@ func partialInsertionSortLessFunc[E any](data []E, a, b int, less func(a, b E) b
return false
}
-// breakPatternsLessFunc scatters some elements around in an attempt to break some patterns
+// breakPatternsCmpFunc scatters some elements around in an attempt to break some patterns
// that might cause imbalanced partitions in quicksort.
-func breakPatternsLessFunc[E any](data []E, a, b int, less func(a, b E) bool) {
+func breakPatternsCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
length := b - a
if length >= 8 {
random := xorshift(length)
@@ -253,12 +253,12 @@ func breakPatternsLessFunc[E any](data []E, a, b int, less func(a, b E) bool) {
}
}
-// choosePivotLessFunc chooses a pivot in data[a:b].
+// choosePivotCmpFunc chooses a pivot in data[a:b].
//
// [0,8): chooses a static pivot.
// [8,shortestNinther): uses the simple median-of-three method.
// [shortestNinther,∞): uses the Tukey ninther method.
-func choosePivotLessFunc[E any](data []E, a, b int, less func(a, b E) bool) (pivot int, hint sortedHint) {
+func choosePivotCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) (pivot int, hint sortedHint) {
const (
shortestNinther = 50
maxSwaps = 4 * 3
@@ -276,12 +276,12 @@ func choosePivotLessFunc[E any](data []E, a, b int, less func(a, b E) bool) (piv
if l >= 8 {
if l >= shortestNinther {
// Tukey ninther method, the idea came from Rust's implementation.
- i = medianAdjacentLessFunc(data, i, &swaps, less)
- j = medianAdjacentLessFunc(data, j, &swaps, less)
- k = medianAdjacentLessFunc(data, k, &swaps, less)
+ i = medianAdjacentCmpFunc(data, i, &swaps, cmp)
+ j = medianAdjacentCmpFunc(data, j, &swaps, cmp)
+ k = medianAdjacentCmpFunc(data, k, &swaps, cmp)
}
// Find the median among i, j, k and stores it into j.
- j = medianLessFunc(data, i, j, k, &swaps, less)
+ j = medianCmpFunc(data, i, j, k, &swaps, cmp)
}
switch swaps {
@@ -294,29 +294,29 @@ func choosePivotLessFunc[E any](data []E, a, b int, less func(a, b E) bool) (piv
}
}
-// order2LessFunc returns x,y where data[x] <= data[y], where x,y=a,b or x,y=b,a.
-func order2LessFunc[E any](data []E, a, b int, swaps *int, less func(a, b E) bool) (int, int) {
- if less(data[b], data[a]) {
+// order2CmpFunc returns x,y where data[x] <= data[y], where x,y=a,b or x,y=b,a.
+func order2CmpFunc[E any](data []E, a, b int, swaps *int, cmp func(a, b E) int) (int, int) {
+ if cmp(data[b], data[a]) < 0 {
*swaps++
return b, a
}
return a, b
}
-// medianLessFunc returns x where data[x] is the median of data[a],data[b],data[c], where x is a, b, or c.
-func medianLessFunc[E any](data []E, a, b, c int, swaps *int, less func(a, b E) bool) int {
- a, b = order2LessFunc(data, a, b, swaps, less)
- b, c = order2LessFunc(data, b, c, swaps, less)
- a, b = order2LessFunc(data, a, b, swaps, less)
+// medianCmpFunc returns x where data[x] is the median of data[a],data[b],data[c], where x is a, b, or c.
+func medianCmpFunc[E any](data []E, a, b, c int, swaps *int, cmp func(a, b E) int) int {
+ a, b = order2CmpFunc(data, a, b, swaps, cmp)
+ b, c = order2CmpFunc(data, b, c, swaps, cmp)
+ a, b = order2CmpFunc(data, a, b, swaps, cmp)
return b
}
-// medianAdjacentLessFunc finds the median of data[a - 1], data[a], data[a + 1] and stores the index into a.
-func medianAdjacentLessFunc[E any](data []E, a int, swaps *int, less func(a, b E) bool) int {
- return medianLessFunc(data, a-1, a, a+1, swaps, less)
+// medianAdjacentCmpFunc finds the median of data[a - 1], data[a], data[a + 1] and stores the index into a.
+func medianAdjacentCmpFunc[E any](data []E, a int, swaps *int, cmp func(a, b E) int) int {
+ return medianCmpFunc(data, a-1, a, a+1, swaps, cmp)
}
-func reverseRangeLessFunc[E any](data []E, a, b int, less func(a, b E) bool) {
+func reverseRangeCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
i := a
j := b - 1
for i < j {
@@ -326,37 +326,37 @@ func reverseRangeLessFunc[E any](data []E, a, b int, less func(a, b E) bool) {
}
}
-func swapRangeLessFunc[E any](data []E, a, b, n int, less func(a, b E) bool) {
+func swapRangeCmpFunc[E any](data []E, a, b, n int, cmp func(a, b E) int) {
for i := 0; i < n; i++ {
data[a+i], data[b+i] = data[b+i], data[a+i]
}
}
-func stableLessFunc[E any](data []E, n int, less func(a, b E) bool) {
+func stableCmpFunc[E any](data []E, n int, cmp func(a, b E) int) {
blockSize := 20 // must be > 0
a, b := 0, blockSize
for b <= n {
- insertionSortLessFunc(data, a, b, less)
+ insertionSortCmpFunc(data, a, b, cmp)
a = b
b += blockSize
}
- insertionSortLessFunc(data, a, n, less)
+ insertionSortCmpFunc(data, a, n, cmp)
for blockSize < n {
a, b = 0, 2*blockSize
for b <= n {
- symMergeLessFunc(data, a, a+blockSize, b, less)
+ symMergeCmpFunc(data, a, a+blockSize, b, cmp)
a = b
b += 2 * blockSize
}
if m := a + blockSize; m < n {
- symMergeLessFunc(data, a, m, n, less)
+ symMergeCmpFunc(data, a, m, n, cmp)
}
blockSize *= 2
}
}
-// symMergeLessFunc merges the two sorted subsequences data[a:m] and data[m:b] using
+// symMergeCmpFunc merges the two sorted subsequences data[a:m] and data[m:b] using
// the SymMerge algorithm from Pok-Son Kim and Arne Kutzner, "Stable Minimum
// Storage Merging by Symmetric Comparisons", in Susanne Albers and Tomasz
// Radzik, editors, Algorithms - ESA 2004, volume 3221 of Lecture Notes in
@@ -375,7 +375,7 @@ func stableLessFunc[E any](data []E, n int, less func(a, b E) bool) {
// symMerge assumes non-degenerate arguments: a < m && m < b.
// Having the caller check this condition eliminates many leaf recursion calls,
// which improves performance.
-func symMergeLessFunc[E any](data []E, a, m, b int, less func(a, b E) bool) {
+func symMergeCmpFunc[E any](data []E, a, m, b int, cmp func(a, b E) int) {
// Avoid unnecessary recursions of symMerge
// by direct insertion of data[a] into data[m:b]
// if data[a:m] only contains one element.
@@ -387,7 +387,7 @@ func symMergeLessFunc[E any](data []E, a, m, b int, less func(a, b E) bool) {
j := b
for i < j {
h := int(uint(i+j) >> 1)
- if less(data[h], data[a]) {
+ if cmp(data[h], data[a]) < 0 {
i = h + 1
} else {
j = h
@@ -411,7 +411,7 @@ func symMergeLessFunc[E any](data []E, a, m, b int, less func(a, b E) bool) {
j := m
for i < j {
h := int(uint(i+j) >> 1)
- if !less(data[m], data[h]) {
+ if !(cmp(data[m], data[h]) < 0) {
i = h + 1
} else {
j = h
@@ -438,7 +438,7 @@ func symMergeLessFunc[E any](data []E, a, m, b int, less func(a, b E) bool) {
for start < r {
c := int(uint(start+r) >> 1)
- if !less(data[p-c], data[c]) {
+ if !(cmp(data[p-c], data[c]) < 0) {
start = c + 1
} else {
r = c
@@ -447,33 +447,33 @@ func symMergeLessFunc[E any](data []E, a, m, b int, less func(a, b E) bool) {
end := n - start
if start < m && m < end {
- rotateLessFunc(data, start, m, end, less)
+ rotateCmpFunc(data, start, m, end, cmp)
}
if a < start && start < mid {
- symMergeLessFunc(data, a, start, mid, less)
+ symMergeCmpFunc(data, a, start, mid, cmp)
}
if mid < end && end < b {
- symMergeLessFunc(data, mid, end, b, less)
+ symMergeCmpFunc(data, mid, end, b, cmp)
}
}
-// rotateLessFunc rotates two consecutive blocks u = data[a:m] and v = data[m:b] in data:
+// rotateCmpFunc rotates two consecutive blocks u = data[a:m] and v = data[m:b] in data:
// Data of the form 'x u v y' is changed to 'x v u y'.
// rotate performs at most b-a many calls to data.Swap,
// and it assumes non-degenerate arguments: a < m && m < b.
-func rotateLessFunc[E any](data []E, a, m, b int, less func(a, b E) bool) {
+func rotateCmpFunc[E any](data []E, a, m, b int, cmp func(a, b E) int) {
i := m - a
j := b - m
for i != j {
if i > j {
- swapRangeLessFunc(data, m-i, m, j, less)
+ swapRangeCmpFunc(data, m-i, m, j, cmp)
i -= j
} else {
- swapRangeLessFunc(data, m-i, m+j-i, i, less)
+ swapRangeCmpFunc(data, m-i, m+j-i, i, cmp)
j -= i
}
}
// i == j
- swapRangeLessFunc(data, m-i, m, i, less)
+ swapRangeCmpFunc(data, m-i, m, i, cmp)
}
diff --git a/vendor/golang.org/x/exp/slices/zsortordered.go b/vendor/golang.org/x/exp/slices/zsortordered.go
index efaa1c8b71..99b47c3986 100644
--- a/vendor/golang.org/x/exp/slices/zsortordered.go
+++ b/vendor/golang.org/x/exp/slices/zsortordered.go
@@ -11,7 +11,7 @@ import "golang.org/x/exp/constraints"
// insertionSortOrdered sorts data[a:b] using insertion sort.
func insertionSortOrdered[E constraints.Ordered](data []E, a, b int) {
for i := a + 1; i < b; i++ {
- for j := i; j > a && (data[j] < data[j-1]); j-- {
+ for j := i; j > a && cmpLess(data[j], data[j-1]); j-- {
data[j], data[j-1] = data[j-1], data[j]
}
}
@@ -26,10 +26,10 @@ func siftDownOrdered[E constraints.Ordered](data []E, lo, hi, first int) {
if child >= hi {
break
}
- if child+1 < hi && (data[first+child] < data[first+child+1]) {
+ if child+1 < hi && cmpLess(data[first+child], data[first+child+1]) {
child++
}
- if !(data[first+root] < data[first+child]) {
+ if !cmpLess(data[first+root], data[first+child]) {
return
}
data[first+root], data[first+child] = data[first+child], data[first+root]
@@ -107,7 +107,7 @@ func pdqsortOrdered[E constraints.Ordered](data []E, a, b, limit int) {
// Probably the slice contains many duplicate elements, partition the slice into
// elements equal to and elements greater than the pivot.
- if a > 0 && !(data[a-1] < data[pivot]) {
+ if a > 0 && !cmpLess(data[a-1], data[pivot]) {
mid := partitionEqualOrdered(data, a, b, pivot)
a = mid
continue
@@ -138,10 +138,10 @@ func partitionOrdered[E constraints.Ordered](data []E, a, b, pivot int) (newpivo
data[a], data[pivot] = data[pivot], data[a]
i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
- for i <= j && (data[i] < data[a]) {
+ for i <= j && cmpLess(data[i], data[a]) {
i++
}
- for i <= j && !(data[j] < data[a]) {
+ for i <= j && !cmpLess(data[j], data[a]) {
j--
}
if i > j {
@@ -153,10 +153,10 @@ func partitionOrdered[E constraints.Ordered](data []E, a, b, pivot int) (newpivo
j--
for {
- for i <= j && (data[i] < data[a]) {
+ for i <= j && cmpLess(data[i], data[a]) {
i++
}
- for i <= j && !(data[j] < data[a]) {
+ for i <= j && !cmpLess(data[j], data[a]) {
j--
}
if i > j {
@@ -177,10 +177,10 @@ func partitionEqualOrdered[E constraints.Ordered](data []E, a, b, pivot int) (ne
i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
for {
- for i <= j && !(data[a] < data[i]) {
+ for i <= j && !cmpLess(data[a], data[i]) {
i++
}
- for i <= j && (data[a] < data[j]) {
+ for i <= j && cmpLess(data[a], data[j]) {
j--
}
if i > j {
@@ -201,7 +201,7 @@ func partialInsertionSortOrdered[E constraints.Ordered](data []E, a, b int) bool
)
i := a + 1
for j := 0; j < maxSteps; j++ {
- for i < b && !(data[i] < data[i-1]) {
+ for i < b && !cmpLess(data[i], data[i-1]) {
i++
}
@@ -218,7 +218,7 @@ func partialInsertionSortOrdered[E constraints.Ordered](data []E, a, b int) bool
// Shift the smaller one to the left.
if i-a >= 2 {
for j := i - 1; j >= 1; j-- {
- if !(data[j] < data[j-1]) {
+ if !cmpLess(data[j], data[j-1]) {
break
}
data[j], data[j-1] = data[j-1], data[j]
@@ -227,7 +227,7 @@ func partialInsertionSortOrdered[E constraints.Ordered](data []E, a, b int) bool
// Shift the greater one to the right.
if b-i >= 2 {
for j := i + 1; j < b; j++ {
- if !(data[j] < data[j-1]) {
+ if !cmpLess(data[j], data[j-1]) {
break
}
data[j], data[j-1] = data[j-1], data[j]
@@ -298,7 +298,7 @@ func choosePivotOrdered[E constraints.Ordered](data []E, a, b int) (pivot int, h
// order2Ordered returns x,y where data[x] <= data[y], where x,y=a,b or x,y=b,a.
func order2Ordered[E constraints.Ordered](data []E, a, b int, swaps *int) (int, int) {
- if data[b] < data[a] {
+ if cmpLess(data[b], data[a]) {
*swaps++
return b, a
}
@@ -389,7 +389,7 @@ func symMergeOrdered[E constraints.Ordered](data []E, a, m, b int) {
j := b
for i < j {
h := int(uint(i+j) >> 1)
- if data[h] < data[a] {
+ if cmpLess(data[h], data[a]) {
i = h + 1
} else {
j = h
@@ -413,7 +413,7 @@ func symMergeOrdered[E constraints.Ordered](data []E, a, m, b int) {
j := m
for i < j {
h := int(uint(i+j) >> 1)
- if !(data[m] < data[h]) {
+ if !cmpLess(data[m], data[h]) {
i = h + 1
} else {
j = h
@@ -440,7 +440,7 @@ func symMergeOrdered[E constraints.Ordered](data []E, a, m, b int) {
for start < r {
c := int(uint(start+r) >> 1)
- if !(data[p-c] < data[c]) {
+ if !cmpLess(data[p-c], data[c]) {
start = c + 1
} else {
r = c
diff --git a/vendor/golang.org/x/mod/LICENSE b/vendor/golang.org/x/mod/LICENSE
index 6a66aea5ea..2a7cf70da6 100644
--- a/vendor/golang.org/x/mod/LICENSE
+++ b/vendor/golang.org/x/mod/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
+Copyright 2009 The Go Authors.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
@@ -10,7 +10,7 @@ notice, this list of conditions and the following disclaimer.
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
+ * Neither the name of Google LLC nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
diff --git a/vendor/golang.org/x/net/LICENSE b/vendor/golang.org/x/net/LICENSE
index 6a66aea5ea..2a7cf70da6 100644
--- a/vendor/golang.org/x/net/LICENSE
+++ b/vendor/golang.org/x/net/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
+Copyright 2009 The Go Authors.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
@@ -10,7 +10,7 @@ notice, this list of conditions and the following disclaimer.
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
+ * Neither the name of Google LLC nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
diff --git a/vendor/golang.org/x/net/http/httpguts/httplex.go b/vendor/golang.org/x/net/http/httpguts/httplex.go
index 6e071e8524..9b4de94019 100644
--- a/vendor/golang.org/x/net/http/httpguts/httplex.go
+++ b/vendor/golang.org/x/net/http/httpguts/httplex.go
@@ -12,7 +12,7 @@ import (
"golang.org/x/net/idna"
)
-var isTokenTable = [127]bool{
+var isTokenTable = [256]bool{
'!': true,
'#': true,
'$': true,
@@ -93,12 +93,7 @@ var isTokenTable = [127]bool{
}
func IsTokenRune(r rune) bool {
- i := int(r)
- return i < len(isTokenTable) && isTokenTable[i]
-}
-
-func isNotToken(r rune) bool {
- return !IsTokenRune(r)
+ return r < utf8.RuneSelf && isTokenTable[byte(r)]
}
// HeaderValuesContainsToken reports whether any string in values
@@ -202,8 +197,8 @@ func ValidHeaderFieldName(v string) bool {
if len(v) == 0 {
return false
}
- for _, r := range v {
- if !IsTokenRune(r) {
+ for i := 0; i < len(v); i++ {
+ if !isTokenTable[v[i]] {
return false
}
}
diff --git a/vendor/golang.org/x/net/http2/client_conn_pool.go b/vendor/golang.org/x/net/http2/client_conn_pool.go
index 780968d6c1..e81b73e6a7 100644
--- a/vendor/golang.org/x/net/http2/client_conn_pool.go
+++ b/vendor/golang.org/x/net/http2/client_conn_pool.go
@@ -8,8 +8,8 @@ package http2
import (
"context"
- "crypto/tls"
"errors"
+ "net"
"net/http"
"sync"
)
@@ -158,7 +158,7 @@ func (c *dialCall) dial(ctx context.Context, addr string) {
// This code decides which ones live or die.
// The return value used is whether c was used.
// c is never closed.
-func (p *clientConnPool) addConnIfNeeded(key string, t *Transport, c *tls.Conn) (used bool, err error) {
+func (p *clientConnPool) addConnIfNeeded(key string, t *Transport, c net.Conn) (used bool, err error) {
p.mu.Lock()
for _, cc := range p.conns[key] {
if cc.CanTakeNewRequest() {
@@ -194,8 +194,8 @@ type addConnCall struct {
err error
}
-func (c *addConnCall) run(t *Transport, key string, tc *tls.Conn) {
- cc, err := t.NewClientConn(tc)
+func (c *addConnCall) run(t *Transport, key string, nc net.Conn) {
+ cc, err := t.NewClientConn(nc)
p := c.p
p.mu.Lock()
diff --git a/vendor/golang.org/x/net/http2/config.go b/vendor/golang.org/x/net/http2/config.go
new file mode 100644
index 0000000000..de58dfb8dc
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/config.go
@@ -0,0 +1,122 @@
+// Copyright 2024 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 http2
+
+import (
+ "math"
+ "net/http"
+ "time"
+)
+
+// http2Config is a package-internal version of net/http.HTTP2Config.
+//
+// http.HTTP2Config was added in Go 1.24.
+// When running with a version of net/http that includes HTTP2Config,
+// we merge the configuration with the fields in Transport or Server
+// to produce an http2Config.
+//
+// Zero valued fields in http2Config are interpreted as in the
+// net/http.HTTPConfig documentation.
+//
+// Precedence order for reconciling configurations is:
+//
+// - Use the net/http.{Server,Transport}.HTTP2Config value, when non-zero.
+// - Otherwise use the http2.{Server.Transport} value.
+// - If the resulting value is zero or out of range, use a default.
+type http2Config struct {
+ MaxConcurrentStreams uint32
+ MaxDecoderHeaderTableSize uint32
+ MaxEncoderHeaderTableSize uint32
+ MaxReadFrameSize uint32
+ MaxUploadBufferPerConnection int32
+ MaxUploadBufferPerStream int32
+ SendPingTimeout time.Duration
+ PingTimeout time.Duration
+ WriteByteTimeout time.Duration
+ PermitProhibitedCipherSuites bool
+ CountError func(errType string)
+}
+
+// configFromServer merges configuration settings from
+// net/http.Server.HTTP2Config and http2.Server.
+func configFromServer(h1 *http.Server, h2 *Server) http2Config {
+ conf := http2Config{
+ MaxConcurrentStreams: h2.MaxConcurrentStreams,
+ MaxEncoderHeaderTableSize: h2.MaxEncoderHeaderTableSize,
+ MaxDecoderHeaderTableSize: h2.MaxDecoderHeaderTableSize,
+ MaxReadFrameSize: h2.MaxReadFrameSize,
+ MaxUploadBufferPerConnection: h2.MaxUploadBufferPerConnection,
+ MaxUploadBufferPerStream: h2.MaxUploadBufferPerStream,
+ SendPingTimeout: h2.ReadIdleTimeout,
+ PingTimeout: h2.PingTimeout,
+ WriteByteTimeout: h2.WriteByteTimeout,
+ PermitProhibitedCipherSuites: h2.PermitProhibitedCipherSuites,
+ CountError: h2.CountError,
+ }
+ fillNetHTTPServerConfig(&conf, h1)
+ setConfigDefaults(&conf, true)
+ return conf
+}
+
+// configFromServer merges configuration settings from h2 and h2.t1.HTTP2
+// (the net/http Transport).
+func configFromTransport(h2 *Transport) http2Config {
+ conf := http2Config{
+ MaxEncoderHeaderTableSize: h2.MaxEncoderHeaderTableSize,
+ MaxDecoderHeaderTableSize: h2.MaxDecoderHeaderTableSize,
+ MaxReadFrameSize: h2.MaxReadFrameSize,
+ SendPingTimeout: h2.ReadIdleTimeout,
+ PingTimeout: h2.PingTimeout,
+ WriteByteTimeout: h2.WriteByteTimeout,
+ }
+
+ // Unlike most config fields, where out-of-range values revert to the default,
+ // Transport.MaxReadFrameSize clips.
+ if conf.MaxReadFrameSize < minMaxFrameSize {
+ conf.MaxReadFrameSize = minMaxFrameSize
+ } else if conf.MaxReadFrameSize > maxFrameSize {
+ conf.MaxReadFrameSize = maxFrameSize
+ }
+
+ if h2.t1 != nil {
+ fillNetHTTPTransportConfig(&conf, h2.t1)
+ }
+ setConfigDefaults(&conf, false)
+ return conf
+}
+
+func setDefault[T ~int | ~int32 | ~uint32 | ~int64](v *T, minval, maxval, defval T) {
+ if *v < minval || *v > maxval {
+ *v = defval
+ }
+}
+
+func setConfigDefaults(conf *http2Config, server bool) {
+ setDefault(&conf.MaxConcurrentStreams, 1, math.MaxUint32, defaultMaxStreams)
+ setDefault(&conf.MaxEncoderHeaderTableSize, 1, math.MaxUint32, initialHeaderTableSize)
+ setDefault(&conf.MaxDecoderHeaderTableSize, 1, math.MaxUint32, initialHeaderTableSize)
+ if server {
+ setDefault(&conf.MaxUploadBufferPerConnection, initialWindowSize, math.MaxInt32, 1<<20)
+ } else {
+ setDefault(&conf.MaxUploadBufferPerConnection, initialWindowSize, math.MaxInt32, transportDefaultConnFlow)
+ }
+ if server {
+ setDefault(&conf.MaxUploadBufferPerStream, 1, math.MaxInt32, 1<<20)
+ } else {
+ setDefault(&conf.MaxUploadBufferPerStream, 1, math.MaxInt32, transportDefaultStreamFlow)
+ }
+ setDefault(&conf.MaxReadFrameSize, minMaxFrameSize, maxFrameSize, defaultMaxReadFrameSize)
+ setDefault(&conf.PingTimeout, 1, math.MaxInt64, 15*time.Second)
+}
+
+// adjustHTTP1MaxHeaderSize converts a limit in bytes on the size of an HTTP/1 header
+// to an HTTP/2 MAX_HEADER_LIST_SIZE value.
+func adjustHTTP1MaxHeaderSize(n int64) int64 {
+ // http2's count is in a slightly different unit and includes 32 bytes per pair.
+ // So, take the net/http.Server value and pad it up a bit, assuming 10 headers.
+ const perFieldOverhead = 32 // per http2 spec
+ const typicalHeaders = 10 // conservative
+ return n + typicalHeaders*perFieldOverhead
+}
diff --git a/vendor/golang.org/x/net/http2/config_go124.go b/vendor/golang.org/x/net/http2/config_go124.go
new file mode 100644
index 0000000000..e3784123c8
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/config_go124.go
@@ -0,0 +1,61 @@
+// Copyright 2024 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 go1.24
+
+package http2
+
+import "net/http"
+
+// fillNetHTTPServerConfig sets fields in conf from srv.HTTP2.
+func fillNetHTTPServerConfig(conf *http2Config, srv *http.Server) {
+ fillNetHTTPConfig(conf, srv.HTTP2)
+}
+
+// fillNetHTTPServerConfig sets fields in conf from tr.HTTP2.
+func fillNetHTTPTransportConfig(conf *http2Config, tr *http.Transport) {
+ fillNetHTTPConfig(conf, tr.HTTP2)
+}
+
+func fillNetHTTPConfig(conf *http2Config, h2 *http.HTTP2Config) {
+ if h2 == nil {
+ return
+ }
+ if h2.MaxConcurrentStreams != 0 {
+ conf.MaxConcurrentStreams = uint32(h2.MaxConcurrentStreams)
+ }
+ if h2.MaxEncoderHeaderTableSize != 0 {
+ conf.MaxEncoderHeaderTableSize = uint32(h2.MaxEncoderHeaderTableSize)
+ }
+ if h2.MaxDecoderHeaderTableSize != 0 {
+ conf.MaxDecoderHeaderTableSize = uint32(h2.MaxDecoderHeaderTableSize)
+ }
+ if h2.MaxConcurrentStreams != 0 {
+ conf.MaxConcurrentStreams = uint32(h2.MaxConcurrentStreams)
+ }
+ if h2.MaxReadFrameSize != 0 {
+ conf.MaxReadFrameSize = uint32(h2.MaxReadFrameSize)
+ }
+ if h2.MaxReceiveBufferPerConnection != 0 {
+ conf.MaxUploadBufferPerConnection = int32(h2.MaxReceiveBufferPerConnection)
+ }
+ if h2.MaxReceiveBufferPerStream != 0 {
+ conf.MaxUploadBufferPerStream = int32(h2.MaxReceiveBufferPerStream)
+ }
+ if h2.SendPingTimeout != 0 {
+ conf.SendPingTimeout = h2.SendPingTimeout
+ }
+ if h2.PingTimeout != 0 {
+ conf.PingTimeout = h2.PingTimeout
+ }
+ if h2.WriteByteTimeout != 0 {
+ conf.WriteByteTimeout = h2.WriteByteTimeout
+ }
+ if h2.PermitProhibitedCipherSuites {
+ conf.PermitProhibitedCipherSuites = true
+ }
+ if h2.CountError != nil {
+ conf.CountError = h2.CountError
+ }
+}
diff --git a/vendor/golang.org/x/net/http2/config_pre_go124.go b/vendor/golang.org/x/net/http2/config_pre_go124.go
new file mode 100644
index 0000000000..060fd6c64c
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/config_pre_go124.go
@@ -0,0 +1,16 @@
+// Copyright 2024 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 !go1.24
+
+package http2
+
+import "net/http"
+
+// Pre-Go 1.24 fallback.
+// The Server.HTTP2 and Transport.HTTP2 config fields were added in Go 1.24.
+
+func fillNetHTTPServerConfig(conf *http2Config, srv *http.Server) {}
+
+func fillNetHTTPTransportConfig(conf *http2Config, tr *http.Transport) {}
diff --git a/vendor/golang.org/x/net/http2/frame.go b/vendor/golang.org/x/net/http2/frame.go
index 43557ab7e9..105c3b279c 100644
--- a/vendor/golang.org/x/net/http2/frame.go
+++ b/vendor/golang.org/x/net/http2/frame.go
@@ -490,6 +490,9 @@ func terminalReadFrameError(err error) bool {
// returned error is ErrFrameTooLarge. Other errors may be of type
// ConnectionError, StreamError, or anything else from the underlying
// reader.
+//
+// If ReadFrame returns an error and a non-nil Frame, the Frame's StreamID
+// indicates the stream responsible for the error.
func (fr *Framer) ReadFrame() (Frame, error) {
fr.errDetail = nil
if fr.lastFrame != nil {
@@ -1521,7 +1524,7 @@ func (fr *Framer) maxHeaderStringLen() int {
// readMetaFrame returns 0 or more CONTINUATION frames from fr and
// merge them into the provided hf and returns a MetaHeadersFrame
// with the decoded hpack values.
-func (fr *Framer) readMetaFrame(hf *HeadersFrame) (*MetaHeadersFrame, error) {
+func (fr *Framer) readMetaFrame(hf *HeadersFrame) (Frame, error) {
if fr.AllowIllegalReads {
return nil, errors.New("illegal use of AllowIllegalReads with ReadMetaHeaders")
}
@@ -1592,7 +1595,7 @@ func (fr *Framer) readMetaFrame(hf *HeadersFrame) (*MetaHeadersFrame, error) {
}
// It would be nice to send a RST_STREAM before sending the GOAWAY,
// but the structure of the server's frame writer makes this difficult.
- return nil, ConnectionError(ErrCodeProtocol)
+ return mh, ConnectionError(ErrCodeProtocol)
}
// Also close the connection after any CONTINUATION frame following an
@@ -1604,11 +1607,11 @@ func (fr *Framer) readMetaFrame(hf *HeadersFrame) (*MetaHeadersFrame, error) {
}
// It would be nice to send a RST_STREAM before sending the GOAWAY,
// but the structure of the server's frame writer makes this difficult.
- return nil, ConnectionError(ErrCodeProtocol)
+ return mh, ConnectionError(ErrCodeProtocol)
}
if _, err := hdec.Write(frag); err != nil {
- return nil, ConnectionError(ErrCodeCompression)
+ return mh, ConnectionError(ErrCodeCompression)
}
if hc.HeadersEnded() {
@@ -1625,7 +1628,7 @@ func (fr *Framer) readMetaFrame(hf *HeadersFrame) (*MetaHeadersFrame, error) {
mh.HeadersFrame.invalidate()
if err := hdec.Close(); err != nil {
- return nil, ConnectionError(ErrCodeCompression)
+ return mh, ConnectionError(ErrCodeCompression)
}
if invalid != nil {
fr.errDetail = invalid
diff --git a/vendor/golang.org/x/net/http2/http2.go b/vendor/golang.org/x/net/http2/http2.go
index 6f2df28187..7688c356b7 100644
--- a/vendor/golang.org/x/net/http2/http2.go
+++ b/vendor/golang.org/x/net/http2/http2.go
@@ -17,15 +17,18 @@ package http2 // import "golang.org/x/net/http2"
import (
"bufio"
+ "context"
"crypto/tls"
+ "errors"
"fmt"
- "io"
+ "net"
"net/http"
"os"
"sort"
"strconv"
"strings"
"sync"
+ "time"
"golang.org/x/net/http/httpguts"
)
@@ -210,12 +213,6 @@ type stringWriter interface {
WriteString(s string) (n int, err error)
}
-// A gate lets two goroutines coordinate their activities.
-type gate chan struct{}
-
-func (g gate) Done() { g <- struct{}{} }
-func (g gate) Wait() { <-g }
-
// A closeWaiter is like a sync.WaitGroup but only goes 1 to 0 (open to closed).
type closeWaiter chan struct{}
@@ -241,13 +238,19 @@ func (cw closeWaiter) Wait() {
// Its buffered writer is lazily allocated as needed, to minimize
// idle memory usage with many connections.
type bufferedWriter struct {
- _ incomparable
- w io.Writer // immutable
- bw *bufio.Writer // non-nil when data is buffered
+ _ incomparable
+ group synctestGroupInterface // immutable
+ conn net.Conn // immutable
+ bw *bufio.Writer // non-nil when data is buffered
+ byteTimeout time.Duration // immutable, WriteByteTimeout
}
-func newBufferedWriter(w io.Writer) *bufferedWriter {
- return &bufferedWriter{w: w}
+func newBufferedWriter(group synctestGroupInterface, conn net.Conn, timeout time.Duration) *bufferedWriter {
+ return &bufferedWriter{
+ group: group,
+ conn: conn,
+ byteTimeout: timeout,
+ }
}
// bufWriterPoolBufferSize is the size of bufio.Writer's
@@ -274,7 +277,7 @@ func (w *bufferedWriter) Available() int {
func (w *bufferedWriter) Write(p []byte) (n int, err error) {
if w.bw == nil {
bw := bufWriterPool.Get().(*bufio.Writer)
- bw.Reset(w.w)
+ bw.Reset((*bufferedWriterTimeoutWriter)(w))
w.bw = bw
}
return w.bw.Write(p)
@@ -292,6 +295,38 @@ func (w *bufferedWriter) Flush() error {
return err
}
+type bufferedWriterTimeoutWriter bufferedWriter
+
+func (w *bufferedWriterTimeoutWriter) Write(p []byte) (n int, err error) {
+ return writeWithByteTimeout(w.group, w.conn, w.byteTimeout, p)
+}
+
+// writeWithByteTimeout writes to conn.
+// If more than timeout passes without any bytes being written to the connection,
+// the write fails.
+func writeWithByteTimeout(group synctestGroupInterface, conn net.Conn, timeout time.Duration, p []byte) (n int, err error) {
+ if timeout <= 0 {
+ return conn.Write(p)
+ }
+ for {
+ var now time.Time
+ if group == nil {
+ now = time.Now()
+ } else {
+ now = group.Now()
+ }
+ conn.SetWriteDeadline(now.Add(timeout))
+ nn, err := conn.Write(p[n:])
+ n += nn
+ if n == len(p) || nn == 0 || !errors.Is(err, os.ErrDeadlineExceeded) {
+ // Either we finished the write, made no progress, or hit the deadline.
+ // Whichever it is, we're done now.
+ conn.SetWriteDeadline(time.Time{})
+ return n, err
+ }
+ }
+}
+
func mustUint31(v int32) uint32 {
if v < 0 || v > 2147483647 {
panic("out of range")
@@ -383,3 +418,14 @@ func validPseudoPath(v string) bool {
// makes that struct also non-comparable, and generally doesn't add
// any size (as long as it's first).
type incomparable [0]func()
+
+// synctestGroupInterface is the methods of synctestGroup used by Server and Transport.
+// It's defined as an interface here to let us keep synctestGroup entirely test-only
+// and not a part of non-test builds.
+type synctestGroupInterface interface {
+ Join()
+ Now() time.Time
+ NewTimer(d time.Duration) timer
+ AfterFunc(d time.Duration, f func()) timer
+ ContextWithTimeout(ctx context.Context, d time.Duration) (context.Context, context.CancelFunc)
+}
diff --git a/vendor/golang.org/x/net/http2/server.go b/vendor/golang.org/x/net/http2/server.go
index ce2e8b40ee..832414b450 100644
--- a/vendor/golang.org/x/net/http2/server.go
+++ b/vendor/golang.org/x/net/http2/server.go
@@ -29,6 +29,7 @@ import (
"bufio"
"bytes"
"context"
+ "crypto/rand"
"crypto/tls"
"errors"
"fmt"
@@ -52,10 +53,14 @@ import (
)
const (
- prefaceTimeout = 10 * time.Second
- firstSettingsTimeout = 2 * time.Second // should be in-flight with preface anyway
- handlerChunkWriteSize = 4 << 10
- defaultMaxStreams = 250 // TODO: make this 100 as the GFE seems to?
+ prefaceTimeout = 10 * time.Second
+ firstSettingsTimeout = 2 * time.Second // should be in-flight with preface anyway
+ handlerChunkWriteSize = 4 << 10
+ defaultMaxStreams = 250 // TODO: make this 100 as the GFE seems to?
+
+ // maxQueuedControlFrames is the maximum number of control frames like
+ // SETTINGS, PING and RST_STREAM that will be queued for writing before
+ // the connection is closed to prevent memory exhaustion attacks.
maxQueuedControlFrames = 10000
)
@@ -127,6 +132,22 @@ type Server struct {
// If zero or negative, there is no timeout.
IdleTimeout time.Duration
+ // ReadIdleTimeout is the timeout after which a health check using a ping
+ // frame will be carried out if no frame is received on the connection.
+ // If zero, no health check is performed.
+ ReadIdleTimeout time.Duration
+
+ // PingTimeout is the timeout after which the connection will be closed
+ // if a response to a ping is not received.
+ // If zero, a default of 15 seconds is used.
+ PingTimeout time.Duration
+
+ // WriteByteTimeout is the timeout after which a connection will be
+ // closed if no data can be written to it. The timeout begins when data is
+ // available to write, and is extended whenever any bytes are written.
+ // If zero or negative, there is no timeout.
+ WriteByteTimeout time.Duration
+
// MaxUploadBufferPerConnection is the size of the initial flow
// control window for each connections. The HTTP/2 spec does not
// allow this to be smaller than 65535 or larger than 2^32-1.
@@ -154,57 +175,39 @@ type Server struct {
// so that we don't embed a Mutex in this struct, which will make the
// struct non-copyable, which might break some callers.
state *serverInternalState
-}
-func (s *Server) initialConnRecvWindowSize() int32 {
- if s.MaxUploadBufferPerConnection >= initialWindowSize {
- return s.MaxUploadBufferPerConnection
- }
- return 1 << 20
+ // Synchronization group used for testing.
+ // Outside of tests, this is nil.
+ group synctestGroupInterface
}
-func (s *Server) initialStreamRecvWindowSize() int32 {
- if s.MaxUploadBufferPerStream > 0 {
- return s.MaxUploadBufferPerStream
+func (s *Server) markNewGoroutine() {
+ if s.group != nil {
+ s.group.Join()
}
- return 1 << 20
}
-func (s *Server) maxReadFrameSize() uint32 {
- if v := s.MaxReadFrameSize; v >= minMaxFrameSize && v <= maxFrameSize {
- return v
+func (s *Server) now() time.Time {
+ if s.group != nil {
+ return s.group.Now()
}
- return defaultMaxReadFrameSize
+ return time.Now()
}
-func (s *Server) maxConcurrentStreams() uint32 {
- if v := s.MaxConcurrentStreams; v > 0 {
- return v
+// newTimer creates a new time.Timer, or a synthetic timer in tests.
+func (s *Server) newTimer(d time.Duration) timer {
+ if s.group != nil {
+ return s.group.NewTimer(d)
}
- return defaultMaxStreams
+ return timeTimer{time.NewTimer(d)}
}
-func (s *Server) maxDecoderHeaderTableSize() uint32 {
- if v := s.MaxDecoderHeaderTableSize; v > 0 {
- return v
+// afterFunc creates a new time.AfterFunc timer, or a synthetic timer in tests.
+func (s *Server) afterFunc(d time.Duration, f func()) timer {
+ if s.group != nil {
+ return s.group.AfterFunc(d, f)
}
- return initialHeaderTableSize
-}
-
-func (s *Server) maxEncoderHeaderTableSize() uint32 {
- if v := s.MaxEncoderHeaderTableSize; v > 0 {
- return v
- }
- return initialHeaderTableSize
-}
-
-// maxQueuedControlFrames is the maximum number of control frames like
-// SETTINGS, PING and RST_STREAM that will be queued for writing before
-// the connection is closed to prevent memory exhaustion attacks.
-func (s *Server) maxQueuedControlFrames() int {
- // TODO: if anybody asks, add a Server field, and remember to define the
- // behavior of negative values.
- return maxQueuedControlFrames
+ return timeTimer{time.AfterFunc(d, f)}
}
type serverInternalState struct {
@@ -303,7 +306,7 @@ func ConfigureServer(s *http.Server, conf *Server) error {
if s.TLSNextProto == nil {
s.TLSNextProto = map[string]func(*http.Server, *tls.Conn, http.Handler){}
}
- protoHandler := func(hs *http.Server, c *tls.Conn, h http.Handler) {
+ protoHandler := func(hs *http.Server, c net.Conn, h http.Handler, sawClientPreface bool) {
if testHookOnConn != nil {
testHookOnConn()
}
@@ -320,12 +323,31 @@ func ConfigureServer(s *http.Server, conf *Server) error {
ctx = bc.BaseContext()
}
conf.ServeConn(c, &ServeConnOpts{
- Context: ctx,
- Handler: h,
- BaseConfig: hs,
+ Context: ctx,
+ Handler: h,
+ BaseConfig: hs,
+ SawClientPreface: sawClientPreface,
})
}
- s.TLSNextProto[NextProtoTLS] = protoHandler
+ s.TLSNextProto[NextProtoTLS] = func(hs *http.Server, c *tls.Conn, h http.Handler) {
+ protoHandler(hs, c, h, false)
+ }
+ // The "unencrypted_http2" TLSNextProto key is used to pass off non-TLS HTTP/2 conns.
+ //
+ // A connection passed in this method has already had the HTTP/2 preface read from it.
+ s.TLSNextProto[nextProtoUnencryptedHTTP2] = func(hs *http.Server, c *tls.Conn, h http.Handler) {
+ nc, err := unencryptedNetConnFromTLSConn(c)
+ if err != nil {
+ if lg := hs.ErrorLog; lg != nil {
+ lg.Print(err)
+ } else {
+ log.Print(err)
+ }
+ go c.Close()
+ return
+ }
+ protoHandler(hs, nc, h, true)
+ }
return nil
}
@@ -400,16 +422,22 @@ func (o *ServeConnOpts) handler() http.Handler {
//
// The opts parameter is optional. If nil, default values are used.
func (s *Server) ServeConn(c net.Conn, opts *ServeConnOpts) {
+ s.serveConn(c, opts, nil)
+}
+
+func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverConn)) {
baseCtx, cancel := serverConnBaseContext(c, opts)
defer cancel()
+ http1srv := opts.baseConfig()
+ conf := configFromServer(http1srv, s)
sc := &serverConn{
srv: s,
- hs: opts.baseConfig(),
+ hs: http1srv,
conn: c,
baseCtx: baseCtx,
remoteAddrStr: c.RemoteAddr().String(),
- bw: newBufferedWriter(c),
+ bw: newBufferedWriter(s.group, c, conf.WriteByteTimeout),
handler: opts.handler(),
streams: make(map[uint32]*stream),
readFrameCh: make(chan readFrameResult),
@@ -419,13 +447,19 @@ func (s *Server) ServeConn(c net.Conn, opts *ServeConnOpts) {
bodyReadCh: make(chan bodyReadMsg), // buffering doesn't matter either way
doneServing: make(chan struct{}),
clientMaxStreams: math.MaxUint32, // Section 6.5.2: "Initially, there is no limit to this value"
- advMaxStreams: s.maxConcurrentStreams(),
+ advMaxStreams: conf.MaxConcurrentStreams,
initialStreamSendWindowSize: initialWindowSize,
+ initialStreamRecvWindowSize: conf.MaxUploadBufferPerStream,
maxFrameSize: initialMaxFrameSize,
+ pingTimeout: conf.PingTimeout,
+ countErrorFunc: conf.CountError,
serveG: newGoroutineLock(),
pushEnabled: true,
sawClientPreface: opts.SawClientPreface,
}
+ if newf != nil {
+ newf(sc)
+ }
s.state.registerConn(sc)
defer s.state.unregisterConn(sc)
@@ -451,15 +485,15 @@ func (s *Server) ServeConn(c net.Conn, opts *ServeConnOpts) {
sc.flow.add(initialWindowSize)
sc.inflow.init(initialWindowSize)
sc.hpackEncoder = hpack.NewEncoder(&sc.headerWriteBuf)
- sc.hpackEncoder.SetMaxDynamicTableSizeLimit(s.maxEncoderHeaderTableSize())
+ sc.hpackEncoder.SetMaxDynamicTableSizeLimit(conf.MaxEncoderHeaderTableSize)
fr := NewFramer(sc.bw, c)
- if s.CountError != nil {
- fr.countError = s.CountError
+ if conf.CountError != nil {
+ fr.countError = conf.CountError
}
- fr.ReadMetaHeaders = hpack.NewDecoder(s.maxDecoderHeaderTableSize(), nil)
+ fr.ReadMetaHeaders = hpack.NewDecoder(conf.MaxDecoderHeaderTableSize, nil)
fr.MaxHeaderListSize = sc.maxHeaderListSize()
- fr.SetMaxReadFrameSize(s.maxReadFrameSize())
+ fr.SetMaxReadFrameSize(conf.MaxReadFrameSize)
sc.framer = fr
if tc, ok := c.(connectionStater); ok {
@@ -492,7 +526,7 @@ func (s *Server) ServeConn(c net.Conn, opts *ServeConnOpts) {
// So for now, do nothing here again.
}
- if !s.PermitProhibitedCipherSuites && isBadCipher(sc.tlsState.CipherSuite) {
+ if !conf.PermitProhibitedCipherSuites && isBadCipher(sc.tlsState.CipherSuite) {
// "Endpoints MAY choose to generate a connection error
// (Section 5.4.1) of type INADEQUATE_SECURITY if one of
// the prohibited cipher suites are negotiated."
@@ -529,7 +563,7 @@ func (s *Server) ServeConn(c net.Conn, opts *ServeConnOpts) {
opts.UpgradeRequest = nil
}
- sc.serve()
+ sc.serve(conf)
}
func serverConnBaseContext(c net.Conn, opts *ServeConnOpts) (ctx context.Context, cancel func()) {
@@ -569,6 +603,7 @@ type serverConn struct {
tlsState *tls.ConnectionState // shared by all handlers, like net/http
remoteAddrStr string
writeSched WriteScheduler
+ countErrorFunc func(errType string)
// Everything following is owned by the serve loop; use serveG.check():
serveG goroutineLock // used to verify funcs are on serve()
@@ -588,6 +623,7 @@ type serverConn struct {
streams map[uint32]*stream
unstartedHandlers []unstartedHandler
initialStreamSendWindowSize int32
+ initialStreamRecvWindowSize int32
maxFrameSize int32
peerMaxHeaderListSize uint32 // zero means unknown (default)
canonHeader map[string]string // http2-lower-case -> Go-Canonical-Case
@@ -598,9 +634,14 @@ type serverConn struct {
inGoAway bool // we've started to or sent GOAWAY
inFrameScheduleLoop bool // whether we're in the scheduleFrameWrite loop
needToSendGoAway bool // we need to schedule a GOAWAY frame write
+ pingSent bool
+ sentPingData [8]byte
goAwayCode ErrCode
- shutdownTimer *time.Timer // nil until used
- idleTimer *time.Timer // nil if unused
+ shutdownTimer timer // nil until used
+ idleTimer timer // nil if unused
+ readIdleTimeout time.Duration
+ pingTimeout time.Duration
+ readIdleTimer timer // nil if unused
// Owned by the writeFrameAsync goroutine:
headerWriteBuf bytes.Buffer
@@ -615,11 +656,7 @@ func (sc *serverConn) maxHeaderListSize() uint32 {
if n <= 0 {
n = http.DefaultMaxHeaderBytes
}
- // http2's count is in a slightly different unit and includes 32 bytes per pair.
- // So, take the net/http.Server value and pad it up a bit, assuming 10 headers.
- const perFieldOverhead = 32 // per http2 spec
- const typicalHeaders = 10 // conservative
- return uint32(n + typicalHeaders*perFieldOverhead)
+ return uint32(adjustHTTP1MaxHeaderSize(int64(n)))
}
func (sc *serverConn) curOpenStreams() uint32 {
@@ -649,12 +686,12 @@ type stream struct {
flow outflow // limits writing from Handler to client
inflow inflow // what the client is allowed to POST/etc to us
state streamState
- resetQueued bool // RST_STREAM queued for write; set by sc.resetStream
- gotTrailerHeader bool // HEADER frame for trailers was seen
- wroteHeaders bool // whether we wrote headers (not status 100)
- readDeadline *time.Timer // nil if unused
- writeDeadline *time.Timer // nil if unused
- closeErr error // set before cw is closed
+ resetQueued bool // RST_STREAM queued for write; set by sc.resetStream
+ gotTrailerHeader bool // HEADER frame for trailers was seen
+ wroteHeaders bool // whether we wrote headers (not status 100)
+ readDeadline timer // nil if unused
+ writeDeadline timer // nil if unused
+ closeErr error // set before cw is closed
trailer http.Header // accumulated trailers
reqTrailer http.Header // handler's Request.Trailer
@@ -732,11 +769,7 @@ func isClosedConnError(err error) bool {
return false
}
- // TODO: remove this string search and be more like the Windows
- // case below. That might involve modifying the standard library
- // to return better error types.
- str := err.Error()
- if strings.Contains(str, "use of closed network connection") {
+ if errors.Is(err, net.ErrClosed) {
return true
}
@@ -815,8 +848,9 @@ type readFrameResult struct {
// consumer is done with the frame.
// It's run on its own goroutine.
func (sc *serverConn) readFrames() {
- gate := make(gate)
- gateDone := gate.Done
+ sc.srv.markNewGoroutine()
+ gate := make(chan struct{})
+ gateDone := func() { gate <- struct{}{} }
for {
f, err := sc.framer.ReadFrame()
select {
@@ -847,6 +881,7 @@ type frameWriteResult struct {
// At most one goroutine can be running writeFrameAsync at a time per
// serverConn.
func (sc *serverConn) writeFrameAsync(wr FrameWriteRequest, wd *writeData) {
+ sc.srv.markNewGoroutine()
var err error
if wd == nil {
err = wr.write.writeFrame(sc)
@@ -885,7 +920,7 @@ func (sc *serverConn) notePanic() {
}
}
-func (sc *serverConn) serve() {
+func (sc *serverConn) serve(conf http2Config) {
sc.serveG.check()
defer sc.notePanic()
defer sc.conn.Close()
@@ -899,18 +934,18 @@ func (sc *serverConn) serve() {
sc.writeFrame(FrameWriteRequest{
write: writeSettings{
- {SettingMaxFrameSize, sc.srv.maxReadFrameSize()},
+ {SettingMaxFrameSize, conf.MaxReadFrameSize},
{SettingMaxConcurrentStreams, sc.advMaxStreams},
{SettingMaxHeaderListSize, sc.maxHeaderListSize()},
- {SettingHeaderTableSize, sc.srv.maxDecoderHeaderTableSize()},
- {SettingInitialWindowSize, uint32(sc.srv.initialStreamRecvWindowSize())},
+ {SettingHeaderTableSize, conf.MaxDecoderHeaderTableSize},
+ {SettingInitialWindowSize, uint32(sc.initialStreamRecvWindowSize)},
},
})
sc.unackedSettings++
// Each connection starts with initialWindowSize inflow tokens.
// If a higher value is configured, we add more tokens.
- if diff := sc.srv.initialConnRecvWindowSize() - initialWindowSize; diff > 0 {
+ if diff := conf.MaxUploadBufferPerConnection - initialWindowSize; diff > 0 {
sc.sendWindowUpdate(nil, int(diff))
}
@@ -926,15 +961,22 @@ func (sc *serverConn) serve() {
sc.setConnState(http.StateIdle)
if sc.srv.IdleTimeout > 0 {
- sc.idleTimer = time.AfterFunc(sc.srv.IdleTimeout, sc.onIdleTimer)
+ sc.idleTimer = sc.srv.afterFunc(sc.srv.IdleTimeout, sc.onIdleTimer)
defer sc.idleTimer.Stop()
}
+ if conf.SendPingTimeout > 0 {
+ sc.readIdleTimeout = conf.SendPingTimeout
+ sc.readIdleTimer = sc.srv.afterFunc(conf.SendPingTimeout, sc.onReadIdleTimer)
+ defer sc.readIdleTimer.Stop()
+ }
+
go sc.readFrames() // closed by defer sc.conn.Close above
- settingsTimer := time.AfterFunc(firstSettingsTimeout, sc.onSettingsTimer)
+ settingsTimer := sc.srv.afterFunc(firstSettingsTimeout, sc.onSettingsTimer)
defer settingsTimer.Stop()
+ lastFrameTime := sc.srv.now()
loopNum := 0
for {
loopNum++
@@ -948,6 +990,7 @@ func (sc *serverConn) serve() {
case res := <-sc.wroteFrameCh:
sc.wroteFrame(res)
case res := <-sc.readFrameCh:
+ lastFrameTime = sc.srv.now()
// Process any written frames before reading new frames from the client since a
// written frame could have triggered a new stream to be started.
if sc.writingFrameAsync {
@@ -979,6 +1022,8 @@ func (sc *serverConn) serve() {
case idleTimerMsg:
sc.vlogf("connection is idle")
sc.goAway(ErrCodeNo)
+ case readIdleTimerMsg:
+ sc.handlePingTimer(lastFrameTime)
case shutdownTimerMsg:
sc.vlogf("GOAWAY close timer fired; closing conn from %v", sc.conn.RemoteAddr())
return
@@ -1001,7 +1046,7 @@ func (sc *serverConn) serve() {
// If the peer is causing us to generate a lot of control frames,
// but not reading them from us, assume they are trying to make us
// run out of memory.
- if sc.queuedControlFrames > sc.srv.maxQueuedControlFrames() {
+ if sc.queuedControlFrames > maxQueuedControlFrames {
sc.vlogf("http2: too many control frames in send queue, closing connection")
return
}
@@ -1017,12 +1062,39 @@ func (sc *serverConn) serve() {
}
}
+func (sc *serverConn) handlePingTimer(lastFrameReadTime time.Time) {
+ if sc.pingSent {
+ sc.vlogf("timeout waiting for PING response")
+ sc.conn.Close()
+ return
+ }
+
+ pingAt := lastFrameReadTime.Add(sc.readIdleTimeout)
+ now := sc.srv.now()
+ if pingAt.After(now) {
+ // We received frames since arming the ping timer.
+ // Reset it for the next possible timeout.
+ sc.readIdleTimer.Reset(pingAt.Sub(now))
+ return
+ }
+
+ sc.pingSent = true
+ // Ignore crypto/rand.Read errors: It generally can't fail, and worse case if it does
+ // is we send a PING frame containing 0s.
+ _, _ = rand.Read(sc.sentPingData[:])
+ sc.writeFrame(FrameWriteRequest{
+ write: &writePing{data: sc.sentPingData},
+ })
+ sc.readIdleTimer.Reset(sc.pingTimeout)
+}
+
type serverMessage int
// Message values sent to serveMsgCh.
var (
settingsTimerMsg = new(serverMessage)
idleTimerMsg = new(serverMessage)
+ readIdleTimerMsg = new(serverMessage)
shutdownTimerMsg = new(serverMessage)
gracefulShutdownMsg = new(serverMessage)
handlerDoneMsg = new(serverMessage)
@@ -1030,6 +1102,7 @@ var (
func (sc *serverConn) onSettingsTimer() { sc.sendServeMsg(settingsTimerMsg) }
func (sc *serverConn) onIdleTimer() { sc.sendServeMsg(idleTimerMsg) }
+func (sc *serverConn) onReadIdleTimer() { sc.sendServeMsg(readIdleTimerMsg) }
func (sc *serverConn) onShutdownTimer() { sc.sendServeMsg(shutdownTimerMsg) }
func (sc *serverConn) sendServeMsg(msg interface{}) {
@@ -1061,10 +1134,10 @@ func (sc *serverConn) readPreface() error {
errc <- nil
}
}()
- timer := time.NewTimer(prefaceTimeout) // TODO: configurable on *Server?
+ timer := sc.srv.newTimer(prefaceTimeout) // TODO: configurable on *Server?
defer timer.Stop()
select {
- case <-timer.C:
+ case <-timer.C():
return errPrefaceTimeout
case err := <-errc:
if err == nil {
@@ -1282,6 +1355,10 @@ func (sc *serverConn) wroteFrame(res frameWriteResult) {
sc.writingFrame = false
sc.writingFrameAsync = false
+ if res.err != nil {
+ sc.conn.Close()
+ }
+
wr := res.wr
if writeEndsStream(wr.write) {
@@ -1429,7 +1506,7 @@ func (sc *serverConn) goAway(code ErrCode) {
func (sc *serverConn) shutDownIn(d time.Duration) {
sc.serveG.check()
- sc.shutdownTimer = time.AfterFunc(d, sc.onShutdownTimer)
+ sc.shutdownTimer = sc.srv.afterFunc(d, sc.onShutdownTimer)
}
func (sc *serverConn) resetStream(se StreamError) {
@@ -1482,6 +1559,11 @@ func (sc *serverConn) processFrameFromReader(res readFrameResult) bool {
sc.goAway(ErrCodeFlowControl)
return true
case ConnectionError:
+ if res.f != nil {
+ if id := res.f.Header().StreamID; id > sc.maxClientStreamID {
+ sc.maxClientStreamID = id
+ }
+ }
sc.logf("http2: server connection error from %v: %v", sc.conn.RemoteAddr(), ev)
sc.goAway(ErrCode(ev))
return true // goAway will handle shutdown
@@ -1551,6 +1633,11 @@ func (sc *serverConn) processFrame(f Frame) error {
func (sc *serverConn) processPing(f *PingFrame) error {
sc.serveG.check()
if f.IsAck() {
+ if sc.pingSent && sc.sentPingData == f.Data {
+ // This is a response to a PING we sent.
+ sc.pingSent = false
+ sc.readIdleTimer.Reset(sc.readIdleTimeout)
+ }
// 6.7 PING: " An endpoint MUST NOT respond to PING frames
// containing this flag."
return nil
@@ -1638,7 +1725,7 @@ func (sc *serverConn) closeStream(st *stream, err error) {
delete(sc.streams, st.id)
if len(sc.streams) == 0 {
sc.setConnState(http.StateIdle)
- if sc.srv.IdleTimeout > 0 {
+ if sc.srv.IdleTimeout > 0 && sc.idleTimer != nil {
sc.idleTimer.Reset(sc.srv.IdleTimeout)
}
if h1ServerKeepAlivesDisabled(sc.hs) {
@@ -1660,6 +1747,7 @@ func (sc *serverConn) closeStream(st *stream, err error) {
}
}
st.closeErr = err
+ st.cancelCtx()
st.cw.Close() // signals Handler's CloseNotifier, unblocks writes, etc
sc.writeSched.CloseStream(st.id)
}
@@ -2020,7 +2108,7 @@ func (sc *serverConn) processHeaders(f *MetaHeadersFrame) error {
// (in Go 1.8), though. That's a more sane option anyway.
if sc.hs.ReadTimeout > 0 {
sc.conn.SetReadDeadline(time.Time{})
- st.readDeadline = time.AfterFunc(sc.hs.ReadTimeout, st.onReadTimeout)
+ st.readDeadline = sc.srv.afterFunc(sc.hs.ReadTimeout, st.onReadTimeout)
}
return sc.scheduleHandler(id, rw, req, handler)
@@ -2116,9 +2204,9 @@ func (sc *serverConn) newStream(id, pusherID uint32, state streamState) *stream
st.cw.Init()
st.flow.conn = &sc.flow // link to conn-level counter
st.flow.add(sc.initialStreamSendWindowSize)
- st.inflow.init(sc.srv.initialStreamRecvWindowSize())
+ st.inflow.init(sc.initialStreamRecvWindowSize)
if sc.hs.WriteTimeout > 0 {
- st.writeDeadline = time.AfterFunc(sc.hs.WriteTimeout, st.onWriteTimeout)
+ st.writeDeadline = sc.srv.afterFunc(sc.hs.WriteTimeout, st.onWriteTimeout)
}
sc.streams[id] = st
@@ -2342,6 +2430,7 @@ func (sc *serverConn) handlerDone() {
// Run on its own goroutine.
func (sc *serverConn) runHandler(rw *responseWriter, req *http.Request, handler func(http.ResponseWriter, *http.Request)) {
+ sc.srv.markNewGoroutine()
defer sc.sendServeMsg(handlerDoneMsg)
didPanic := true
defer func() {
@@ -2638,7 +2727,7 @@ func (rws *responseWriterState) writeChunk(p []byte) (n int, err error) {
var date string
if _, ok := rws.snapHeader["Date"]; !ok {
// TODO(bradfitz): be faster here, like net/http? measure.
- date = time.Now().UTC().Format(http.TimeFormat)
+ date = rws.conn.srv.now().UTC().Format(http.TimeFormat)
}
for _, v := range rws.snapHeader["Trailer"] {
@@ -2760,7 +2849,7 @@ func (rws *responseWriterState) promoteUndeclaredTrailers() {
func (w *responseWriter) SetReadDeadline(deadline time.Time) error {
st := w.rws.stream
- if !deadline.IsZero() && deadline.Before(time.Now()) {
+ if !deadline.IsZero() && deadline.Before(w.rws.conn.srv.now()) {
// If we're setting a deadline in the past, reset the stream immediately
// so writes after SetWriteDeadline returns will fail.
st.onReadTimeout()
@@ -2776,9 +2865,9 @@ func (w *responseWriter) SetReadDeadline(deadline time.Time) error {
if deadline.IsZero() {
st.readDeadline = nil
} else if st.readDeadline == nil {
- st.readDeadline = time.AfterFunc(deadline.Sub(time.Now()), st.onReadTimeout)
+ st.readDeadline = sc.srv.afterFunc(deadline.Sub(sc.srv.now()), st.onReadTimeout)
} else {
- st.readDeadline.Reset(deadline.Sub(time.Now()))
+ st.readDeadline.Reset(deadline.Sub(sc.srv.now()))
}
})
return nil
@@ -2786,7 +2875,7 @@ func (w *responseWriter) SetReadDeadline(deadline time.Time) error {
func (w *responseWriter) SetWriteDeadline(deadline time.Time) error {
st := w.rws.stream
- if !deadline.IsZero() && deadline.Before(time.Now()) {
+ if !deadline.IsZero() && deadline.Before(w.rws.conn.srv.now()) {
// If we're setting a deadline in the past, reset the stream immediately
// so writes after SetWriteDeadline returns will fail.
st.onWriteTimeout()
@@ -2802,14 +2891,19 @@ func (w *responseWriter) SetWriteDeadline(deadline time.Time) error {
if deadline.IsZero() {
st.writeDeadline = nil
} else if st.writeDeadline == nil {
- st.writeDeadline = time.AfterFunc(deadline.Sub(time.Now()), st.onWriteTimeout)
+ st.writeDeadline = sc.srv.afterFunc(deadline.Sub(sc.srv.now()), st.onWriteTimeout)
} else {
- st.writeDeadline.Reset(deadline.Sub(time.Now()))
+ st.writeDeadline.Reset(deadline.Sub(sc.srv.now()))
}
})
return nil
}
+func (w *responseWriter) EnableFullDuplex() error {
+ // We always support full duplex responses, so this is a no-op.
+ return nil
+}
+
func (w *responseWriter) Flush() {
w.FlushError()
}
@@ -3256,7 +3350,7 @@ func (sc *serverConn) countError(name string, err error) error {
if sc == nil || sc.srv == nil {
return err
}
- f := sc.srv.CountError
+ f := sc.countErrorFunc
if f == nil {
return err
}
diff --git a/vendor/golang.org/x/net/http2/testsync.go b/vendor/golang.org/x/net/http2/testsync.go
deleted file mode 100644
index 61075bd16d..0000000000
--- a/vendor/golang.org/x/net/http2/testsync.go
+++ /dev/null
@@ -1,331 +0,0 @@
-// Copyright 2024 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 http2
-
-import (
- "context"
- "sync"
- "time"
-)
-
-// testSyncHooks coordinates goroutines in tests.
-//
-// For example, a call to ClientConn.RoundTrip involves several goroutines, including:
-// - the goroutine running RoundTrip;
-// - the clientStream.doRequest goroutine, which writes the request; and
-// - the clientStream.readLoop goroutine, which reads the response.
-//
-// Using testSyncHooks, a test can start a RoundTrip and identify when all these goroutines
-// are blocked waiting for some condition such as reading the Request.Body or waiting for
-// flow control to become available.
-//
-// The testSyncHooks also manage timers and synthetic time in tests.
-// This permits us to, for example, start a request and cause it to time out waiting for
-// response headers without resorting to time.Sleep calls.
-type testSyncHooks struct {
- // active/inactive act as a mutex and condition variable.
- //
- // - neither chan contains a value: testSyncHooks is locked.
- // - active contains a value: unlocked, and at least one goroutine is not blocked
- // - inactive contains a value: unlocked, and all goroutines are blocked
- active chan struct{}
- inactive chan struct{}
-
- // goroutine counts
- total int // total goroutines
- condwait map[*sync.Cond]int // blocked in sync.Cond.Wait
- blocked []*testBlockedGoroutine // otherwise blocked
-
- // fake time
- now time.Time
- timers []*fakeTimer
-
- // Transport testing: Report various events.
- newclientconn func(*ClientConn)
- newstream func(*clientStream)
-}
-
-// testBlockedGoroutine is a blocked goroutine.
-type testBlockedGoroutine struct {
- f func() bool // blocked until f returns true
- ch chan struct{} // closed when unblocked
-}
-
-func newTestSyncHooks() *testSyncHooks {
- h := &testSyncHooks{
- active: make(chan struct{}, 1),
- inactive: make(chan struct{}, 1),
- condwait: map[*sync.Cond]int{},
- }
- h.inactive <- struct{}{}
- h.now = time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
- return h
-}
-
-// lock acquires the testSyncHooks mutex.
-func (h *testSyncHooks) lock() {
- select {
- case <-h.active:
- case <-h.inactive:
- }
-}
-
-// waitInactive waits for all goroutines to become inactive.
-func (h *testSyncHooks) waitInactive() {
- for {
- <-h.inactive
- if !h.unlock() {
- break
- }
- }
-}
-
-// unlock releases the testSyncHooks mutex.
-// It reports whether any goroutines are active.
-func (h *testSyncHooks) unlock() (active bool) {
- // Look for a blocked goroutine which can be unblocked.
- blocked := h.blocked[:0]
- unblocked := false
- for _, b := range h.blocked {
- if !unblocked && b.f() {
- unblocked = true
- close(b.ch)
- } else {
- blocked = append(blocked, b)
- }
- }
- h.blocked = blocked
-
- // Count goroutines blocked on condition variables.
- condwait := 0
- for _, count := range h.condwait {
- condwait += count
- }
-
- if h.total > condwait+len(blocked) {
- h.active <- struct{}{}
- return true
- } else {
- h.inactive <- struct{}{}
- return false
- }
-}
-
-// goRun starts a new goroutine.
-func (h *testSyncHooks) goRun(f func()) {
- h.lock()
- h.total++
- h.unlock()
- go func() {
- defer func() {
- h.lock()
- h.total--
- h.unlock()
- }()
- f()
- }()
-}
-
-// blockUntil indicates that a goroutine is blocked waiting for some condition to become true.
-// It waits until f returns true before proceeding.
-//
-// Example usage:
-//
-// h.blockUntil(func() bool {
-// // Is the context done yet?
-// select {
-// case <-ctx.Done():
-// default:
-// return false
-// }
-// return true
-// })
-// // Wait for the context to become done.
-// <-ctx.Done()
-//
-// The function f passed to blockUntil must be non-blocking and idempotent.
-func (h *testSyncHooks) blockUntil(f func() bool) {
- if f() {
- return
- }
- ch := make(chan struct{})
- h.lock()
- h.blocked = append(h.blocked, &testBlockedGoroutine{
- f: f,
- ch: ch,
- })
- h.unlock()
- <-ch
-}
-
-// broadcast is sync.Cond.Broadcast.
-func (h *testSyncHooks) condBroadcast(cond *sync.Cond) {
- h.lock()
- delete(h.condwait, cond)
- h.unlock()
- cond.Broadcast()
-}
-
-// broadcast is sync.Cond.Wait.
-func (h *testSyncHooks) condWait(cond *sync.Cond) {
- h.lock()
- h.condwait[cond]++
- h.unlock()
-}
-
-// newTimer creates a new fake timer.
-func (h *testSyncHooks) newTimer(d time.Duration) timer {
- h.lock()
- defer h.unlock()
- t := &fakeTimer{
- hooks: h,
- when: h.now.Add(d),
- c: make(chan time.Time),
- }
- h.timers = append(h.timers, t)
- return t
-}
-
-// afterFunc creates a new fake AfterFunc timer.
-func (h *testSyncHooks) afterFunc(d time.Duration, f func()) timer {
- h.lock()
- defer h.unlock()
- t := &fakeTimer{
- hooks: h,
- when: h.now.Add(d),
- f: f,
- }
- h.timers = append(h.timers, t)
- return t
-}
-
-func (h *testSyncHooks) contextWithTimeout(ctx context.Context, d time.Duration) (context.Context, context.CancelFunc) {
- ctx, cancel := context.WithCancel(ctx)
- t := h.afterFunc(d, cancel)
- return ctx, func() {
- t.Stop()
- cancel()
- }
-}
-
-func (h *testSyncHooks) timeUntilEvent() time.Duration {
- h.lock()
- defer h.unlock()
- var next time.Time
- for _, t := range h.timers {
- if next.IsZero() || t.when.Before(next) {
- next = t.when
- }
- }
- if d := next.Sub(h.now); d > 0 {
- return d
- }
- return 0
-}
-
-// advance advances time and causes synthetic timers to fire.
-func (h *testSyncHooks) advance(d time.Duration) {
- h.lock()
- defer h.unlock()
- h.now = h.now.Add(d)
- timers := h.timers[:0]
- for _, t := range h.timers {
- t := t // remove after go.mod depends on go1.22
- t.mu.Lock()
- switch {
- case t.when.After(h.now):
- timers = append(timers, t)
- case t.when.IsZero():
- // stopped timer
- default:
- t.when = time.Time{}
- if t.c != nil {
- close(t.c)
- }
- if t.f != nil {
- h.total++
- go func() {
- defer func() {
- h.lock()
- h.total--
- h.unlock()
- }()
- t.f()
- }()
- }
- }
- t.mu.Unlock()
- }
- h.timers = timers
-}
-
-// A timer wraps a time.Timer, or a synthetic equivalent in tests.
-// Unlike time.Timer, timer is single-use: The timer channel is closed when the timer expires.
-type timer interface {
- C() <-chan time.Time
- Stop() bool
- Reset(d time.Duration) bool
-}
-
-// timeTimer implements timer using real time.
-type timeTimer struct {
- t *time.Timer
- c chan time.Time
-}
-
-// newTimeTimer creates a new timer using real time.
-func newTimeTimer(d time.Duration) timer {
- ch := make(chan time.Time)
- t := time.AfterFunc(d, func() {
- close(ch)
- })
- return &timeTimer{t, ch}
-}
-
-// newTimeAfterFunc creates an AfterFunc timer using real time.
-func newTimeAfterFunc(d time.Duration, f func()) timer {
- return &timeTimer{
- t: time.AfterFunc(d, f),
- }
-}
-
-func (t timeTimer) C() <-chan time.Time { return t.c }
-func (t timeTimer) Stop() bool { return t.t.Stop() }
-func (t timeTimer) Reset(d time.Duration) bool { return t.t.Reset(d) }
-
-// fakeTimer implements timer using fake time.
-type fakeTimer struct {
- hooks *testSyncHooks
-
- mu sync.Mutex
- when time.Time // when the timer will fire
- c chan time.Time // closed when the timer fires; mutually exclusive with f
- f func() // called when the timer fires; mutually exclusive with c
-}
-
-func (t *fakeTimer) C() <-chan time.Time { return t.c }
-
-func (t *fakeTimer) Stop() bool {
- t.mu.Lock()
- defer t.mu.Unlock()
- stopped := t.when.IsZero()
- t.when = time.Time{}
- return stopped
-}
-
-func (t *fakeTimer) Reset(d time.Duration) bool {
- if t.c != nil || t.f == nil {
- panic("fakeTimer only supports Reset on AfterFunc timers")
- }
- t.mu.Lock()
- defer t.mu.Unlock()
- t.hooks.lock()
- defer t.hooks.unlock()
- active := !t.when.IsZero()
- t.when = t.hooks.now.Add(d)
- if !active {
- t.hooks.timers = append(t.hooks.timers, t)
- }
- return active
-}
diff --git a/vendor/golang.org/x/net/http2/timer.go b/vendor/golang.org/x/net/http2/timer.go
new file mode 100644
index 0000000000..0b1c17b812
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/timer.go
@@ -0,0 +1,20 @@
+// Copyright 2024 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 http2
+
+import "time"
+
+// A timer is a time.Timer, as an interface which can be replaced in tests.
+type timer = interface {
+ C() <-chan time.Time
+ Reset(d time.Duration) bool
+ Stop() bool
+}
+
+// timeTimer adapts a time.Timer to the timer interface.
+type timeTimer struct {
+ *time.Timer
+}
+
+func (t timeTimer) C() <-chan time.Time { return t.Timer.C }
diff --git a/vendor/golang.org/x/net/http2/transport.go b/vendor/golang.org/x/net/http2/transport.go
index ce375c8c75..f5968f4407 100644
--- a/vendor/golang.org/x/net/http2/transport.go
+++ b/vendor/golang.org/x/net/http2/transport.go
@@ -25,7 +25,6 @@ import (
"net/http"
"net/http/httptrace"
"net/textproto"
- "os"
"sort"
"strconv"
"strings"
@@ -185,42 +184,80 @@ type Transport struct {
connPoolOnce sync.Once
connPoolOrDef ClientConnPool // non-nil version of ConnPool
- syncHooks *testSyncHooks
+ *transportTestHooks
}
-func (t *Transport) maxHeaderListSize() uint32 {
- if t.MaxHeaderListSize == 0 {
- return 10 << 20
+// Hook points used for testing.
+// Outside of tests, t.transportTestHooks is nil and these all have minimal implementations.
+// Inside tests, see the testSyncHooks function docs.
+
+type transportTestHooks struct {
+ newclientconn func(*ClientConn)
+ group synctestGroupInterface
+}
+
+func (t *Transport) markNewGoroutine() {
+ if t != nil && t.transportTestHooks != nil {
+ t.transportTestHooks.group.Join()
}
- if t.MaxHeaderListSize == 0xffffffff {
- return 0
+}
+
+func (t *Transport) now() time.Time {
+ if t != nil && t.transportTestHooks != nil {
+ return t.transportTestHooks.group.Now()
}
- return t.MaxHeaderListSize
+ return time.Now()
}
-func (t *Transport) maxFrameReadSize() uint32 {
- if t.MaxReadFrameSize == 0 {
- return 0 // use the default provided by the peer
+func (t *Transport) timeSince(when time.Time) time.Duration {
+ if t != nil && t.transportTestHooks != nil {
+ return t.now().Sub(when)
}
- if t.MaxReadFrameSize < minMaxFrameSize {
- return minMaxFrameSize
+ return time.Since(when)
+}
+
+// newTimer creates a new time.Timer, or a synthetic timer in tests.
+func (t *Transport) newTimer(d time.Duration) timer {
+ if t.transportTestHooks != nil {
+ return t.transportTestHooks.group.NewTimer(d)
}
- if t.MaxReadFrameSize > maxFrameSize {
- return maxFrameSize
+ return timeTimer{time.NewTimer(d)}
+}
+
+// afterFunc creates a new time.AfterFunc timer, or a synthetic timer in tests.
+func (t *Transport) afterFunc(d time.Duration, f func()) timer {
+ if t.transportTestHooks != nil {
+ return t.transportTestHooks.group.AfterFunc(d, f)
}
- return t.MaxReadFrameSize
+ return timeTimer{time.AfterFunc(d, f)}
}
-func (t *Transport) disableCompression() bool {
- return t.DisableCompression || (t.t1 != nil && t.t1.DisableCompression)
+func (t *Transport) contextWithTimeout(ctx context.Context, d time.Duration) (context.Context, context.CancelFunc) {
+ if t.transportTestHooks != nil {
+ return t.transportTestHooks.group.ContextWithTimeout(ctx, d)
+ }
+ return context.WithTimeout(ctx, d)
}
-func (t *Transport) pingTimeout() time.Duration {
- if t.PingTimeout == 0 {
- return 15 * time.Second
+func (t *Transport) maxHeaderListSize() uint32 {
+ n := int64(t.MaxHeaderListSize)
+ if t.t1 != nil && t.t1.MaxResponseHeaderBytes != 0 {
+ n = t.t1.MaxResponseHeaderBytes
+ if n > 0 {
+ n = adjustHTTP1MaxHeaderSize(n)
+ }
+ }
+ if n <= 0 {
+ return 10 << 20
}
- return t.PingTimeout
+ if n >= 0xffffffff {
+ return 0
+ }
+ return uint32(n)
+}
+func (t *Transport) disableCompression() bool {
+ return t.DisableCompression || (t.t1 != nil && t.t1.DisableCompression)
}
// ConfigureTransport configures a net/http HTTP/1 Transport to use HTTP/2.
@@ -258,8 +295,8 @@ func configureTransports(t1 *http.Transport) (*Transport, error) {
if !strSliceContains(t1.TLSClientConfig.NextProtos, "http/1.1") {
t1.TLSClientConfig.NextProtos = append(t1.TLSClientConfig.NextProtos, "http/1.1")
}
- upgradeFn := func(authority string, c *tls.Conn) http.RoundTripper {
- addr := authorityAddr("https", authority)
+ upgradeFn := func(scheme, authority string, c net.Conn) http.RoundTripper {
+ addr := authorityAddr(scheme, authority)
if used, err := connPool.addConnIfNeeded(addr, t2, c); err != nil {
go c.Close()
return erringRoundTripper{err}
@@ -270,18 +307,37 @@ func configureTransports(t1 *http.Transport) (*Transport, error) {
// was unknown)
go c.Close()
}
+ if scheme == "http" {
+ return (*unencryptedTransport)(t2)
+ }
return t2
}
- if m := t1.TLSNextProto; len(m) == 0 {
- t1.TLSNextProto = map[string]func(string, *tls.Conn) http.RoundTripper{
- "h2": upgradeFn,
+ if t1.TLSNextProto == nil {
+ t1.TLSNextProto = make(map[string]func(string, *tls.Conn) http.RoundTripper)
+ }
+ t1.TLSNextProto[NextProtoTLS] = func(authority string, c *tls.Conn) http.RoundTripper {
+ return upgradeFn("https", authority, c)
+ }
+ // The "unencrypted_http2" TLSNextProto key is used to pass off non-TLS HTTP/2 conns.
+ t1.TLSNextProto[nextProtoUnencryptedHTTP2] = func(authority string, c *tls.Conn) http.RoundTripper {
+ nc, err := unencryptedNetConnFromTLSConn(c)
+ if err != nil {
+ go c.Close()
+ return erringRoundTripper{err}
}
- } else {
- m["h2"] = upgradeFn
+ return upgradeFn("http", authority, nc)
}
return t2, nil
}
+// unencryptedTransport is a Transport with a RoundTrip method that
+// always permits http:// URLs.
+type unencryptedTransport Transport
+
+func (t *unencryptedTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+ return (*Transport)(t).RoundTripOpt(req, RoundTripOpt{allowHTTP: true})
+}
+
func (t *Transport) connPool() ClientConnPool {
t.connPoolOnce.Do(t.initConnPool)
return t.connPoolOrDef
@@ -301,7 +357,7 @@ type ClientConn struct {
t *Transport
tconn net.Conn // usually *tls.Conn, except specialized impls
tlsState *tls.ConnectionState // nil only for specialized impls
- reused uint32 // whether conn is being reused; atomic
+ atomicReused uint32 // whether conn is being reused; atomic
singleUse bool // whether being used for a single http.Request
getConnCalled bool // used by clientConnPool
@@ -332,11 +388,22 @@ type ClientConn struct {
lastActive time.Time
lastIdle time.Time // time last idle
// Settings from peer: (also guarded by wmu)
- maxFrameSize uint32
- maxConcurrentStreams uint32
- peerMaxHeaderListSize uint64
- peerMaxHeaderTableSize uint32
- initialWindowSize uint32
+ maxFrameSize uint32
+ maxConcurrentStreams uint32
+ peerMaxHeaderListSize uint64
+ peerMaxHeaderTableSize uint32
+ initialWindowSize uint32
+ initialStreamRecvWindowSize int32
+ readIdleTimeout time.Duration
+ pingTimeout time.Duration
+
+ // pendingResets is the number of RST_STREAM frames we have sent to the peer,
+ // without confirming that the peer has received them. When we send a RST_STREAM,
+ // we bundle it with a PING frame, unless a PING is already in flight. We count
+ // the reset stream against the connection's concurrency limit until we get
+ // a PING response. This limits the number of requests we'll try to send to a
+ // completely unresponsive connection.
+ pendingResets int
// reqHeaderMu is a 1-element semaphore channel controlling access to sending new requests.
// Write to reqHeaderMu to lock it, read from it to unlock.
@@ -352,60 +419,6 @@ type ClientConn struct {
werr error // first write error that has occurred
hbuf bytes.Buffer // HPACK encoder writes into this
henc *hpack.Encoder
-
- syncHooks *testSyncHooks // can be nil
-}
-
-// Hook points used for testing.
-// Outside of tests, cc.syncHooks is nil and these all have minimal implementations.
-// Inside tests, see the testSyncHooks function docs.
-
-// goRun starts a new goroutine.
-func (cc *ClientConn) goRun(f func()) {
- if cc.syncHooks != nil {
- cc.syncHooks.goRun(f)
- return
- }
- go f()
-}
-
-// condBroadcast is cc.cond.Broadcast.
-func (cc *ClientConn) condBroadcast() {
- if cc.syncHooks != nil {
- cc.syncHooks.condBroadcast(cc.cond)
- }
- cc.cond.Broadcast()
-}
-
-// condWait is cc.cond.Wait.
-func (cc *ClientConn) condWait() {
- if cc.syncHooks != nil {
- cc.syncHooks.condWait(cc.cond)
- }
- cc.cond.Wait()
-}
-
-// newTimer creates a new time.Timer, or a synthetic timer in tests.
-func (cc *ClientConn) newTimer(d time.Duration) timer {
- if cc.syncHooks != nil {
- return cc.syncHooks.newTimer(d)
- }
- return newTimeTimer(d)
-}
-
-// afterFunc creates a new time.AfterFunc timer, or a synthetic timer in tests.
-func (cc *ClientConn) afterFunc(d time.Duration, f func()) timer {
- if cc.syncHooks != nil {
- return cc.syncHooks.afterFunc(d, f)
- }
- return newTimeAfterFunc(d, f)
-}
-
-func (cc *ClientConn) contextWithTimeout(ctx context.Context, d time.Duration) (context.Context, context.CancelFunc) {
- if cc.syncHooks != nil {
- return cc.syncHooks.contextWithTimeout(ctx, d)
- }
- return context.WithTimeout(ctx, d)
}
// clientStream is the state for a single HTTP/2 stream. One of these
@@ -448,12 +461,12 @@ type clientStream struct {
sentHeaders bool
// owned by clientConnReadLoop:
- firstByte bool // got the first response byte
- pastHeaders bool // got first MetaHeadersFrame (actual headers)
- pastTrailers bool // got optional second MetaHeadersFrame (trailers)
- num1xx uint8 // number of 1xx responses seen
- readClosed bool // peer sent an END_STREAM flag
- readAborted bool // read loop reset the stream
+ firstByte bool // got the first response byte
+ pastHeaders bool // got first MetaHeadersFrame (actual headers)
+ pastTrailers bool // got optional second MetaHeadersFrame (trailers)
+ readClosed bool // peer sent an END_STREAM flag
+ readAborted bool // read loop reset the stream
+ totalHeaderSize int64 // total size of 1xx headers seen
trailer http.Header // accumulated trailers
resTrailer *http.Header // client's Response.Trailer
@@ -487,7 +500,7 @@ func (cs *clientStream) abortStreamLocked(err error) {
// TODO(dneil): Clean up tests where cs.cc.cond is nil.
if cs.cc.cond != nil {
// Wake up writeRequestBody if it is waiting on flow control.
- cs.cc.condBroadcast()
+ cs.cc.cond.Broadcast()
}
}
@@ -497,7 +510,7 @@ func (cs *clientStream) abortRequestBodyWrite() {
defer cc.mu.Unlock()
if cs.reqBody != nil && cs.reqBodyClosed == nil {
cs.closeReqBodyLocked()
- cc.condBroadcast()
+ cc.cond.Broadcast()
}
}
@@ -507,13 +520,15 @@ func (cs *clientStream) closeReqBodyLocked() {
}
cs.reqBodyClosed = make(chan struct{})
reqBodyClosed := cs.reqBodyClosed
- cs.cc.goRun(func() {
+ go func() {
+ cs.cc.t.markNewGoroutine()
cs.reqBody.Close()
close(reqBodyClosed)
- })
+ }()
}
type stickyErrWriter struct {
+ group synctestGroupInterface
conn net.Conn
timeout time.Duration
err *error
@@ -523,22 +538,9 @@ func (sew stickyErrWriter) Write(p []byte) (n int, err error) {
if *sew.err != nil {
return 0, *sew.err
}
- for {
- if sew.timeout != 0 {
- sew.conn.SetWriteDeadline(time.Now().Add(sew.timeout))
- }
- nn, err := sew.conn.Write(p[n:])
- n += nn
- if n < len(p) && nn > 0 && errors.Is(err, os.ErrDeadlineExceeded) {
- // Keep extending the deadline so long as we're making progress.
- continue
- }
- if sew.timeout != 0 {
- sew.conn.SetWriteDeadline(time.Time{})
- }
- *sew.err = err
- return n, err
- }
+ n, err = writeWithByteTimeout(sew.group, sew.conn, sew.timeout, p)
+ *sew.err = err
+ return n, err
}
// noCachedConnError is the concrete type of ErrNoCachedConn, which
@@ -569,6 +571,8 @@ type RoundTripOpt struct {
// no cached connection is available, RoundTripOpt
// will return ErrNoCachedConn.
OnlyCachedConn bool
+
+ allowHTTP bool // allow http:// URLs
}
func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) {
@@ -601,7 +605,14 @@ func authorityAddr(scheme string, authority string) (addr string) {
// RoundTripOpt is like RoundTrip, but takes options.
func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Response, error) {
- if !(req.URL.Scheme == "https" || (req.URL.Scheme == "http" && t.AllowHTTP)) {
+ switch req.URL.Scheme {
+ case "https":
+ // Always okay.
+ case "http":
+ if !t.AllowHTTP && !opt.allowHTTP {
+ return nil, errors.New("http2: unencrypted HTTP/2 not enabled")
+ }
+ default:
return nil, errors.New("http2: unsupported scheme")
}
@@ -612,7 +623,7 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Res
t.vlogf("http2: Transport failed to get client conn for %s: %v", addr, err)
return nil, err
}
- reused := !atomic.CompareAndSwapUint32(&cc.reused, 0, 1)
+ reused := !atomic.CompareAndSwapUint32(&cc.atomicReused, 0, 1)
traceGotConn(req, cc, reused)
res, err := cc.RoundTrip(req)
if err != nil && retry <= 6 {
@@ -626,21 +637,7 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Res
backoff := float64(uint(1) << (uint(retry) - 1))
backoff += backoff * (0.1 * mathrand.Float64())
d := time.Second * time.Duration(backoff)
- var tm timer
- if t.syncHooks != nil {
- tm = t.syncHooks.newTimer(d)
- t.syncHooks.blockUntil(func() bool {
- select {
- case <-tm.C():
- case <-req.Context().Done():
- default:
- return false
- }
- return true
- })
- } else {
- tm = newTimeTimer(d)
- }
+ tm := t.newTimer(d)
select {
case <-tm.C():
t.vlogf("RoundTrip retrying after failure: %v", roundTripErr)
@@ -651,6 +648,22 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Res
}
}
}
+ if err == errClientConnNotEstablished {
+ // This ClientConn was created recently,
+ // this is the first request to use it,
+ // and the connection is closed and not usable.
+ //
+ // In this state, cc.idleTimer will remove the conn from the pool
+ // when it fires. Stop the timer and remove it here so future requests
+ // won't try to use this connection.
+ //
+ // If the timer has already fired and we're racing it, the redundant
+ // call to MarkDead is harmless.
+ if cc.idleTimer != nil {
+ cc.idleTimer.Stop()
+ }
+ t.connPool().MarkDead(cc)
+ }
if err != nil {
t.vlogf("RoundTrip failure: %v", err)
return nil, err
@@ -669,9 +682,10 @@ func (t *Transport) CloseIdleConnections() {
}
var (
- errClientConnClosed = errors.New("http2: client conn is closed")
- errClientConnUnusable = errors.New("http2: client conn not usable")
- errClientConnGotGoAway = errors.New("http2: Transport received Server's graceful shutdown GOAWAY")
+ errClientConnClosed = errors.New("http2: client conn is closed")
+ errClientConnUnusable = errors.New("http2: client conn not usable")
+ errClientConnNotEstablished = errors.New("http2: client conn could not be established")
+ errClientConnGotGoAway = errors.New("http2: Transport received Server's graceful shutdown GOAWAY")
)
// shouldRetryRequest is called by RoundTrip when a request fails to get
@@ -725,8 +739,8 @@ func canRetryError(err error) bool {
}
func (t *Transport) dialClientConn(ctx context.Context, addr string, singleUse bool) (*ClientConn, error) {
- if t.syncHooks != nil {
- return t.newClientConn(nil, singleUse, t.syncHooks)
+ if t.transportTestHooks != nil {
+ return t.newClientConn(nil, singleUse)
}
host, _, err := net.SplitHostPort(addr)
if err != nil {
@@ -736,7 +750,7 @@ func (t *Transport) dialClientConn(ctx context.Context, addr string, singleUse b
if err != nil {
return nil, err
}
- return t.newClientConn(tconn, singleUse, nil)
+ return t.newClientConn(tconn, singleUse)
}
func (t *Transport) newTLSConfig(host string) *tls.Config {
@@ -787,48 +801,37 @@ func (t *Transport) expectContinueTimeout() time.Duration {
return t.t1.ExpectContinueTimeout
}
-func (t *Transport) maxDecoderHeaderTableSize() uint32 {
- if v := t.MaxDecoderHeaderTableSize; v > 0 {
- return v
- }
- return initialHeaderTableSize
-}
-
-func (t *Transport) maxEncoderHeaderTableSize() uint32 {
- if v := t.MaxEncoderHeaderTableSize; v > 0 {
- return v
- }
- return initialHeaderTableSize
-}
-
func (t *Transport) NewClientConn(c net.Conn) (*ClientConn, error) {
- return t.newClientConn(c, t.disableKeepAlives(), nil)
+ return t.newClientConn(c, t.disableKeepAlives())
}
-func (t *Transport) newClientConn(c net.Conn, singleUse bool, hooks *testSyncHooks) (*ClientConn, error) {
+func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, error) {
+ conf := configFromTransport(t)
cc := &ClientConn{
- t: t,
- tconn: c,
- readerDone: make(chan struct{}),
- nextStreamID: 1,
- maxFrameSize: 16 << 10, // spec default
- initialWindowSize: 65535, // spec default
- maxConcurrentStreams: initialMaxConcurrentStreams, // "infinite", per spec. Use a smaller value until we have received server settings.
- peerMaxHeaderListSize: 0xffffffffffffffff, // "infinite", per spec. Use 2^64-1 instead.
- streams: make(map[uint32]*clientStream),
- singleUse: singleUse,
- wantSettingsAck: true,
- pings: make(map[[8]byte]chan struct{}),
- reqHeaderMu: make(chan struct{}, 1),
- syncHooks: hooks,
- }
- if hooks != nil {
- hooks.newclientconn(cc)
+ t: t,
+ tconn: c,
+ readerDone: make(chan struct{}),
+ nextStreamID: 1,
+ maxFrameSize: 16 << 10, // spec default
+ initialWindowSize: 65535, // spec default
+ initialStreamRecvWindowSize: conf.MaxUploadBufferPerStream,
+ maxConcurrentStreams: initialMaxConcurrentStreams, // "infinite", per spec. Use a smaller value until we have received server settings.
+ peerMaxHeaderListSize: 0xffffffffffffffff, // "infinite", per spec. Use 2^64-1 instead.
+ streams: make(map[uint32]*clientStream),
+ singleUse: singleUse,
+ wantSettingsAck: true,
+ readIdleTimeout: conf.SendPingTimeout,
+ pingTimeout: conf.PingTimeout,
+ pings: make(map[[8]byte]chan struct{}),
+ reqHeaderMu: make(chan struct{}, 1),
+ lastActive: t.now(),
+ }
+ var group synctestGroupInterface
+ if t.transportTestHooks != nil {
+ t.markNewGoroutine()
+ t.transportTestHooks.newclientconn(cc)
c = cc.tconn
- }
- if d := t.idleConnTimeout(); d != 0 {
- cc.idleTimeout = d
- cc.idleTimer = cc.afterFunc(d, cc.onIdleTimeout)
+ group = t.group
}
if VerboseLogs {
t.vlogf("http2: Transport creating client conn %p to %v", cc, c.RemoteAddr())
@@ -840,30 +843,25 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool, hooks *testSyncHoo
// TODO: adjust this writer size to account for frame size +
// MTU + crypto/tls record padding.
cc.bw = bufio.NewWriter(stickyErrWriter{
+ group: group,
conn: c,
- timeout: t.WriteByteTimeout,
+ timeout: conf.WriteByteTimeout,
err: &cc.werr,
})
cc.br = bufio.NewReader(c)
cc.fr = NewFramer(cc.bw, cc.br)
- if t.maxFrameReadSize() != 0 {
- cc.fr.SetMaxReadFrameSize(t.maxFrameReadSize())
- }
+ cc.fr.SetMaxReadFrameSize(conf.MaxReadFrameSize)
if t.CountError != nil {
cc.fr.countError = t.CountError
}
- maxHeaderTableSize := t.maxDecoderHeaderTableSize()
+ maxHeaderTableSize := conf.MaxDecoderHeaderTableSize
cc.fr.ReadMetaHeaders = hpack.NewDecoder(maxHeaderTableSize, nil)
cc.fr.MaxHeaderListSize = t.maxHeaderListSize()
cc.henc = hpack.NewEncoder(&cc.hbuf)
- cc.henc.SetMaxDynamicTableSizeLimit(t.maxEncoderHeaderTableSize())
+ cc.henc.SetMaxDynamicTableSizeLimit(conf.MaxEncoderHeaderTableSize)
cc.peerMaxHeaderTableSize = initialHeaderTableSize
- if t.AllowHTTP {
- cc.nextStreamID = 3
- }
-
if cs, ok := c.(connectionStater); ok {
state := cs.ConnectionState()
cc.tlsState = &state
@@ -871,11 +869,9 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool, hooks *testSyncHoo
initialSettings := []Setting{
{ID: SettingEnablePush, Val: 0},
- {ID: SettingInitialWindowSize, Val: transportDefaultStreamFlow},
- }
- if max := t.maxFrameReadSize(); max != 0 {
- initialSettings = append(initialSettings, Setting{ID: SettingMaxFrameSize, Val: max})
+ {ID: SettingInitialWindowSize, Val: uint32(cc.initialStreamRecvWindowSize)},
}
+ initialSettings = append(initialSettings, Setting{ID: SettingMaxFrameSize, Val: conf.MaxReadFrameSize})
if max := t.maxHeaderListSize(); max != 0 {
initialSettings = append(initialSettings, Setting{ID: SettingMaxHeaderListSize, Val: max})
}
@@ -885,23 +881,29 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool, hooks *testSyncHoo
cc.bw.Write(clientPreface)
cc.fr.WriteSettings(initialSettings...)
- cc.fr.WriteWindowUpdate(0, transportDefaultConnFlow)
- cc.inflow.init(transportDefaultConnFlow + initialWindowSize)
+ cc.fr.WriteWindowUpdate(0, uint32(conf.MaxUploadBufferPerConnection))
+ cc.inflow.init(conf.MaxUploadBufferPerConnection + initialWindowSize)
cc.bw.Flush()
if cc.werr != nil {
cc.Close()
return nil, cc.werr
}
- cc.goRun(cc.readLoop)
+ // Start the idle timer after the connection is fully initialized.
+ if d := t.idleConnTimeout(); d != 0 {
+ cc.idleTimeout = d
+ cc.idleTimer = t.afterFunc(d, cc.onIdleTimeout)
+ }
+
+ go cc.readLoop()
return cc, nil
}
func (cc *ClientConn) healthCheck() {
- pingTimeout := cc.t.pingTimeout()
+ pingTimeout := cc.pingTimeout
// We don't need to periodically ping in the health check, because the readLoop of ClientConn will
// trigger the healthCheck again if there is no frame received.
- ctx, cancel := cc.contextWithTimeout(context.Background(), pingTimeout)
+ ctx, cancel := cc.t.contextWithTimeout(context.Background(), pingTimeout)
defer cancel()
cc.vlogf("http2: Transport sending health check")
err := cc.Ping(ctx)
@@ -936,7 +938,20 @@ func (cc *ClientConn) setGoAway(f *GoAwayFrame) {
}
last := f.LastStreamID
for streamID, cs := range cc.streams {
- if streamID > last {
+ if streamID <= last {
+ // The server's GOAWAY indicates that it received this stream.
+ // It will either finish processing it, or close the connection
+ // without doing so. Either way, leave the stream alone for now.
+ continue
+ }
+ if streamID == 1 && cc.goAway.ErrCode != ErrCodeNo {
+ // Don't retry the first stream on a connection if we get a non-NO error.
+ // If the server is sending an error on a new connection,
+ // retrying the request on a new one probably isn't going to work.
+ cs.abortStreamLocked(fmt.Errorf("http2: Transport received GOAWAY from server ErrCode:%v", cc.goAway.ErrCode))
+ } else {
+ // Aborting the stream with errClentConnGotGoAway indicates that
+ // the request should be retried on a new connection.
cs.abortStreamLocked(errClientConnGotGoAway)
}
}
@@ -1013,7 +1028,7 @@ func (cc *ClientConn) State() ClientConnState {
return ClientConnState{
Closed: cc.closed,
Closing: cc.closing || cc.singleUse || cc.doNotReuse || cc.goAway != nil,
- StreamsActive: len(cc.streams),
+ StreamsActive: len(cc.streams) + cc.pendingResets,
StreamsReserved: cc.streamsReserved,
StreamsPending: cc.pendingRequests,
LastIdle: cc.lastIdle,
@@ -1045,16 +1060,38 @@ func (cc *ClientConn) idleStateLocked() (st clientConnIdleState) {
// writing it.
maxConcurrentOkay = true
} else {
- maxConcurrentOkay = int64(len(cc.streams)+cc.streamsReserved+1) <= int64(cc.maxConcurrentStreams)
+ // We can take a new request if the total of
+ // - active streams;
+ // - reservation slots for new streams; and
+ // - streams for which we have sent a RST_STREAM and a PING,
+ // but received no subsequent frame
+ // is less than the concurrency limit.
+ maxConcurrentOkay = cc.currentRequestCountLocked() < int(cc.maxConcurrentStreams)
}
st.canTakeNewRequest = cc.goAway == nil && !cc.closed && !cc.closing && maxConcurrentOkay &&
!cc.doNotReuse &&
int64(cc.nextStreamID)+2*int64(cc.pendingRequests) < math.MaxInt32 &&
!cc.tooIdleLocked()
+
+ // If this connection has never been used for a request and is closed,
+ // then let it take a request (which will fail).
+ //
+ // This avoids a situation where an error early in a connection's lifetime
+ // goes unreported.
+ if cc.nextStreamID == 1 && cc.streamsReserved == 0 && cc.closed {
+ st.canTakeNewRequest = true
+ }
+
return
}
+// currentRequestCountLocked reports the number of concurrency slots currently in use,
+// including active streams, reserved slots, and reset streams waiting for acknowledgement.
+func (cc *ClientConn) currentRequestCountLocked() int {
+ return len(cc.streams) + cc.streamsReserved + cc.pendingResets
+}
+
func (cc *ClientConn) canTakeNewRequestLocked() bool {
st := cc.idleStateLocked()
return st.canTakeNewRequest
@@ -1067,7 +1104,7 @@ func (cc *ClientConn) tooIdleLocked() bool {
// times are compared based on their wall time. We don't want
// to reuse a connection that's been sitting idle during
// VM/laptop suspend if monotonic time was also frozen.
- return cc.idleTimeout != 0 && !cc.lastIdle.IsZero() && time.Since(cc.lastIdle.Round(0)) > cc.idleTimeout
+ return cc.idleTimeout != 0 && !cc.lastIdle.IsZero() && cc.t.timeSince(cc.lastIdle.Round(0)) > cc.idleTimeout
}
// onIdleTimeout is called from a time.AfterFunc goroutine. It will
@@ -1131,7 +1168,8 @@ func (cc *ClientConn) Shutdown(ctx context.Context) error {
// Wait for all in-flight streams to complete or connection to close
done := make(chan struct{})
cancelled := false // guarded by cc.mu
- cc.goRun(func() {
+ go func() {
+ cc.t.markNewGoroutine()
cc.mu.Lock()
defer cc.mu.Unlock()
for {
@@ -1143,9 +1181,9 @@ func (cc *ClientConn) Shutdown(ctx context.Context) error {
if cancelled {
break
}
- cc.condWait()
+ cc.cond.Wait()
}
- })
+ }()
shutdownEnterWaitStateHook()
select {
case <-done:
@@ -1155,7 +1193,7 @@ func (cc *ClientConn) Shutdown(ctx context.Context) error {
cc.mu.Lock()
// Free the goroutine above
cancelled = true
- cc.condBroadcast()
+ cc.cond.Broadcast()
cc.mu.Unlock()
return ctx.Err()
}
@@ -1193,7 +1231,7 @@ func (cc *ClientConn) closeForError(err error) {
for _, cs := range cc.streams {
cs.abortStreamLocked(err)
}
- cc.condBroadcast()
+ cc.cond.Broadcast()
cc.mu.Unlock()
cc.closeConn()
}
@@ -1308,23 +1346,30 @@ func (cc *ClientConn) roundTrip(req *http.Request, streamf func(*clientStream))
respHeaderRecv: make(chan struct{}),
donec: make(chan struct{}),
}
- cc.goRun(func() {
- cs.doRequest(req)
- })
+
+ // TODO(bradfitz): this is a copy of the logic in net/http. Unify somewhere?
+ if !cc.t.disableCompression() &&
+ req.Header.Get("Accept-Encoding") == "" &&
+ req.Header.Get("Range") == "" &&
+ !cs.isHead {
+ // Request gzip only, not deflate. Deflate is ambiguous and
+ // not as universally supported anyway.
+ // See: https://zlib.net/zlib_faq.html#faq39
+ //
+ // Note that we don't request this for HEAD requests,
+ // due to a bug in nginx:
+ // http://trac.nginx.org/nginx/ticket/358
+ // https://golang.org/issue/5522
+ //
+ // We don't request gzip if the request is for a range, since
+ // auto-decoding a portion of a gzipped document will just fail
+ // anyway. See https://golang.org/issue/8923
+ cs.requestedGzip = true
+ }
+
+ go cs.doRequest(req, streamf)
waitDone := func() error {
- if cc.syncHooks != nil {
- cc.syncHooks.blockUntil(func() bool {
- select {
- case <-cs.donec:
- case <-ctx.Done():
- case <-cs.reqCancel:
- default:
- return false
- }
- return true
- })
- }
select {
case <-cs.donec:
return nil
@@ -1385,24 +1430,7 @@ func (cc *ClientConn) roundTrip(req *http.Request, streamf func(*clientStream))
return err
}
- if streamf != nil {
- streamf(cs)
- }
-
for {
- if cc.syncHooks != nil {
- cc.syncHooks.blockUntil(func() bool {
- select {
- case <-cs.respHeaderRecv:
- case <-cs.abort:
- case <-ctx.Done():
- case <-cs.reqCancel:
- default:
- return false
- }
- return true
- })
- }
select {
case <-cs.respHeaderRecv:
return handleResponseHeaders()
@@ -1432,8 +1460,9 @@ func (cc *ClientConn) roundTrip(req *http.Request, streamf func(*clientStream))
// doRequest runs for the duration of the request lifetime.
//
// It sends the request and performs post-request cleanup (closing Request.Body, etc.).
-func (cs *clientStream) doRequest(req *http.Request) {
- err := cs.writeRequest(req)
+func (cs *clientStream) doRequest(req *http.Request, streamf func(*clientStream)) {
+ cs.cc.t.markNewGoroutine()
+ err := cs.writeRequest(req, streamf)
cs.cleanupWriteRequest(err)
}
@@ -1444,7 +1473,7 @@ func (cs *clientStream) doRequest(req *http.Request) {
//
// It returns non-nil if the request ends otherwise.
// If the returned error is StreamError, the error Code may be used in resetting the stream.
-func (cs *clientStream) writeRequest(req *http.Request) (err error) {
+func (cs *clientStream) writeRequest(req *http.Request, streamf func(*clientStream)) (err error) {
cc := cs.cc
ctx := cs.ctx
@@ -1458,21 +1487,6 @@ func (cs *clientStream) writeRequest(req *http.Request) (err error) {
if cc.reqHeaderMu == nil {
panic("RoundTrip on uninitialized ClientConn") // for tests
}
- var newStreamHook func(*clientStream)
- if cc.syncHooks != nil {
- newStreamHook = cc.syncHooks.newstream
- cc.syncHooks.blockUntil(func() bool {
- select {
- case cc.reqHeaderMu <- struct{}{}:
- <-cc.reqHeaderMu
- case <-cs.reqCancel:
- case <-ctx.Done():
- default:
- return false
- }
- return true
- })
- }
select {
case cc.reqHeaderMu <- struct{}{}:
case <-cs.reqCancel:
@@ -1497,28 +1511,8 @@ func (cs *clientStream) writeRequest(req *http.Request) (err error) {
}
cc.mu.Unlock()
- if newStreamHook != nil {
- newStreamHook(cs)
- }
-
- // TODO(bradfitz): this is a copy of the logic in net/http. Unify somewhere?
- if !cc.t.disableCompression() &&
- req.Header.Get("Accept-Encoding") == "" &&
- req.Header.Get("Range") == "" &&
- !cs.isHead {
- // Request gzip only, not deflate. Deflate is ambiguous and
- // not as universally supported anyway.
- // See: https://zlib.net/zlib_faq.html#faq39
- //
- // Note that we don't request this for HEAD requests,
- // due to a bug in nginx:
- // http://trac.nginx.org/nginx/ticket/358
- // https://golang.org/issue/5522
- //
- // We don't request gzip if the request is for a range, since
- // auto-decoding a portion of a gzipped document will just fail
- // anyway. See https://golang.org/issue/8923
- cs.requestedGzip = true
+ if streamf != nil {
+ streamf(cs)
}
continueTimeout := cc.t.expectContinueTimeout()
@@ -1581,7 +1575,7 @@ func (cs *clientStream) writeRequest(req *http.Request) (err error) {
var respHeaderTimer <-chan time.Time
var respHeaderRecv chan struct{}
if d := cc.responseHeaderTimeout(); d != 0 {
- timer := cc.newTimer(d)
+ timer := cc.t.newTimer(d)
defer timer.Stop()
respHeaderTimer = timer.C()
respHeaderRecv = cs.respHeaderRecv
@@ -1590,21 +1584,6 @@ func (cs *clientStream) writeRequest(req *http.Request) (err error) {
// or until the request is aborted (via context, error, or otherwise),
// whichever comes first.
for {
- if cc.syncHooks != nil {
- cc.syncHooks.blockUntil(func() bool {
- select {
- case <-cs.peerClosed:
- case <-respHeaderTimer:
- case <-respHeaderRecv:
- case <-cs.abort:
- case <-ctx.Done():
- case <-cs.reqCancel:
- default:
- return false
- }
- return true
- })
- }
select {
case <-cs.peerClosed:
return nil
@@ -1689,6 +1668,7 @@ func (cs *clientStream) cleanupWriteRequest(err error) {
cs.reqBodyClosed = make(chan struct{})
}
bodyClosed := cs.reqBodyClosed
+ closeOnIdle := cc.singleUse || cc.doNotReuse || cc.t.disableKeepAlives() || cc.goAway != nil
cc.mu.Unlock()
if mustCloseBody {
cs.reqBody.Close()
@@ -1713,16 +1693,40 @@ func (cs *clientStream) cleanupWriteRequest(err error) {
if cs.sentHeaders {
if se, ok := err.(StreamError); ok {
if se.Cause != errFromPeer {
- cc.writeStreamReset(cs.ID, se.Code, err)
+ cc.writeStreamReset(cs.ID, se.Code, false, err)
}
} else {
- cc.writeStreamReset(cs.ID, ErrCodeCancel, err)
+ // We're cancelling an in-flight request.
+ //
+ // This could be due to the server becoming unresponsive.
+ // To avoid sending too many requests on a dead connection,
+ // we let the request continue to consume a concurrency slot
+ // until we can confirm the server is still responding.
+ // We do this by sending a PING frame along with the RST_STREAM
+ // (unless a ping is already in flight).
+ //
+ // For simplicity, we don't bother tracking the PING payload:
+ // We reset cc.pendingResets any time we receive a PING ACK.
+ //
+ // We skip this if the conn is going to be closed on idle,
+ // because it's short lived and will probably be closed before
+ // we get the ping response.
+ ping := false
+ if !closeOnIdle {
+ cc.mu.Lock()
+ if cc.pendingResets == 0 {
+ ping = true
+ }
+ cc.pendingResets++
+ cc.mu.Unlock()
+ }
+ cc.writeStreamReset(cs.ID, ErrCodeCancel, ping, err)
}
}
cs.bufPipe.CloseWithError(err) // no-op if already closed
} else {
if cs.sentHeaders && !cs.sentEndStream {
- cc.writeStreamReset(cs.ID, ErrCodeNo, nil)
+ cc.writeStreamReset(cs.ID, ErrCodeNo, false, nil)
}
cs.bufPipe.CloseWithError(errRequestCanceled)
}
@@ -1744,16 +1748,21 @@ func (cs *clientStream) cleanupWriteRequest(err error) {
// Must hold cc.mu.
func (cc *ClientConn) awaitOpenSlotForStreamLocked(cs *clientStream) error {
for {
- cc.lastActive = time.Now()
+ if cc.closed && cc.nextStreamID == 1 && cc.streamsReserved == 0 {
+ // This is the very first request sent to this connection.
+ // Return a fatal error which aborts the retry loop.
+ return errClientConnNotEstablished
+ }
+ cc.lastActive = cc.t.now()
if cc.closed || !cc.canTakeNewRequestLocked() {
return errClientConnUnusable
}
cc.lastIdle = time.Time{}
- if int64(len(cc.streams)) < int64(cc.maxConcurrentStreams) {
+ if cc.currentRequestCountLocked() < int(cc.maxConcurrentStreams) {
return nil
}
cc.pendingRequests++
- cc.condWait()
+ cc.cond.Wait()
cc.pendingRequests--
select {
case <-cs.abort:
@@ -2015,7 +2024,7 @@ func (cs *clientStream) awaitFlowControl(maxBytes int) (taken int32, err error)
cs.flow.take(take)
return take, nil
}
- cc.condWait()
+ cc.cond.Wait()
}
}
@@ -2275,7 +2284,7 @@ type resAndError struct {
func (cc *ClientConn) addStreamLocked(cs *clientStream) {
cs.flow.add(int32(cc.initialWindowSize))
cs.flow.setConnFlow(&cc.flow)
- cs.inflow.init(transportDefaultStreamFlow)
+ cs.inflow.init(cc.initialStreamRecvWindowSize)
cs.ID = cc.nextStreamID
cc.nextStreamID += 2
cc.streams[cs.ID] = cs
@@ -2291,14 +2300,14 @@ func (cc *ClientConn) forgetStreamID(id uint32) {
if len(cc.streams) != slen-1 {
panic("forgetting unknown stream id")
}
- cc.lastActive = time.Now()
+ cc.lastActive = cc.t.now()
if len(cc.streams) == 0 && cc.idleTimer != nil {
cc.idleTimer.Reset(cc.idleTimeout)
- cc.lastIdle = time.Now()
+ cc.lastIdle = cc.t.now()
}
// Wake up writeRequestBody via clientStream.awaitFlowControl and
// wake up RoundTrip if there is a pending request.
- cc.condBroadcast()
+ cc.cond.Broadcast()
closeOnIdle := cc.singleUse || cc.doNotReuse || cc.t.disableKeepAlives() || cc.goAway != nil
if closeOnIdle && cc.streamsReserved == 0 && len(cc.streams) == 0 {
@@ -2320,6 +2329,7 @@ type clientConnReadLoop struct {
// readLoop runs in its own goroutine and reads and dispatches frames.
func (cc *ClientConn) readLoop() {
+ cc.t.markNewGoroutine()
rl := &clientConnReadLoop{cc: cc}
defer rl.cleanup()
cc.readerErr = rl.run()
@@ -2353,7 +2363,6 @@ func isEOFOrNetReadError(err error) bool {
func (rl *clientConnReadLoop) cleanup() {
cc := rl.cc
- cc.t.connPool().MarkDead(cc)
defer cc.closeConn()
defer close(cc.readerDone)
@@ -2377,6 +2386,24 @@ func (rl *clientConnReadLoop) cleanup() {
}
cc.closed = true
+ // If the connection has never been used, and has been open for only a short time,
+ // leave it in the connection pool for a little while.
+ //
+ // This avoids a situation where new connections are constantly created,
+ // added to the pool, fail, and are removed from the pool, without any error
+ // being surfaced to the user.
+ const unusedWaitTime = 5 * time.Second
+ idleTime := cc.t.now().Sub(cc.lastActive)
+ if atomic.LoadUint32(&cc.atomicReused) == 0 && idleTime < unusedWaitTime {
+ cc.idleTimer = cc.t.afterFunc(unusedWaitTime-idleTime, func() {
+ cc.t.connPool().MarkDead(cc)
+ })
+ } else {
+ cc.mu.Unlock() // avoid any deadlocks in MarkDead
+ cc.t.connPool().MarkDead(cc)
+ cc.mu.Lock()
+ }
+
for _, cs := range cc.streams {
select {
case <-cs.peerClosed:
@@ -2386,7 +2413,7 @@ func (rl *clientConnReadLoop) cleanup() {
cs.abortStreamLocked(err)
}
}
- cc.condBroadcast()
+ cc.cond.Broadcast()
cc.mu.Unlock()
}
@@ -2420,10 +2447,10 @@ func (cc *ClientConn) countReadFrameError(err error) {
func (rl *clientConnReadLoop) run() error {
cc := rl.cc
gotSettings := false
- readIdleTimeout := cc.t.ReadIdleTimeout
+ readIdleTimeout := cc.readIdleTimeout
var t timer
if readIdleTimeout != 0 {
- t = cc.afterFunc(readIdleTimeout, cc.healthCheck)
+ t = cc.t.afterFunc(readIdleTimeout, cc.healthCheck)
}
for {
f, err := cc.fr.ReadFrame()
@@ -2604,15 +2631,34 @@ func (rl *clientConnReadLoop) handleResponse(cs *clientStream, f *MetaHeadersFra
if f.StreamEnded() {
return nil, errors.New("1xx informational response with END_STREAM flag")
}
- cs.num1xx++
- const max1xxResponses = 5 // arbitrary bound on number of informational responses, same as net/http
- if cs.num1xx > max1xxResponses {
- return nil, errors.New("http2: too many 1xx informational responses")
- }
if fn := cs.get1xxTraceFunc(); fn != nil {
+ // If the 1xx response is being delivered to the user,
+ // then they're responsible for limiting the number
+ // of responses.
if err := fn(statusCode, textproto.MIMEHeader(header)); err != nil {
return nil, err
}
+ } else {
+ // If the user didn't examine the 1xx response, then we
+ // limit the size of all 1xx headers.
+ //
+ // This differs a bit from the HTTP/1 implementation, which
+ // limits the size of all 1xx headers plus the final response.
+ // Use the larger limit of MaxHeaderListSize and
+ // net/http.Transport.MaxResponseHeaderBytes.
+ limit := int64(cs.cc.t.maxHeaderListSize())
+ if t1 := cs.cc.t.t1; t1 != nil && t1.MaxResponseHeaderBytes > limit {
+ limit = t1.MaxResponseHeaderBytes
+ }
+ for _, h := range f.Fields {
+ cs.totalHeaderSize += int64(h.Size())
+ }
+ if cs.totalHeaderSize > limit {
+ if VerboseLogs {
+ log.Printf("http2: 1xx informational responses too large")
+ }
+ return nil, errors.New("header list too large")
+ }
}
if statusCode == 100 {
traceGot100Continue(cs.trace)
@@ -3021,7 +3067,7 @@ func (rl *clientConnReadLoop) processSettingsNoWrite(f *SettingsFrame) error {
for _, cs := range cc.streams {
cs.flow.add(delta)
}
- cc.condBroadcast()
+ cc.cond.Broadcast()
cc.initialWindowSize = s.Val
case SettingHeaderTableSize:
@@ -3076,7 +3122,7 @@ func (rl *clientConnReadLoop) processWindowUpdate(f *WindowUpdateFrame) error {
return ConnectionError(ErrCodeFlowControl)
}
- cc.condBroadcast()
+ cc.cond.Broadcast()
return nil
}
@@ -3120,7 +3166,8 @@ func (cc *ClientConn) Ping(ctx context.Context) error {
}
var pingError error
errc := make(chan struct{})
- cc.goRun(func() {
+ go func() {
+ cc.t.markNewGoroutine()
cc.wmu.Lock()
defer cc.wmu.Unlock()
if pingError = cc.fr.WritePing(false, p); pingError != nil {
@@ -3131,20 +3178,7 @@ func (cc *ClientConn) Ping(ctx context.Context) error {
close(errc)
return
}
- })
- if cc.syncHooks != nil {
- cc.syncHooks.blockUntil(func() bool {
- select {
- case <-c:
- case <-errc:
- case <-ctx.Done():
- case <-cc.readerDone:
- default:
- return false
- }
- return true
- })
- }
+ }()
select {
case <-c:
return nil
@@ -3168,6 +3202,11 @@ func (rl *clientConnReadLoop) processPing(f *PingFrame) error {
close(c)
delete(cc.pings, f.Data)
}
+ if cc.pendingResets > 0 {
+ // See clientStream.cleanupWriteRequest.
+ cc.pendingResets = 0
+ cc.cond.Broadcast()
+ }
return nil
}
cc := rl.cc
@@ -3190,13 +3229,20 @@ func (rl *clientConnReadLoop) processPushPromise(f *PushPromiseFrame) error {
return ConnectionError(ErrCodeProtocol)
}
-func (cc *ClientConn) writeStreamReset(streamID uint32, code ErrCode, err error) {
+// writeStreamReset sends a RST_STREAM frame.
+// When ping is true, it also sends a PING frame with a random payload.
+func (cc *ClientConn) writeStreamReset(streamID uint32, code ErrCode, ping bool, err error) {
// TODO: map err to more interesting error codes, once the
// HTTP community comes up with some. But currently for
// RST_STREAM there's no equivalent to GOAWAY frame's debug
// data, and the error codes are all pretty vague ("cancel").
cc.wmu.Lock()
cc.fr.WriteRSTStream(streamID, code)
+ if ping {
+ var payload [8]byte
+ rand.Read(payload[:])
+ cc.fr.WritePing(false, payload)
+ }
cc.bw.Flush()
cc.wmu.Unlock()
}
@@ -3350,7 +3396,7 @@ func traceGotConn(req *http.Request, cc *ClientConn, reused bool) {
cc.mu.Lock()
ci.WasIdle = len(cc.streams) == 0 && reused
if ci.WasIdle && !cc.lastActive.IsZero() {
- ci.IdleTime = time.Since(cc.lastActive)
+ ci.IdleTime = cc.t.timeSince(cc.lastActive)
}
cc.mu.Unlock()
diff --git a/vendor/golang.org/x/net/http2/unencrypted.go b/vendor/golang.org/x/net/http2/unencrypted.go
new file mode 100644
index 0000000000..b2de211613
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/unencrypted.go
@@ -0,0 +1,32 @@
+// Copyright 2024 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 http2
+
+import (
+ "crypto/tls"
+ "errors"
+ "net"
+)
+
+const nextProtoUnencryptedHTTP2 = "unencrypted_http2"
+
+// unencryptedNetConnFromTLSConn retrieves a net.Conn wrapped in a *tls.Conn.
+//
+// TLSNextProto functions accept a *tls.Conn.
+//
+// When passing an unencrypted HTTP/2 connection to a TLSNextProto function,
+// we pass a *tls.Conn with an underlying net.Conn containing the unencrypted connection.
+// To be extra careful about mistakes (accidentally dropping TLS encryption in a place
+// where we want it), the tls.Conn contains a net.Conn with an UnencryptedNetConn method
+// that returns the actual connection we want to use.
+func unencryptedNetConnFromTLSConn(tc *tls.Conn) (net.Conn, error) {
+ conner, ok := tc.NetConn().(interface {
+ UnencryptedNetConn() net.Conn
+ })
+ if !ok {
+ return nil, errors.New("http2: TLS conn unexpectedly found in unencrypted handoff")
+ }
+ return conner.UnencryptedNetConn(), nil
+}
diff --git a/vendor/golang.org/x/net/http2/write.go b/vendor/golang.org/x/net/http2/write.go
index 33f61398a1..6ff6bee7e9 100644
--- a/vendor/golang.org/x/net/http2/write.go
+++ b/vendor/golang.org/x/net/http2/write.go
@@ -131,6 +131,16 @@ func (se StreamError) writeFrame(ctx writeContext) error {
func (se StreamError) staysWithinBuffer(max int) bool { return frameHeaderLen+4 <= max }
+type writePing struct {
+ data [8]byte
+}
+
+func (w writePing) writeFrame(ctx writeContext) error {
+ return ctx.Framer().WritePing(false, w.data)
+}
+
+func (w writePing) staysWithinBuffer(max int) bool { return frameHeaderLen+len(w.data) <= max }
+
type writePingAck struct{ pf *PingFrame }
func (w writePingAck) writeFrame(ctx writeContext) error {
diff --git a/vendor/golang.org/x/net/http2/writesched_priority.go b/vendor/golang.org/x/net/http2/writesched_priority.go
index 0a242c669e..f6783339d1 100644
--- a/vendor/golang.org/x/net/http2/writesched_priority.go
+++ b/vendor/golang.org/x/net/http2/writesched_priority.go
@@ -443,8 +443,8 @@ func (ws *priorityWriteScheduler) addClosedOrIdleNode(list *[]*priorityNode, max
}
func (ws *priorityWriteScheduler) removeNode(n *priorityNode) {
- for k := n.kids; k != nil; k = k.next {
- k.setParent(n.parent)
+ for n.kids != nil {
+ n.kids.setParent(n.parent)
}
n.setParent(nil)
delete(ws.nodes, n.id)
diff --git a/vendor/golang.org/x/net/proxy/per_host.go b/vendor/golang.org/x/net/proxy/per_host.go
index 573fe79e86..d7d4b8b6e3 100644
--- a/vendor/golang.org/x/net/proxy/per_host.go
+++ b/vendor/golang.org/x/net/proxy/per_host.go
@@ -137,9 +137,7 @@ func (p *PerHost) AddNetwork(net *net.IPNet) {
// AddZone specifies a DNS suffix that will use the bypass proxy. A zone of
// "example.com" matches "example.com" and all of its subdomains.
func (p *PerHost) AddZone(zone string) {
- if strings.HasSuffix(zone, ".") {
- zone = zone[:len(zone)-1]
- }
+ zone = strings.TrimSuffix(zone, ".")
if !strings.HasPrefix(zone, ".") {
zone = "." + zone
}
@@ -148,8 +146,6 @@ func (p *PerHost) AddZone(zone string) {
// AddHost specifies a host name that will use the bypass proxy.
func (p *PerHost) AddHost(host string) {
- if strings.HasSuffix(host, ".") {
- host = host[:len(host)-1]
- }
+ host = strings.TrimSuffix(host, ".")
p.bypassHosts = append(p.bypassHosts, host)
}
diff --git a/vendor/golang.org/x/net/websocket/hybi.go b/vendor/golang.org/x/net/websocket/hybi.go
index 48a069e190..dda7434666 100644
--- a/vendor/golang.org/x/net/websocket/hybi.go
+++ b/vendor/golang.org/x/net/websocket/hybi.go
@@ -16,7 +16,6 @@ import (
"encoding/binary"
"fmt"
"io"
- "io/ioutil"
"net/http"
"net/url"
"strings"
@@ -279,7 +278,7 @@ func (handler *hybiFrameHandler) HandleFrame(frame frameReader) (frameReader, er
}
}
if header := frame.HeaderReader(); header != nil {
- io.Copy(ioutil.Discard, header)
+ io.Copy(io.Discard, header)
}
switch frame.PayloadType() {
case ContinuationFrame:
@@ -294,7 +293,7 @@ func (handler *hybiFrameHandler) HandleFrame(frame frameReader) (frameReader, er
if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF {
return nil, err
}
- io.Copy(ioutil.Discard, frame)
+ io.Copy(io.Discard, frame)
if frame.PayloadType() == PingFrame {
if _, err := handler.WritePong(b[:n]); err != nil {
return nil, err
diff --git a/vendor/golang.org/x/net/websocket/websocket.go b/vendor/golang.org/x/net/websocket/websocket.go
index 90a2257cd5..ac76165ceb 100644
--- a/vendor/golang.org/x/net/websocket/websocket.go
+++ b/vendor/golang.org/x/net/websocket/websocket.go
@@ -8,7 +8,7 @@
// This package currently lacks some features found in an alternative
// and more actively maintained WebSocket package:
//
-// https://pkg.go.dev/nhooyr.io/websocket
+// https://pkg.go.dev/github.com/coder/websocket
package websocket // import "golang.org/x/net/websocket"
import (
@@ -17,7 +17,6 @@ import (
"encoding/json"
"errors"
"io"
- "io/ioutil"
"net"
"net/http"
"net/url"
@@ -208,7 +207,7 @@ again:
n, err = ws.frameReader.Read(msg)
if err == io.EOF {
if trailer := ws.frameReader.TrailerReader(); trailer != nil {
- io.Copy(ioutil.Discard, trailer)
+ io.Copy(io.Discard, trailer)
}
ws.frameReader = nil
goto again
@@ -330,7 +329,7 @@ func (cd Codec) Receive(ws *Conn, v interface{}) (err error) {
ws.rio.Lock()
defer ws.rio.Unlock()
if ws.frameReader != nil {
- _, err = io.Copy(ioutil.Discard, ws.frameReader)
+ _, err = io.Copy(io.Discard, ws.frameReader)
if err != nil {
return err
}
@@ -362,7 +361,7 @@ again:
return ErrFrameTooLarge
}
payloadType := frame.PayloadType()
- data, err := ioutil.ReadAll(frame)
+ data, err := io.ReadAll(frame)
if err != nil {
return err
}
diff --git a/vendor/golang.org/x/oauth2/LICENSE b/vendor/golang.org/x/oauth2/LICENSE
index 6a66aea5ea..2a7cf70da6 100644
--- a/vendor/golang.org/x/oauth2/LICENSE
+++ b/vendor/golang.org/x/oauth2/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
+Copyright 2009 The Go Authors.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
@@ -10,7 +10,7 @@ notice, this list of conditions and the following disclaimer.
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
+ * Neither the name of Google LLC nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
diff --git a/vendor/golang.org/x/oauth2/internal/client_appengine.go b/vendor/golang.org/x/oauth2/internal/client_appengine.go
deleted file mode 100644
index d28140f789..0000000000
--- a/vendor/golang.org/x/oauth2/internal/client_appengine.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build appengine
-
-package internal
-
-import "google.golang.org/appengine/urlfetch"
-
-func init() {
- appengineClientHook = urlfetch.Client
-}
diff --git a/vendor/golang.org/x/oauth2/internal/transport.go b/vendor/golang.org/x/oauth2/internal/transport.go
index 572074a637..b9db01ddfd 100644
--- a/vendor/golang.org/x/oauth2/internal/transport.go
+++ b/vendor/golang.org/x/oauth2/internal/transport.go
@@ -18,16 +18,11 @@ var HTTPClient ContextKey
// because nobody else can create a ContextKey, being unexported.
type ContextKey struct{}
-var appengineClientHook func(context.Context) *http.Client
-
func ContextClient(ctx context.Context) *http.Client {
if ctx != nil {
if hc, ok := ctx.Value(HTTPClient).(*http.Client); ok {
return hc
}
}
- if appengineClientHook != nil {
- return appengineClientHook(ctx)
- }
return http.DefaultClient
}
diff --git a/vendor/golang.org/x/oauth2/oauth2.go b/vendor/golang.org/x/oauth2/oauth2.go
index 90a2c3d6dc..09f6a49b80 100644
--- a/vendor/golang.org/x/oauth2/oauth2.go
+++ b/vendor/golang.org/x/oauth2/oauth2.go
@@ -393,7 +393,7 @@ func ReuseTokenSource(t *Token, src TokenSource) TokenSource {
}
}
-// ReuseTokenSource returns a TokenSource that acts in the same manner as the
+// ReuseTokenSourceWithExpiry returns a TokenSource that acts in the same manner as the
// TokenSource returned by ReuseTokenSource, except the expiry buffer is
// configurable. The expiration time of a token is calculated as
// t.Expiry.Add(-earlyExpiry).
diff --git a/vendor/golang.org/x/oauth2/token.go b/vendor/golang.org/x/oauth2/token.go
index 5bbb332174..109997d77c 100644
--- a/vendor/golang.org/x/oauth2/token.go
+++ b/vendor/golang.org/x/oauth2/token.go
@@ -49,6 +49,13 @@ type Token struct {
// mechanisms for that TokenSource will not be used.
Expiry time.Time `json:"expiry,omitempty"`
+ // ExpiresIn is the OAuth2 wire format "expires_in" field,
+ // which specifies how many seconds later the token expires,
+ // relative to an unknown time base approximately around "now".
+ // It is the application's responsibility to populate
+ // `Expiry` from `ExpiresIn` when required.
+ ExpiresIn int64 `json:"expires_in,omitempty"`
+
// raw optionally contains extra metadata from the server
// when updating a token.
raw interface{}
diff --git a/vendor/golang.org/x/sync/LICENSE b/vendor/golang.org/x/sync/LICENSE
index 6a66aea5ea..2a7cf70da6 100644
--- a/vendor/golang.org/x/sync/LICENSE
+++ b/vendor/golang.org/x/sync/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
+Copyright 2009 The Go Authors.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
@@ -10,7 +10,7 @@ notice, this list of conditions and the following disclaimer.
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
+ * Neither the name of Google LLC nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
diff --git a/vendor/golang.org/x/sync/semaphore/semaphore.go b/vendor/golang.org/x/sync/semaphore/semaphore.go
index 30f632c577..b618162aab 100644
--- a/vendor/golang.org/x/sync/semaphore/semaphore.go
+++ b/vendor/golang.org/x/sync/semaphore/semaphore.go
@@ -35,11 +35,25 @@ type Weighted struct {
// Acquire acquires the semaphore with a weight of n, blocking until resources
// are available or ctx is done. On success, returns nil. On failure, returns
// ctx.Err() and leaves the semaphore unchanged.
-//
-// If ctx is already done, Acquire may still succeed without blocking.
func (s *Weighted) Acquire(ctx context.Context, n int64) error {
+ done := ctx.Done()
+
s.mu.Lock()
+ select {
+ case <-done:
+ // ctx becoming done has "happened before" acquiring the semaphore,
+ // whether it became done before the call began or while we were
+ // waiting for the mutex. We prefer to fail even if we could acquire
+ // the mutex without blocking.
+ s.mu.Unlock()
+ return ctx.Err()
+ default:
+ }
if s.size-s.cur >= n && s.waiters.Len() == 0 {
+ // Since we hold s.mu and haven't synchronized since checking done, if
+ // ctx becomes done before we return here, it becoming done must have
+ // "happened concurrently" with this call - it cannot "happen before"
+ // we return in this branch. So, we're ok to always acquire here.
s.cur += n
s.mu.Unlock()
return nil
@@ -48,7 +62,7 @@ func (s *Weighted) Acquire(ctx context.Context, n int64) error {
if n > s.size {
// Don't make other Acquire calls block on one that's doomed to fail.
s.mu.Unlock()
- <-ctx.Done()
+ <-done
return ctx.Err()
}
@@ -58,14 +72,14 @@ func (s *Weighted) Acquire(ctx context.Context, n int64) error {
s.mu.Unlock()
select {
- case <-ctx.Done():
- err := ctx.Err()
+ case <-done:
s.mu.Lock()
select {
case <-ready:
- // Acquired the semaphore after we were canceled. Rather than trying to
- // fix up the queue, just pretend we didn't notice the cancelation.
- err = nil
+ // Acquired the semaphore after we were canceled.
+ // Pretend we didn't and put the tokens back.
+ s.cur -= n
+ s.notifyWaiters()
default:
isFront := s.waiters.Front() == elem
s.waiters.Remove(elem)
@@ -75,9 +89,19 @@ func (s *Weighted) Acquire(ctx context.Context, n int64) error {
}
}
s.mu.Unlock()
- return err
+ return ctx.Err()
case <-ready:
+ // Acquired the semaphore. Check that ctx isn't already done.
+ // We check the done channel instead of calling ctx.Err because we
+ // already have the channel, and ctx.Err is O(n) with the nesting
+ // depth of ctx.
+ select {
+ case <-done:
+ s.Release(n)
+ return ctx.Err()
+ default:
+ }
return nil
}
}
diff --git a/vendor/golang.org/x/sys/LICENSE b/vendor/golang.org/x/sys/LICENSE
index 6a66aea5ea..2a7cf70da6 100644
--- a/vendor/golang.org/x/sys/LICENSE
+++ b/vendor/golang.org/x/sys/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
+Copyright 2009 The Go Authors.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
@@ -10,7 +10,7 @@ notice, this list of conditions and the following disclaimer.
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
+ * Neither the name of Google LLC nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
diff --git a/vendor/golang.org/x/sys/cpu/asm_darwin_x86_gc.s b/vendor/golang.org/x/sys/cpu/asm_darwin_x86_gc.s
new file mode 100644
index 0000000000..ec2acfe540
--- /dev/null
+++ b/vendor/golang.org/x/sys/cpu/asm_darwin_x86_gc.s
@@ -0,0 +1,17 @@
+// Copyright 2024 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 darwin && amd64 && gc
+
+#include "textflag.h"
+
+TEXT libc_sysctl_trampoline<>(SB),NOSPLIT,$0-0
+ JMP libc_sysctl(SB)
+GLOBL ·libc_sysctl_trampoline_addr(SB), RODATA, $8
+DATA ·libc_sysctl_trampoline_addr(SB)/8, $libc_sysctl_trampoline<>(SB)
+
+TEXT libc_sysctlbyname_trampoline<>(SB),NOSPLIT,$0-0
+ JMP libc_sysctlbyname(SB)
+GLOBL ·libc_sysctlbyname_trampoline_addr(SB), RODATA, $8
+DATA ·libc_sysctlbyname_trampoline_addr(SB)/8, $libc_sysctlbyname_trampoline<>(SB)
diff --git a/vendor/golang.org/x/sys/cpu/cpu.go b/vendor/golang.org/x/sys/cpu/cpu.go
index 8fa707aa4b..02609d5b21 100644
--- a/vendor/golang.org/x/sys/cpu/cpu.go
+++ b/vendor/golang.org/x/sys/cpu/cpu.go
@@ -105,6 +105,8 @@ var ARM64 struct {
HasSVE bool // Scalable Vector Extensions
HasSVE2 bool // Scalable Vector Extensions 2
HasASIMDFHM bool // Advanced SIMD multiplication FP16 to FP32
+ HasDIT bool // Data Independent Timing support
+ HasI8MM bool // Advanced SIMD Int8 matrix multiplication instructions
_ CacheLinePad
}
@@ -199,6 +201,25 @@ var S390X struct {
_ CacheLinePad
}
+// RISCV64 contains the supported CPU features and performance characteristics for riscv64
+// platforms. The booleans in RISCV64, with the exception of HasFastMisaligned, indicate
+// the presence of RISC-V extensions.
+//
+// It is safe to assume that all the RV64G extensions are supported and so they are omitted from
+// this structure. As riscv64 Go programs require at least RV64G, the code that populates
+// this structure cannot run successfully if some of the RV64G extensions are missing.
+// The struct is padded to avoid false sharing.
+var RISCV64 struct {
+ _ CacheLinePad
+ HasFastMisaligned bool // Fast misaligned accesses
+ HasC bool // Compressed instruction-set extension
+ HasV bool // Vector extension compatible with RVV 1.0
+ HasZba bool // Address generation instructions extension
+ HasZbb bool // Basic bit-manipulation extension
+ HasZbs bool // Single-bit instructions extension
+ _ CacheLinePad
+}
+
func init() {
archInit()
initOptions()
diff --git a/vendor/golang.org/x/sys/cpu/cpu_arm64.go b/vendor/golang.org/x/sys/cpu/cpu_arm64.go
index 0e27a21e1f..af2aa99f9f 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_arm64.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_arm64.go
@@ -38,6 +38,8 @@ func initOptions() {
{Name: "dcpop", Feature: &ARM64.HasDCPOP},
{Name: "asimddp", Feature: &ARM64.HasASIMDDP},
{Name: "asimdfhm", Feature: &ARM64.HasASIMDFHM},
+ {Name: "dit", Feature: &ARM64.HasDIT},
+ {Name: "i8mm", Feature: &ARM64.HasI8MM},
}
}
@@ -145,6 +147,11 @@ func parseARM64SystemRegisters(isar0, isar1, pfr0 uint64) {
ARM64.HasLRCPC = true
}
+ switch extractBits(isar1, 52, 55) {
+ case 1:
+ ARM64.HasI8MM = true
+ }
+
// ID_AA64PFR0_EL1
switch extractBits(pfr0, 16, 19) {
case 0:
@@ -168,6 +175,11 @@ func parseARM64SystemRegisters(isar0, isar1, pfr0 uint64) {
parseARM64SVERegister(getzfr0())
}
+
+ switch extractBits(pfr0, 48, 51) {
+ case 1:
+ ARM64.HasDIT = true
+ }
}
func parseARM64SVERegister(zfr0 uint64) {
diff --git a/vendor/golang.org/x/sys/cpu/cpu_darwin_x86.go b/vendor/golang.org/x/sys/cpu/cpu_darwin_x86.go
new file mode 100644
index 0000000000..b838cb9e95
--- /dev/null
+++ b/vendor/golang.org/x/sys/cpu/cpu_darwin_x86.go
@@ -0,0 +1,61 @@
+// Copyright 2024 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 darwin && amd64 && gc
+
+package cpu
+
+// darwinSupportsAVX512 checks Darwin kernel for AVX512 support via sysctl
+// call (see issue 43089). It also restricts AVX512 support for Darwin to
+// kernel version 21.3.0 (MacOS 12.2.0) or later (see issue 49233).
+//
+// Background:
+// Darwin implements a special mechanism to economize on thread state when
+// AVX512 specific registers are not in use. This scheme minimizes state when
+// preempting threads that haven't yet used any AVX512 instructions, but adds
+// special requirements to check for AVX512 hardware support at runtime (e.g.
+// via sysctl call or commpage inspection). See issue 43089 and link below for
+// full background:
+// https://github.com/apple-oss-distributions/xnu/blob/xnu-11215.1.10/osfmk/i386/fpu.c#L214-L240
+//
+// Additionally, all versions of the Darwin kernel from 19.6.0 through 21.2.0
+// (corresponding to MacOS 10.15.6 - 12.1) have a bug that can cause corruption
+// of the AVX512 mask registers (K0-K7) upon signal return. For this reason
+// AVX512 is considered unsafe to use on Darwin for kernel versions prior to
+// 21.3.0, where a fix has been confirmed. See issue 49233 for full background.
+func darwinSupportsAVX512() bool {
+ return darwinSysctlEnabled([]byte("hw.optional.avx512f\x00")) && darwinKernelVersionCheck(21, 3, 0)
+}
+
+// Ensure Darwin kernel version is at least major.minor.patch, avoiding dependencies
+func darwinKernelVersionCheck(major, minor, patch int) bool {
+ var release [256]byte
+ err := darwinOSRelease(&release)
+ if err != nil {
+ return false
+ }
+
+ var mmp [3]int
+ c := 0
+Loop:
+ for _, b := range release[:] {
+ switch {
+ case b >= '0' && b <= '9':
+ mmp[c] = 10*mmp[c] + int(b-'0')
+ case b == '.':
+ c++
+ if c > 2 {
+ return false
+ }
+ case b == 0:
+ break Loop
+ default:
+ return false
+ }
+ }
+ if c != 2 {
+ return false
+ }
+ return mmp[0] > major || mmp[0] == major && (mmp[1] > minor || mmp[1] == minor && mmp[2] >= patch)
+}
diff --git a/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go b/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go
index 910728fb16..32a44514e2 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go
@@ -6,10 +6,10 @@
package cpu
-// cpuid is implemented in cpu_x86.s for gc compiler
+// cpuid is implemented in cpu_gc_x86.s for gc compiler
// and in cpu_gccgo.c for gccgo.
func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32)
-// xgetbv with ecx = 0 is implemented in cpu_x86.s for gc compiler
+// xgetbv with ecx = 0 is implemented in cpu_gc_x86.s for gc compiler
// and in cpu_gccgo.c for gccgo.
func xgetbv() (eax, edx uint32)
diff --git a/vendor/golang.org/x/sys/cpu/cpu_x86.s b/vendor/golang.org/x/sys/cpu/cpu_gc_x86.s
similarity index 94%
rename from vendor/golang.org/x/sys/cpu/cpu_x86.s
rename to vendor/golang.org/x/sys/cpu/cpu_gc_x86.s
index 7d7ba33efb..ce208ce6d6 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_x86.s
+++ b/vendor/golang.org/x/sys/cpu/cpu_gc_x86.s
@@ -18,7 +18,7 @@ TEXT ·cpuid(SB), NOSPLIT, $0-24
RET
// func xgetbv() (eax, edx uint32)
-TEXT ·xgetbv(SB),NOSPLIT,$0-8
+TEXT ·xgetbv(SB), NOSPLIT, $0-8
MOVL $0, CX
XGETBV
MOVL AX, eax+0(FP)
diff --git a/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go b/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go
index 99c60fe9f9..170d21ddfd 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go
@@ -23,9 +23,3 @@ func xgetbv() (eax, edx uint32) {
gccgoXgetbv(&a, &d)
return a, d
}
-
-// gccgo doesn't build on Darwin, per:
-// https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/gcc.rb#L76
-func darwinSupportsAVX512() bool {
- return false
-}
diff --git a/vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go b/vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go
index 3d386d0fc2..f1caf0f78e 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go
@@ -35,8 +35,10 @@ const (
hwcap_SHA512 = 1 << 21
hwcap_SVE = 1 << 22
hwcap_ASIMDFHM = 1 << 23
+ hwcap_DIT = 1 << 24
hwcap2_SVE2 = 1 << 1
+ hwcap2_I8MM = 1 << 13
)
// linuxKernelCanEmulateCPUID reports whether we're running
@@ -106,9 +108,11 @@ func doinit() {
ARM64.HasSHA512 = isSet(hwCap, hwcap_SHA512)
ARM64.HasSVE = isSet(hwCap, hwcap_SVE)
ARM64.HasASIMDFHM = isSet(hwCap, hwcap_ASIMDFHM)
+ ARM64.HasDIT = isSet(hwCap, hwcap_DIT)
// HWCAP2 feature bits
ARM64.HasSVE2 = isSet(hwCap2, hwcap2_SVE2)
+ ARM64.HasI8MM = isSet(hwCap2, hwcap2_I8MM)
}
func isSet(hwc uint, value uint) bool {
diff --git a/vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go b/vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go
index cd63e73355..7d902b6847 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-//go:build linux && !arm && !arm64 && !mips64 && !mips64le && !ppc64 && !ppc64le && !s390x
+//go:build linux && !arm && !arm64 && !mips64 && !mips64le && !ppc64 && !ppc64le && !s390x && !riscv64
package cpu
diff --git a/vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go b/vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go
new file mode 100644
index 0000000000..cb4a0c5728
--- /dev/null
+++ b/vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go
@@ -0,0 +1,137 @@
+// Copyright 2024 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 cpu
+
+import (
+ "syscall"
+ "unsafe"
+)
+
+// RISC-V extension discovery code for Linux. The approach here is to first try the riscv_hwprobe
+// syscall falling back to HWCAP to check for the C extension if riscv_hwprobe is not available.
+//
+// A note on detection of the Vector extension using HWCAP.
+//
+// Support for the Vector extension version 1.0 was added to the Linux kernel in release 6.5.
+// Support for the riscv_hwprobe syscall was added in 6.4. It follows that if the riscv_hwprobe
+// syscall is not available then neither is the Vector extension (which needs kernel support).
+// The riscv_hwprobe syscall should then be all we need to detect the Vector extension.
+// However, some RISC-V board manufacturers ship boards with an older kernel on top of which
+// they have back-ported various versions of the Vector extension patches but not the riscv_hwprobe
+// patches. These kernels advertise support for the Vector extension using HWCAP. Falling
+// back to HWCAP to detect the Vector extension, if riscv_hwprobe is not available, or simply not
+// bothering with riscv_hwprobe at all and just using HWCAP may then seem like an attractive option.
+//
+// Unfortunately, simply checking the 'V' bit in AT_HWCAP will not work as this bit is used by
+// RISC-V board and cloud instance providers to mean different things. The Lichee Pi 4A board
+// and the Scaleway RV1 cloud instances use the 'V' bit to advertise their support for the unratified
+// 0.7.1 version of the Vector Specification. The Banana Pi BPI-F3 and the CanMV-K230 board use
+// it to advertise support for 1.0 of the Vector extension. Versions 0.7.1 and 1.0 of the Vector
+// extension are binary incompatible. HWCAP can then not be used in isolation to populate the
+// HasV field as this field indicates that the underlying CPU is compatible with RVV 1.0.
+//
+// There is a way at runtime to distinguish between versions 0.7.1 and 1.0 of the Vector
+// specification by issuing a RVV 1.0 vsetvli instruction and checking the vill bit of the vtype
+// register. This check would allow us to safely detect version 1.0 of the Vector extension
+// with HWCAP, if riscv_hwprobe were not available. However, the check cannot
+// be added until the assembler supports the Vector instructions.
+//
+// Note the riscv_hwprobe syscall does not suffer from these ambiguities by design as all of the
+// extensions it advertises support for are explicitly versioned. It's also worth noting that
+// the riscv_hwprobe syscall is the only way to detect multi-letter RISC-V extensions, e.g., Zba.
+// These cannot be detected using HWCAP and so riscv_hwprobe must be used to detect the majority
+// of RISC-V extensions.
+//
+// Please see https://docs.kernel.org/arch/riscv/hwprobe.html for more information.
+
+// golang.org/x/sys/cpu is not allowed to depend on golang.org/x/sys/unix so we must
+// reproduce the constants, types and functions needed to make the riscv_hwprobe syscall
+// here.
+
+const (
+ // Copied from golang.org/x/sys/unix/ztypes_linux_riscv64.go.
+ riscv_HWPROBE_KEY_IMA_EXT_0 = 0x4
+ riscv_HWPROBE_IMA_C = 0x2
+ riscv_HWPROBE_IMA_V = 0x4
+ riscv_HWPROBE_EXT_ZBA = 0x8
+ riscv_HWPROBE_EXT_ZBB = 0x10
+ riscv_HWPROBE_EXT_ZBS = 0x20
+ riscv_HWPROBE_KEY_CPUPERF_0 = 0x5
+ riscv_HWPROBE_MISALIGNED_FAST = 0x3
+ riscv_HWPROBE_MISALIGNED_MASK = 0x7
+)
+
+const (
+ // sys_RISCV_HWPROBE is copied from golang.org/x/sys/unix/zsysnum_linux_riscv64.go.
+ sys_RISCV_HWPROBE = 258
+)
+
+// riscvHWProbePairs is copied from golang.org/x/sys/unix/ztypes_linux_riscv64.go.
+type riscvHWProbePairs struct {
+ key int64
+ value uint64
+}
+
+const (
+ // CPU features
+ hwcap_RISCV_ISA_C = 1 << ('C' - 'A')
+)
+
+func doinit() {
+ // A slice of key/value pair structures is passed to the RISCVHWProbe syscall. The key
+ // field should be initialised with one of the key constants defined above, e.g.,
+ // RISCV_HWPROBE_KEY_IMA_EXT_0. The syscall will set the value field to the appropriate value.
+ // If the kernel does not recognise a key it will set the key field to -1 and the value field to 0.
+
+ pairs := []riscvHWProbePairs{
+ {riscv_HWPROBE_KEY_IMA_EXT_0, 0},
+ {riscv_HWPROBE_KEY_CPUPERF_0, 0},
+ }
+
+ // This call only indicates that extensions are supported if they are implemented on all cores.
+ if riscvHWProbe(pairs, 0) {
+ if pairs[0].key != -1 {
+ v := uint(pairs[0].value)
+ RISCV64.HasC = isSet(v, riscv_HWPROBE_IMA_C)
+ RISCV64.HasV = isSet(v, riscv_HWPROBE_IMA_V)
+ RISCV64.HasZba = isSet(v, riscv_HWPROBE_EXT_ZBA)
+ RISCV64.HasZbb = isSet(v, riscv_HWPROBE_EXT_ZBB)
+ RISCV64.HasZbs = isSet(v, riscv_HWPROBE_EXT_ZBS)
+ }
+ if pairs[1].key != -1 {
+ v := pairs[1].value & riscv_HWPROBE_MISALIGNED_MASK
+ RISCV64.HasFastMisaligned = v == riscv_HWPROBE_MISALIGNED_FAST
+ }
+ }
+
+ // Let's double check with HWCAP if the C extension does not appear to be supported.
+ // This may happen if we're running on a kernel older than 6.4.
+
+ if !RISCV64.HasC {
+ RISCV64.HasC = isSet(hwCap, hwcap_RISCV_ISA_C)
+ }
+}
+
+func isSet(hwc uint, value uint) bool {
+ return hwc&value != 0
+}
+
+// riscvHWProbe is a simplified version of the generated wrapper function found in
+// golang.org/x/sys/unix/zsyscall_linux_riscv64.go. We simplify it by removing the
+// cpuCount and cpus parameters which we do not need. We always want to pass 0 for
+// these parameters here so the kernel only reports the extensions that are present
+// on all cores.
+func riscvHWProbe(pairs []riscvHWProbePairs, flags uint) bool {
+ var _zero uintptr
+ var p0 unsafe.Pointer
+ if len(pairs) > 0 {
+ p0 = unsafe.Pointer(&pairs[0])
+ } else {
+ p0 = unsafe.Pointer(&_zero)
+ }
+
+ _, _, e1 := syscall.Syscall6(sys_RISCV_HWPROBE, uintptr(p0), uintptr(len(pairs)), uintptr(0), uintptr(0), uintptr(flags), 0)
+ return e1 == 0
+}
diff --git a/vendor/golang.org/x/sys/cpu/cpu_other_x86.go b/vendor/golang.org/x/sys/cpu/cpu_other_x86.go
new file mode 100644
index 0000000000..a0fd7e2f75
--- /dev/null
+++ b/vendor/golang.org/x/sys/cpu/cpu_other_x86.go
@@ -0,0 +1,11 @@
+// Copyright 2024 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 386 || amd64p32 || (amd64 && (!darwin || !gc))
+
+package cpu
+
+func darwinSupportsAVX512() bool {
+ panic("only implemented for gc && amd64 && darwin")
+}
diff --git a/vendor/golang.org/x/sys/cpu/cpu_riscv64.go b/vendor/golang.org/x/sys/cpu/cpu_riscv64.go
index 7f0c79c004..aca3199c91 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_riscv64.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_riscv64.go
@@ -8,4 +8,13 @@ package cpu
const cacheLineSize = 64
-func initOptions() {}
+func initOptions() {
+ options = []option{
+ {Name: "fastmisaligned", Feature: &RISCV64.HasFastMisaligned},
+ {Name: "c", Feature: &RISCV64.HasC},
+ {Name: "v", Feature: &RISCV64.HasV},
+ {Name: "zba", Feature: &RISCV64.HasZba},
+ {Name: "zbb", Feature: &RISCV64.HasZbb},
+ {Name: "zbs", Feature: &RISCV64.HasZbs},
+ }
+}
diff --git a/vendor/golang.org/x/sys/cpu/cpu_x86.go b/vendor/golang.org/x/sys/cpu/cpu_x86.go
index c29f5e4c5a..600a680786 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_x86.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_x86.go
@@ -92,10 +92,8 @@ func archInit() {
osSupportsAVX = isSet(1, eax) && isSet(2, eax)
if runtime.GOOS == "darwin" {
- // Darwin doesn't save/restore AVX-512 mask registers correctly across signal handlers.
- // Since users can't rely on mask register contents, let's not advertise AVX-512 support.
- // See issue 49233.
- osSupportsAVX512 = false
+ // Darwin requires special AVX512 checks, see cpu_darwin_x86.go
+ osSupportsAVX512 = osSupportsAVX && darwinSupportsAVX512()
} else {
// Check if OPMASK and ZMM registers have OS support.
osSupportsAVX512 = osSupportsAVX && isSet(5, eax) && isSet(6, eax) && isSet(7, eax)
diff --git a/vendor/golang.org/x/sys/cpu/syscall_darwin_x86_gc.go b/vendor/golang.org/x/sys/cpu/syscall_darwin_x86_gc.go
new file mode 100644
index 0000000000..4d0888b0c0
--- /dev/null
+++ b/vendor/golang.org/x/sys/cpu/syscall_darwin_x86_gc.go
@@ -0,0 +1,98 @@
+// Copyright 2024 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.
+
+// Minimal copy of x/sys/unix so the cpu package can make a
+// system call on Darwin without depending on x/sys/unix.
+
+//go:build darwin && amd64 && gc
+
+package cpu
+
+import (
+ "syscall"
+ "unsafe"
+)
+
+type _C_int int32
+
+// adapted from unix.Uname() at x/sys/unix/syscall_darwin.go L419
+func darwinOSRelease(release *[256]byte) error {
+ // from x/sys/unix/zerrors_openbsd_amd64.go
+ const (
+ CTL_KERN = 0x1
+ KERN_OSRELEASE = 0x2
+ )
+
+ mib := []_C_int{CTL_KERN, KERN_OSRELEASE}
+ n := unsafe.Sizeof(*release)
+
+ return sysctl(mib, &release[0], &n, nil, 0)
+}
+
+type Errno = syscall.Errno
+
+var _zero uintptr // Single-word zero for use when we need a valid pointer to 0 bytes.
+
+// from x/sys/unix/zsyscall_darwin_amd64.go L791-807
+func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) error {
+ var _p0 unsafe.Pointer
+ if len(mib) > 0 {
+ _p0 = unsafe.Pointer(&mib[0])
+ } else {
+ _p0 = unsafe.Pointer(&_zero)
+ }
+ if _, _, err := syscall_syscall6(
+ libc_sysctl_trampoline_addr,
+ uintptr(_p0),
+ uintptr(len(mib)),
+ uintptr(unsafe.Pointer(old)),
+ uintptr(unsafe.Pointer(oldlen)),
+ uintptr(unsafe.Pointer(new)),
+ uintptr(newlen),
+ ); err != 0 {
+ return err
+ }
+
+ return nil
+}
+
+var libc_sysctl_trampoline_addr uintptr
+
+// adapted from internal/cpu/cpu_arm64_darwin.go
+func darwinSysctlEnabled(name []byte) bool {
+ out := int32(0)
+ nout := unsafe.Sizeof(out)
+ if ret := sysctlbyname(&name[0], (*byte)(unsafe.Pointer(&out)), &nout, nil, 0); ret != nil {
+ return false
+ }
+ return out > 0
+}
+
+//go:cgo_import_dynamic libc_sysctl sysctl "/usr/lib/libSystem.B.dylib"
+
+var libc_sysctlbyname_trampoline_addr uintptr
+
+// adapted from runtime/sys_darwin.go in the pattern of sysctl() above, as defined in x/sys/unix
+func sysctlbyname(name *byte, old *byte, oldlen *uintptr, new *byte, newlen uintptr) error {
+ if _, _, err := syscall_syscall6(
+ libc_sysctlbyname_trampoline_addr,
+ uintptr(unsafe.Pointer(name)),
+ uintptr(unsafe.Pointer(old)),
+ uintptr(unsafe.Pointer(oldlen)),
+ uintptr(unsafe.Pointer(new)),
+ uintptr(newlen),
+ 0,
+ ); err != 0 {
+ return err
+ }
+
+ return nil
+}
+
+//go:cgo_import_dynamic libc_sysctlbyname sysctlbyname "/usr/lib/libSystem.B.dylib"
+
+// Implemented in the runtime package (runtime/sys_darwin.go)
+func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+
+//go:linkname syscall_syscall6 syscall.syscall6
diff --git a/vendor/golang.org/x/sys/execabs/execabs.go b/vendor/golang.org/x/sys/execabs/execabs.go
deleted file mode 100644
index 3bf40fdfec..0000000000
--- a/vendor/golang.org/x/sys/execabs/execabs.go
+++ /dev/null
@@ -1,102 +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.
-
-// Package execabs is a drop-in replacement for os/exec
-// that requires PATH lookups to find absolute paths.
-// That is, execabs.Command("cmd") runs the same PATH lookup
-// as exec.Command("cmd"), but if the result is a path
-// which is relative, the Run and Start methods will report
-// an error instead of running the executable.
-//
-// See https://blog.golang.org/path-security for more information
-// about when it may be necessary or appropriate to use this package.
-package execabs
-
-import (
- "context"
- "fmt"
- "os/exec"
- "path/filepath"
- "reflect"
- "unsafe"
-)
-
-// ErrNotFound is the error resulting if a path search failed to find an executable file.
-// It is an alias for exec.ErrNotFound.
-var ErrNotFound = exec.ErrNotFound
-
-// Cmd represents an external command being prepared or run.
-// It is an alias for exec.Cmd.
-type Cmd = exec.Cmd
-
-// Error is returned by LookPath when it fails to classify a file as an executable.
-// It is an alias for exec.Error.
-type Error = exec.Error
-
-// An ExitError reports an unsuccessful exit by a command.
-// It is an alias for exec.ExitError.
-type ExitError = exec.ExitError
-
-func relError(file, path string) error {
- return fmt.Errorf("%s resolves to executable in current directory (.%c%s)", file, filepath.Separator, path)
-}
-
-// LookPath searches for an executable named file in the directories
-// named by the PATH environment variable. If file contains a slash,
-// it is tried directly and the PATH is not consulted. The result will be
-// an absolute path.
-//
-// LookPath differs from exec.LookPath in its handling of PATH lookups,
-// which are used for file names without slashes. If exec.LookPath's
-// PATH lookup would have returned an executable from the current directory,
-// LookPath instead returns an error.
-func LookPath(file string) (string, error) {
- path, err := exec.LookPath(file)
- if err != nil && !isGo119ErrDot(err) {
- return "", err
- }
- if filepath.Base(file) == file && !filepath.IsAbs(path) {
- return "", relError(file, path)
- }
- return path, nil
-}
-
-func fixCmd(name string, cmd *exec.Cmd) {
- if filepath.Base(name) == name && !filepath.IsAbs(cmd.Path) && !isGo119ErrFieldSet(cmd) {
- // exec.Command was called with a bare binary name and
- // exec.LookPath returned a path which is not absolute.
- // Set cmd.lookPathErr and clear cmd.Path so that it
- // cannot be run.
- lookPathErr := (*error)(unsafe.Pointer(reflect.ValueOf(cmd).Elem().FieldByName("lookPathErr").Addr().Pointer()))
- if *lookPathErr == nil {
- *lookPathErr = relError(name, cmd.Path)
- }
- cmd.Path = ""
- }
-}
-
-// CommandContext is like Command but includes a context.
-//
-// The provided context is used to kill the process (by calling os.Process.Kill)
-// if the context becomes done before the command completes on its own.
-func CommandContext(ctx context.Context, name string, arg ...string) *exec.Cmd {
- cmd := exec.CommandContext(ctx, name, arg...)
- fixCmd(name, cmd)
- return cmd
-
-}
-
-// Command returns the Cmd struct to execute the named program with the given arguments.
-// See exec.Command for most details.
-//
-// Command differs from exec.Command in its handling of PATH lookups,
-// which are used when the program name contains no slashes.
-// If exec.Command would have returned an exec.Cmd configured to run an
-// executable from the current directory, Command instead
-// returns an exec.Cmd that will return an error from Start or Run.
-func Command(name string, arg ...string) *exec.Cmd {
- cmd := exec.Command(name, arg...)
- fixCmd(name, cmd)
- return cmd
-}
diff --git a/vendor/golang.org/x/sys/execabs/execabs_go118.go b/vendor/golang.org/x/sys/execabs/execabs_go118.go
deleted file mode 100644
index 5627d70e39..0000000000
--- a/vendor/golang.org/x/sys/execabs/execabs_go118.go
+++ /dev/null
@@ -1,17 +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.
-
-//go:build !go1.19
-
-package execabs
-
-import "os/exec"
-
-func isGo119ErrDot(err error) bool {
- return false
-}
-
-func isGo119ErrFieldSet(cmd *exec.Cmd) bool {
- return false
-}
diff --git a/vendor/golang.org/x/sys/execabs/execabs_go119.go b/vendor/golang.org/x/sys/execabs/execabs_go119.go
deleted file mode 100644
index d60ab1b419..0000000000
--- a/vendor/golang.org/x/sys/execabs/execabs_go119.go
+++ /dev/null
@@ -1,20 +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.
-
-//go:build go1.19
-
-package execabs
-
-import (
- "errors"
- "os/exec"
-)
-
-func isGo119ErrDot(err error) bool {
- return errors.Is(err, exec.ErrDot)
-}
-
-func isGo119ErrFieldSet(cmd *exec.Cmd) bool {
- return cmd.Err != nil
-}
diff --git a/vendor/golang.org/x/sys/unix/README.md b/vendor/golang.org/x/sys/unix/README.md
index 7d3c060e12..6e08a76a71 100644
--- a/vendor/golang.org/x/sys/unix/README.md
+++ b/vendor/golang.org/x/sys/unix/README.md
@@ -156,7 +156,7 @@ from the generated architecture-specific files listed below, and merge these
into a common file for each OS.
The merge is performed in the following steps:
-1. Construct the set of common code that is idential in all architecture-specific files.
+1. Construct the set of common code that is identical in all architecture-specific files.
2. Write this common code to the merged file.
3. Remove the common code from all architecture-specific files.
diff --git a/vendor/golang.org/x/sys/unix/ioctl_linux.go b/vendor/golang.org/x/sys/unix/ioctl_linux.go
index dbe680eab8..7ca4fa12aa 100644
--- a/vendor/golang.org/x/sys/unix/ioctl_linux.go
+++ b/vendor/golang.org/x/sys/unix/ioctl_linux.go
@@ -58,6 +58,102 @@ func IoctlGetEthtoolDrvinfo(fd int, ifname string) (*EthtoolDrvinfo, error) {
return &value, err
}
+// IoctlGetEthtoolTsInfo fetches ethtool timestamping and PHC
+// association for the network device specified by ifname.
+func IoctlGetEthtoolTsInfo(fd int, ifname string) (*EthtoolTsInfo, error) {
+ ifr, err := NewIfreq(ifname)
+ if err != nil {
+ return nil, err
+ }
+
+ value := EthtoolTsInfo{Cmd: ETHTOOL_GET_TS_INFO}
+ ifrd := ifr.withData(unsafe.Pointer(&value))
+
+ err = ioctlIfreqData(fd, SIOCETHTOOL, &ifrd)
+ return &value, err
+}
+
+// IoctlGetHwTstamp retrieves the hardware timestamping configuration
+// for the network device specified by ifname.
+func IoctlGetHwTstamp(fd int, ifname string) (*HwTstampConfig, error) {
+ ifr, err := NewIfreq(ifname)
+ if err != nil {
+ return nil, err
+ }
+
+ value := HwTstampConfig{}
+ ifrd := ifr.withData(unsafe.Pointer(&value))
+
+ err = ioctlIfreqData(fd, SIOCGHWTSTAMP, &ifrd)
+ return &value, err
+}
+
+// IoctlSetHwTstamp updates the hardware timestamping configuration for
+// the network device specified by ifname.
+func IoctlSetHwTstamp(fd int, ifname string, cfg *HwTstampConfig) error {
+ ifr, err := NewIfreq(ifname)
+ if err != nil {
+ return err
+ }
+ ifrd := ifr.withData(unsafe.Pointer(cfg))
+ return ioctlIfreqData(fd, SIOCSHWTSTAMP, &ifrd)
+}
+
+// FdToClockID derives the clock ID from the file descriptor number
+// - see clock_gettime(3), FD_TO_CLOCKID macros. The resulting ID is
+// suitable for system calls like ClockGettime.
+func FdToClockID(fd int) int32 { return int32((int(^fd) << 3) | 3) }
+
+// IoctlPtpClockGetcaps returns the description of a given PTP device.
+func IoctlPtpClockGetcaps(fd int) (*PtpClockCaps, error) {
+ var value PtpClockCaps
+ err := ioctlPtr(fd, PTP_CLOCK_GETCAPS2, unsafe.Pointer(&value))
+ return &value, err
+}
+
+// IoctlPtpSysOffsetPrecise returns a description of the clock
+// offset compared to the system clock.
+func IoctlPtpSysOffsetPrecise(fd int) (*PtpSysOffsetPrecise, error) {
+ var value PtpSysOffsetPrecise
+ err := ioctlPtr(fd, PTP_SYS_OFFSET_PRECISE2, unsafe.Pointer(&value))
+ return &value, err
+}
+
+// IoctlPtpSysOffsetExtended returns an extended description of the
+// clock offset compared to the system clock. The samples parameter
+// specifies the desired number of measurements.
+func IoctlPtpSysOffsetExtended(fd int, samples uint) (*PtpSysOffsetExtended, error) {
+ value := PtpSysOffsetExtended{Samples: uint32(samples)}
+ err := ioctlPtr(fd, PTP_SYS_OFFSET_EXTENDED2, unsafe.Pointer(&value))
+ return &value, err
+}
+
+// IoctlPtpPinGetfunc returns the configuration of the specified
+// I/O pin on given PTP device.
+func IoctlPtpPinGetfunc(fd int, index uint) (*PtpPinDesc, error) {
+ value := PtpPinDesc{Index: uint32(index)}
+ err := ioctlPtr(fd, PTP_PIN_GETFUNC2, unsafe.Pointer(&value))
+ return &value, err
+}
+
+// IoctlPtpPinSetfunc updates configuration of the specified PTP
+// I/O pin.
+func IoctlPtpPinSetfunc(fd int, pd *PtpPinDesc) error {
+ return ioctlPtr(fd, PTP_PIN_SETFUNC2, unsafe.Pointer(pd))
+}
+
+// IoctlPtpPeroutRequest configures the periodic output mode of the
+// PTP I/O pins.
+func IoctlPtpPeroutRequest(fd int, r *PtpPeroutRequest) error {
+ return ioctlPtr(fd, PTP_PEROUT_REQUEST2, unsafe.Pointer(r))
+}
+
+// IoctlPtpExttsRequest configures the external timestamping mode
+// of the PTP I/O pins.
+func IoctlPtpExttsRequest(fd int, r *PtpExttsRequest) error {
+ return ioctlPtr(fd, PTP_EXTTS_REQUEST2, unsafe.Pointer(r))
+}
+
// IoctlGetWatchdogInfo fetches information about a watchdog device from the
// Linux watchdog API. For more information, see:
// https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html.
diff --git a/vendor/golang.org/x/sys/unix/mkerrors.sh b/vendor/golang.org/x/sys/unix/mkerrors.sh
index 4ed2e488b6..6ab02b6c31 100644
--- a/vendor/golang.org/x/sys/unix/mkerrors.sh
+++ b/vendor/golang.org/x/sys/unix/mkerrors.sh
@@ -58,6 +58,7 @@ includes_Darwin='
#define _DARWIN_USE_64_BIT_INODE
#define __APPLE_USE_RFC_3542
#include
+#include
#include
#include
#include
@@ -157,6 +158,16 @@ includes_Linux='
#endif
#define _GNU_SOURCE
+// See the description in unix/linux/types.go
+#if defined(__ARM_EABI__) || \
+ (defined(__mips__) && (_MIPS_SIM == _ABIO32)) || \
+ (defined(__powerpc__) && (!defined(__powerpc64__)))
+# ifdef _TIME_BITS
+# undef _TIME_BITS
+# endif
+# define _TIME_BITS 32
+#endif
+
// is broken on powerpc64, as it fails to include definitions of
// these structures. We just include them copied from .
#if defined(__powerpc__)
@@ -255,6 +266,7 @@ struct ltchars {
#include
#include
#include
+#include
#include
#include
#include
@@ -526,6 +538,7 @@ ccflags="$@"
$2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|TCP|MCAST|EVFILT|NOTE|SHUT|PROT|MAP|MREMAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR|LOCAL|TCPOPT|UDP)_/ ||
$2 ~ /^NFC_(GENL|PROTO|COMM|RF|SE|DIRECTION|LLCP|SOCKPROTO)_/ ||
$2 ~ /^NFC_.*_(MAX)?SIZE$/ ||
+ $2 ~ /^PTP_/ ||
$2 ~ /^RAW_PAYLOAD_/ ||
$2 ~ /^[US]F_/ ||
$2 ~ /^TP_STATUS_/ ||
@@ -551,6 +564,7 @@ ccflags="$@"
$2 !~ /^RTC_VL_(ACCURACY|BACKUP|DATA)/ &&
$2 ~ /^(NETLINK|NLM|NLMSG|NLA|IFA|IFAN|RT|RTC|RTCF|RTN|RTPROT|RTNH|ARPHRD|ETH_P|NETNSA)_/ ||
$2 ~ /^SOCK_|SK_DIAG_|SKNLGRP_$/ ||
+ $2 ~ /^(CONNECT|SAE)_/ ||
$2 ~ /^FIORDCHK$/ ||
$2 ~ /^SIOC/ ||
$2 ~ /^TIOC/ ||
@@ -654,7 +668,7 @@ errors=$(
signals=$(
echo '#include ' | $CC -x c - -E -dM $ccflags |
awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print $2 }' |
- grep -v 'SIGSTKSIZE\|SIGSTKSZ\|SIGRT\|SIGMAX64' |
+ grep -E -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT|SIGMAX64)' |
sort
)
@@ -664,7 +678,7 @@ echo '#include ' | $CC -x c - -E -dM $ccflags |
sort >_error.grep
echo '#include ' | $CC -x c - -E -dM $ccflags |
awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print "^\t" $2 "[ \t]*=" }' |
- grep -v 'SIGSTKSIZE\|SIGSTKSZ\|SIGRT\|SIGMAX64' |
+ grep -E -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT|SIGMAX64)' |
sort >_signal.grep
echo '// mkerrors.sh' "$@"
diff --git a/vendor/golang.org/x/sys/unix/mremap.go b/vendor/golang.org/x/sys/unix/mremap.go
index fd45fe529d..3a5e776f89 100644
--- a/vendor/golang.org/x/sys/unix/mremap.go
+++ b/vendor/golang.org/x/sys/unix/mremap.go
@@ -50,3 +50,8 @@ func (m *mremapMmapper) Mremap(oldData []byte, newLength int, flags int) (data [
func Mremap(oldData []byte, newLength int, flags int) (data []byte, err error) {
return mapper.Mremap(oldData, newLength, flags)
}
+
+func MremapPtr(oldAddr unsafe.Pointer, oldSize uintptr, newAddr unsafe.Pointer, newSize uintptr, flags int) (ret unsafe.Pointer, err error) {
+ xaddr, err := mapper.mremap(uintptr(oldAddr), oldSize, newSize, flags, uintptr(newAddr))
+ return unsafe.Pointer(xaddr), err
+}
diff --git a/vendor/golang.org/x/sys/unix/syscall_aix.go b/vendor/golang.org/x/sys/unix/syscall_aix.go
index 67ce6cef2d..6f15ba1eaf 100644
--- a/vendor/golang.org/x/sys/unix/syscall_aix.go
+++ b/vendor/golang.org/x/sys/unix/syscall_aix.go
@@ -360,7 +360,7 @@ func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int,
var status _C_int
var r Pid_t
err = ERESTART
- // AIX wait4 may return with ERESTART errno, while the processus is still
+ // AIX wait4 may return with ERESTART errno, while the process is still
// active.
for err == ERESTART {
r, err = wait4(Pid_t(pid), &status, options, rusage)
diff --git a/vendor/golang.org/x/sys/unix/syscall_darwin.go b/vendor/golang.org/x/sys/unix/syscall_darwin.go
index 59542a897d..099867deed 100644
--- a/vendor/golang.org/x/sys/unix/syscall_darwin.go
+++ b/vendor/golang.org/x/sys/unix/syscall_darwin.go
@@ -402,6 +402,18 @@ func IoctlSetIfreqMTU(fd int, ifreq *IfreqMTU) error {
return ioctlPtr(fd, SIOCSIFMTU, unsafe.Pointer(ifreq))
}
+//sys renamexNp(from string, to string, flag uint32) (err error)
+
+func RenamexNp(from string, to string, flag uint32) (err error) {
+ return renamexNp(from, to, flag)
+}
+
+//sys renameatxNp(fromfd int, from string, tofd int, to string, flag uint32) (err error)
+
+func RenameatxNp(fromfd int, from string, tofd int, to string, flag uint32) (err error) {
+ return renameatxNp(fromfd, from, tofd, to, flag)
+}
+
//sys sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS_SYSCTL
func Uname(uname *Utsname) error {
@@ -542,6 +554,55 @@ func SysctlKinfoProcSlice(name string, args ...int) ([]KinfoProc, error) {
}
}
+//sys pthread_chdir_np(path string) (err error)
+
+func PthreadChdir(path string) (err error) {
+ return pthread_chdir_np(path)
+}
+
+//sys pthread_fchdir_np(fd int) (err error)
+
+func PthreadFchdir(fd int) (err error) {
+ return pthread_fchdir_np(fd)
+}
+
+// Connectx calls connectx(2) to initiate a connection on a socket.
+//
+// srcIf, srcAddr, and dstAddr are filled into a [SaEndpoints] struct and passed as the endpoints argument.
+//
+// - srcIf is the optional source interface index. 0 means unspecified.
+// - srcAddr is the optional source address. nil means unspecified.
+// - dstAddr is the destination address.
+//
+// On success, Connectx returns the number of bytes enqueued for transmission.
+func Connectx(fd int, srcIf uint32, srcAddr, dstAddr Sockaddr, associd SaeAssocID, flags uint32, iov []Iovec, connid *SaeConnID) (n uintptr, err error) {
+ endpoints := SaEndpoints{
+ Srcif: srcIf,
+ }
+
+ if srcAddr != nil {
+ addrp, addrlen, err := srcAddr.sockaddr()
+ if err != nil {
+ return 0, err
+ }
+ endpoints.Srcaddr = (*RawSockaddr)(addrp)
+ endpoints.Srcaddrlen = uint32(addrlen)
+ }
+
+ if dstAddr != nil {
+ addrp, addrlen, err := dstAddr.sockaddr()
+ if err != nil {
+ return 0, err
+ }
+ endpoints.Dstaddr = (*RawSockaddr)(addrp)
+ endpoints.Dstaddrlen = uint32(addrlen)
+ }
+
+ err = connectx(fd, &endpoints, associd, flags, iov, &n, connid)
+ return
+}
+
+//sys connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error)
//sys sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error)
//sys shmat(id int, addr uintptr, flag int) (ret uintptr, err error)
diff --git a/vendor/golang.org/x/sys/unix/syscall_hurd.go b/vendor/golang.org/x/sys/unix/syscall_hurd.go
index ba46651f8e..a6a2d2fc2b 100644
--- a/vendor/golang.org/x/sys/unix/syscall_hurd.go
+++ b/vendor/golang.org/x/sys/unix/syscall_hurd.go
@@ -11,6 +11,7 @@ package unix
int ioctl(int, unsigned long int, uintptr_t);
*/
import "C"
+import "unsafe"
func ioctl(fd int, req uint, arg uintptr) (err error) {
r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(arg))
diff --git a/vendor/golang.org/x/sys/unix/syscall_linux.go b/vendor/golang.org/x/sys/unix/syscall_linux.go
index 5682e2628a..230a94549a 100644
--- a/vendor/golang.org/x/sys/unix/syscall_linux.go
+++ b/vendor/golang.org/x/sys/unix/syscall_linux.go
@@ -1295,6 +1295,48 @@ func GetsockoptTCPInfo(fd, level, opt int) (*TCPInfo, error) {
return &value, err
}
+// GetsockoptTCPCCVegasInfo returns algorithm specific congestion control information for a socket using the "vegas"
+// algorithm.
+//
+// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option:
+//
+// algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION)
+func GetsockoptTCPCCVegasInfo(fd, level, opt int) (*TCPVegasInfo, error) {
+ var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment
+ vallen := _Socklen(SizeofTCPCCInfo)
+ err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
+ out := (*TCPVegasInfo)(unsafe.Pointer(&value[0]))
+ return out, err
+}
+
+// GetsockoptTCPCCDCTCPInfo returns algorithm specific congestion control information for a socket using the "dctp"
+// algorithm.
+//
+// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option:
+//
+// algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION)
+func GetsockoptTCPCCDCTCPInfo(fd, level, opt int) (*TCPDCTCPInfo, error) {
+ var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment
+ vallen := _Socklen(SizeofTCPCCInfo)
+ err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
+ out := (*TCPDCTCPInfo)(unsafe.Pointer(&value[0]))
+ return out, err
+}
+
+// GetsockoptTCPCCBBRInfo returns algorithm specific congestion control information for a socket using the "bbr"
+// algorithm.
+//
+// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option:
+//
+// algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION)
+func GetsockoptTCPCCBBRInfo(fd, level, opt int) (*TCPBBRInfo, error) {
+ var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment
+ vallen := _Socklen(SizeofTCPCCInfo)
+ err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
+ out := (*TCPBBRInfo)(unsafe.Pointer(&value[0]))
+ return out, err
+}
+
// GetsockoptString returns the string value of the socket option opt for the
// socket associated with fd at the given socket level.
func GetsockoptString(fd, level, opt int) (string, error) {
@@ -1818,6 +1860,7 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
//sys ClockAdjtime(clockid int32, buf *Timex) (state int, err error)
//sys ClockGetres(clockid int32, res *Timespec) (err error)
//sys ClockGettime(clockid int32, time *Timespec) (err error)
+//sys ClockSettime(clockid int32, time *Timespec) (err error)
//sys ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error)
//sys Close(fd int) (err error)
//sys CloseRange(first uint, last uint, flags uint) (err error)
@@ -1959,7 +2002,26 @@ func Getpgrp() (pid int) {
//sysnb Getpid() (pid int)
//sysnb Getppid() (ppid int)
//sys Getpriority(which int, who int) (prio int, err error)
-//sys Getrandom(buf []byte, flags int) (n int, err error)
+
+func Getrandom(buf []byte, flags int) (n int, err error) {
+ vdsoRet, supported := vgetrandom(buf, uint32(flags))
+ if supported {
+ if vdsoRet < 0 {
+ return 0, errnoErr(syscall.Errno(-vdsoRet))
+ }
+ return vdsoRet, nil
+ }
+ var p *byte
+ if len(buf) > 0 {
+ p = &buf[0]
+ }
+ r, _, e := Syscall(SYS_GETRANDOM, uintptr(unsafe.Pointer(p)), uintptr(len(buf)), uintptr(flags))
+ if e != 0 {
+ return 0, errnoErr(e)
+ }
+ return int(r), nil
+}
+
//sysnb Getrusage(who int, rusage *Rusage) (err error)
//sysnb Getsid(pid int) (sid int, err error)
//sysnb Gettid() (tid int)
@@ -2592,3 +2654,4 @@ func SchedGetAttr(pid int, flags uint) (*SchedAttr, error) {
}
//sys Cachestat(fd uint, crange *CachestatRange, cstat *Cachestat_t, flags uint) (err error)
+//sys Mseal(b []byte, flags uint) (err error)
diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go b/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go
index cf2ee6c75e..745e5c7e6c 100644
--- a/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go
@@ -182,3 +182,5 @@ func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error
}
return kexecFileLoad(kernelFd, initrdFd, cmdlineLen, cmdline, flags)
}
+
+const SYS_FSTATAT = SYS_NEWFSTATAT
diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go b/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go
index 3d0e98451f..dd2262a407 100644
--- a/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go
+++ b/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go
@@ -214,3 +214,5 @@ func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error
}
return kexecFileLoad(kernelFd, initrdFd, cmdlineLen, cmdline, flags)
}
+
+const SYS_FSTATAT = SYS_NEWFSTATAT
diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go b/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go
index 6f5a288944..8cf3670bda 100644
--- a/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go
@@ -187,3 +187,5 @@ func RISCVHWProbe(pairs []RISCVHWProbePairs, set *CPUSet, flags uint) (err error
}
return riscvHWProbe(pairs, setSize, set, flags)
}
+
+const SYS_FSTATAT = SYS_NEWFSTATAT
diff --git a/vendor/golang.org/x/sys/unix/syscall_openbsd.go b/vendor/golang.org/x/sys/unix/syscall_openbsd.go
index b25343c71a..b86ded549c 100644
--- a/vendor/golang.org/x/sys/unix/syscall_openbsd.go
+++ b/vendor/golang.org/x/sys/unix/syscall_openbsd.go
@@ -293,6 +293,7 @@ func Uname(uname *Utsname) error {
//sys Mkfifoat(dirfd int, path string, mode uint32) (err error)
//sys Mknod(path string, mode uint32, dev int) (err error)
//sys Mknodat(dirfd int, path string, mode uint32, dev int) (err error)
+//sys Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error)
//sys Nanosleep(time *Timespec, leftover *Timespec) (err error)
//sys Open(path string, mode int, perm uint32) (fd int, err error)
//sys Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error)
diff --git a/vendor/golang.org/x/sys/unix/syscall_unix.go b/vendor/golang.org/x/sys/unix/syscall_unix.go
index 77081de8c7..4e92e5aa40 100644
--- a/vendor/golang.org/x/sys/unix/syscall_unix.go
+++ b/vendor/golang.org/x/sys/unix/syscall_unix.go
@@ -154,6 +154,15 @@ func Munmap(b []byte) (err error) {
return mapper.Munmap(b)
}
+func MmapPtr(fd int, offset int64, addr unsafe.Pointer, length uintptr, prot int, flags int) (ret unsafe.Pointer, err error) {
+ xaddr, err := mapper.mmap(uintptr(addr), length, prot, flags, fd, offset)
+ return unsafe.Pointer(xaddr), err
+}
+
+func MunmapPtr(addr unsafe.Pointer, length uintptr) (err error) {
+ return mapper.munmap(uintptr(addr), length)
+}
+
func Read(fd int, p []byte) (n int, err error) {
n, err = read(fd, p)
if raceenabled {
diff --git a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
index 312ae6ac1d..7bf5c04bb0 100644
--- a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
+++ b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
@@ -768,6 +768,15 @@ func Munmap(b []byte) (err error) {
return mapper.Munmap(b)
}
+func MmapPtr(fd int, offset int64, addr unsafe.Pointer, length uintptr, prot int, flags int) (ret unsafe.Pointer, err error) {
+ xaddr, err := mapper.mmap(uintptr(addr), length, prot, flags, fd, offset)
+ return unsafe.Pointer(xaddr), err
+}
+
+func MunmapPtr(addr unsafe.Pointer, length uintptr) (err error) {
+ return mapper.munmap(uintptr(addr), length)
+}
+
//sys Gethostname(buf []byte) (err error) = SYS___GETHOSTNAME_A
//sysnb Getgid() (gid int)
//sysnb Getpid() (pid int)
@@ -816,10 +825,10 @@ func Lstat(path string, stat *Stat_t) (err error) {
// for checking symlinks begins with $VERSION/ $SYSNAME/ $SYSSYMR/ $SYSSYMA/
func isSpecialPath(path []byte) (v bool) {
var special = [4][8]byte{
- [8]byte{'V', 'E', 'R', 'S', 'I', 'O', 'N', '/'},
- [8]byte{'S', 'Y', 'S', 'N', 'A', 'M', 'E', '/'},
- [8]byte{'S', 'Y', 'S', 'S', 'Y', 'M', 'R', '/'},
- [8]byte{'S', 'Y', 'S', 'S', 'Y', 'M', 'A', '/'}}
+ {'V', 'E', 'R', 'S', 'I', 'O', 'N', '/'},
+ {'S', 'Y', 'S', 'N', 'A', 'M', 'E', '/'},
+ {'S', 'Y', 'S', 'S', 'Y', 'M', 'R', '/'},
+ {'S', 'Y', 'S', 'S', 'Y', 'M', 'A', '/'}}
var i, j int
for i = 0; i < len(special); i++ {
@@ -3115,3 +3124,90 @@ func legacy_Mkfifoat(dirfd int, path string, mode uint32) (err error) {
//sys Posix_openpt(oflag int) (fd int, err error) = SYS_POSIX_OPENPT
//sys Grantpt(fildes int) (rc int, err error) = SYS_GRANTPT
//sys Unlockpt(fildes int) (rc int, err error) = SYS_UNLOCKPT
+
+func fcntlAsIs(fd uintptr, cmd int, arg uintptr) (val int, err error) {
+ runtime.EnterSyscall()
+ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCNTL<<4, uintptr(fd), uintptr(cmd), arg)
+ runtime.ExitSyscall()
+ val = int(r0)
+ if int64(r0) == -1 {
+ err = errnoErr2(e1, e2)
+ }
+ return
+}
+
+func Fcntl(fd uintptr, cmd int, op interface{}) (ret int, err error) {
+ switch op.(type) {
+ case *Flock_t:
+ err = FcntlFlock(fd, cmd, op.(*Flock_t))
+ if err != nil {
+ ret = -1
+ }
+ return
+ case int:
+ return FcntlInt(fd, cmd, op.(int))
+ case *F_cnvrt:
+ return fcntlAsIs(fd, cmd, uintptr(unsafe.Pointer(op.(*F_cnvrt))))
+ case unsafe.Pointer:
+ return fcntlAsIs(fd, cmd, uintptr(op.(unsafe.Pointer)))
+ default:
+ return -1, EINVAL
+ }
+ return
+}
+
+func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
+ if raceenabled {
+ raceReleaseMerge(unsafe.Pointer(&ioSync))
+ }
+ return sendfile(outfd, infd, offset, count)
+}
+
+func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
+ // TODO: use LE call instead if the call is implemented
+ originalOffset, err := Seek(infd, 0, SEEK_CUR)
+ if err != nil {
+ return -1, err
+ }
+ //start reading data from in_fd
+ if offset != nil {
+ _, err := Seek(infd, *offset, SEEK_SET)
+ if err != nil {
+ return -1, err
+ }
+ }
+
+ buf := make([]byte, count)
+ readBuf := make([]byte, 0)
+ var n int = 0
+ for i := 0; i < count; i += n {
+ n, err := Read(infd, buf)
+ if n == 0 {
+ if err != nil {
+ return -1, err
+ } else { // EOF
+ break
+ }
+ }
+ readBuf = append(readBuf, buf...)
+ buf = buf[0:0]
+ }
+
+ n2, err := Write(outfd, readBuf)
+ if err != nil {
+ return -1, err
+ }
+
+ //When sendfile() returns, this variable will be set to the
+ // offset of the byte following the last byte that was read.
+ if offset != nil {
+ *offset = *offset + int64(n)
+ // If offset is not NULL, then sendfile() does not modify the file
+ // offset of in_fd
+ _, err := Seek(infd, originalOffset, SEEK_SET)
+ if err != nil {
+ return -1, err
+ }
+ }
+ return n2, nil
+}
diff --git a/vendor/golang.org/x/sys/unix/vgetrandom_linux.go b/vendor/golang.org/x/sys/unix/vgetrandom_linux.go
new file mode 100644
index 0000000000..07ac8e09d1
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/vgetrandom_linux.go
@@ -0,0 +1,13 @@
+// Copyright 2024 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 linux && go1.24
+
+package unix
+
+import _ "unsafe"
+
+//go:linkname vgetrandom runtime.vgetrandom
+//go:noescape
+func vgetrandom(p []byte, flags uint32) (ret int, supported bool)
diff --git a/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go b/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go
new file mode 100644
index 0000000000..297e97bce9
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go
@@ -0,0 +1,11 @@
+// Copyright 2024 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 !linux || !go1.24
+
+package unix
+
+func vgetrandom(p []byte, flags uint32) (ret int, supported bool) {
+ return -1, false
+}
diff --git a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
index e40fa85245..d73c4652e6 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
@@ -237,6 +237,9 @@ const (
CLOCK_UPTIME_RAW_APPROX = 0x9
CLONE_NOFOLLOW = 0x1
CLONE_NOOWNERCOPY = 0x2
+ CONNECT_DATA_AUTHENTICATED = 0x4
+ CONNECT_DATA_IDEMPOTENT = 0x2
+ CONNECT_RESUME_ON_READ_WRITE = 0x1
CR0 = 0x0
CR1 = 0x1000
CR2 = 0x2000
@@ -1169,6 +1172,11 @@ const (
PT_WRITE_D = 0x5
PT_WRITE_I = 0x4
PT_WRITE_U = 0x6
+ RENAME_EXCL = 0x4
+ RENAME_NOFOLLOW_ANY = 0x10
+ RENAME_RESERVED1 = 0x8
+ RENAME_SECLUDE = 0x1
+ RENAME_SWAP = 0x2
RLIMIT_AS = 0x5
RLIMIT_CORE = 0x4
RLIMIT_CPU = 0x0
@@ -1260,6 +1268,10 @@ const (
RTV_SSTHRESH = 0x20
RUSAGE_CHILDREN = -0x1
RUSAGE_SELF = 0x0
+ SAE_ASSOCID_ALL = 0xffffffff
+ SAE_ASSOCID_ANY = 0x0
+ SAE_CONNID_ALL = 0xffffffff
+ SAE_CONNID_ANY = 0x0
SCM_CREDS = 0x3
SCM_RIGHTS = 0x1
SCM_TIMESTAMP = 0x2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
index bb02aa6c05..4a55a40058 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
@@ -237,6 +237,9 @@ const (
CLOCK_UPTIME_RAW_APPROX = 0x9
CLONE_NOFOLLOW = 0x1
CLONE_NOOWNERCOPY = 0x2
+ CONNECT_DATA_AUTHENTICATED = 0x4
+ CONNECT_DATA_IDEMPOTENT = 0x2
+ CONNECT_RESUME_ON_READ_WRITE = 0x1
CR0 = 0x0
CR1 = 0x1000
CR2 = 0x2000
@@ -1169,6 +1172,11 @@ const (
PT_WRITE_D = 0x5
PT_WRITE_I = 0x4
PT_WRITE_U = 0x6
+ RENAME_EXCL = 0x4
+ RENAME_NOFOLLOW_ANY = 0x10
+ RENAME_RESERVED1 = 0x8
+ RENAME_SECLUDE = 0x1
+ RENAME_SWAP = 0x2
RLIMIT_AS = 0x5
RLIMIT_CORE = 0x4
RLIMIT_CPU = 0x0
@@ -1260,6 +1268,10 @@ const (
RTV_SSTHRESH = 0x20
RUSAGE_CHILDREN = -0x1
RUSAGE_SELF = 0x0
+ SAE_ASSOCID_ALL = 0xffffffff
+ SAE_ASSOCID_ANY = 0x0
+ SAE_CONNID_ALL = 0xffffffff
+ SAE_CONNID_ANY = 0x0
SCM_CREDS = 0x3
SCM_RIGHTS = 0x1
SCM_TIMESTAMP = 0x2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux.go b/vendor/golang.org/x/sys/unix/zerrors_linux.go
index 877a62b479..ccba391c9f 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux.go
@@ -457,6 +457,7 @@ const (
B600 = 0x8
B75 = 0x2
B9600 = 0xd
+ BCACHEFS_SUPER_MAGIC = 0xca451a4e
BDEVFS_MAGIC = 0x62646576
BINDERFS_SUPER_MAGIC = 0x6c6f6f70
BINFMTFS_MAGIC = 0x42494e4d
@@ -494,6 +495,7 @@ const (
BPF_F_TEST_REG_INVARIANTS = 0x80
BPF_F_TEST_RND_HI32 = 0x4
BPF_F_TEST_RUN_ON_CPU = 0x1
+ BPF_F_TEST_SKB_CHECKSUM_COMPLETE = 0x4
BPF_F_TEST_STATE_FREQ = 0x8
BPF_F_TEST_XDP_LIVE_FRAMES = 0x2
BPF_F_XDP_DEV_BOUND_ONLY = 0x40
@@ -928,6 +930,7 @@ const (
EPOLL_CTL_ADD = 0x1
EPOLL_CTL_DEL = 0x2
EPOLL_CTL_MOD = 0x3
+ EPOLL_IOC_TYPE = 0x8a
EROFS_SUPER_MAGIC_V1 = 0xe0f5e1e2
ESP_V4_FLOW = 0xa
ESP_V6_FLOW = 0xc
@@ -941,9 +944,6 @@ const (
ETHTOOL_FEC_OFF = 0x4
ETHTOOL_FEC_RS = 0x8
ETHTOOL_FLAG_ALL = 0x7
- ETHTOOL_FLAG_COMPACT_BITSETS = 0x1
- ETHTOOL_FLAG_OMIT_REPLY = 0x2
- ETHTOOL_FLAG_STATS = 0x4
ETHTOOL_FLASHDEV = 0x33
ETHTOOL_FLASH_MAX_FILENAME = 0x80
ETHTOOL_FWVERS_LEN = 0x20
@@ -1705,6 +1705,7 @@ const (
KEXEC_ARCH_S390 = 0x160000
KEXEC_ARCH_SH = 0x2a0000
KEXEC_ARCH_X86_64 = 0x3e0000
+ KEXEC_CRASH_HOTPLUG_SUPPORT = 0x8
KEXEC_FILE_DEBUG = 0x8
KEXEC_FILE_NO_INITRAMFS = 0x4
KEXEC_FILE_ON_CRASH = 0x2
@@ -1780,6 +1781,7 @@ const (
KEY_SPEC_USER_KEYRING = -0x4
KEY_SPEC_USER_SESSION_KEYRING = -0x5
LANDLOCK_ACCESS_FS_EXECUTE = 0x1
+ LANDLOCK_ACCESS_FS_IOCTL_DEV = 0x8000
LANDLOCK_ACCESS_FS_MAKE_BLOCK = 0x800
LANDLOCK_ACCESS_FS_MAKE_CHAR = 0x40
LANDLOCK_ACCESS_FS_MAKE_DIR = 0x80
@@ -1861,6 +1863,19 @@ const (
MAP_FILE = 0x0
MAP_FIXED = 0x10
MAP_FIXED_NOREPLACE = 0x100000
+ MAP_HUGE_16GB = 0x88000000
+ MAP_HUGE_16KB = 0x38000000
+ MAP_HUGE_16MB = 0x60000000
+ MAP_HUGE_1GB = 0x78000000
+ MAP_HUGE_1MB = 0x50000000
+ MAP_HUGE_256MB = 0x70000000
+ MAP_HUGE_2GB = 0x7c000000
+ MAP_HUGE_2MB = 0x54000000
+ MAP_HUGE_32MB = 0x64000000
+ MAP_HUGE_512KB = 0x4c000000
+ MAP_HUGE_512MB = 0x74000000
+ MAP_HUGE_64KB = 0x40000000
+ MAP_HUGE_8MB = 0x5c000000
MAP_HUGE_MASK = 0x3f
MAP_HUGE_SHIFT = 0x1a
MAP_PRIVATE = 0x2
@@ -1908,6 +1923,7 @@ const (
MNT_EXPIRE = 0x4
MNT_FORCE = 0x1
MNT_ID_REQ_SIZE_VER0 = 0x18
+ MNT_ID_REQ_SIZE_VER1 = 0x20
MODULE_INIT_COMPRESSED_FILE = 0x4
MODULE_INIT_IGNORE_MODVERSIONS = 0x1
MODULE_INIT_IGNORE_VERMAGIC = 0x2
@@ -2173,7 +2189,7 @@ const (
NFT_REG_SIZE = 0x10
NFT_REJECT_ICMPX_MAX = 0x3
NFT_RT_MAX = 0x4
- NFT_SECMARK_CTX_MAXLEN = 0x100
+ NFT_SECMARK_CTX_MAXLEN = 0x1000
NFT_SET_MAXNAMELEN = 0x100
NFT_SOCKET_MAX = 0x3
NFT_TABLE_F_MASK = 0x7
@@ -2342,9 +2358,11 @@ const (
PERF_MEM_LVLNUM_IO = 0xa
PERF_MEM_LVLNUM_L1 = 0x1
PERF_MEM_LVLNUM_L2 = 0x2
+ PERF_MEM_LVLNUM_L2_MHB = 0x5
PERF_MEM_LVLNUM_L3 = 0x3
PERF_MEM_LVLNUM_L4 = 0x4
PERF_MEM_LVLNUM_LFB = 0xc
+ PERF_MEM_LVLNUM_MSC = 0x6
PERF_MEM_LVLNUM_NA = 0xf
PERF_MEM_LVLNUM_PMEM = 0xe
PERF_MEM_LVLNUM_RAM = 0xd
@@ -2417,6 +2435,7 @@ const (
PRIO_PGRP = 0x1
PRIO_PROCESS = 0x0
PRIO_USER = 0x2
+ PROCFS_IOCTL_MAGIC = 'f'
PROC_SUPER_MAGIC = 0x9fa0
PROT_EXEC = 0x4
PROT_GROWSDOWN = 0x1000000
@@ -2498,6 +2517,23 @@ const (
PR_PAC_GET_ENABLED_KEYS = 0x3d
PR_PAC_RESET_KEYS = 0x36
PR_PAC_SET_ENABLED_KEYS = 0x3c
+ PR_PPC_DEXCR_CTRL_CLEAR = 0x4
+ PR_PPC_DEXCR_CTRL_CLEAR_ONEXEC = 0x10
+ PR_PPC_DEXCR_CTRL_EDITABLE = 0x1
+ PR_PPC_DEXCR_CTRL_MASK = 0x1f
+ PR_PPC_DEXCR_CTRL_SET = 0x2
+ PR_PPC_DEXCR_CTRL_SET_ONEXEC = 0x8
+ PR_PPC_DEXCR_IBRTPD = 0x1
+ PR_PPC_DEXCR_NPHIE = 0x3
+ PR_PPC_DEXCR_SBHE = 0x0
+ PR_PPC_DEXCR_SRAPD = 0x2
+ PR_PPC_GET_DEXCR = 0x48
+ PR_PPC_SET_DEXCR = 0x49
+ PR_RISCV_CTX_SW_FENCEI_OFF = 0x1
+ PR_RISCV_CTX_SW_FENCEI_ON = 0x0
+ PR_RISCV_SCOPE_PER_PROCESS = 0x0
+ PR_RISCV_SCOPE_PER_THREAD = 0x1
+ PR_RISCV_SET_ICACHE_FLUSH_CTX = 0x47
PR_RISCV_V_GET_CONTROL = 0x46
PR_RISCV_V_SET_CONTROL = 0x45
PR_RISCV_V_VSTATE_CTRL_CUR_MASK = 0x3
@@ -2589,6 +2625,28 @@ const (
PR_UNALIGN_NOPRINT = 0x1
PR_UNALIGN_SIGBUS = 0x2
PSTOREFS_MAGIC = 0x6165676c
+ PTP_CLK_MAGIC = '='
+ PTP_ENABLE_FEATURE = 0x1
+ PTP_EXTTS_EDGES = 0x6
+ PTP_EXTTS_EVENT_VALID = 0x1
+ PTP_EXTTS_V1_VALID_FLAGS = 0x7
+ PTP_EXTTS_VALID_FLAGS = 0x1f
+ PTP_EXT_OFFSET = 0x10
+ PTP_FALLING_EDGE = 0x4
+ PTP_MAX_SAMPLES = 0x19
+ PTP_PEROUT_DUTY_CYCLE = 0x2
+ PTP_PEROUT_ONE_SHOT = 0x1
+ PTP_PEROUT_PHASE = 0x4
+ PTP_PEROUT_V1_VALID_FLAGS = 0x0
+ PTP_PEROUT_VALID_FLAGS = 0x7
+ PTP_PIN_GETFUNC = 0xc0603d06
+ PTP_PIN_GETFUNC2 = 0xc0603d0f
+ PTP_RISING_EDGE = 0x2
+ PTP_STRICT_FLAGS = 0x8
+ PTP_SYS_OFFSET_EXTENDED = 0xc4c03d09
+ PTP_SYS_OFFSET_EXTENDED2 = 0xc4c03d12
+ PTP_SYS_OFFSET_PRECISE = 0xc0403d08
+ PTP_SYS_OFFSET_PRECISE2 = 0xc0403d11
PTRACE_ATTACH = 0x10
PTRACE_CONT = 0x7
PTRACE_DETACH = 0x11
@@ -2902,11 +2960,12 @@ const (
RUSAGE_SELF = 0x0
RUSAGE_THREAD = 0x1
RWF_APPEND = 0x10
+ RWF_ATOMIC = 0x40
RWF_DSYNC = 0x2
RWF_HIPRI = 0x1
RWF_NOAPPEND = 0x20
RWF_NOWAIT = 0x8
- RWF_SUPPORTED = 0x3f
+ RWF_SUPPORTED = 0x7f
RWF_SYNC = 0x4
RWF_WRITE_LIFE_NOT_SET = 0x0
SCHED_BATCH = 0x3
@@ -3179,6 +3238,7 @@ const (
STATX_ATTR_MOUNT_ROOT = 0x2000
STATX_ATTR_NODUMP = 0x40
STATX_ATTR_VERITY = 0x100000
+ STATX_ATTR_WRITE_ATOMIC = 0x400000
STATX_BASIC_STATS = 0x7ff
STATX_BLOCKS = 0x400
STATX_BTIME = 0x800
@@ -3192,8 +3252,10 @@ const (
STATX_MTIME = 0x40
STATX_NLINK = 0x4
STATX_SIZE = 0x200
+ STATX_SUBVOL = 0x8000
STATX_TYPE = 0x1
STATX_UID = 0x8
+ STATX_WRITE_ATOMIC = 0x10000
STATX__RESERVED = 0x80000000
SYNC_FILE_RANGE_WAIT_AFTER = 0x4
SYNC_FILE_RANGE_WAIT_BEFORE = 0x1
@@ -3592,6 +3654,7 @@ const (
XDP_UMEM_PGOFF_COMPLETION_RING = 0x180000000
XDP_UMEM_PGOFF_FILL_RING = 0x100000000
XDP_UMEM_REG = 0x4
+ XDP_UMEM_TX_METADATA_LEN = 0x4
XDP_UMEM_TX_SW_CSUM = 0x2
XDP_UMEM_UNALIGNED_CHUNK_FLAG = 0x1
XDP_USE_NEED_WAKEUP = 0x8
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
index e4bc0bd57c..0c00cb3f3a 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
@@ -78,6 +78,8 @@ const (
ECHOPRT = 0x400
EFD_CLOEXEC = 0x80000
EFD_NONBLOCK = 0x800
+ EPIOCGPARAMS = 0x80088a02
+ EPIOCSPARAMS = 0x40088a01
EPOLL_CLOEXEC = 0x80000
EXTPROC = 0x10000
FF1 = 0x8000
@@ -151,9 +153,14 @@ const (
NFDBITS = 0x20
NLDLY = 0x100
NOFLSH = 0x80
+ NS_GET_MNTNS_ID = 0x8008b705
NS_GET_NSTYPE = 0xb703
NS_GET_OWNER_UID = 0xb704
NS_GET_PARENT = 0xb702
+ NS_GET_PID_FROM_PIDNS = 0x8004b706
+ NS_GET_PID_IN_PIDNS = 0x8004b708
+ NS_GET_TGID_FROM_PIDNS = 0x8004b707
+ NS_GET_TGID_IN_PIDNS = 0x8004b709
NS_GET_USERNS = 0xb701
OLCUC = 0x2
ONLCR = 0x4
@@ -230,6 +237,20 @@ const (
PPPIOCUNBRIDGECHAN = 0x7434
PPPIOCXFERUNIT = 0x744e
PR_SET_PTRACER_ANY = 0xffffffff
+ PTP_CLOCK_GETCAPS = 0x80503d01
+ PTP_CLOCK_GETCAPS2 = 0x80503d0a
+ PTP_ENABLE_PPS = 0x40043d04
+ PTP_ENABLE_PPS2 = 0x40043d0d
+ PTP_EXTTS_REQUEST = 0x40103d02
+ PTP_EXTTS_REQUEST2 = 0x40103d0b
+ PTP_MASK_CLEAR_ALL = 0x3d13
+ PTP_MASK_EN_SINGLE = 0x40043d14
+ PTP_PEROUT_REQUEST = 0x40383d03
+ PTP_PEROUT_REQUEST2 = 0x40383d0c
+ PTP_PIN_SETFUNC = 0x40603d07
+ PTP_PIN_SETFUNC2 = 0x40603d10
+ PTP_SYS_OFFSET = 0x43403d05
+ PTP_SYS_OFFSET2 = 0x43403d0e
PTRACE_GETFPREGS = 0xe
PTRACE_GETFPXREGS = 0x12
PTRACE_GET_THREAD_AREA = 0x19
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
index 689317afdb..dfb364554d 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
@@ -78,6 +78,8 @@ const (
ECHOPRT = 0x400
EFD_CLOEXEC = 0x80000
EFD_NONBLOCK = 0x800
+ EPIOCGPARAMS = 0x80088a02
+ EPIOCSPARAMS = 0x40088a01
EPOLL_CLOEXEC = 0x80000
EXTPROC = 0x10000
FF1 = 0x8000
@@ -151,9 +153,14 @@ const (
NFDBITS = 0x40
NLDLY = 0x100
NOFLSH = 0x80
+ NS_GET_MNTNS_ID = 0x8008b705
NS_GET_NSTYPE = 0xb703
NS_GET_OWNER_UID = 0xb704
NS_GET_PARENT = 0xb702
+ NS_GET_PID_FROM_PIDNS = 0x8004b706
+ NS_GET_PID_IN_PIDNS = 0x8004b708
+ NS_GET_TGID_FROM_PIDNS = 0x8004b707
+ NS_GET_TGID_IN_PIDNS = 0x8004b709
NS_GET_USERNS = 0xb701
OLCUC = 0x2
ONLCR = 0x4
@@ -230,6 +237,20 @@ const (
PPPIOCUNBRIDGECHAN = 0x7434
PPPIOCXFERUNIT = 0x744e
PR_SET_PTRACER_ANY = 0xffffffffffffffff
+ PTP_CLOCK_GETCAPS = 0x80503d01
+ PTP_CLOCK_GETCAPS2 = 0x80503d0a
+ PTP_ENABLE_PPS = 0x40043d04
+ PTP_ENABLE_PPS2 = 0x40043d0d
+ PTP_EXTTS_REQUEST = 0x40103d02
+ PTP_EXTTS_REQUEST2 = 0x40103d0b
+ PTP_MASK_CLEAR_ALL = 0x3d13
+ PTP_MASK_EN_SINGLE = 0x40043d14
+ PTP_PEROUT_REQUEST = 0x40383d03
+ PTP_PEROUT_REQUEST2 = 0x40383d0c
+ PTP_PIN_SETFUNC = 0x40603d07
+ PTP_PIN_SETFUNC2 = 0x40603d10
+ PTP_SYS_OFFSET = 0x43403d05
+ PTP_SYS_OFFSET2 = 0x43403d0e
PTRACE_ARCH_PRCTL = 0x1e
PTRACE_GETFPREGS = 0xe
PTRACE_GETFPXREGS = 0x12
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
index 5cca668ac3..d46dcf78ab 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
@@ -78,6 +78,8 @@ const (
ECHOPRT = 0x400
EFD_CLOEXEC = 0x80000
EFD_NONBLOCK = 0x800
+ EPIOCGPARAMS = 0x80088a02
+ EPIOCSPARAMS = 0x40088a01
EPOLL_CLOEXEC = 0x80000
EXTPROC = 0x10000
FF1 = 0x8000
@@ -148,9 +150,14 @@ const (
NFDBITS = 0x20
NLDLY = 0x100
NOFLSH = 0x80
+ NS_GET_MNTNS_ID = 0x8008b705
NS_GET_NSTYPE = 0xb703
NS_GET_OWNER_UID = 0xb704
NS_GET_PARENT = 0xb702
+ NS_GET_PID_FROM_PIDNS = 0x8004b706
+ NS_GET_PID_IN_PIDNS = 0x8004b708
+ NS_GET_TGID_FROM_PIDNS = 0x8004b707
+ NS_GET_TGID_IN_PIDNS = 0x8004b709
NS_GET_USERNS = 0xb701
OLCUC = 0x2
ONLCR = 0x4
@@ -227,6 +234,20 @@ const (
PPPIOCUNBRIDGECHAN = 0x7434
PPPIOCXFERUNIT = 0x744e
PR_SET_PTRACER_ANY = 0xffffffff
+ PTP_CLOCK_GETCAPS = 0x80503d01
+ PTP_CLOCK_GETCAPS2 = 0x80503d0a
+ PTP_ENABLE_PPS = 0x40043d04
+ PTP_ENABLE_PPS2 = 0x40043d0d
+ PTP_EXTTS_REQUEST = 0x40103d02
+ PTP_EXTTS_REQUEST2 = 0x40103d0b
+ PTP_MASK_CLEAR_ALL = 0x3d13
+ PTP_MASK_EN_SINGLE = 0x40043d14
+ PTP_PEROUT_REQUEST = 0x40383d03
+ PTP_PEROUT_REQUEST2 = 0x40383d0c
+ PTP_PIN_SETFUNC = 0x40603d07
+ PTP_PIN_SETFUNC2 = 0x40603d10
+ PTP_SYS_OFFSET = 0x43403d05
+ PTP_SYS_OFFSET2 = 0x43403d0e
PTRACE_GETCRUNCHREGS = 0x19
PTRACE_GETFDPIC = 0x1f
PTRACE_GETFDPIC_EXEC = 0x0
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
index 14270508b0..3af3248a7f 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
@@ -78,6 +78,8 @@ const (
ECHOPRT = 0x400
EFD_CLOEXEC = 0x80000
EFD_NONBLOCK = 0x800
+ EPIOCGPARAMS = 0x80088a02
+ EPIOCSPARAMS = 0x40088a01
EPOLL_CLOEXEC = 0x80000
ESR_MAGIC = 0x45535201
EXTPROC = 0x10000
@@ -152,9 +154,14 @@ const (
NFDBITS = 0x40
NLDLY = 0x100
NOFLSH = 0x80
+ NS_GET_MNTNS_ID = 0x8008b705
NS_GET_NSTYPE = 0xb703
NS_GET_OWNER_UID = 0xb704
NS_GET_PARENT = 0xb702
+ NS_GET_PID_FROM_PIDNS = 0x8004b706
+ NS_GET_PID_IN_PIDNS = 0x8004b708
+ NS_GET_TGID_FROM_PIDNS = 0x8004b707
+ NS_GET_TGID_IN_PIDNS = 0x8004b709
NS_GET_USERNS = 0xb701
OLCUC = 0x2
ONLCR = 0x4
@@ -233,6 +240,20 @@ const (
PROT_BTI = 0x10
PROT_MTE = 0x20
PR_SET_PTRACER_ANY = 0xffffffffffffffff
+ PTP_CLOCK_GETCAPS = 0x80503d01
+ PTP_CLOCK_GETCAPS2 = 0x80503d0a
+ PTP_ENABLE_PPS = 0x40043d04
+ PTP_ENABLE_PPS2 = 0x40043d0d
+ PTP_EXTTS_REQUEST = 0x40103d02
+ PTP_EXTTS_REQUEST2 = 0x40103d0b
+ PTP_MASK_CLEAR_ALL = 0x3d13
+ PTP_MASK_EN_SINGLE = 0x40043d14
+ PTP_PEROUT_REQUEST = 0x40383d03
+ PTP_PEROUT_REQUEST2 = 0x40383d0c
+ PTP_PIN_SETFUNC = 0x40603d07
+ PTP_PIN_SETFUNC2 = 0x40603d10
+ PTP_SYS_OFFSET = 0x43403d05
+ PTP_SYS_OFFSET2 = 0x43403d0e
PTRACE_PEEKMTETAGS = 0x21
PTRACE_POKEMTETAGS = 0x22
PTRACE_SYSEMU = 0x1f
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go
index 28e39afdcb..292bcf0283 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go
@@ -78,6 +78,8 @@ const (
ECHOPRT = 0x400
EFD_CLOEXEC = 0x80000
EFD_NONBLOCK = 0x800
+ EPIOCGPARAMS = 0x80088a02
+ EPIOCSPARAMS = 0x40088a01
EPOLL_CLOEXEC = 0x80000
EXTPROC = 0x10000
FF1 = 0x8000
@@ -152,9 +154,14 @@ const (
NFDBITS = 0x40
NLDLY = 0x100
NOFLSH = 0x80
+ NS_GET_MNTNS_ID = 0x8008b705
NS_GET_NSTYPE = 0xb703
NS_GET_OWNER_UID = 0xb704
NS_GET_PARENT = 0xb702
+ NS_GET_PID_FROM_PIDNS = 0x8004b706
+ NS_GET_PID_IN_PIDNS = 0x8004b708
+ NS_GET_TGID_FROM_PIDNS = 0x8004b707
+ NS_GET_TGID_IN_PIDNS = 0x8004b709
NS_GET_USERNS = 0xb701
OLCUC = 0x2
ONLCR = 0x4
@@ -231,6 +238,20 @@ const (
PPPIOCUNBRIDGECHAN = 0x7434
PPPIOCXFERUNIT = 0x744e
PR_SET_PTRACER_ANY = 0xffffffffffffffff
+ PTP_CLOCK_GETCAPS = 0x80503d01
+ PTP_CLOCK_GETCAPS2 = 0x80503d0a
+ PTP_ENABLE_PPS = 0x40043d04
+ PTP_ENABLE_PPS2 = 0x40043d0d
+ PTP_EXTTS_REQUEST = 0x40103d02
+ PTP_EXTTS_REQUEST2 = 0x40103d0b
+ PTP_MASK_CLEAR_ALL = 0x3d13
+ PTP_MASK_EN_SINGLE = 0x40043d14
+ PTP_PEROUT_REQUEST = 0x40383d03
+ PTP_PEROUT_REQUEST2 = 0x40383d0c
+ PTP_PIN_SETFUNC = 0x40603d07
+ PTP_PIN_SETFUNC2 = 0x40603d10
+ PTP_SYS_OFFSET = 0x43403d05
+ PTP_SYS_OFFSET2 = 0x43403d0e
PTRACE_SYSEMU = 0x1f
PTRACE_SYSEMU_SINGLESTEP = 0x20
RLIMIT_AS = 0x9
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
index cd66e92cb4..782b7110fa 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
@@ -78,6 +78,8 @@ const (
ECHOPRT = 0x400
EFD_CLOEXEC = 0x80000
EFD_NONBLOCK = 0x80
+ EPIOCGPARAMS = 0x40088a02
+ EPIOCSPARAMS = 0x80088a01
EPOLL_CLOEXEC = 0x80000
EXTPROC = 0x10000
FF1 = 0x8000
@@ -148,9 +150,14 @@ const (
NFDBITS = 0x20
NLDLY = 0x100
NOFLSH = 0x80
+ NS_GET_MNTNS_ID = 0x4008b705
NS_GET_NSTYPE = 0x2000b703
NS_GET_OWNER_UID = 0x2000b704
NS_GET_PARENT = 0x2000b702
+ NS_GET_PID_FROM_PIDNS = 0x4004b706
+ NS_GET_PID_IN_PIDNS = 0x4004b708
+ NS_GET_TGID_FROM_PIDNS = 0x4004b707
+ NS_GET_TGID_IN_PIDNS = 0x4004b709
NS_GET_USERNS = 0x2000b701
OLCUC = 0x2
ONLCR = 0x4
@@ -227,6 +234,20 @@ const (
PPPIOCUNBRIDGECHAN = 0x20007434
PPPIOCXFERUNIT = 0x2000744e
PR_SET_PTRACER_ANY = 0xffffffff
+ PTP_CLOCK_GETCAPS = 0x40503d01
+ PTP_CLOCK_GETCAPS2 = 0x40503d0a
+ PTP_ENABLE_PPS = 0x80043d04
+ PTP_ENABLE_PPS2 = 0x80043d0d
+ PTP_EXTTS_REQUEST = 0x80103d02
+ PTP_EXTTS_REQUEST2 = 0x80103d0b
+ PTP_MASK_CLEAR_ALL = 0x20003d13
+ PTP_MASK_EN_SINGLE = 0x80043d14
+ PTP_PEROUT_REQUEST = 0x80383d03
+ PTP_PEROUT_REQUEST2 = 0x80383d0c
+ PTP_PIN_SETFUNC = 0x80603d07
+ PTP_PIN_SETFUNC2 = 0x80603d10
+ PTP_SYS_OFFSET = 0x83403d05
+ PTP_SYS_OFFSET2 = 0x83403d0e
PTRACE_GETFPREGS = 0xe
PTRACE_GET_THREAD_AREA = 0x19
PTRACE_GET_THREAD_AREA_3264 = 0xc4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
index c1595eba78..84973fd927 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
@@ -78,6 +78,8 @@ const (
ECHOPRT = 0x400
EFD_CLOEXEC = 0x80000
EFD_NONBLOCK = 0x80
+ EPIOCGPARAMS = 0x40088a02
+ EPIOCSPARAMS = 0x80088a01
EPOLL_CLOEXEC = 0x80000
EXTPROC = 0x10000
FF1 = 0x8000
@@ -148,9 +150,14 @@ const (
NFDBITS = 0x40
NLDLY = 0x100
NOFLSH = 0x80
+ NS_GET_MNTNS_ID = 0x4008b705
NS_GET_NSTYPE = 0x2000b703
NS_GET_OWNER_UID = 0x2000b704
NS_GET_PARENT = 0x2000b702
+ NS_GET_PID_FROM_PIDNS = 0x4004b706
+ NS_GET_PID_IN_PIDNS = 0x4004b708
+ NS_GET_TGID_FROM_PIDNS = 0x4004b707
+ NS_GET_TGID_IN_PIDNS = 0x4004b709
NS_GET_USERNS = 0x2000b701
OLCUC = 0x2
ONLCR = 0x4
@@ -227,6 +234,20 @@ const (
PPPIOCUNBRIDGECHAN = 0x20007434
PPPIOCXFERUNIT = 0x2000744e
PR_SET_PTRACER_ANY = 0xffffffffffffffff
+ PTP_CLOCK_GETCAPS = 0x40503d01
+ PTP_CLOCK_GETCAPS2 = 0x40503d0a
+ PTP_ENABLE_PPS = 0x80043d04
+ PTP_ENABLE_PPS2 = 0x80043d0d
+ PTP_EXTTS_REQUEST = 0x80103d02
+ PTP_EXTTS_REQUEST2 = 0x80103d0b
+ PTP_MASK_CLEAR_ALL = 0x20003d13
+ PTP_MASK_EN_SINGLE = 0x80043d14
+ PTP_PEROUT_REQUEST = 0x80383d03
+ PTP_PEROUT_REQUEST2 = 0x80383d0c
+ PTP_PIN_SETFUNC = 0x80603d07
+ PTP_PIN_SETFUNC2 = 0x80603d10
+ PTP_SYS_OFFSET = 0x83403d05
+ PTP_SYS_OFFSET2 = 0x83403d0e
PTRACE_GETFPREGS = 0xe
PTRACE_GET_THREAD_AREA = 0x19
PTRACE_GET_THREAD_AREA_3264 = 0xc4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
index ee9456b0da..6d9cbc3b27 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
@@ -78,6 +78,8 @@ const (
ECHOPRT = 0x400
EFD_CLOEXEC = 0x80000
EFD_NONBLOCK = 0x80
+ EPIOCGPARAMS = 0x40088a02
+ EPIOCSPARAMS = 0x80088a01
EPOLL_CLOEXEC = 0x80000
EXTPROC = 0x10000
FF1 = 0x8000
@@ -148,9 +150,14 @@ const (
NFDBITS = 0x40
NLDLY = 0x100
NOFLSH = 0x80
+ NS_GET_MNTNS_ID = 0x4008b705
NS_GET_NSTYPE = 0x2000b703
NS_GET_OWNER_UID = 0x2000b704
NS_GET_PARENT = 0x2000b702
+ NS_GET_PID_FROM_PIDNS = 0x4004b706
+ NS_GET_PID_IN_PIDNS = 0x4004b708
+ NS_GET_TGID_FROM_PIDNS = 0x4004b707
+ NS_GET_TGID_IN_PIDNS = 0x4004b709
NS_GET_USERNS = 0x2000b701
OLCUC = 0x2
ONLCR = 0x4
@@ -227,6 +234,20 @@ const (
PPPIOCUNBRIDGECHAN = 0x20007434
PPPIOCXFERUNIT = 0x2000744e
PR_SET_PTRACER_ANY = 0xffffffffffffffff
+ PTP_CLOCK_GETCAPS = 0x40503d01
+ PTP_CLOCK_GETCAPS2 = 0x40503d0a
+ PTP_ENABLE_PPS = 0x80043d04
+ PTP_ENABLE_PPS2 = 0x80043d0d
+ PTP_EXTTS_REQUEST = 0x80103d02
+ PTP_EXTTS_REQUEST2 = 0x80103d0b
+ PTP_MASK_CLEAR_ALL = 0x20003d13
+ PTP_MASK_EN_SINGLE = 0x80043d14
+ PTP_PEROUT_REQUEST = 0x80383d03
+ PTP_PEROUT_REQUEST2 = 0x80383d0c
+ PTP_PIN_SETFUNC = 0x80603d07
+ PTP_PIN_SETFUNC2 = 0x80603d10
+ PTP_SYS_OFFSET = 0x83403d05
+ PTP_SYS_OFFSET2 = 0x83403d0e
PTRACE_GETFPREGS = 0xe
PTRACE_GET_THREAD_AREA = 0x19
PTRACE_GET_THREAD_AREA_3264 = 0xc4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
index 8cfca81e1b..5f9fedbce0 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
@@ -78,6 +78,8 @@ const (
ECHOPRT = 0x400
EFD_CLOEXEC = 0x80000
EFD_NONBLOCK = 0x80
+ EPIOCGPARAMS = 0x40088a02
+ EPIOCSPARAMS = 0x80088a01
EPOLL_CLOEXEC = 0x80000
EXTPROC = 0x10000
FF1 = 0x8000
@@ -148,9 +150,14 @@ const (
NFDBITS = 0x20
NLDLY = 0x100
NOFLSH = 0x80
+ NS_GET_MNTNS_ID = 0x4008b705
NS_GET_NSTYPE = 0x2000b703
NS_GET_OWNER_UID = 0x2000b704
NS_GET_PARENT = 0x2000b702
+ NS_GET_PID_FROM_PIDNS = 0x4004b706
+ NS_GET_PID_IN_PIDNS = 0x4004b708
+ NS_GET_TGID_FROM_PIDNS = 0x4004b707
+ NS_GET_TGID_IN_PIDNS = 0x4004b709
NS_GET_USERNS = 0x2000b701
OLCUC = 0x2
ONLCR = 0x4
@@ -227,6 +234,20 @@ const (
PPPIOCUNBRIDGECHAN = 0x20007434
PPPIOCXFERUNIT = 0x2000744e
PR_SET_PTRACER_ANY = 0xffffffff
+ PTP_CLOCK_GETCAPS = 0x40503d01
+ PTP_CLOCK_GETCAPS2 = 0x40503d0a
+ PTP_ENABLE_PPS = 0x80043d04
+ PTP_ENABLE_PPS2 = 0x80043d0d
+ PTP_EXTTS_REQUEST = 0x80103d02
+ PTP_EXTTS_REQUEST2 = 0x80103d0b
+ PTP_MASK_CLEAR_ALL = 0x20003d13
+ PTP_MASK_EN_SINGLE = 0x80043d14
+ PTP_PEROUT_REQUEST = 0x80383d03
+ PTP_PEROUT_REQUEST2 = 0x80383d0c
+ PTP_PIN_SETFUNC = 0x80603d07
+ PTP_PIN_SETFUNC2 = 0x80603d10
+ PTP_SYS_OFFSET = 0x83403d05
+ PTP_SYS_OFFSET2 = 0x83403d0e
PTRACE_GETFPREGS = 0xe
PTRACE_GET_THREAD_AREA = 0x19
PTRACE_GET_THREAD_AREA_3264 = 0xc4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
index 60b0deb3af..bb0026ee0c 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
@@ -78,6 +78,8 @@ const (
ECHOPRT = 0x20
EFD_CLOEXEC = 0x80000
EFD_NONBLOCK = 0x800
+ EPIOCGPARAMS = 0x40088a02
+ EPIOCSPARAMS = 0x80088a01
EPOLL_CLOEXEC = 0x80000
EXTPROC = 0x10000000
FF1 = 0x4000
@@ -150,9 +152,14 @@ const (
NL3 = 0x300
NLDLY = 0x300
NOFLSH = 0x80000000
+ NS_GET_MNTNS_ID = 0x4008b705
NS_GET_NSTYPE = 0x2000b703
NS_GET_OWNER_UID = 0x2000b704
NS_GET_PARENT = 0x2000b702
+ NS_GET_PID_FROM_PIDNS = 0x4004b706
+ NS_GET_PID_IN_PIDNS = 0x4004b708
+ NS_GET_TGID_FROM_PIDNS = 0x4004b707
+ NS_GET_TGID_IN_PIDNS = 0x4004b709
NS_GET_USERNS = 0x2000b701
OLCUC = 0x4
ONLCR = 0x2
@@ -230,6 +237,20 @@ const (
PPPIOCXFERUNIT = 0x2000744e
PROT_SAO = 0x10
PR_SET_PTRACER_ANY = 0xffffffff
+ PTP_CLOCK_GETCAPS = 0x40503d01
+ PTP_CLOCK_GETCAPS2 = 0x40503d0a
+ PTP_ENABLE_PPS = 0x80043d04
+ PTP_ENABLE_PPS2 = 0x80043d0d
+ PTP_EXTTS_REQUEST = 0x80103d02
+ PTP_EXTTS_REQUEST2 = 0x80103d0b
+ PTP_MASK_CLEAR_ALL = 0x20003d13
+ PTP_MASK_EN_SINGLE = 0x80043d14
+ PTP_PEROUT_REQUEST = 0x80383d03
+ PTP_PEROUT_REQUEST2 = 0x80383d0c
+ PTP_PIN_SETFUNC = 0x80603d07
+ PTP_PIN_SETFUNC2 = 0x80603d10
+ PTP_SYS_OFFSET = 0x83403d05
+ PTP_SYS_OFFSET2 = 0x83403d0e
PTRACE_GETEVRREGS = 0x14
PTRACE_GETFPREGS = 0xe
PTRACE_GETREGS64 = 0x16
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
index f90aa7281b..46120db5c9 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
@@ -78,6 +78,8 @@ const (
ECHOPRT = 0x20
EFD_CLOEXEC = 0x80000
EFD_NONBLOCK = 0x800
+ EPIOCGPARAMS = 0x40088a02
+ EPIOCSPARAMS = 0x80088a01
EPOLL_CLOEXEC = 0x80000
EXTPROC = 0x10000000
FF1 = 0x4000
@@ -150,9 +152,14 @@ const (
NL3 = 0x300
NLDLY = 0x300
NOFLSH = 0x80000000
+ NS_GET_MNTNS_ID = 0x4008b705
NS_GET_NSTYPE = 0x2000b703
NS_GET_OWNER_UID = 0x2000b704
NS_GET_PARENT = 0x2000b702
+ NS_GET_PID_FROM_PIDNS = 0x4004b706
+ NS_GET_PID_IN_PIDNS = 0x4004b708
+ NS_GET_TGID_FROM_PIDNS = 0x4004b707
+ NS_GET_TGID_IN_PIDNS = 0x4004b709
NS_GET_USERNS = 0x2000b701
OLCUC = 0x4
ONLCR = 0x2
@@ -230,6 +237,20 @@ const (
PPPIOCXFERUNIT = 0x2000744e
PROT_SAO = 0x10
PR_SET_PTRACER_ANY = 0xffffffffffffffff
+ PTP_CLOCK_GETCAPS = 0x40503d01
+ PTP_CLOCK_GETCAPS2 = 0x40503d0a
+ PTP_ENABLE_PPS = 0x80043d04
+ PTP_ENABLE_PPS2 = 0x80043d0d
+ PTP_EXTTS_REQUEST = 0x80103d02
+ PTP_EXTTS_REQUEST2 = 0x80103d0b
+ PTP_MASK_CLEAR_ALL = 0x20003d13
+ PTP_MASK_EN_SINGLE = 0x80043d14
+ PTP_PEROUT_REQUEST = 0x80383d03
+ PTP_PEROUT_REQUEST2 = 0x80383d0c
+ PTP_PIN_SETFUNC = 0x80603d07
+ PTP_PIN_SETFUNC2 = 0x80603d10
+ PTP_SYS_OFFSET = 0x83403d05
+ PTP_SYS_OFFSET2 = 0x83403d0e
PTRACE_GETEVRREGS = 0x14
PTRACE_GETFPREGS = 0xe
PTRACE_GETREGS64 = 0x16
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
index ba9e015033..5c951634fb 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
@@ -78,6 +78,8 @@ const (
ECHOPRT = 0x20
EFD_CLOEXEC = 0x80000
EFD_NONBLOCK = 0x800
+ EPIOCGPARAMS = 0x40088a02
+ EPIOCSPARAMS = 0x80088a01
EPOLL_CLOEXEC = 0x80000
EXTPROC = 0x10000000
FF1 = 0x4000
@@ -150,9 +152,14 @@ const (
NL3 = 0x300
NLDLY = 0x300
NOFLSH = 0x80000000
+ NS_GET_MNTNS_ID = 0x4008b705
NS_GET_NSTYPE = 0x2000b703
NS_GET_OWNER_UID = 0x2000b704
NS_GET_PARENT = 0x2000b702
+ NS_GET_PID_FROM_PIDNS = 0x4004b706
+ NS_GET_PID_IN_PIDNS = 0x4004b708
+ NS_GET_TGID_FROM_PIDNS = 0x4004b707
+ NS_GET_TGID_IN_PIDNS = 0x4004b709
NS_GET_USERNS = 0x2000b701
OLCUC = 0x4
ONLCR = 0x2
@@ -230,6 +237,20 @@ const (
PPPIOCXFERUNIT = 0x2000744e
PROT_SAO = 0x10
PR_SET_PTRACER_ANY = 0xffffffffffffffff
+ PTP_CLOCK_GETCAPS = 0x40503d01
+ PTP_CLOCK_GETCAPS2 = 0x40503d0a
+ PTP_ENABLE_PPS = 0x80043d04
+ PTP_ENABLE_PPS2 = 0x80043d0d
+ PTP_EXTTS_REQUEST = 0x80103d02
+ PTP_EXTTS_REQUEST2 = 0x80103d0b
+ PTP_MASK_CLEAR_ALL = 0x20003d13
+ PTP_MASK_EN_SINGLE = 0x80043d14
+ PTP_PEROUT_REQUEST = 0x80383d03
+ PTP_PEROUT_REQUEST2 = 0x80383d0c
+ PTP_PIN_SETFUNC = 0x80603d07
+ PTP_PIN_SETFUNC2 = 0x80603d10
+ PTP_SYS_OFFSET = 0x83403d05
+ PTP_SYS_OFFSET2 = 0x83403d0e
PTRACE_GETEVRREGS = 0x14
PTRACE_GETFPREGS = 0xe
PTRACE_GETREGS64 = 0x16
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
index 07cdfd6e9f..11a84d5af2 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
@@ -78,6 +78,8 @@ const (
ECHOPRT = 0x400
EFD_CLOEXEC = 0x80000
EFD_NONBLOCK = 0x800
+ EPIOCGPARAMS = 0x80088a02
+ EPIOCSPARAMS = 0x40088a01
EPOLL_CLOEXEC = 0x80000
EXTPROC = 0x10000
FF1 = 0x8000
@@ -148,9 +150,14 @@ const (
NFDBITS = 0x40
NLDLY = 0x100
NOFLSH = 0x80
+ NS_GET_MNTNS_ID = 0x8008b705
NS_GET_NSTYPE = 0xb703
NS_GET_OWNER_UID = 0xb704
NS_GET_PARENT = 0xb702
+ NS_GET_PID_FROM_PIDNS = 0x8004b706
+ NS_GET_PID_IN_PIDNS = 0x8004b708
+ NS_GET_TGID_FROM_PIDNS = 0x8004b707
+ NS_GET_TGID_IN_PIDNS = 0x8004b709
NS_GET_USERNS = 0xb701
OLCUC = 0x2
ONLCR = 0x4
@@ -227,6 +234,20 @@ const (
PPPIOCUNBRIDGECHAN = 0x7434
PPPIOCXFERUNIT = 0x744e
PR_SET_PTRACER_ANY = 0xffffffffffffffff
+ PTP_CLOCK_GETCAPS = 0x80503d01
+ PTP_CLOCK_GETCAPS2 = 0x80503d0a
+ PTP_ENABLE_PPS = 0x40043d04
+ PTP_ENABLE_PPS2 = 0x40043d0d
+ PTP_EXTTS_REQUEST = 0x40103d02
+ PTP_EXTTS_REQUEST2 = 0x40103d0b
+ PTP_MASK_CLEAR_ALL = 0x3d13
+ PTP_MASK_EN_SINGLE = 0x40043d14
+ PTP_PEROUT_REQUEST = 0x40383d03
+ PTP_PEROUT_REQUEST2 = 0x40383d0c
+ PTP_PIN_SETFUNC = 0x40603d07
+ PTP_PIN_SETFUNC2 = 0x40603d10
+ PTP_SYS_OFFSET = 0x43403d05
+ PTP_SYS_OFFSET2 = 0x43403d0e
PTRACE_GETFDPIC = 0x21
PTRACE_GETFDPIC_EXEC = 0x0
PTRACE_GETFDPIC_INTERP = 0x1
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
index 2f1dd214a7..f78c4617ca 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
@@ -78,6 +78,8 @@ const (
ECHOPRT = 0x400
EFD_CLOEXEC = 0x80000
EFD_NONBLOCK = 0x800
+ EPIOCGPARAMS = 0x80088a02
+ EPIOCSPARAMS = 0x40088a01
EPOLL_CLOEXEC = 0x80000
EXTPROC = 0x10000
FF1 = 0x8000
@@ -148,9 +150,14 @@ const (
NFDBITS = 0x40
NLDLY = 0x100
NOFLSH = 0x80
+ NS_GET_MNTNS_ID = 0x8008b705
NS_GET_NSTYPE = 0xb703
NS_GET_OWNER_UID = 0xb704
NS_GET_PARENT = 0xb702
+ NS_GET_PID_FROM_PIDNS = 0x8004b706
+ NS_GET_PID_IN_PIDNS = 0x8004b708
+ NS_GET_TGID_FROM_PIDNS = 0x8004b707
+ NS_GET_TGID_IN_PIDNS = 0x8004b709
NS_GET_USERNS = 0xb701
OLCUC = 0x2
ONLCR = 0x4
@@ -227,6 +234,20 @@ const (
PPPIOCUNBRIDGECHAN = 0x7434
PPPIOCXFERUNIT = 0x744e
PR_SET_PTRACER_ANY = 0xffffffffffffffff
+ PTP_CLOCK_GETCAPS = 0x80503d01
+ PTP_CLOCK_GETCAPS2 = 0x80503d0a
+ PTP_ENABLE_PPS = 0x40043d04
+ PTP_ENABLE_PPS2 = 0x40043d0d
+ PTP_EXTTS_REQUEST = 0x40103d02
+ PTP_EXTTS_REQUEST2 = 0x40103d0b
+ PTP_MASK_CLEAR_ALL = 0x3d13
+ PTP_MASK_EN_SINGLE = 0x40043d14
+ PTP_PEROUT_REQUEST = 0x40383d03
+ PTP_PEROUT_REQUEST2 = 0x40383d0c
+ PTP_PIN_SETFUNC = 0x40603d07
+ PTP_PIN_SETFUNC2 = 0x40603d10
+ PTP_SYS_OFFSET = 0x43403d05
+ PTP_SYS_OFFSET2 = 0x43403d0e
PTRACE_DISABLE_TE = 0x5010
PTRACE_ENABLE_TE = 0x5009
PTRACE_GET_LAST_BREAK = 0x5006
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
index f40519d901..aeb777c344 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
@@ -82,6 +82,8 @@ const (
EFD_CLOEXEC = 0x400000
EFD_NONBLOCK = 0x4000
EMT_TAGOVF = 0x1
+ EPIOCGPARAMS = 0x40088a02
+ EPIOCSPARAMS = 0x80088a01
EPOLL_CLOEXEC = 0x400000
EXTPROC = 0x10000
FF1 = 0x8000
@@ -153,9 +155,14 @@ const (
NFDBITS = 0x40
NLDLY = 0x100
NOFLSH = 0x80
+ NS_GET_MNTNS_ID = 0x4008b705
NS_GET_NSTYPE = 0x2000b703
NS_GET_OWNER_UID = 0x2000b704
NS_GET_PARENT = 0x2000b702
+ NS_GET_PID_FROM_PIDNS = 0x4004b706
+ NS_GET_PID_IN_PIDNS = 0x4004b708
+ NS_GET_TGID_FROM_PIDNS = 0x4004b707
+ NS_GET_TGID_IN_PIDNS = 0x4004b709
NS_GET_USERNS = 0x2000b701
OLCUC = 0x2
ONLCR = 0x4
@@ -232,6 +239,20 @@ const (
PPPIOCUNBRIDGECHAN = 0x20007434
PPPIOCXFERUNIT = 0x2000744e
PR_SET_PTRACER_ANY = 0xffffffffffffffff
+ PTP_CLOCK_GETCAPS = 0x40503d01
+ PTP_CLOCK_GETCAPS2 = 0x40503d0a
+ PTP_ENABLE_PPS = 0x80043d04
+ PTP_ENABLE_PPS2 = 0x80043d0d
+ PTP_EXTTS_REQUEST = 0x80103d02
+ PTP_EXTTS_REQUEST2 = 0x80103d0b
+ PTP_MASK_CLEAR_ALL = 0x20003d13
+ PTP_MASK_EN_SINGLE = 0x80043d14
+ PTP_PEROUT_REQUEST = 0x80383d03
+ PTP_PEROUT_REQUEST2 = 0x80383d0c
+ PTP_PIN_SETFUNC = 0x80603d07
+ PTP_PIN_SETFUNC2 = 0x80603d10
+ PTP_SYS_OFFSET = 0x83403d05
+ PTP_SYS_OFFSET2 = 0x83403d0e
PTRACE_GETFPAREGS = 0x14
PTRACE_GETFPREGS = 0xe
PTRACE_GETFPREGS64 = 0x19
diff --git a/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
index da08b2ab3d..1ec2b1407b 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
@@ -581,6 +581,8 @@ const (
AT_EMPTY_PATH = 0x1000
AT_REMOVEDIR = 0x200
RENAME_NOREPLACE = 1 << 0
+ ST_RDONLY = 1
+ ST_NOSUID = 2
)
const (
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
index ccb02f240a..24b346e1a3 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
@@ -740,6 +740,54 @@ func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) {
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func renamexNp(from string, to string, flag uint32) (err error) {
+ var _p0 *byte
+ _p0, err = BytePtrFromString(from)
+ if err != nil {
+ return
+ }
+ var _p1 *byte
+ _p1, err = BytePtrFromString(to)
+ if err != nil {
+ return
+ }
+ _, _, e1 := syscall_syscall(libc_renamex_np_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flag))
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+var libc_renamex_np_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_renamex_np renamex_np "/usr/lib/libSystem.B.dylib"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func renameatxNp(fromfd int, from string, tofd int, to string, flag uint32) (err error) {
+ var _p0 *byte
+ _p0, err = BytePtrFromString(from)
+ if err != nil {
+ return
+ }
+ var _p1 *byte
+ _p1, err = BytePtrFromString(to)
+ if err != nil {
+ return
+ }
+ _, _, e1 := syscall_syscall6(libc_renameatx_np_trampoline_addr, uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), uintptr(flag), 0)
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+var libc_renameatx_np_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_renameatx_np renameatx_np "/usr/lib/libSystem.B.dylib"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
var _p0 unsafe.Pointer
if len(mib) > 0 {
@@ -760,6 +808,59 @@ var libc_sysctl_trampoline_addr uintptr
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func pthread_chdir_np(path string) (err error) {
+ var _p0 *byte
+ _p0, err = BytePtrFromString(path)
+ if err != nil {
+ return
+ }
+ _, _, e1 := syscall_syscall(libc_pthread_chdir_np_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0)
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+var libc_pthread_chdir_np_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_pthread_chdir_np pthread_chdir_np "/usr/lib/libSystem.B.dylib"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func pthread_fchdir_np(fd int) (err error) {
+ _, _, e1 := syscall_syscall(libc_pthread_fchdir_np_trampoline_addr, uintptr(fd), 0, 0)
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+var libc_pthread_fchdir_np_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_pthread_fchdir_np pthread_fchdir_np "/usr/lib/libSystem.B.dylib"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) {
+ var _p0 unsafe.Pointer
+ if len(iov) > 0 {
+ _p0 = unsafe.Pointer(&iov[0])
+ } else {
+ _p0 = unsafe.Pointer(&_zero)
+ }
+ _, _, e1 := syscall_syscall9(libc_connectx_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(endpoints)), uintptr(associd), uintptr(flags), uintptr(_p0), uintptr(len(iov)), uintptr(unsafe.Pointer(n)), uintptr(unsafe.Pointer(connid)), 0)
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+var libc_connectx_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_connectx connectx "/usr/lib/libSystem.B.dylib"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
_, _, e1 := syscall_syscall6(libc_sendfile_trampoline_addr, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags))
if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s
index 8b8bb28402..ebd213100b 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s
+++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s
@@ -223,11 +223,36 @@ TEXT libc_ioctl_trampoline<>(SB),NOSPLIT,$0-0
GLOBL ·libc_ioctl_trampoline_addr(SB), RODATA, $8
DATA ·libc_ioctl_trampoline_addr(SB)/8, $libc_ioctl_trampoline<>(SB)
+TEXT libc_renamex_np_trampoline<>(SB),NOSPLIT,$0-0
+ JMP libc_renamex_np(SB)
+GLOBL ·libc_renamex_np_trampoline_addr(SB), RODATA, $8
+DATA ·libc_renamex_np_trampoline_addr(SB)/8, $libc_renamex_np_trampoline<>(SB)
+
+TEXT libc_renameatx_np_trampoline<>(SB),NOSPLIT,$0-0
+ JMP libc_renameatx_np(SB)
+GLOBL ·libc_renameatx_np_trampoline_addr(SB), RODATA, $8
+DATA ·libc_renameatx_np_trampoline_addr(SB)/8, $libc_renameatx_np_trampoline<>(SB)
+
TEXT libc_sysctl_trampoline<>(SB),NOSPLIT,$0-0
JMP libc_sysctl(SB)
GLOBL ·libc_sysctl_trampoline_addr(SB), RODATA, $8
DATA ·libc_sysctl_trampoline_addr(SB)/8, $libc_sysctl_trampoline<>(SB)
+TEXT libc_pthread_chdir_np_trampoline<>(SB),NOSPLIT,$0-0
+ JMP libc_pthread_chdir_np(SB)
+GLOBL ·libc_pthread_chdir_np_trampoline_addr(SB), RODATA, $8
+DATA ·libc_pthread_chdir_np_trampoline_addr(SB)/8, $libc_pthread_chdir_np_trampoline<>(SB)
+
+TEXT libc_pthread_fchdir_np_trampoline<>(SB),NOSPLIT,$0-0
+ JMP libc_pthread_fchdir_np(SB)
+GLOBL ·libc_pthread_fchdir_np_trampoline_addr(SB), RODATA, $8
+DATA ·libc_pthread_fchdir_np_trampoline_addr(SB)/8, $libc_pthread_fchdir_np_trampoline<>(SB)
+
+TEXT libc_connectx_trampoline<>(SB),NOSPLIT,$0-0
+ JMP libc_connectx(SB)
+GLOBL ·libc_connectx_trampoline_addr(SB), RODATA, $8
+DATA ·libc_connectx_trampoline_addr(SB)/8, $libc_connectx_trampoline<>(SB)
+
TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0
JMP libc_sendfile(SB)
GLOBL ·libc_sendfile_trampoline_addr(SB), RODATA, $8
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
index 1b40b997b5..824b9c2d5e 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
@@ -740,6 +740,54 @@ func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) {
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func renamexNp(from string, to string, flag uint32) (err error) {
+ var _p0 *byte
+ _p0, err = BytePtrFromString(from)
+ if err != nil {
+ return
+ }
+ var _p1 *byte
+ _p1, err = BytePtrFromString(to)
+ if err != nil {
+ return
+ }
+ _, _, e1 := syscall_syscall(libc_renamex_np_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flag))
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+var libc_renamex_np_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_renamex_np renamex_np "/usr/lib/libSystem.B.dylib"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func renameatxNp(fromfd int, from string, tofd int, to string, flag uint32) (err error) {
+ var _p0 *byte
+ _p0, err = BytePtrFromString(from)
+ if err != nil {
+ return
+ }
+ var _p1 *byte
+ _p1, err = BytePtrFromString(to)
+ if err != nil {
+ return
+ }
+ _, _, e1 := syscall_syscall6(libc_renameatx_np_trampoline_addr, uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), uintptr(flag), 0)
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+var libc_renameatx_np_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_renameatx_np renameatx_np "/usr/lib/libSystem.B.dylib"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
var _p0 unsafe.Pointer
if len(mib) > 0 {
@@ -760,6 +808,59 @@ var libc_sysctl_trampoline_addr uintptr
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func pthread_chdir_np(path string) (err error) {
+ var _p0 *byte
+ _p0, err = BytePtrFromString(path)
+ if err != nil {
+ return
+ }
+ _, _, e1 := syscall_syscall(libc_pthread_chdir_np_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0)
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+var libc_pthread_chdir_np_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_pthread_chdir_np pthread_chdir_np "/usr/lib/libSystem.B.dylib"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func pthread_fchdir_np(fd int) (err error) {
+ _, _, e1 := syscall_syscall(libc_pthread_fchdir_np_trampoline_addr, uintptr(fd), 0, 0)
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+var libc_pthread_fchdir_np_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_pthread_fchdir_np pthread_fchdir_np "/usr/lib/libSystem.B.dylib"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) {
+ var _p0 unsafe.Pointer
+ if len(iov) > 0 {
+ _p0 = unsafe.Pointer(&iov[0])
+ } else {
+ _p0 = unsafe.Pointer(&_zero)
+ }
+ _, _, e1 := syscall_syscall9(libc_connectx_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(endpoints)), uintptr(associd), uintptr(flags), uintptr(_p0), uintptr(len(iov)), uintptr(unsafe.Pointer(n)), uintptr(unsafe.Pointer(connid)), 0)
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+var libc_connectx_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_connectx connectx "/usr/lib/libSystem.B.dylib"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
_, _, e1 := syscall_syscall6(libc_sendfile_trampoline_addr, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags))
if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s
index 08362c1ab7..4f178a2293 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s
+++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s
@@ -223,11 +223,36 @@ TEXT libc_ioctl_trampoline<>(SB),NOSPLIT,$0-0
GLOBL ·libc_ioctl_trampoline_addr(SB), RODATA, $8
DATA ·libc_ioctl_trampoline_addr(SB)/8, $libc_ioctl_trampoline<>(SB)
+TEXT libc_renamex_np_trampoline<>(SB),NOSPLIT,$0-0
+ JMP libc_renamex_np(SB)
+GLOBL ·libc_renamex_np_trampoline_addr(SB), RODATA, $8
+DATA ·libc_renamex_np_trampoline_addr(SB)/8, $libc_renamex_np_trampoline<>(SB)
+
+TEXT libc_renameatx_np_trampoline<>(SB),NOSPLIT,$0-0
+ JMP libc_renameatx_np(SB)
+GLOBL ·libc_renameatx_np_trampoline_addr(SB), RODATA, $8
+DATA ·libc_renameatx_np_trampoline_addr(SB)/8, $libc_renameatx_np_trampoline<>(SB)
+
TEXT libc_sysctl_trampoline<>(SB),NOSPLIT,$0-0
JMP libc_sysctl(SB)
GLOBL ·libc_sysctl_trampoline_addr(SB), RODATA, $8
DATA ·libc_sysctl_trampoline_addr(SB)/8, $libc_sysctl_trampoline<>(SB)
+TEXT libc_pthread_chdir_np_trampoline<>(SB),NOSPLIT,$0-0
+ JMP libc_pthread_chdir_np(SB)
+GLOBL ·libc_pthread_chdir_np_trampoline_addr(SB), RODATA, $8
+DATA ·libc_pthread_chdir_np_trampoline_addr(SB)/8, $libc_pthread_chdir_np_trampoline<>(SB)
+
+TEXT libc_pthread_fchdir_np_trampoline<>(SB),NOSPLIT,$0-0
+ JMP libc_pthread_fchdir_np(SB)
+GLOBL ·libc_pthread_fchdir_np_trampoline_addr(SB), RODATA, $8
+DATA ·libc_pthread_fchdir_np_trampoline_addr(SB)/8, $libc_pthread_fchdir_np_trampoline<>(SB)
+
+TEXT libc_connectx_trampoline<>(SB),NOSPLIT,$0-0
+ JMP libc_connectx(SB)
+GLOBL ·libc_connectx_trampoline_addr(SB), RODATA, $8
+DATA ·libc_connectx_trampoline_addr(SB)/8, $libc_connectx_trampoline<>(SB)
+
TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0
JMP libc_sendfile(SB)
GLOBL ·libc_sendfile_trampoline_addr(SB), RODATA, $8
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux.go b/vendor/golang.org/x/sys/unix/zsyscall_linux.go
index 87d8612a1d..5cc1e8eb2f 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_linux.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_linux.go
@@ -592,6 +592,16 @@ func ClockGettime(clockid int32, time *Timespec) (err error) {
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func ClockSettime(clockid int32, time *Timespec) (err error) {
+ _, _, e1 := Syscall(SYS_CLOCK_SETTIME, uintptr(clockid), uintptr(unsafe.Pointer(time)), 0)
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
func ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error) {
_, _, e1 := Syscall6(SYS_CLOCK_NANOSLEEP, uintptr(clockid), uintptr(flags), uintptr(unsafe.Pointer(request)), uintptr(unsafe.Pointer(remain)), 0, 0)
if e1 != 0 {
@@ -971,23 +981,6 @@ func Getpriority(which int, who int) (prio int, err error) {
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-func Getrandom(buf []byte, flags int) (n int, err error) {
- var _p0 unsafe.Pointer
- if len(buf) > 0 {
- _p0 = unsafe.Pointer(&buf[0])
- } else {
- _p0 = unsafe.Pointer(&_zero)
- }
- r0, _, e1 := Syscall(SYS_GETRANDOM, uintptr(_p0), uintptr(len(buf)), uintptr(flags))
- n = int(r0)
- if e1 != 0 {
- err = errnoErr(e1)
- }
- return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
func Getrusage(who int, rusage *Rusage) (err error) {
_, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
if e1 != 0 {
@@ -2229,3 +2222,19 @@ func Cachestat(fd uint, crange *CachestatRange, cstat *Cachestat_t, flags uint)
}
return
}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Mseal(b []byte, flags uint) (err error) {
+ var _p0 unsafe.Pointer
+ if len(b) > 0 {
+ _p0 = unsafe.Pointer(&b[0])
+ } else {
+ _p0 = unsafe.Pointer(&_zero)
+ }
+ _, _, e1 := Syscall(SYS_MSEAL, uintptr(_p0), uintptr(len(b)), uintptr(flags))
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go
index 9dc42410b7..1851df14e8 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go
@@ -1493,6 +1493,30 @@ var libc_mknodat_trampoline_addr uintptr
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error) {
+ var _p0 *byte
+ _p0, err = BytePtrFromString(fsType)
+ if err != nil {
+ return
+ }
+ var _p1 *byte
+ _p1, err = BytePtrFromString(dir)
+ if err != nil {
+ return
+ }
+ _, _, e1 := syscall_syscall6(libc_mount_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags), uintptr(data), 0, 0)
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+var libc_mount_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_mount mount "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
_, _, e1 := syscall_syscall(libc_nanosleep_trampoline_addr, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.s b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.s
index 41b5617316..0b43c69365 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.s
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.s
@@ -463,6 +463,11 @@ TEXT libc_mknodat_trampoline<>(SB),NOSPLIT,$0-0
GLOBL ·libc_mknodat_trampoline_addr(SB), RODATA, $4
DATA ·libc_mknodat_trampoline_addr(SB)/4, $libc_mknodat_trampoline<>(SB)
+TEXT libc_mount_trampoline<>(SB),NOSPLIT,$0-0
+ JMP libc_mount(SB)
+GLOBL ·libc_mount_trampoline_addr(SB), RODATA, $4
+DATA ·libc_mount_trampoline_addr(SB)/4, $libc_mount_trampoline<>(SB)
+
TEXT libc_nanosleep_trampoline<>(SB),NOSPLIT,$0-0
JMP libc_nanosleep(SB)
GLOBL ·libc_nanosleep_trampoline_addr(SB), RODATA, $4
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go
index 0d3a0751cd..e1ec0dbe4e 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go
@@ -1493,6 +1493,30 @@ var libc_mknodat_trampoline_addr uintptr
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error) {
+ var _p0 *byte
+ _p0, err = BytePtrFromString(fsType)
+ if err != nil {
+ return
+ }
+ var _p1 *byte
+ _p1, err = BytePtrFromString(dir)
+ if err != nil {
+ return
+ }
+ _, _, e1 := syscall_syscall6(libc_mount_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags), uintptr(data), 0, 0)
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+var libc_mount_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_mount mount "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
_, _, e1 := syscall_syscall(libc_nanosleep_trampoline_addr, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.s b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.s
index 4019a656f6..880c6d6e31 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.s
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.s
@@ -463,6 +463,11 @@ TEXT libc_mknodat_trampoline<>(SB),NOSPLIT,$0-0
GLOBL ·libc_mknodat_trampoline_addr(SB), RODATA, $8
DATA ·libc_mknodat_trampoline_addr(SB)/8, $libc_mknodat_trampoline<>(SB)
+TEXT libc_mount_trampoline<>(SB),NOSPLIT,$0-0
+ JMP libc_mount(SB)
+GLOBL ·libc_mount_trampoline_addr(SB), RODATA, $8
+DATA ·libc_mount_trampoline_addr(SB)/8, $libc_mount_trampoline<>(SB)
+
TEXT libc_nanosleep_trampoline<>(SB),NOSPLIT,$0-0
JMP libc_nanosleep(SB)
GLOBL ·libc_nanosleep_trampoline_addr(SB), RODATA, $8
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go
index c39f7776db..7c8452a63e 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go
@@ -1493,6 +1493,30 @@ var libc_mknodat_trampoline_addr uintptr
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error) {
+ var _p0 *byte
+ _p0, err = BytePtrFromString(fsType)
+ if err != nil {
+ return
+ }
+ var _p1 *byte
+ _p1, err = BytePtrFromString(dir)
+ if err != nil {
+ return
+ }
+ _, _, e1 := syscall_syscall6(libc_mount_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags), uintptr(data), 0, 0)
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+var libc_mount_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_mount mount "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
_, _, e1 := syscall_syscall(libc_nanosleep_trampoline_addr, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.s b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.s
index ac4af24f90..b8ef95b0fa 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.s
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.s
@@ -463,6 +463,11 @@ TEXT libc_mknodat_trampoline<>(SB),NOSPLIT,$0-0
GLOBL ·libc_mknodat_trampoline_addr(SB), RODATA, $4
DATA ·libc_mknodat_trampoline_addr(SB)/4, $libc_mknodat_trampoline<>(SB)
+TEXT libc_mount_trampoline<>(SB),NOSPLIT,$0-0
+ JMP libc_mount(SB)
+GLOBL ·libc_mount_trampoline_addr(SB), RODATA, $4
+DATA ·libc_mount_trampoline_addr(SB)/4, $libc_mount_trampoline<>(SB)
+
TEXT libc_nanosleep_trampoline<>(SB),NOSPLIT,$0-0
JMP libc_nanosleep(SB)
GLOBL ·libc_nanosleep_trampoline_addr(SB), RODATA, $4
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go
index 57571d072f..2ffdf861f7 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go
@@ -1493,6 +1493,30 @@ var libc_mknodat_trampoline_addr uintptr
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error) {
+ var _p0 *byte
+ _p0, err = BytePtrFromString(fsType)
+ if err != nil {
+ return
+ }
+ var _p1 *byte
+ _p1, err = BytePtrFromString(dir)
+ if err != nil {
+ return
+ }
+ _, _, e1 := syscall_syscall6(libc_mount_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags), uintptr(data), 0, 0)
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+var libc_mount_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_mount mount "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
_, _, e1 := syscall_syscall(libc_nanosleep_trampoline_addr, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.s b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.s
index f77d532121..2af3b5c762 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.s
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.s
@@ -463,6 +463,11 @@ TEXT libc_mknodat_trampoline<>(SB),NOSPLIT,$0-0
GLOBL ·libc_mknodat_trampoline_addr(SB), RODATA, $8
DATA ·libc_mknodat_trampoline_addr(SB)/8, $libc_mknodat_trampoline<>(SB)
+TEXT libc_mount_trampoline<>(SB),NOSPLIT,$0-0
+ JMP libc_mount(SB)
+GLOBL ·libc_mount_trampoline_addr(SB), RODATA, $8
+DATA ·libc_mount_trampoline_addr(SB)/8, $libc_mount_trampoline<>(SB)
+
TEXT libc_nanosleep_trampoline<>(SB),NOSPLIT,$0-0
JMP libc_nanosleep(SB)
GLOBL ·libc_nanosleep_trampoline_addr(SB), RODATA, $8
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go
index e62963e67e..1da08d5267 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go
@@ -1493,6 +1493,30 @@ var libc_mknodat_trampoline_addr uintptr
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error) {
+ var _p0 *byte
+ _p0, err = BytePtrFromString(fsType)
+ if err != nil {
+ return
+ }
+ var _p1 *byte
+ _p1, err = BytePtrFromString(dir)
+ if err != nil {
+ return
+ }
+ _, _, e1 := syscall_syscall6(libc_mount_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags), uintptr(data), 0, 0)
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+var libc_mount_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_mount mount "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
_, _, e1 := syscall_syscall(libc_nanosleep_trampoline_addr, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.s b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.s
index fae140b62c..b7a251353b 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.s
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.s
@@ -463,6 +463,11 @@ TEXT libc_mknodat_trampoline<>(SB),NOSPLIT,$0-0
GLOBL ·libc_mknodat_trampoline_addr(SB), RODATA, $8
DATA ·libc_mknodat_trampoline_addr(SB)/8, $libc_mknodat_trampoline<>(SB)
+TEXT libc_mount_trampoline<>(SB),NOSPLIT,$0-0
+ JMP libc_mount(SB)
+GLOBL ·libc_mount_trampoline_addr(SB), RODATA, $8
+DATA ·libc_mount_trampoline_addr(SB)/8, $libc_mount_trampoline<>(SB)
+
TEXT libc_nanosleep_trampoline<>(SB),NOSPLIT,$0-0
JMP libc_nanosleep(SB)
GLOBL ·libc_nanosleep_trampoline_addr(SB), RODATA, $8
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.go
index 00831354c8..6e85b0aac9 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.go
@@ -1493,6 +1493,30 @@ var libc_mknodat_trampoline_addr uintptr
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error) {
+ var _p0 *byte
+ _p0, err = BytePtrFromString(fsType)
+ if err != nil {
+ return
+ }
+ var _p1 *byte
+ _p1, err = BytePtrFromString(dir)
+ if err != nil {
+ return
+ }
+ _, _, e1 := syscall_syscall6(libc_mount_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags), uintptr(data), 0, 0)
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+var libc_mount_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_mount mount "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
_, _, e1 := syscall_syscall(libc_nanosleep_trampoline_addr, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.s b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.s
index 9d1e0ff06d..f15dadf055 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.s
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.s
@@ -555,6 +555,12 @@ TEXT libc_mknodat_trampoline<>(SB),NOSPLIT,$0-0
GLOBL ·libc_mknodat_trampoline_addr(SB), RODATA, $8
DATA ·libc_mknodat_trampoline_addr(SB)/8, $libc_mknodat_trampoline<>(SB)
+TEXT libc_mount_trampoline<>(SB),NOSPLIT,$0-0
+ CALL libc_mount(SB)
+ RET
+GLOBL ·libc_mount_trampoline_addr(SB), RODATA, $8
+DATA ·libc_mount_trampoline_addr(SB)/8, $libc_mount_trampoline<>(SB)
+
TEXT libc_nanosleep_trampoline<>(SB),NOSPLIT,$0-0
CALL libc_nanosleep(SB)
RET
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go
index 79029ed584..28b487df25 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go
@@ -1493,6 +1493,30 @@ var libc_mknodat_trampoline_addr uintptr
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error) {
+ var _p0 *byte
+ _p0, err = BytePtrFromString(fsType)
+ if err != nil {
+ return
+ }
+ var _p1 *byte
+ _p1, err = BytePtrFromString(dir)
+ if err != nil {
+ return
+ }
+ _, _, e1 := syscall_syscall6(libc_mount_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags), uintptr(data), 0, 0)
+ if e1 != 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+var libc_mount_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_mount mount "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
_, _, e1 := syscall_syscall(libc_nanosleep_trampoline_addr, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.s b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.s
index da115f9a4b..1e7f321e43 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.s
+++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.s
@@ -463,6 +463,11 @@ TEXT libc_mknodat_trampoline<>(SB),NOSPLIT,$0-0
GLOBL ·libc_mknodat_trampoline_addr(SB), RODATA, $8
DATA ·libc_mknodat_trampoline_addr(SB)/8, $libc_mknodat_trampoline<>(SB)
+TEXT libc_mount_trampoline<>(SB),NOSPLIT,$0-0
+ JMP libc_mount(SB)
+GLOBL ·libc_mount_trampoline_addr(SB), RODATA, $8
+DATA ·libc_mount_trampoline_addr(SB)/8, $libc_mount_trampoline<>(SB)
+
TEXT libc_nanosleep_trampoline<>(SB),NOSPLIT,$0-0
JMP libc_nanosleep(SB)
GLOBL ·libc_nanosleep_trampoline_addr(SB), RODATA, $8
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
index 53aef5dc58..524b0820cb 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
@@ -457,4 +457,5 @@ const (
SYS_LSM_GET_SELF_ATTR = 459
SYS_LSM_SET_SELF_ATTR = 460
SYS_LSM_LIST_MODULES = 461
+ SYS_MSEAL = 462
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
index 71d524763d..f485dbf456 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
@@ -341,6 +341,7 @@ const (
SYS_STATX = 332
SYS_IO_PGETEVENTS = 333
SYS_RSEQ = 334
+ SYS_URETPROBE = 335
SYS_PIDFD_SEND_SIGNAL = 424
SYS_IO_URING_SETUP = 425
SYS_IO_URING_ENTER = 426
@@ -379,4 +380,5 @@ const (
SYS_LSM_GET_SELF_ATTR = 459
SYS_LSM_SET_SELF_ATTR = 460
SYS_LSM_LIST_MODULES = 461
+ SYS_MSEAL = 462
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
index c747706131..70b35bf3b0 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
@@ -421,4 +421,5 @@ const (
SYS_LSM_GET_SELF_ATTR = 459
SYS_LSM_SET_SELF_ATTR = 460
SYS_LSM_LIST_MODULES = 461
+ SYS_MSEAL = 462
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
index f96e214f6d..1893e2fe88 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
@@ -85,7 +85,7 @@ const (
SYS_SPLICE = 76
SYS_TEE = 77
SYS_READLINKAT = 78
- SYS_FSTATAT = 79
+ SYS_NEWFSTATAT = 79
SYS_FSTAT = 80
SYS_SYNC = 81
SYS_FSYNC = 82
@@ -324,4 +324,5 @@ const (
SYS_LSM_GET_SELF_ATTR = 459
SYS_LSM_SET_SELF_ATTR = 460
SYS_LSM_LIST_MODULES = 461
+ SYS_MSEAL = 462
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go
index 28425346cf..16a4017da0 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go
@@ -84,6 +84,8 @@ const (
SYS_SPLICE = 76
SYS_TEE = 77
SYS_READLINKAT = 78
+ SYS_NEWFSTATAT = 79
+ SYS_FSTAT = 80
SYS_SYNC = 81
SYS_FSYNC = 82
SYS_FDATASYNC = 83
@@ -318,4 +320,5 @@ const (
SYS_LSM_GET_SELF_ATTR = 459
SYS_LSM_SET_SELF_ATTR = 460
SYS_LSM_LIST_MODULES = 461
+ SYS_MSEAL = 462
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
index d0953018da..7e567f1eff 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
@@ -441,4 +441,5 @@ const (
SYS_LSM_GET_SELF_ATTR = 4459
SYS_LSM_SET_SELF_ATTR = 4460
SYS_LSM_LIST_MODULES = 4461
+ SYS_MSEAL = 4462
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
index 295c7f4b81..38ae55e5ef 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
@@ -371,4 +371,5 @@ const (
SYS_LSM_GET_SELF_ATTR = 5459
SYS_LSM_SET_SELF_ATTR = 5460
SYS_LSM_LIST_MODULES = 5461
+ SYS_MSEAL = 5462
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
index d1a9eaca7a..55e92e60a8 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
@@ -371,4 +371,5 @@ const (
SYS_LSM_GET_SELF_ATTR = 5459
SYS_LSM_SET_SELF_ATTR = 5460
SYS_LSM_LIST_MODULES = 5461
+ SYS_MSEAL = 5462
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
index bec157c39f..60658d6a02 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
@@ -441,4 +441,5 @@ const (
SYS_LSM_GET_SELF_ATTR = 4459
SYS_LSM_SET_SELF_ATTR = 4460
SYS_LSM_LIST_MODULES = 4461
+ SYS_MSEAL = 4462
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
index 7ee7bdc435..e203e8a7ed 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
@@ -448,4 +448,5 @@ const (
SYS_LSM_GET_SELF_ATTR = 459
SYS_LSM_SET_SELF_ATTR = 460
SYS_LSM_LIST_MODULES = 461
+ SYS_MSEAL = 462
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
index fad1f25b44..5944b97d54 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
@@ -420,4 +420,5 @@ const (
SYS_LSM_GET_SELF_ATTR = 459
SYS_LSM_SET_SELF_ATTR = 460
SYS_LSM_LIST_MODULES = 461
+ SYS_MSEAL = 462
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
index 7d3e16357d..c66d416dad 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
@@ -420,4 +420,5 @@ const (
SYS_LSM_GET_SELF_ATTR = 459
SYS_LSM_SET_SELF_ATTR = 460
SYS_LSM_LIST_MODULES = 461
+ SYS_MSEAL = 462
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
index 0ed53ad9f7..a5459e766f 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
@@ -84,7 +84,7 @@ const (
SYS_SPLICE = 76
SYS_TEE = 77
SYS_READLINKAT = 78
- SYS_FSTATAT = 79
+ SYS_NEWFSTATAT = 79
SYS_FSTAT = 80
SYS_SYNC = 81
SYS_FSYNC = 82
@@ -325,4 +325,5 @@ const (
SYS_LSM_GET_SELF_ATTR = 459
SYS_LSM_SET_SELF_ATTR = 460
SYS_LSM_LIST_MODULES = 461
+ SYS_MSEAL = 462
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
index 2fba04ad50..01d86825bb 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
@@ -386,4 +386,5 @@ const (
SYS_LSM_GET_SELF_ATTR = 459
SYS_LSM_SET_SELF_ATTR = 460
SYS_LSM_LIST_MODULES = 461
+ SYS_MSEAL = 462
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
index 621d00d741..7b703e77cd 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
@@ -399,4 +399,5 @@ const (
SYS_LSM_GET_SELF_ATTR = 459
SYS_LSM_SET_SELF_ATTR = 460
SYS_LSM_LIST_MODULES = 461
+ SYS_MSEAL = 462
)
diff --git a/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
index 091d107f3a..d003c3d437 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
@@ -306,6 +306,19 @@ type XVSockPgen struct {
type _Socklen uint32
+type SaeAssocID uint32
+
+type SaeConnID uint32
+
+type SaEndpoints struct {
+ Srcif uint32
+ Srcaddr *RawSockaddr
+ Srcaddrlen uint32
+ Dstaddr *RawSockaddr
+ Dstaddrlen uint32
+ _ [4]byte
+}
+
type Xucred struct {
Version uint32
Uid uint32
diff --git a/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
index 28ff4ef74d..0d45a941aa 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
@@ -306,6 +306,19 @@ type XVSockPgen struct {
type _Socklen uint32
+type SaeAssocID uint32
+
+type SaeConnID uint32
+
+type SaEndpoints struct {
+ Srcif uint32
+ Srcaddr *RawSockaddr
+ Srcaddrlen uint32
+ Dstaddr *RawSockaddr
+ Dstaddrlen uint32
+ _ [4]byte
+}
+
type Xucred struct {
Version uint32
Uid uint32
diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go
index 6cbd094a3a..51e13eb055 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go
@@ -625,6 +625,7 @@ const (
POLLRDNORM = 0x40
POLLWRBAND = 0x100
POLLWRNORM = 0x4
+ POLLRDHUP = 0x4000
)
type CapRights struct {
diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go
index 7c03b6ee77..d002d8ef3c 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go
@@ -630,6 +630,7 @@ const (
POLLRDNORM = 0x40
POLLWRBAND = 0x100
POLLWRNORM = 0x4
+ POLLRDHUP = 0x4000
)
type CapRights struct {
diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go
index 422107ee8b..3f863d898d 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go
@@ -616,6 +616,7 @@ const (
POLLRDNORM = 0x40
POLLWRBAND = 0x100
POLLWRNORM = 0x4
+ POLLRDHUP = 0x4000
)
type CapRights struct {
diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go
index 505a12acfd..61c7293106 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go
@@ -610,6 +610,7 @@ const (
POLLRDNORM = 0x40
POLLWRBAND = 0x100
POLLWRNORM = 0x4
+ POLLRDHUP = 0x4000
)
type CapRights struct {
diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go
index cc986c7900..b5d17414f0 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go
@@ -612,6 +612,7 @@ const (
POLLRDNORM = 0x40
POLLWRBAND = 0x100
POLLWRNORM = 0x4
+ POLLRDHUP = 0x4000
)
type CapRights struct {
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux.go b/vendor/golang.org/x/sys/unix/ztypes_linux.go
index 4740b83485..8daaf3faf4 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux.go
@@ -87,30 +87,35 @@ type StatxTimestamp struct {
}
type Statx_t struct {
- Mask uint32
- Blksize uint32
- Attributes uint64
- Nlink uint32
- Uid uint32
- Gid uint32
- Mode uint16
- _ [1]uint16
- Ino uint64
- Size uint64
- Blocks uint64
- Attributes_mask uint64
- Atime StatxTimestamp
- Btime StatxTimestamp
- Ctime StatxTimestamp
- Mtime StatxTimestamp
- Rdev_major uint32
- Rdev_minor uint32
- Dev_major uint32
- Dev_minor uint32
- Mnt_id uint64
- Dio_mem_align uint32
- Dio_offset_align uint32
- _ [12]uint64
+ Mask uint32
+ Blksize uint32
+ Attributes uint64
+ Nlink uint32
+ Uid uint32
+ Gid uint32
+ Mode uint16
+ _ [1]uint16
+ Ino uint64
+ Size uint64
+ Blocks uint64
+ Attributes_mask uint64
+ Atime StatxTimestamp
+ Btime StatxTimestamp
+ Ctime StatxTimestamp
+ Mtime StatxTimestamp
+ Rdev_major uint32
+ Rdev_minor uint32
+ Dev_major uint32
+ Dev_minor uint32
+ Mnt_id uint64
+ Dio_mem_align uint32
+ Dio_offset_align uint32
+ Subvol uint64
+ Atomic_write_unit_min uint32
+ Atomic_write_unit_max uint32
+ Atomic_write_segments_max uint32
+ _ [1]uint32
+ _ [9]uint64
}
type Fsid struct {
@@ -515,6 +520,29 @@ type TCPInfo struct {
Total_rto_time uint32
}
+type TCPVegasInfo struct {
+ Enabled uint32
+ Rttcnt uint32
+ Rtt uint32
+ Minrtt uint32
+}
+
+type TCPDCTCPInfo struct {
+ Enabled uint16
+ Ce_state uint16
+ Alpha uint32
+ Ab_ecn uint32
+ Ab_tot uint32
+}
+
+type TCPBBRInfo struct {
+ Bw_lo uint32
+ Bw_hi uint32
+ Min_rtt uint32
+ Pacing_gain uint32
+ Cwnd_gain uint32
+}
+
type CanFilter struct {
Id uint32
Mask uint32
@@ -556,6 +584,7 @@ const (
SizeofICMPv6Filter = 0x20
SizeofUcred = 0xc
SizeofTCPInfo = 0xf8
+ SizeofTCPCCInfo = 0x14
SizeofCanFilter = 0x8
SizeofTCPRepairOpt = 0x8
)
@@ -1723,12 +1752,6 @@ const (
IFLA_IPVLAN_UNSPEC = 0x0
IFLA_IPVLAN_MODE = 0x1
IFLA_IPVLAN_FLAGS = 0x2
- NETKIT_NEXT = -0x1
- NETKIT_PASS = 0x0
- NETKIT_DROP = 0x2
- NETKIT_REDIRECT = 0x7
- NETKIT_L2 = 0x0
- NETKIT_L3 = 0x1
IFLA_NETKIT_UNSPEC = 0x0
IFLA_NETKIT_PEER_INFO = 0x1
IFLA_NETKIT_PRIMARY = 0x2
@@ -1767,6 +1790,7 @@ const (
IFLA_VXLAN_DF = 0x1d
IFLA_VXLAN_VNIFILTER = 0x1e
IFLA_VXLAN_LOCALBYPASS = 0x1f
+ IFLA_VXLAN_LABEL_POLICY = 0x20
IFLA_GENEVE_UNSPEC = 0x0
IFLA_GENEVE_ID = 0x1
IFLA_GENEVE_REMOTE = 0x2
@@ -1796,6 +1820,8 @@ const (
IFLA_GTP_ROLE = 0x4
IFLA_GTP_CREATE_SOCKETS = 0x5
IFLA_GTP_RESTART_COUNT = 0x6
+ IFLA_GTP_LOCAL = 0x7
+ IFLA_GTP_LOCAL6 = 0x8
IFLA_BOND_UNSPEC = 0x0
IFLA_BOND_MODE = 0x1
IFLA_BOND_ACTIVE_SLAVE = 0x2
@@ -1828,6 +1854,7 @@ const (
IFLA_BOND_AD_LACP_ACTIVE = 0x1d
IFLA_BOND_MISSED_MAX = 0x1e
IFLA_BOND_NS_IP6_TARGET = 0x1f
+ IFLA_BOND_COUPLED_CONTROL = 0x20
IFLA_BOND_AD_INFO_UNSPEC = 0x0
IFLA_BOND_AD_INFO_AGGREGATOR = 0x1
IFLA_BOND_AD_INFO_NUM_PORTS = 0x2
@@ -1896,6 +1923,7 @@ const (
IFLA_HSR_SEQ_NR = 0x5
IFLA_HSR_VERSION = 0x6
IFLA_HSR_PROTOCOL = 0x7
+ IFLA_HSR_INTERLINK = 0x8
IFLA_STATS_UNSPEC = 0x0
IFLA_STATS_LINK_64 = 0x1
IFLA_STATS_LINK_XSTATS = 0x2
@@ -1948,6 +1976,15 @@ const (
IFLA_DSA_MASTER = 0x1
)
+const (
+ NETKIT_NEXT = -0x1
+ NETKIT_PASS = 0x0
+ NETKIT_DROP = 0x2
+ NETKIT_REDIRECT = 0x7
+ NETKIT_L2 = 0x0
+ NETKIT_L3 = 0x1
+)
+
const (
NF_INET_PRE_ROUTING = 0x0
NF_INET_LOCAL_IN = 0x1
@@ -2485,7 +2522,7 @@ type XDPMmapOffsets struct {
type XDPUmemReg struct {
Addr uint64
Len uint64
- Chunk_size uint32
+ Size uint32
Headroom uint32
Flags uint32
Tx_metadata_len uint32
@@ -3473,7 +3510,7 @@ const (
DEVLINK_PORT_FN_ATTR_STATE = 0x2
DEVLINK_PORT_FN_ATTR_OPSTATE = 0x3
DEVLINK_PORT_FN_ATTR_CAPS = 0x4
- DEVLINK_PORT_FUNCTION_ATTR_MAX = 0x5
+ DEVLINK_PORT_FUNCTION_ATTR_MAX = 0x6
)
type FsverityDigest struct {
@@ -3765,7 +3802,7 @@ const (
ETHTOOL_MSG_PSE_GET = 0x24
ETHTOOL_MSG_PSE_SET = 0x25
ETHTOOL_MSG_RSS_GET = 0x26
- ETHTOOL_MSG_USER_MAX = 0x2b
+ ETHTOOL_MSG_USER_MAX = 0x2c
ETHTOOL_MSG_KERNEL_NONE = 0x0
ETHTOOL_MSG_STRSET_GET_REPLY = 0x1
ETHTOOL_MSG_LINKINFO_GET_REPLY = 0x2
@@ -3805,7 +3842,10 @@ const (
ETHTOOL_MSG_MODULE_NTF = 0x24
ETHTOOL_MSG_PSE_GET_REPLY = 0x25
ETHTOOL_MSG_RSS_GET_REPLY = 0x26
- ETHTOOL_MSG_KERNEL_MAX = 0x2b
+ ETHTOOL_MSG_KERNEL_MAX = 0x2c
+ ETHTOOL_FLAG_COMPACT_BITSETS = 0x1
+ ETHTOOL_FLAG_OMIT_REPLY = 0x2
+ ETHTOOL_FLAG_STATS = 0x4
ETHTOOL_A_HEADER_UNSPEC = 0x0
ETHTOOL_A_HEADER_DEV_INDEX = 0x1
ETHTOOL_A_HEADER_DEV_NAME = 0x2
@@ -3947,7 +3987,7 @@ const (
ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL = 0x17
ETHTOOL_A_COALESCE_USE_CQE_MODE_TX = 0x18
ETHTOOL_A_COALESCE_USE_CQE_MODE_RX = 0x19
- ETHTOOL_A_COALESCE_MAX = 0x1c
+ ETHTOOL_A_COALESCE_MAX = 0x1e
ETHTOOL_A_PAUSE_UNSPEC = 0x0
ETHTOOL_A_PAUSE_HEADER = 0x1
ETHTOOL_A_PAUSE_AUTONEG = 0x2
@@ -3975,7 +4015,7 @@ const (
ETHTOOL_A_TSINFO_TX_TYPES = 0x3
ETHTOOL_A_TSINFO_RX_FILTERS = 0x4
ETHTOOL_A_TSINFO_PHC_INDEX = 0x5
- ETHTOOL_A_TSINFO_MAX = 0x5
+ ETHTOOL_A_TSINFO_MAX = 0x6
ETHTOOL_A_CABLE_TEST_UNSPEC = 0x0
ETHTOOL_A_CABLE_TEST_HEADER = 0x1
ETHTOOL_A_CABLE_TEST_MAX = 0x1
@@ -4078,6 +4118,106 @@ type EthtoolDrvinfo struct {
Regdump_len uint32
}
+type EthtoolTsInfo struct {
+ Cmd uint32
+ So_timestamping uint32
+ Phc_index int32
+ Tx_types uint32
+ Tx_reserved [3]uint32
+ Rx_filters uint32
+ Rx_reserved [3]uint32
+}
+
+type HwTstampConfig struct {
+ Flags int32
+ Tx_type int32
+ Rx_filter int32
+}
+
+const (
+ HWTSTAMP_FILTER_NONE = 0x0
+ HWTSTAMP_FILTER_ALL = 0x1
+ HWTSTAMP_FILTER_SOME = 0x2
+ HWTSTAMP_FILTER_PTP_V1_L4_EVENT = 0x3
+ HWTSTAMP_FILTER_PTP_V2_L4_EVENT = 0x6
+ HWTSTAMP_FILTER_PTP_V2_L2_EVENT = 0x9
+ HWTSTAMP_FILTER_PTP_V2_EVENT = 0xc
+)
+
+const (
+ HWTSTAMP_TX_OFF = 0x0
+ HWTSTAMP_TX_ON = 0x1
+ HWTSTAMP_TX_ONESTEP_SYNC = 0x2
+)
+
+type (
+ PtpClockCaps struct {
+ Max_adj int32
+ N_alarm int32
+ N_ext_ts int32
+ N_per_out int32
+ Pps int32
+ N_pins int32
+ Cross_timestamping int32
+ Adjust_phase int32
+ Max_phase_adj int32
+ Rsv [11]int32
+ }
+ PtpClockTime struct {
+ Sec int64
+ Nsec uint32
+ Reserved uint32
+ }
+ PtpExttsEvent struct {
+ T PtpClockTime
+ Index uint32
+ Flags uint32
+ Rsv [2]uint32
+ }
+ PtpExttsRequest struct {
+ Index uint32
+ Flags uint32
+ Rsv [2]uint32
+ }
+ PtpPeroutRequest struct {
+ StartOrPhase PtpClockTime
+ Period PtpClockTime
+ Index uint32
+ Flags uint32
+ On PtpClockTime
+ }
+ PtpPinDesc struct {
+ Name [64]byte
+ Index uint32
+ Func uint32
+ Chan uint32
+ Rsv [5]uint32
+ }
+ PtpSysOffset struct {
+ Samples uint32
+ Rsv [3]uint32
+ Ts [51]PtpClockTime
+ }
+ PtpSysOffsetExtended struct {
+ Samples uint32
+ Rsv [3]uint32
+ Ts [25][3]PtpClockTime
+ }
+ PtpSysOffsetPrecise struct {
+ Device PtpClockTime
+ Realtime PtpClockTime
+ Monoraw PtpClockTime
+ Rsv [4]uint32
+ }
+)
+
+const (
+ PTP_PF_NONE = 0x0
+ PTP_PF_EXTTS = 0x1
+ PTP_PF_PEROUT = 0x2
+ PTP_PF_PHYSYNC = 0x3
+)
+
type (
HIDRawReportDescriptor struct {
Size uint32
@@ -4605,7 +4745,7 @@ const (
NL80211_ATTR_MAC_HINT = 0xc8
NL80211_ATTR_MAC_MASK = 0xd7
NL80211_ATTR_MAX_AP_ASSOC_STA = 0xca
- NL80211_ATTR_MAX = 0x14a
+ NL80211_ATTR_MAX = 0x14c
NL80211_ATTR_MAX_CRIT_PROT_DURATION = 0xb4
NL80211_ATTR_MAX_CSA_COUNTERS = 0xce
NL80211_ATTR_MAX_MATCH_SETS = 0x85
@@ -5209,7 +5349,7 @@ const (
NL80211_FREQUENCY_ATTR_GO_CONCURRENT = 0xf
NL80211_FREQUENCY_ATTR_INDOOR_ONLY = 0xe
NL80211_FREQUENCY_ATTR_IR_CONCURRENT = 0xf
- NL80211_FREQUENCY_ATTR_MAX = 0x20
+ NL80211_FREQUENCY_ATTR_MAX = 0x21
NL80211_FREQUENCY_ATTR_MAX_TX_POWER = 0x6
NL80211_FREQUENCY_ATTR_NO_10MHZ = 0x11
NL80211_FREQUENCY_ATTR_NO_160MHZ = 0xc
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
index 15adc04142..ad05b51a60 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
@@ -727,6 +727,37 @@ const (
RISCV_HWPROBE_EXT_ZBA = 0x8
RISCV_HWPROBE_EXT_ZBB = 0x10
RISCV_HWPROBE_EXT_ZBS = 0x20
+ RISCV_HWPROBE_EXT_ZICBOZ = 0x40
+ RISCV_HWPROBE_EXT_ZBC = 0x80
+ RISCV_HWPROBE_EXT_ZBKB = 0x100
+ RISCV_HWPROBE_EXT_ZBKC = 0x200
+ RISCV_HWPROBE_EXT_ZBKX = 0x400
+ RISCV_HWPROBE_EXT_ZKND = 0x800
+ RISCV_HWPROBE_EXT_ZKNE = 0x1000
+ RISCV_HWPROBE_EXT_ZKNH = 0x2000
+ RISCV_HWPROBE_EXT_ZKSED = 0x4000
+ RISCV_HWPROBE_EXT_ZKSH = 0x8000
+ RISCV_HWPROBE_EXT_ZKT = 0x10000
+ RISCV_HWPROBE_EXT_ZVBB = 0x20000
+ RISCV_HWPROBE_EXT_ZVBC = 0x40000
+ RISCV_HWPROBE_EXT_ZVKB = 0x80000
+ RISCV_HWPROBE_EXT_ZVKG = 0x100000
+ RISCV_HWPROBE_EXT_ZVKNED = 0x200000
+ RISCV_HWPROBE_EXT_ZVKNHA = 0x400000
+ RISCV_HWPROBE_EXT_ZVKNHB = 0x800000
+ RISCV_HWPROBE_EXT_ZVKSED = 0x1000000
+ RISCV_HWPROBE_EXT_ZVKSH = 0x2000000
+ RISCV_HWPROBE_EXT_ZVKT = 0x4000000
+ RISCV_HWPROBE_EXT_ZFH = 0x8000000
+ RISCV_HWPROBE_EXT_ZFHMIN = 0x10000000
+ RISCV_HWPROBE_EXT_ZIHINTNTL = 0x20000000
+ RISCV_HWPROBE_EXT_ZVFH = 0x40000000
+ RISCV_HWPROBE_EXT_ZVFHMIN = 0x80000000
+ RISCV_HWPROBE_EXT_ZFA = 0x100000000
+ RISCV_HWPROBE_EXT_ZTSO = 0x200000000
+ RISCV_HWPROBE_EXT_ZACAS = 0x400000000
+ RISCV_HWPROBE_EXT_ZICOND = 0x800000000
+ RISCV_HWPROBE_EXT_ZIHINTPAUSE = 0x1000000000
RISCV_HWPROBE_KEY_CPUPERF_0 = 0x5
RISCV_HWPROBE_MISALIGNED_UNKNOWN = 0x0
RISCV_HWPROBE_MISALIGNED_EMULATED = 0x1
@@ -734,4 +765,6 @@ const (
RISCV_HWPROBE_MISALIGNED_FAST = 0x3
RISCV_HWPROBE_MISALIGNED_UNSUPPORTED = 0x4
RISCV_HWPROBE_MISALIGNED_MASK = 0x7
+ RISCV_HWPROBE_KEY_ZICBOZ_BLOCK_SIZE = 0x6
+ RISCV_HWPROBE_WHICH_CPUS = 0x1
)
diff --git a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
index d9a13af468..2e5d5a4435 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
@@ -377,6 +377,12 @@ type Flock_t struct {
Pid int32
}
+type F_cnvrt struct {
+ Cvtcmd int32
+ Pccsid int16
+ Fccsid int16
+}
+
type Termios struct {
Cflag uint32
Iflag uint32
diff --git a/vendor/golang.org/x/sys/windows/dll_windows.go b/vendor/golang.org/x/sys/windows/dll_windows.go
index 115341fba6..4e613cf633 100644
--- a/vendor/golang.org/x/sys/windows/dll_windows.go
+++ b/vendor/golang.org/x/sys/windows/dll_windows.go
@@ -65,7 +65,7 @@ func LoadDLL(name string) (dll *DLL, err error) {
return d, nil
}
-// MustLoadDLL is like LoadDLL but panics if load operation failes.
+// MustLoadDLL is like LoadDLL but panics if load operation fails.
func MustLoadDLL(name string) *DLL {
d, e := LoadDLL(name)
if e != nil {
diff --git a/vendor/golang.org/x/sys/windows/security_windows.go b/vendor/golang.org/x/sys/windows/security_windows.go
index 6f7d2ac70a..b6e1ab76f8 100644
--- a/vendor/golang.org/x/sys/windows/security_windows.go
+++ b/vendor/golang.org/x/sys/windows/security_windows.go
@@ -894,7 +894,7 @@ type ACL struct {
aclRevision byte
sbz1 byte
aclSize uint16
- aceCount uint16
+ AceCount uint16
sbz2 uint16
}
@@ -1087,6 +1087,27 @@ type EXPLICIT_ACCESS struct {
Trustee TRUSTEE
}
+// https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-ace_header
+type ACE_HEADER struct {
+ AceType uint8
+ AceFlags uint8
+ AceSize uint16
+}
+
+// https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-access_allowed_ace
+type ACCESS_ALLOWED_ACE struct {
+ Header ACE_HEADER
+ Mask ACCESS_MASK
+ SidStart uint32
+}
+
+const (
+ // Constants for AceType
+ // https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-ace_header
+ ACCESS_ALLOWED_ACE_TYPE = 0
+ ACCESS_DENIED_ACE_TYPE = 1
+)
+
// This type is the union inside of TRUSTEE and must be created using one of the TrusteeValueFrom* functions.
type TrusteeValue uintptr
@@ -1158,6 +1179,7 @@ type OBJECTS_AND_NAME struct {
//sys makeSelfRelativeSD(absoluteSD *SECURITY_DESCRIPTOR, selfRelativeSD *SECURITY_DESCRIPTOR, selfRelativeSDSize *uint32) (err error) = advapi32.MakeSelfRelativeSD
//sys setEntriesInAcl(countExplicitEntries uint32, explicitEntries *EXPLICIT_ACCESS, oldACL *ACL, newACL **ACL) (ret error) = advapi32.SetEntriesInAclW
+//sys GetAce(acl *ACL, aceIndex uint32, pAce **ACCESS_ALLOWED_ACE) (err error) = advapi32.GetAce
// Control returns the security descriptor control bits.
func (sd *SECURITY_DESCRIPTOR) Control() (control SECURITY_DESCRIPTOR_CONTROL, revision uint32, err error) {
diff --git a/vendor/golang.org/x/sys/windows/syscall_windows.go b/vendor/golang.org/x/sys/windows/syscall_windows.go
index 6525c62f3c..4510bfc3f5 100644
--- a/vendor/golang.org/x/sys/windows/syscall_windows.go
+++ b/vendor/golang.org/x/sys/windows/syscall_windows.go
@@ -17,8 +17,10 @@ import (
"unsafe"
)
-type Handle uintptr
-type HWND uintptr
+type (
+ Handle uintptr
+ HWND uintptr
+)
const (
InvalidHandle = ^Handle(0)
@@ -211,6 +213,10 @@ func NewCallbackCDecl(fn interface{}) uintptr {
//sys OpenProcess(desiredAccess uint32, inheritHandle bool, processId uint32) (handle Handle, err error)
//sys ShellExecute(hwnd Handle, verb *uint16, file *uint16, args *uint16, cwd *uint16, showCmd int32) (err error) [failretval<=32] = shell32.ShellExecuteW
//sys GetWindowThreadProcessId(hwnd HWND, pid *uint32) (tid uint32, err error) = user32.GetWindowThreadProcessId
+//sys LoadKeyboardLayout(name *uint16, flags uint32) (hkl Handle, err error) [failretval==0] = user32.LoadKeyboardLayoutW
+//sys UnloadKeyboardLayout(hkl Handle) (err error) = user32.UnloadKeyboardLayout
+//sys GetKeyboardLayout(tid uint32) (hkl Handle) = user32.GetKeyboardLayout
+//sys ToUnicodeEx(vkey uint32, scancode uint32, keystate *byte, pwszBuff *uint16, cchBuff int32, flags uint32, hkl Handle) (ret int32) = user32.ToUnicodeEx
//sys GetShellWindow() (shellWindow HWND) = user32.GetShellWindow
//sys MessageBox(hwnd HWND, text *uint16, caption *uint16, boxtype uint32) (ret int32, err error) [failretval==0] = user32.MessageBoxW
//sys ExitWindowsEx(flags uint32, reason uint32) (err error) = user32.ExitWindowsEx
@@ -307,6 +313,10 @@ func NewCallbackCDecl(fn interface{}) uintptr {
//sys SetConsoleMode(console Handle, mode uint32) (err error) = kernel32.SetConsoleMode
//sys GetConsoleScreenBufferInfo(console Handle, info *ConsoleScreenBufferInfo) (err error) = kernel32.GetConsoleScreenBufferInfo
//sys setConsoleCursorPosition(console Handle, position uint32) (err error) = kernel32.SetConsoleCursorPosition
+//sys GetConsoleCP() (cp uint32, err error) = kernel32.GetConsoleCP
+//sys GetConsoleOutputCP() (cp uint32, err error) = kernel32.GetConsoleOutputCP
+//sys SetConsoleCP(cp uint32) (err error) = kernel32.SetConsoleCP
+//sys SetConsoleOutputCP(cp uint32) (err error) = kernel32.SetConsoleOutputCP
//sys WriteConsole(console Handle, buf *uint16, towrite uint32, written *uint32, reserved *byte) (err error) = kernel32.WriteConsoleW
//sys ReadConsole(console Handle, buf *uint16, toread uint32, read *uint32, inputControl *byte) (err error) = kernel32.ReadConsoleW
//sys resizePseudoConsole(pconsole Handle, size uint32) (hr error) = kernel32.ResizePseudoConsole
@@ -715,20 +725,12 @@ func DurationSinceBoot() time.Duration {
}
func Ftruncate(fd Handle, length int64) (err error) {
- curoffset, e := Seek(fd, 0, 1)
- if e != nil {
- return e
- }
- defer Seek(fd, curoffset, 0)
- _, e = Seek(fd, length, 0)
- if e != nil {
- return e
+ type _FILE_END_OF_FILE_INFO struct {
+ EndOfFile int64
}
- e = SetEndOfFile(fd)
- if e != nil {
- return e
- }
- return nil
+ var info _FILE_END_OF_FILE_INFO
+ info.EndOfFile = length
+ return SetFileInformationByHandle(fd, FileEndOfFileInfo, (*byte)(unsafe.Pointer(&info)), uint32(unsafe.Sizeof(info)))
}
func Gettimeofday(tv *Timeval) (err error) {
@@ -884,6 +886,11 @@ const socket_error = uintptr(^uint32(0))
//sys GetACP() (acp uint32) = kernel32.GetACP
//sys MultiByteToWideChar(codePage uint32, dwFlags uint32, str *byte, nstr int32, wchar *uint16, nwchar int32) (nwrite int32, err error) = kernel32.MultiByteToWideChar
//sys getBestInterfaceEx(sockaddr unsafe.Pointer, pdwBestIfIndex *uint32) (errcode error) = iphlpapi.GetBestInterfaceEx
+//sys GetIfEntry2Ex(level uint32, row *MibIfRow2) (errcode error) = iphlpapi.GetIfEntry2Ex
+//sys GetUnicastIpAddressEntry(row *MibUnicastIpAddressRow) (errcode error) = iphlpapi.GetUnicastIpAddressEntry
+//sys NotifyIpInterfaceChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) = iphlpapi.NotifyIpInterfaceChange
+//sys NotifyUnicastIpAddressChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) = iphlpapi.NotifyUnicastIpAddressChange
+//sys CancelMibChangeNotify2(notificationHandle Handle) (errcode error) = iphlpapi.CancelMibChangeNotify2
// For testing: clients can set this flag to force
// creation of IPv6 sockets to return EAFNOSUPPORT.
@@ -1368,9 +1375,11 @@ func SetsockoptLinger(fd Handle, level, opt int, l *Linger) (err error) {
func SetsockoptInet4Addr(fd Handle, level, opt int, value [4]byte) (err error) {
return Setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(&value[0])), 4)
}
+
func SetsockoptIPMreq(fd Handle, level, opt int, mreq *IPMreq) (err error) {
return Setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(mreq)), int32(unsafe.Sizeof(*mreq)))
}
+
func SetsockoptIPv6Mreq(fd Handle, level, opt int, mreq *IPv6Mreq) (err error) {
return syscall.EWINDOWS
}
@@ -1673,13 +1682,16 @@ func (s NTStatus) Error() string {
// do not use NTUnicodeString, and instead UTF16PtrFromString should be used for
// the more common *uint16 string type.
func NewNTUnicodeString(s string) (*NTUnicodeString, error) {
- var u NTUnicodeString
- s16, err := UTF16PtrFromString(s)
+ s16, err := UTF16FromString(s)
if err != nil {
return nil, err
}
- RtlInitUnicodeString(&u, s16)
- return &u, nil
+ n := uint16(len(s16) * 2)
+ return &NTUnicodeString{
+ Length: n - 2, // subtract 2 bytes for the NULL terminator
+ MaximumLength: n,
+ Buffer: &s16[0],
+ }, nil
}
// Slice returns a uint16 slice that aliases the data in the NTUnicodeString.
diff --git a/vendor/golang.org/x/sys/windows/types_windows.go b/vendor/golang.org/x/sys/windows/types_windows.go
index d8cb71db0a..51311e205f 100644
--- a/vendor/golang.org/x/sys/windows/types_windows.go
+++ b/vendor/golang.org/x/sys/windows/types_windows.go
@@ -1060,6 +1060,7 @@ const (
SIO_GET_EXTENSION_FUNCTION_POINTER = IOC_INOUT | IOC_WS2 | 6
SIO_KEEPALIVE_VALS = IOC_IN | IOC_VENDOR | 4
SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12
+ SIO_UDP_NETRESET = IOC_IN | IOC_VENDOR | 15
// cf. http://support.microsoft.com/default.aspx?scid=kb;en-us;257460
@@ -2003,7 +2004,21 @@ const (
MOVEFILE_FAIL_IF_NOT_TRACKABLE = 0x20
)
-const GAA_FLAG_INCLUDE_PREFIX = 0x00000010
+// Flags for GetAdaptersAddresses, see
+// https://learn.microsoft.com/en-us/windows/win32/api/iphlpapi/nf-iphlpapi-getadaptersaddresses.
+const (
+ GAA_FLAG_SKIP_UNICAST = 0x1
+ GAA_FLAG_SKIP_ANYCAST = 0x2
+ GAA_FLAG_SKIP_MULTICAST = 0x4
+ GAA_FLAG_SKIP_DNS_SERVER = 0x8
+ GAA_FLAG_INCLUDE_PREFIX = 0x10
+ GAA_FLAG_SKIP_FRIENDLY_NAME = 0x20
+ GAA_FLAG_INCLUDE_WINS_INFO = 0x40
+ GAA_FLAG_INCLUDE_GATEWAYS = 0x80
+ GAA_FLAG_INCLUDE_ALL_INTERFACES = 0x100
+ GAA_FLAG_INCLUDE_ALL_COMPARTMENTS = 0x200
+ GAA_FLAG_INCLUDE_TUNNEL_BINDINGORDER = 0x400
+)
const (
IF_TYPE_OTHER = 1
@@ -2017,6 +2032,50 @@ const (
IF_TYPE_IEEE1394 = 144
)
+// Enum NL_PREFIX_ORIGIN for [IpAdapterUnicastAddress], see
+// https://learn.microsoft.com/en-us/windows/win32/api/nldef/ne-nldef-nl_prefix_origin
+const (
+ IpPrefixOriginOther = 0
+ IpPrefixOriginManual = 1
+ IpPrefixOriginWellKnown = 2
+ IpPrefixOriginDhcp = 3
+ IpPrefixOriginRouterAdvertisement = 4
+ IpPrefixOriginUnchanged = 1 << 4
+)
+
+// Enum NL_SUFFIX_ORIGIN for [IpAdapterUnicastAddress], see
+// https://learn.microsoft.com/en-us/windows/win32/api/nldef/ne-nldef-nl_suffix_origin
+const (
+ NlsoOther = 0
+ NlsoManual = 1
+ NlsoWellKnown = 2
+ NlsoDhcp = 3
+ NlsoLinkLayerAddress = 4
+ NlsoRandom = 5
+ IpSuffixOriginOther = 0
+ IpSuffixOriginManual = 1
+ IpSuffixOriginWellKnown = 2
+ IpSuffixOriginDhcp = 3
+ IpSuffixOriginLinkLayerAddress = 4
+ IpSuffixOriginRandom = 5
+ IpSuffixOriginUnchanged = 1 << 4
+)
+
+// Enum NL_DAD_STATE for [IpAdapterUnicastAddress], see
+// https://learn.microsoft.com/en-us/windows/win32/api/nldef/ne-nldef-nl_dad_state
+const (
+ NldsInvalid = 0
+ NldsTentative = 1
+ NldsDuplicate = 2
+ NldsDeprecated = 3
+ NldsPreferred = 4
+ IpDadStateInvalid = 0
+ IpDadStateTentative = 1
+ IpDadStateDuplicate = 2
+ IpDadStateDeprecated = 3
+ IpDadStatePreferred = 4
+)
+
type SocketAddress struct {
Sockaddr *syscall.RawSockaddrAny
SockaddrLength int32
@@ -2144,6 +2203,132 @@ const (
IfOperStatusLowerLayerDown = 7
)
+const (
+ IF_MAX_PHYS_ADDRESS_LENGTH = 32
+ IF_MAX_STRING_SIZE = 256
+)
+
+// MIB_IF_ENTRY_LEVEL enumeration from netioapi.h or
+// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/nf-netioapi-getifentry2ex.
+const (
+ MibIfEntryNormal = 0
+ MibIfEntryNormalWithoutStatistics = 2
+)
+
+// MIB_NOTIFICATION_TYPE enumeration from netioapi.h or
+// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ne-netioapi-mib_notification_type.
+const (
+ MibParameterNotification = 0
+ MibAddInstance = 1
+ MibDeleteInstance = 2
+ MibInitialNotification = 3
+)
+
+// MibIfRow2 stores information about a particular interface. See
+// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-mib_if_row2.
+type MibIfRow2 struct {
+ InterfaceLuid uint64
+ InterfaceIndex uint32
+ InterfaceGuid GUID
+ Alias [IF_MAX_STRING_SIZE + 1]uint16
+ Description [IF_MAX_STRING_SIZE + 1]uint16
+ PhysicalAddressLength uint32
+ PhysicalAddress [IF_MAX_PHYS_ADDRESS_LENGTH]uint8
+ PermanentPhysicalAddress [IF_MAX_PHYS_ADDRESS_LENGTH]uint8
+ Mtu uint32
+ Type uint32
+ TunnelType uint32
+ MediaType uint32
+ PhysicalMediumType uint32
+ AccessType uint32
+ DirectionType uint32
+ InterfaceAndOperStatusFlags uint8
+ OperStatus uint32
+ AdminStatus uint32
+ MediaConnectState uint32
+ NetworkGuid GUID
+ ConnectionType uint32
+ TransmitLinkSpeed uint64
+ ReceiveLinkSpeed uint64
+ InOctets uint64
+ InUcastPkts uint64
+ InNUcastPkts uint64
+ InDiscards uint64
+ InErrors uint64
+ InUnknownProtos uint64
+ InUcastOctets uint64
+ InMulticastOctets uint64
+ InBroadcastOctets uint64
+ OutOctets uint64
+ OutUcastPkts uint64
+ OutNUcastPkts uint64
+ OutDiscards uint64
+ OutErrors uint64
+ OutUcastOctets uint64
+ OutMulticastOctets uint64
+ OutBroadcastOctets uint64
+ OutQLen uint64
+}
+
+// MIB_UNICASTIPADDRESS_ROW stores information about a unicast IP address. See
+// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-mib_unicastipaddress_row.
+type MibUnicastIpAddressRow struct {
+ Address RawSockaddrInet6 // SOCKADDR_INET union
+ InterfaceLuid uint64
+ InterfaceIndex uint32
+ PrefixOrigin uint32
+ SuffixOrigin uint32
+ ValidLifetime uint32
+ PreferredLifetime uint32
+ OnLinkPrefixLength uint8
+ SkipAsSource uint8
+ DadState uint32
+ ScopeId uint32
+ CreationTimeStamp Filetime
+}
+
+const ScopeLevelCount = 16
+
+// MIB_IPINTERFACE_ROW stores interface management information for a particular IP address family on a network interface.
+// See https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-mib_ipinterface_row.
+type MibIpInterfaceRow struct {
+ Family uint16
+ InterfaceLuid uint64
+ InterfaceIndex uint32
+ MaxReassemblySize uint32
+ InterfaceIdentifier uint64
+ MinRouterAdvertisementInterval uint32
+ MaxRouterAdvertisementInterval uint32
+ AdvertisingEnabled uint8
+ ForwardingEnabled uint8
+ WeakHostSend uint8
+ WeakHostReceive uint8
+ UseAutomaticMetric uint8
+ UseNeighborUnreachabilityDetection uint8
+ ManagedAddressConfigurationSupported uint8
+ OtherStatefulConfigurationSupported uint8
+ AdvertiseDefaultRoute uint8
+ RouterDiscoveryBehavior uint32
+ DadTransmits uint32
+ BaseReachableTime uint32
+ RetransmitTime uint32
+ PathMtuDiscoveryTimeout uint32
+ LinkLocalAddressBehavior uint32
+ LinkLocalAddressTimeout uint32
+ ZoneIndices [ScopeLevelCount]uint32
+ SitePrefixLength uint32
+ Metric uint32
+ NlMtu uint32
+ Connected uint8
+ SupportsWakeUpPatterns uint8
+ SupportsNeighborDiscovery uint8
+ SupportsRouterDiscovery uint8
+ ReachableTime uint32
+ TransmitOffload uint32
+ ReceiveOffload uint32
+ DisableDefaultRoutes uint8
+}
+
// Console related constants used for the mode parameter to SetConsoleMode. See
// https://docs.microsoft.com/en-us/windows/console/setconsolemode for details.
@@ -3404,3 +3589,14 @@ type DCB struct {
EvtChar byte
wReserved1 uint16
}
+
+// Keyboard Layout Flags.
+// See https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-loadkeyboardlayoutw
+const (
+ KLF_ACTIVATE = 0x00000001
+ KLF_SUBSTITUTE_OK = 0x00000002
+ KLF_REORDER = 0x00000008
+ KLF_REPLACELANG = 0x00000010
+ KLF_NOTELLSHELL = 0x00000080
+ KLF_SETFORPROCESS = 0x00000100
+)
diff --git a/vendor/golang.org/x/sys/windows/zsyscall_windows.go b/vendor/golang.org/x/sys/windows/zsyscall_windows.go
index 9f73df75b5..6f5252880c 100644
--- a/vendor/golang.org/x/sys/windows/zsyscall_windows.go
+++ b/vendor/golang.org/x/sys/windows/zsyscall_windows.go
@@ -91,6 +91,7 @@ var (
procEnumServicesStatusExW = modadvapi32.NewProc("EnumServicesStatusExW")
procEqualSid = modadvapi32.NewProc("EqualSid")
procFreeSid = modadvapi32.NewProc("FreeSid")
+ procGetAce = modadvapi32.NewProc("GetAce")
procGetLengthSid = modadvapi32.NewProc("GetLengthSid")
procGetNamedSecurityInfoW = modadvapi32.NewProc("GetNamedSecurityInfoW")
procGetSecurityDescriptorControl = modadvapi32.NewProc("GetSecurityDescriptorControl")
@@ -180,10 +181,15 @@ var (
procDnsRecordListFree = moddnsapi.NewProc("DnsRecordListFree")
procDwmGetWindowAttribute = moddwmapi.NewProc("DwmGetWindowAttribute")
procDwmSetWindowAttribute = moddwmapi.NewProc("DwmSetWindowAttribute")
+ procCancelMibChangeNotify2 = modiphlpapi.NewProc("CancelMibChangeNotify2")
procGetAdaptersAddresses = modiphlpapi.NewProc("GetAdaptersAddresses")
procGetAdaptersInfo = modiphlpapi.NewProc("GetAdaptersInfo")
procGetBestInterfaceEx = modiphlpapi.NewProc("GetBestInterfaceEx")
procGetIfEntry = modiphlpapi.NewProc("GetIfEntry")
+ procGetIfEntry2Ex = modiphlpapi.NewProc("GetIfEntry2Ex")
+ procGetUnicastIpAddressEntry = modiphlpapi.NewProc("GetUnicastIpAddressEntry")
+ procNotifyIpInterfaceChange = modiphlpapi.NewProc("NotifyIpInterfaceChange")
+ procNotifyUnicastIpAddressChange = modiphlpapi.NewProc("NotifyUnicastIpAddressChange")
procAddDllDirectory = modkernel32.NewProc("AddDllDirectory")
procAssignProcessToJobObject = modkernel32.NewProc("AssignProcessToJobObject")
procCancelIo = modkernel32.NewProc("CancelIo")
@@ -246,7 +252,9 @@ var (
procGetCommandLineW = modkernel32.NewProc("GetCommandLineW")
procGetComputerNameExW = modkernel32.NewProc("GetComputerNameExW")
procGetComputerNameW = modkernel32.NewProc("GetComputerNameW")
+ procGetConsoleCP = modkernel32.NewProc("GetConsoleCP")
procGetConsoleMode = modkernel32.NewProc("GetConsoleMode")
+ procGetConsoleOutputCP = modkernel32.NewProc("GetConsoleOutputCP")
procGetConsoleScreenBufferInfo = modkernel32.NewProc("GetConsoleScreenBufferInfo")
procGetCurrentDirectoryW = modkernel32.NewProc("GetCurrentDirectoryW")
procGetCurrentProcessId = modkernel32.NewProc("GetCurrentProcessId")
@@ -346,8 +354,10 @@ var (
procSetCommMask = modkernel32.NewProc("SetCommMask")
procSetCommState = modkernel32.NewProc("SetCommState")
procSetCommTimeouts = modkernel32.NewProc("SetCommTimeouts")
+ procSetConsoleCP = modkernel32.NewProc("SetConsoleCP")
procSetConsoleCursorPosition = modkernel32.NewProc("SetConsoleCursorPosition")
procSetConsoleMode = modkernel32.NewProc("SetConsoleMode")
+ procSetConsoleOutputCP = modkernel32.NewProc("SetConsoleOutputCP")
procSetCurrentDirectoryW = modkernel32.NewProc("SetCurrentDirectoryW")
procSetDefaultDllDirectories = modkernel32.NewProc("SetDefaultDllDirectories")
procSetDllDirectoryW = modkernel32.NewProc("SetDllDirectoryW")
@@ -477,12 +487,16 @@ var (
procGetDesktopWindow = moduser32.NewProc("GetDesktopWindow")
procGetForegroundWindow = moduser32.NewProc("GetForegroundWindow")
procGetGUIThreadInfo = moduser32.NewProc("GetGUIThreadInfo")
+ procGetKeyboardLayout = moduser32.NewProc("GetKeyboardLayout")
procGetShellWindow = moduser32.NewProc("GetShellWindow")
procGetWindowThreadProcessId = moduser32.NewProc("GetWindowThreadProcessId")
procIsWindow = moduser32.NewProc("IsWindow")
procIsWindowUnicode = moduser32.NewProc("IsWindowUnicode")
procIsWindowVisible = moduser32.NewProc("IsWindowVisible")
+ procLoadKeyboardLayoutW = moduser32.NewProc("LoadKeyboardLayoutW")
procMessageBoxW = moduser32.NewProc("MessageBoxW")
+ procToUnicodeEx = moduser32.NewProc("ToUnicodeEx")
+ procUnloadKeyboardLayout = moduser32.NewProc("UnloadKeyboardLayout")
procCreateEnvironmentBlock = moduserenv.NewProc("CreateEnvironmentBlock")
procDestroyEnvironmentBlock = moduserenv.NewProc("DestroyEnvironmentBlock")
procGetUserProfileDirectoryW = moduserenv.NewProc("GetUserProfileDirectoryW")
@@ -788,6 +802,14 @@ func FreeSid(sid *SID) (err error) {
return
}
+func GetAce(acl *ACL, aceIndex uint32, pAce **ACCESS_ALLOWED_ACE) (err error) {
+ r1, _, e1 := syscall.Syscall(procGetAce.Addr(), 3, uintptr(unsafe.Pointer(acl)), uintptr(aceIndex), uintptr(unsafe.Pointer(pAce)))
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
func GetLengthSid(sid *SID) (len uint32) {
r0, _, _ := syscall.Syscall(procGetLengthSid.Addr(), 1, uintptr(unsafe.Pointer(sid)), 0, 0)
len = uint32(r0)
@@ -1589,6 +1611,14 @@ func DwmSetWindowAttribute(hwnd HWND, attribute uint32, value unsafe.Pointer, si
return
}
+func CancelMibChangeNotify2(notificationHandle Handle) (errcode error) {
+ r0, _, _ := syscall.SyscallN(procCancelMibChangeNotify2.Addr(), uintptr(notificationHandle))
+ if r0 != 0 {
+ errcode = syscall.Errno(r0)
+ }
+ return
+}
+
func GetAdaptersAddresses(family uint32, flags uint32, reserved uintptr, adapterAddresses *IpAdapterAddresses, sizePointer *uint32) (errcode error) {
r0, _, _ := syscall.Syscall6(procGetAdaptersAddresses.Addr(), 5, uintptr(family), uintptr(flags), uintptr(reserved), uintptr(unsafe.Pointer(adapterAddresses)), uintptr(unsafe.Pointer(sizePointer)), 0)
if r0 != 0 {
@@ -1621,6 +1651,46 @@ func GetIfEntry(pIfRow *MibIfRow) (errcode error) {
return
}
+func GetIfEntry2Ex(level uint32, row *MibIfRow2) (errcode error) {
+ r0, _, _ := syscall.SyscallN(procGetIfEntry2Ex.Addr(), uintptr(level), uintptr(unsafe.Pointer(row)))
+ if r0 != 0 {
+ errcode = syscall.Errno(r0)
+ }
+ return
+}
+
+func GetUnicastIpAddressEntry(row *MibUnicastIpAddressRow) (errcode error) {
+ r0, _, _ := syscall.SyscallN(procGetUnicastIpAddressEntry.Addr(), uintptr(unsafe.Pointer(row)))
+ if r0 != 0 {
+ errcode = syscall.Errno(r0)
+ }
+ return
+}
+
+func NotifyIpInterfaceChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) {
+ var _p0 uint32
+ if initialNotification {
+ _p0 = 1
+ }
+ r0, _, _ := syscall.SyscallN(procNotifyIpInterfaceChange.Addr(), uintptr(family), uintptr(callback), uintptr(callerContext), uintptr(_p0), uintptr(unsafe.Pointer(notificationHandle)))
+ if r0 != 0 {
+ errcode = syscall.Errno(r0)
+ }
+ return
+}
+
+func NotifyUnicastIpAddressChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) {
+ var _p0 uint32
+ if initialNotification {
+ _p0 = 1
+ }
+ r0, _, _ := syscall.SyscallN(procNotifyUnicastIpAddressChange.Addr(), uintptr(family), uintptr(callback), uintptr(callerContext), uintptr(_p0), uintptr(unsafe.Pointer(notificationHandle)))
+ if r0 != 0 {
+ errcode = syscall.Errno(r0)
+ }
+ return
+}
+
func AddDllDirectory(path *uint16) (cookie uintptr, err error) {
r0, _, e1 := syscall.Syscall(procAddDllDirectory.Addr(), 1, uintptr(unsafe.Pointer(path)), 0, 0)
cookie = uintptr(r0)
@@ -2149,6 +2219,15 @@ func GetComputerName(buf *uint16, n *uint32) (err error) {
return
}
+func GetConsoleCP() (cp uint32, err error) {
+ r0, _, e1 := syscall.Syscall(procGetConsoleCP.Addr(), 0, 0, 0, 0)
+ cp = uint32(r0)
+ if cp == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
func GetConsoleMode(console Handle, mode *uint32) (err error) {
r1, _, e1 := syscall.Syscall(procGetConsoleMode.Addr(), 2, uintptr(console), uintptr(unsafe.Pointer(mode)), 0)
if r1 == 0 {
@@ -2157,6 +2236,15 @@ func GetConsoleMode(console Handle, mode *uint32) (err error) {
return
}
+func GetConsoleOutputCP() (cp uint32, err error) {
+ r0, _, e1 := syscall.Syscall(procGetConsoleOutputCP.Addr(), 0, 0, 0, 0)
+ cp = uint32(r0)
+ if cp == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
func GetConsoleScreenBufferInfo(console Handle, info *ConsoleScreenBufferInfo) (err error) {
r1, _, e1 := syscall.Syscall(procGetConsoleScreenBufferInfo.Addr(), 2, uintptr(console), uintptr(unsafe.Pointer(info)), 0)
if r1 == 0 {
@@ -3025,6 +3113,14 @@ func SetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) {
return
}
+func SetConsoleCP(cp uint32) (err error) {
+ r1, _, e1 := syscall.Syscall(procSetConsoleCP.Addr(), 1, uintptr(cp), 0, 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
func setConsoleCursorPosition(console Handle, position uint32) (err error) {
r1, _, e1 := syscall.Syscall(procSetConsoleCursorPosition.Addr(), 2, uintptr(console), uintptr(position), 0)
if r1 == 0 {
@@ -3041,6 +3137,14 @@ func SetConsoleMode(console Handle, mode uint32) (err error) {
return
}
+func SetConsoleOutputCP(cp uint32) (err error) {
+ r1, _, e1 := syscall.Syscall(procSetConsoleOutputCP.Addr(), 1, uintptr(cp), 0, 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
func SetCurrentDirectory(path *uint16) (err error) {
r1, _, e1 := syscall.Syscall(procSetCurrentDirectoryW.Addr(), 1, uintptr(unsafe.Pointer(path)), 0, 0)
if r1 == 0 {
@@ -4073,6 +4177,12 @@ func GetGUIThreadInfo(thread uint32, info *GUIThreadInfo) (err error) {
return
}
+func GetKeyboardLayout(tid uint32) (hkl Handle) {
+ r0, _, _ := syscall.Syscall(procGetKeyboardLayout.Addr(), 1, uintptr(tid), 0, 0)
+ hkl = Handle(r0)
+ return
+}
+
func GetShellWindow() (shellWindow HWND) {
r0, _, _ := syscall.Syscall(procGetShellWindow.Addr(), 0, 0, 0, 0)
shellWindow = HWND(r0)
@@ -4106,6 +4216,15 @@ func IsWindowVisible(hwnd HWND) (isVisible bool) {
return
}
+func LoadKeyboardLayout(name *uint16, flags uint32) (hkl Handle, err error) {
+ r0, _, e1 := syscall.Syscall(procLoadKeyboardLayoutW.Addr(), 2, uintptr(unsafe.Pointer(name)), uintptr(flags), 0)
+ hkl = Handle(r0)
+ if hkl == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
func MessageBox(hwnd HWND, text *uint16, caption *uint16, boxtype uint32) (ret int32, err error) {
r0, _, e1 := syscall.Syscall6(procMessageBoxW.Addr(), 4, uintptr(hwnd), uintptr(unsafe.Pointer(text)), uintptr(unsafe.Pointer(caption)), uintptr(boxtype), 0, 0)
ret = int32(r0)
@@ -4115,6 +4234,20 @@ func MessageBox(hwnd HWND, text *uint16, caption *uint16, boxtype uint32) (ret i
return
}
+func ToUnicodeEx(vkey uint32, scancode uint32, keystate *byte, pwszBuff *uint16, cchBuff int32, flags uint32, hkl Handle) (ret int32) {
+ r0, _, _ := syscall.Syscall9(procToUnicodeEx.Addr(), 7, uintptr(vkey), uintptr(scancode), uintptr(unsafe.Pointer(keystate)), uintptr(unsafe.Pointer(pwszBuff)), uintptr(cchBuff), uintptr(flags), uintptr(hkl), 0, 0)
+ ret = int32(r0)
+ return
+}
+
+func UnloadKeyboardLayout(hkl Handle) (err error) {
+ r1, _, e1 := syscall.Syscall(procUnloadKeyboardLayout.Addr(), 1, uintptr(hkl), 0, 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
func CreateEnvironmentBlock(block **uint16, token Token, inheritExisting bool) (err error) {
var _p0 uint32
if inheritExisting {
diff --git a/vendor/golang.org/x/term/LICENSE b/vendor/golang.org/x/term/LICENSE
index 6a66aea5ea..2a7cf70da6 100644
--- a/vendor/golang.org/x/term/LICENSE
+++ b/vendor/golang.org/x/term/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
+Copyright 2009 The Go Authors.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
@@ -10,7 +10,7 @@ notice, this list of conditions and the following disclaimer.
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
+ * Neither the name of Google LLC nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
diff --git a/vendor/golang.org/x/term/README.md b/vendor/golang.org/x/term/README.md
index d03d0aefef..05ff623f94 100644
--- a/vendor/golang.org/x/term/README.md
+++ b/vendor/golang.org/x/term/README.md
@@ -4,16 +4,13 @@
This repository provides Go terminal and console support packages.
-## Download/Install
-
-The easiest way to install is to run `go get -u golang.org/x/term`. You can
-also manually git clone the repository to `$GOPATH/src/golang.org/x/term`.
-
## Report Issues / Send Patches
This repository uses Gerrit for code changes. To learn how to submit changes to
-this repository, see https://golang.org/doc/contribute.html.
+this repository, see https://go.dev/doc/contribute.
+
+The git repository is https://go.googlesource.com/term.
The main issue tracker for the term repository is located at
-https://github.com/golang/go/issues. Prefix your issue with "x/term:" in the
+https://go.dev/issues. Prefix your issue with "x/term:" in the
subject line, so it is easy to find.
diff --git a/vendor/golang.org/x/term/term_windows.go b/vendor/golang.org/x/term/term_windows.go
index 465f560604..df6bf948e1 100644
--- a/vendor/golang.org/x/term/term_windows.go
+++ b/vendor/golang.org/x/term/term_windows.go
@@ -26,6 +26,7 @@ func makeRaw(fd int) (*State, error) {
return nil, err
}
raw := st &^ (windows.ENABLE_ECHO_INPUT | windows.ENABLE_PROCESSED_INPUT | windows.ENABLE_LINE_INPUT | windows.ENABLE_PROCESSED_OUTPUT)
+ raw |= windows.ENABLE_VIRTUAL_TERMINAL_INPUT
if err := windows.SetConsoleMode(windows.Handle(fd), raw); err != nil {
return nil, err
}
diff --git a/vendor/golang.org/x/text/LICENSE b/vendor/golang.org/x/text/LICENSE
index 6a66aea5ea..2a7cf70da6 100644
--- a/vendor/golang.org/x/text/LICENSE
+++ b/vendor/golang.org/x/text/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
+Copyright 2009 The Go Authors.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
@@ -10,7 +10,7 @@ notice, this list of conditions and the following disclaimer.
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
+ * Neither the name of Google LLC nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
diff --git a/vendor/golang.org/x/text/internal/catmsg/codec.go b/vendor/golang.org/x/text/internal/catmsg/codec.go
index 49c9fc9789..547802b0f3 100644
--- a/vendor/golang.org/x/text/internal/catmsg/codec.go
+++ b/vendor/golang.org/x/text/internal/catmsg/codec.go
@@ -257,7 +257,7 @@ func (d *Decoder) setError(err error) {
// Language returns the language in which the message is being rendered.
//
// The destination language may be a child language of the language used for
-// encoding. For instance, a decoding language of "pt-PT"" is consistent with an
+// encoding. For instance, a decoding language of "pt-PT" is consistent with an
// encoding language of "pt".
func (d *Decoder) Language() language.Tag { return d.tag }
diff --git a/vendor/golang.org/x/text/message/message.go b/vendor/golang.org/x/text/message/message.go
index 48d76630ca..91a9726421 100644
--- a/vendor/golang.org/x/text/message/message.go
+++ b/vendor/golang.org/x/text/message/message.go
@@ -138,21 +138,20 @@ func (p *Printer) Printf(key Reference, a ...interface{}) (n int, err error) {
func lookupAndFormat(p *printer, r Reference, a []interface{}) {
p.fmt.Reset(a)
- var id, msg string
switch v := r.(type) {
case string:
- id, msg = v, v
+ if p.catContext.Execute(v) == catalog.ErrNotFound {
+ p.Render(v)
+ return
+ }
case key:
- id, msg = v.id, v.fallback
- default:
- panic("key argument is not a Reference")
- }
-
- if p.catContext.Execute(id) == catalog.ErrNotFound {
- if p.catContext.Execute(msg) == catalog.ErrNotFound {
- p.Render(msg)
+ if p.catContext.Execute(v.id) == catalog.ErrNotFound &&
+ p.catContext.Execute(v.fallback) == catalog.ErrNotFound {
+ p.Render(v.fallback)
return
}
+ default:
+ panic("key argument is not a Reference")
}
}
diff --git a/vendor/golang.org/x/tools/LICENSE b/vendor/golang.org/x/tools/LICENSE
index 6a66aea5ea..2a7cf70da6 100644
--- a/vendor/golang.org/x/tools/LICENSE
+++ b/vendor/golang.org/x/tools/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
+Copyright 2009 The Go Authors.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
@@ -10,7 +10,7 @@ notice, this list of conditions and the following disclaimer.
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
+ * Neither the name of Google LLC nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
diff --git a/vendor/golang.org/x/tools/cmd/stringer/gotypesalias.go b/vendor/golang.org/x/tools/cmd/stringer/gotypesalias.go
new file mode 100644
index 0000000000..288c10c2d0
--- /dev/null
+++ b/vendor/golang.org/x/tools/cmd/stringer/gotypesalias.go
@@ -0,0 +1,12 @@
+// Copyright 2024 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 go1.23
+
+//go:debug gotypesalias=1
+
+package main
+
+// Materialize aliases whenever the go toolchain version is after 1.23 (#69772).
+// Remove this file after go.mod >= 1.23 (which implies gotypesalias=1).
diff --git a/vendor/golang.org/x/tools/cmd/stringer/stringer.go b/vendor/golang.org/x/tools/cmd/stringer/stringer.go
index 998d1a51bf..09be11ca58 100644
--- a/vendor/golang.org/x/tools/cmd/stringer/stringer.go
+++ b/vendor/golang.org/x/tools/cmd/stringer/stringer.go
@@ -58,6 +58,11 @@
// where t is the lower-cased name of the first type listed. It can be overridden
// with the -output flag.
//
+// Types can also be declared in tests, in which case type declarations in the
+// non-test package or its test variant are preferred over types defined in the
+// package with suffix "_test".
+// The default output file for type declarations in tests is t_string_test.go with t picked as above.
+//
// The -linecomment flag tells stringer to generate the text of any line comment, trimmed
// of leading spaces, instead of the constant name. For instance, if the constants above had a
// Pill prefix, one could write
@@ -128,10 +133,6 @@ func main() {
// Parse the package once.
var dir string
- g := Generator{
- trimPrefix: *trimprefix,
- lineComment: *linecomment,
- }
// TODO(suzmue): accept other patterns for packages (directories, list of files, import paths, etc).
if len(args) == 1 && isDirectory(args[0]) {
dir = args[0]
@@ -142,33 +143,90 @@ func main() {
dir = filepath.Dir(args[0])
}
- g.parsePackage(args, tags)
+ // For each type, generate code in the first package where the type is declared.
+ // The order of packages is as follows:
+ // package x
+ // package x compiled for tests
+ // package x_test
+ //
+ // Each package pass could result in a separate generated file.
+ // These files must have the same package and test/not-test nature as the types
+ // from which they were generated.
+ //
+ // Types will be excluded when generated, to avoid repetitions.
+ pkgs := loadPackages(args, tags, *trimprefix, *linecomment, nil /* logf */)
+ sort.Slice(pkgs, func(i, j int) bool {
+ // Put x_test packages last.
+ iTest := strings.HasSuffix(pkgs[i].name, "_test")
+ jTest := strings.HasSuffix(pkgs[j].name, "_test")
+ if iTest != jTest {
+ return !iTest
+ }
- // Print the header and package clause.
- g.Printf("// Code generated by \"stringer %s\"; DO NOT EDIT.\n", strings.Join(os.Args[1:], " "))
- g.Printf("\n")
- g.Printf("package %s", g.pkg.name)
- g.Printf("\n")
- g.Printf("import \"strconv\"\n") // Used by all methods.
+ return len(pkgs[i].files) < len(pkgs[j].files)
+ })
+ for _, pkg := range pkgs {
+ g := Generator{
+ pkg: pkg,
+ }
- // Run generate for each type.
- for _, typeName := range types {
- g.generate(typeName)
+ // Print the header and package clause.
+ g.Printf("// Code generated by \"stringer %s\"; DO NOT EDIT.\n", strings.Join(os.Args[1:], " "))
+ g.Printf("\n")
+ g.Printf("package %s", g.pkg.name)
+ g.Printf("\n")
+ g.Printf("import \"strconv\"\n") // Used by all methods.
+
+ // Run generate for types that can be found. Keep the rest for the remainingTypes iteration.
+ var foundTypes, remainingTypes []string
+ for _, typeName := range types {
+ values := findValues(typeName, pkg)
+ if len(values) > 0 {
+ g.generate(typeName, values)
+ foundTypes = append(foundTypes, typeName)
+ } else {
+ remainingTypes = append(remainingTypes, typeName)
+ }
+ }
+ if len(foundTypes) == 0 {
+ // This package didn't have any of the relevant types, skip writing a file.
+ continue
+ }
+ if len(remainingTypes) > 0 && output != nil && *output != "" {
+ log.Fatalf("cannot write to single file (-output=%q) when matching types are found in multiple packages", *output)
+ }
+ types = remainingTypes
+
+ // Format the output.
+ src := g.format()
+
+ // Write to file.
+ outputName := *output
+ if outputName == "" {
+ // Type names will be unique across packages since only the first
+ // match is picked.
+ // So there won't be collisions between a package compiled for tests
+ // and the separate package of tests (package foo_test).
+ outputName = filepath.Join(dir, baseName(pkg, foundTypes[0]))
+ }
+ err := os.WriteFile(outputName, src, 0644)
+ if err != nil {
+ log.Fatalf("writing output: %s", err)
+ }
}
- // Format the output.
- src := g.format()
-
- // Write to file.
- outputName := *output
- if outputName == "" {
- baseName := fmt.Sprintf("%s_string.go", types[0])
- outputName = filepath.Join(dir, strings.ToLower(baseName))
+ if len(types) > 0 {
+ log.Fatalf("no values defined for types: %s", strings.Join(types, ","))
}
- err := os.WriteFile(outputName, src, 0644)
- if err != nil {
- log.Fatalf("writing output: %s", err)
+}
+
+// baseName that will put the generated code together with pkg.
+func baseName(pkg *Package, typename string) string {
+ suffix := "string.go"
+ if pkg.hasTestFiles {
+ suffix = "string_test.go"
}
+ return fmt.Sprintf("%s_%s", strings.ToLower(typename), suffix)
}
// isDirectory reports whether the named file is a directory.
@@ -186,8 +244,7 @@ type Generator struct {
buf bytes.Buffer // Accumulated output.
pkg *Package // Package we are scanning.
- trimPrefix string
- lineComment bool
+ logf func(format string, args ...interface{}) // test logging hook; nil when not testing
}
func (g *Generator) Printf(format string, args ...interface{}) {
@@ -207,53 +264,74 @@ type File struct {
}
type Package struct {
- name string
- defs map[*ast.Ident]types.Object
- files []*File
+ name string
+ defs map[*ast.Ident]types.Object
+ files []*File
+ hasTestFiles bool
}
-// parsePackage analyzes the single package constructed from the patterns and tags.
-// parsePackage exits if there is an error.
-func (g *Generator) parsePackage(patterns []string, tags []string) {
+// loadPackages analyzes the single package constructed from the patterns and tags.
+// loadPackages exits if there is an error.
+//
+// Returns all variants (such as tests) of the package.
+//
+// logf is a test logging hook. It can be nil when not testing.
+func loadPackages(
+ patterns, tags []string,
+ trimPrefix string, lineComment bool,
+ logf func(format string, args ...interface{}),
+) []*Package {
cfg := &packages.Config{
- Mode: packages.NeedName | packages.NeedTypes | packages.NeedTypesInfo | packages.NeedSyntax,
- // TODO: Need to think about constants in test files. Maybe write type_string_test.go
- // in a separate pass? For later.
- Tests: false,
+ Mode: packages.NeedName | packages.NeedTypes | packages.NeedTypesInfo | packages.NeedSyntax | packages.NeedFiles,
+ // Tests are included, let the caller decide how to fold them in.
+ Tests: true,
BuildFlags: []string{fmt.Sprintf("-tags=%s", strings.Join(tags, " "))},
+ Logf: logf,
}
pkgs, err := packages.Load(cfg, patterns...)
if err != nil {
log.Fatal(err)
}
- if len(pkgs) != 1 {
- log.Fatalf("error: %d packages found", len(pkgs))
+ if len(pkgs) == 0 {
+ log.Fatalf("error: no packages matching %v", strings.Join(patterns, " "))
}
- g.addPackage(pkgs[0])
-}
-// addPackage adds a type checked Package and its syntax files to the generator.
-func (g *Generator) addPackage(pkg *packages.Package) {
- g.pkg = &Package{
- name: pkg.Name,
- defs: pkg.TypesInfo.Defs,
- files: make([]*File, len(pkg.Syntax)),
- }
+ out := make([]*Package, len(pkgs))
+ for i, pkg := range pkgs {
+ p := &Package{
+ name: pkg.Name,
+ defs: pkg.TypesInfo.Defs,
+ files: make([]*File, len(pkg.Syntax)),
+ }
- for i, file := range pkg.Syntax {
- g.pkg.files[i] = &File{
- file: file,
- pkg: g.pkg,
- trimPrefix: g.trimPrefix,
- lineComment: g.lineComment,
+ for j, file := range pkg.Syntax {
+ p.files[j] = &File{
+ file: file,
+ pkg: p,
+
+ trimPrefix: trimPrefix,
+ lineComment: lineComment,
+ }
}
+
+ // Keep track of test files, since we might want to generated
+ // code that ends up in that kind of package.
+ // Can be replaced once https://go.dev/issue/38445 lands.
+ for _, f := range pkg.GoFiles {
+ if strings.HasSuffix(f, "_test.go") {
+ p.hasTestFiles = true
+ break
+ }
+ }
+
+ out[i] = p
}
+ return out
}
-// generate produces the String method for the named type.
-func (g *Generator) generate(typeName string) {
+func findValues(typeName string, pkg *Package) []Value {
values := make([]Value, 0, 100)
- for _, file := range g.pkg.files {
+ for _, file := range pkg.files {
// Set the state for this run of the walker.
file.typeName = typeName
file.values = nil
@@ -262,10 +340,11 @@ func (g *Generator) generate(typeName string) {
values = append(values, file.values...)
}
}
+ return values
+}
- if len(values) == 0 {
- log.Fatalf("no values defined for type %s", typeName)
- }
+// generate produces the String method for the named type.
+func (g *Generator) generate(typeName string, values []Value) {
// Generate code that will fail if the constants change value.
g.Printf("func _() {\n")
g.Printf("\t// An \"invalid array index\" compiler error signifies that the constant values have changed.\n")
diff --git a/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go b/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
index 03543bd4bb..f3ab0a2e12 100644
--- a/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
+++ b/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
@@ -2,22 +2,64 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// Package gcexportdata provides functions for locating, reading, and
-// writing export data files containing type information produced by the
-// gc compiler. This package supports go1.7 export data format and all
-// later versions.
-//
-// Although it might seem convenient for this package to live alongside
-// go/types in the standard library, this would cause version skew
-// problems for developer tools that use it, since they must be able to
-// consume the outputs of the gc compiler both before and after a Go
-// update such as from Go 1.7 to Go 1.8. Because this package lives in
-// golang.org/x/tools, sites can update their version of this repo some
-// time before the Go 1.8 release and rebuild and redeploy their
-// developer tools, which will then be able to consume both Go 1.7 and
-// Go 1.8 export data files, so they will work before and after the
-// Go update. (See discussion at https://golang.org/issue/15651.)
-package gcexportdata // import "golang.org/x/tools/go/gcexportdata"
+// Package gcexportdata provides functions for reading and writing
+// export data, which is a serialized description of the API of a Go
+// package including the names, kinds, types, and locations of all
+// exported declarations.
+//
+// The standard Go compiler (cmd/compile) writes an export data file
+// for each package it compiles, which it later reads when compiling
+// packages that import the earlier one. The compiler must thus
+// contain logic to both write and read export data.
+// (See the "Export" section in the cmd/compile/README file.)
+//
+// The [Read] function in this package can read files produced by the
+// compiler, producing [go/types] data structures. As a matter of
+// policy, Read supports export data files produced by only the last
+// two Go releases plus tip; see https://go.dev/issue/68898. The
+// export data files produced by the compiler contain additional
+// details related to generics, inlining, and other optimizations that
+// cannot be decoded by the [Read] function.
+//
+// In files written by the compiler, the export data is not at the
+// start of the file. Before calling Read, use [NewReader] to locate
+// the desired portion of the file.
+//
+// The [Write] function in this package encodes the exported API of a
+// Go package ([types.Package]) as a file. Such files can be later
+// decoded by Read, but cannot be consumed by the compiler.
+//
+// # Future changes
+//
+// Although Read supports the formats written by both Write and the
+// compiler, the two are quite different, and there is an open
+// proposal (https://go.dev/issue/69491) to separate these APIs.
+//
+// Under that proposal, this package would ultimately provide only the
+// Read operation for compiler export data, which must be defined in
+// this module (golang.org/x/tools), not in the standard library, to
+// avoid version skew for developer tools that need to read compiler
+// export data both before and after a Go release, such as from Go
+// 1.23 to Go 1.24. Because this package lives in the tools module,
+// clients can update their version of the module some time before the
+// Go 1.24 release and rebuild and redeploy their tools, which will
+// then be able to consume both Go 1.23 and Go 1.24 export data files,
+// so they will work before and after the Go update. (See discussion
+// at https://go.dev/issue/15651.)
+//
+// The operations to import and export [go/types] data structures
+// would be defined in the go/types package as Import and Export.
+// [Write] would (eventually) delegate to Export,
+// and [Read], when it detects a file produced by Export,
+// would delegate to Import.
+//
+// # Deprecations
+//
+// The [NewImporter] and [Find] functions are deprecated and should
+// not be used in new code. The [WriteBundle] and [ReadBundle]
+// functions are experimental, and there is an open proposal to
+// deprecate them (https://go.dev/issue/69573).
+package gcexportdata
import (
"bufio"
@@ -47,7 +89,7 @@ import (
func Find(importPath, srcDir string) (filename, path string) {
cmd := exec.Command("go", "list", "-json", "-export", "--", importPath)
cmd.Dir = srcDir
- out, err := cmd.CombinedOutput()
+ out, err := cmd.Output()
if err != nil {
return "", ""
}
@@ -100,6 +142,11 @@ func readAll(r io.Reader) ([]byte, error) {
// Read reads export data from in, decodes it, and returns type
// information for the package.
//
+// Read is capable of reading export data produced by [Write] at the
+// same source code version, or by the last two Go releases (plus tip)
+// of the standard Go compiler. Reading files from older compilers may
+// produce an error.
+//
// The package path (effectively its linker symbol prefix) is
// specified by path, since unlike the package name, this information
// may not be recorded in the export data.
@@ -128,14 +175,26 @@ func Read(in io.Reader, fset *token.FileSet, imports map[string]*types.Package,
// (from "version"). Select appropriate importer.
if len(data) > 0 {
switch data[0] {
- case 'v', 'c', 'd': // binary, till go1.10
+ case 'v', 'c', 'd':
+ // binary, produced by cmd/compile till go1.10
return nil, fmt.Errorf("binary (%c) import format is no longer supported", data[0])
- case 'i': // indexed, till go1.19
+ case 'i':
+ // indexed, produced by cmd/compile till go1.19,
+ // and also by [Write].
+ //
+ // If proposal #69491 is accepted, go/types
+ // serialization will be implemented by
+ // types.Export, to which Write would eventually
+ // delegate (explicitly dropping any pretence at
+ // inter-version Write-Read compatibility).
+ // This [Read] function would delegate to types.Import
+ // when it detects that the file was produced by Export.
_, pkg, err := gcimporter.IImportData(fset, imports, data[1:], path)
return pkg, err
- case 'u': // unified, from go1.20
+ case 'u':
+ // unified, produced by cmd/compile since go1.20
_, pkg, err := gcimporter.UImportData(fset, imports, data[1:], path)
return pkg, err
diff --git a/vendor/golang.org/x/tools/go/internal/packagesdriver/sizes.go b/vendor/golang.org/x/tools/go/internal/packagesdriver/sizes.go
deleted file mode 100644
index 0454cdd78e..0000000000
--- a/vendor/golang.org/x/tools/go/internal/packagesdriver/sizes.go
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package packagesdriver fetches type sizes for go/packages and go/analysis.
-package packagesdriver
-
-import (
- "context"
- "fmt"
- "strings"
-
- "golang.org/x/tools/internal/gocommand"
-)
-
-var debug = false
-
-func GetSizesForArgsGolist(ctx context.Context, inv gocommand.Invocation, gocmdRunner *gocommand.Runner) (string, string, error) {
- inv.Verb = "list"
- inv.Args = []string{"-f", "{{context.GOARCH}} {{context.Compiler}}", "--", "unsafe"}
- stdout, stderr, friendlyErr, rawErr := gocmdRunner.RunRaw(ctx, inv)
- var goarch, compiler string
- if rawErr != nil {
- if rawErrMsg := rawErr.Error(); strings.Contains(rawErrMsg, "cannot find main module") || strings.Contains(rawErrMsg, "go.mod file not found") {
- // User's running outside of a module. All bets are off. Get GOARCH and guess compiler is gc.
- // TODO(matloob): Is this a problem in practice?
- inv.Verb = "env"
- inv.Args = []string{"GOARCH"}
- envout, enverr := gocmdRunner.Run(ctx, inv)
- if enverr != nil {
- return "", "", enverr
- }
- goarch = strings.TrimSpace(envout.String())
- compiler = "gc"
- } else {
- return "", "", friendlyErr
- }
- } else {
- fields := strings.Fields(stdout.String())
- if len(fields) < 2 {
- return "", "", fmt.Errorf("could not parse GOARCH and Go compiler in format \" \":\nstdout: <<%s>>\nstderr: <<%s>>",
- stdout.String(), stderr.String())
- }
- goarch = fields[0]
- compiler = fields[1]
- }
- return compiler, goarch, nil
-}
diff --git a/vendor/golang.org/x/tools/go/packages/doc.go b/vendor/golang.org/x/tools/go/packages/doc.go
index da4ab89fe6..f1931d10ee 100644
--- a/vendor/golang.org/x/tools/go/packages/doc.go
+++ b/vendor/golang.org/x/tools/go/packages/doc.go
@@ -5,12 +5,20 @@
/*
Package packages loads Go packages for inspection and analysis.
-The Load function takes as input a list of patterns and return a list of Package
-structs describing individual packages matched by those patterns.
-The LoadMode controls the amount of detail in the loaded packages.
-
-Load passes most patterns directly to the underlying build tool,
-but all patterns with the prefix "query=", where query is a
+The [Load] function takes as input a list of patterns and returns a
+list of [Package] values describing individual packages matched by those
+patterns.
+A [Config] specifies configuration options, the most important of which is
+the [LoadMode], which controls the amount of detail in the loaded packages.
+
+Load passes most patterns directly to the underlying build tool.
+The default build tool is the go command.
+Its supported patterns are described at
+https://pkg.go.dev/cmd/go#hdr-Package_lists_and_patterns.
+Other build systems may be supported by providing a "driver";
+see [The driver protocol].
+
+All patterns with the prefix "query=", where query is a
non-empty string of letters from [a-z], are reserved and may be
interpreted as query operators.
@@ -35,7 +43,7 @@ The Package struct provides basic information about the package, including
- Imports, a map from source import strings to the Packages they name;
- Types, the type information for the package's exported symbols;
- Syntax, the parsed syntax trees for the package's source code; and
- - TypeInfo, the result of a complete type-check of the package syntax trees.
+ - TypesInfo, the result of a complete type-check of the package syntax trees.
(See the documentation for type Package for the complete list of fields
and more detailed descriptions.)
@@ -56,7 +64,7 @@ graph using the Imports fields.
The Load function can be configured by passing a pointer to a Config as
the first argument. A nil Config is equivalent to the zero Config, which
-causes Load to run in LoadFiles mode, collecting minimal information.
+causes Load to run in [LoadFiles] mode, collecting minimal information.
See the documentation for type Config for details.
As noted earlier, the Config.Mode controls the amount of detail
@@ -64,9 +72,40 @@ reported about the loaded packages. See the documentation for type LoadMode
for details.
Most tools should pass their command-line arguments (after any flags)
-uninterpreted to the loader, so that the loader can interpret them
+uninterpreted to Load, so that it can interpret them
according to the conventions of the underlying build system.
+
See the Example function for typical usage.
+
+# The driver protocol
+
+Load may be used to load Go packages even in Go projects that use
+alternative build systems, by installing an appropriate "driver"
+program for the build system and specifying its location in the
+GOPACKAGESDRIVER environment variable.
+For example,
+https://github.com/bazelbuild/rules_go/wiki/Editor-and-tool-integration
+explains how to use the driver for Bazel.
+
+The driver program is responsible for interpreting patterns in its
+preferred notation and reporting information about the packages that
+those patterns identify. Drivers must also support the special "file="
+and "pattern=" patterns described above.
+
+The patterns are provided as positional command-line arguments. A
+JSON-encoded [DriverRequest] message providing additional information
+is written to the driver's standard input. The driver must write a
+JSON-encoded [DriverResponse] message to its standard output. (This
+message differs from the JSON schema produced by 'go list'.)
+
+The value of the PWD environment variable seen by the driver process
+is the preferred name of its working directory. (The working directory
+may have other aliases due to symbolic links; see the comment on the
+Dir field of [exec.Cmd] for related information.)
+When the driver process emits in its response the name of a file
+that is a descendant of this directory, it must use an absolute path
+that has the value of PWD as a prefix, to ensure that the returned
+filenames satisfy the original query.
*/
package packages // import "golang.org/x/tools/go/packages"
@@ -168,14 +207,6 @@ Instead, ssadump no longer requests the runtime package,
but seeks it among the dependencies of the user-specified packages,
and emits an error if it is not found.
-Overlays: The Overlay field in the Config allows providing alternate contents
-for Go source files, by providing a mapping from file path to contents.
-go/packages will pull in new imports added in overlay files when go/packages
-is run in LoadImports mode or greater.
-Overlay support for the go list driver isn't complete yet: if the file doesn't
-exist on disk, it will only be recognized in an overlay if it is a non-test file
-and the package would be reported even without the overlay.
-
Questions & Tasks
- Add GOARCH/GOOS?
diff --git a/vendor/golang.org/x/tools/go/packages/external.go b/vendor/golang.org/x/tools/go/packages/external.go
index 7242a0a7d2..96db9daf31 100644
--- a/vendor/golang.org/x/tools/go/packages/external.go
+++ b/vendor/golang.org/x/tools/go/packages/external.go
@@ -2,48 +2,87 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// This file enables an external tool to intercept package requests.
-// If the tool is present then its results are used in preference to
-// the go list command.
-
package packages
+// This file defines the protocol that enables an external "driver"
+// tool to supply package metadata in place of 'go list'.
+
import (
"bytes"
"encoding/json"
"fmt"
- exec "golang.org/x/sys/execabs"
"os"
+ "os/exec"
"strings"
)
-// The Driver Protocol
+// DriverRequest defines the schema of a request for package metadata
+// from an external driver program. The JSON-encoded DriverRequest
+// message is provided to the driver program's standard input. The
+// query patterns are provided as command-line arguments.
//
-// The driver, given the inputs to a call to Load, returns metadata about the packages specified.
-// This allows for different build systems to support go/packages by telling go/packages how the
-// packages' source is organized.
-// The driver is a binary, either specified by the GOPACKAGESDRIVER environment variable or in
-// the path as gopackagesdriver. It's given the inputs to load in its argv. See the package
-// documentation in doc.go for the full description of the patterns that need to be supported.
-// A driver receives as a JSON-serialized driverRequest struct in standard input and will
-// produce a JSON-serialized driverResponse (see definition in packages.go) in its standard output.
-
-// driverRequest is used to provide the portion of Load's Config that is needed by a driver.
-type driverRequest struct {
+// See the package documentation for an overview.
+type DriverRequest struct {
Mode LoadMode `json:"mode"`
+
// Env specifies the environment the underlying build system should be run in.
Env []string `json:"env"`
+
// BuildFlags are flags that should be passed to the underlying build system.
BuildFlags []string `json:"build_flags"`
+
// Tests specifies whether the patterns should also return test packages.
Tests bool `json:"tests"`
- // Overlay maps file paths (relative to the driver's working directory) to the byte contents
- // of overlay files.
+
+ // Overlay maps file paths (relative to the driver's working directory)
+ // to the contents of overlay files (see Config.Overlay).
Overlay map[string][]byte `json:"overlay"`
}
+// DriverResponse defines the schema of a response from an external
+// driver program, providing the results of a query for package
+// metadata. The driver program must write a JSON-encoded
+// DriverResponse message to its standard output.
+//
+// See the package documentation for an overview.
+type DriverResponse struct {
+ // NotHandled is returned if the request can't be handled by the current
+ // driver. If an external driver returns a response with NotHandled, the
+ // rest of the DriverResponse is ignored, and go/packages will fallback
+ // to the next driver. If go/packages is extended in the future to support
+ // lists of multiple drivers, go/packages will fall back to the next driver.
+ NotHandled bool
+
+ // Compiler and Arch are the arguments pass of types.SizesFor
+ // to get a types.Sizes to use when type checking.
+ Compiler string
+ Arch string
+
+ // Roots is the set of package IDs that make up the root packages.
+ // We have to encode this separately because when we encode a single package
+ // we cannot know if it is one of the roots as that requires knowledge of the
+ // graph it is part of.
+ Roots []string `json:",omitempty"`
+
+ // Packages is the full set of packages in the graph.
+ // The packages are not connected into a graph.
+ // The Imports if populated will be stubs that only have their ID set.
+ // Imports will be connected and then type and syntax information added in a
+ // later pass (see refine).
+ Packages []*Package
+
+ // GoVersion is the minor version number used by the driver
+ // (e.g. the go command on the PATH) when selecting .go files.
+ // Zero means unknown.
+ GoVersion int
+}
+
+// driver is the type for functions that query the build system for the
+// packages named by the patterns.
+type driver func(cfg *Config, patterns []string) (*DriverResponse, error)
+
// findExternalDriver returns the file path of a tool that supplies
-// the build system package structure, or "" if not found."
+// the build system package structure, or "" if not found.
// If GOPACKAGESDRIVER is set in the environment findExternalTool returns its
// value, otherwise it searches for a binary named gopackagesdriver on the PATH.
func findExternalDriver(cfg *Config) driver {
@@ -64,8 +103,8 @@ func findExternalDriver(cfg *Config) driver {
return nil
}
}
- return func(cfg *Config, words ...string) (*driverResponse, error) {
- req, err := json.Marshal(driverRequest{
+ return func(cfg *Config, patterns []string) (*DriverResponse, error) {
+ req, err := json.Marshal(DriverRequest{
Mode: cfg.Mode,
Env: cfg.Env,
BuildFlags: cfg.BuildFlags,
@@ -78,9 +117,21 @@ func findExternalDriver(cfg *Config) driver {
buf := new(bytes.Buffer)
stderr := new(bytes.Buffer)
- cmd := exec.CommandContext(cfg.Context, tool, words...)
+ cmd := exec.CommandContext(cfg.Context, tool, patterns...)
cmd.Dir = cfg.Dir
- cmd.Env = cfg.Env
+ // The cwd gets resolved to the real path. On Darwin, where
+ // /tmp is a symlink, this breaks anything that expects the
+ // working directory to keep the original path, including the
+ // go command when dealing with modules.
+ //
+ // os.Getwd stdlib has a special feature where if the
+ // cwd and the PWD are the same node then it trusts
+ // the PWD, so by setting it in the env for the child
+ // process we fix up all the paths returned by the go
+ // command.
+ //
+ // (See similar trick in Invocation.run in ../../internal/gocommand/invoke.go)
+ cmd.Env = append(slicesClip(cfg.Env), "PWD="+cfg.Dir)
cmd.Stdin = bytes.NewReader(req)
cmd.Stdout = buf
cmd.Stderr = stderr
@@ -92,10 +143,14 @@ func findExternalDriver(cfg *Config) driver {
fmt.Fprintf(os.Stderr, "%s stderr: <<%s>>\n", cmdDebugStr(cmd), stderr)
}
- var response driverResponse
+ var response DriverResponse
if err := json.Unmarshal(buf.Bytes(), &response); err != nil {
return nil, err
}
return &response, nil
}
}
+
+// slicesClip removes unused capacity from the slice, returning s[:len(s):len(s)].
+// TODO(adonovan): use go1.21 slices.Clip.
+func slicesClip[S ~[]E, E any](s S) S { return s[:len(s):len(s)] }
diff --git a/vendor/golang.org/x/tools/go/packages/golist.go b/vendor/golang.org/x/tools/go/packages/golist.go
index b5de9cf9f2..76f910ecec 100644
--- a/vendor/golang.org/x/tools/go/packages/golist.go
+++ b/vendor/golang.org/x/tools/go/packages/golist.go
@@ -9,9 +9,9 @@ import (
"context"
"encoding/json"
"fmt"
- "io/ioutil"
"log"
"os"
+ "os/exec"
"path"
"path/filepath"
"reflect"
@@ -21,8 +21,6 @@ import (
"sync"
"unicode"
- exec "golang.org/x/sys/execabs"
- "golang.org/x/tools/go/internal/packagesdriver"
"golang.org/x/tools/internal/gocommand"
"golang.org/x/tools/internal/packagesinternal"
)
@@ -36,23 +34,23 @@ type goTooOldError struct {
error
}
-// responseDeduper wraps a driverResponse, deduplicating its contents.
+// responseDeduper wraps a DriverResponse, deduplicating its contents.
type responseDeduper struct {
seenRoots map[string]bool
seenPackages map[string]*Package
- dr *driverResponse
+ dr *DriverResponse
}
func newDeduper() *responseDeduper {
return &responseDeduper{
- dr: &driverResponse{},
+ dr: &DriverResponse{},
seenRoots: map[string]bool{},
seenPackages: map[string]*Package{},
}
}
-// addAll fills in r with a driverResponse.
-func (r *responseDeduper) addAll(dr *driverResponse) {
+// addAll fills in r with a DriverResponse.
+func (r *responseDeduper) addAll(dr *DriverResponse) {
for _, pkg := range dr.Packages {
r.addPackage(pkg)
}
@@ -82,6 +80,12 @@ type golistState struct {
cfg *Config
ctx context.Context
+ runner *gocommand.Runner
+
+ // overlay is the JSON file that encodes the Config.Overlay
+ // mapping, used by 'go list -overlay=...'.
+ overlay string
+
envOnce sync.Once
goEnvError error
goEnv map[string]string
@@ -129,7 +133,10 @@ func (state *golistState) mustGetEnv() map[string]string {
// goListDriver uses the go list command to interpret the patterns and produce
// the build system package structure.
// See driver for more details.
-func goListDriver(cfg *Config, patterns ...string) (*driverResponse, error) {
+//
+// overlay is the JSON file that encodes the cfg.Overlay
+// mapping, used by 'go list -overlay=...'
+func goListDriver(cfg *Config, runner *gocommand.Runner, overlay string, patterns []string) (_ *DriverResponse, err error) {
// Make sure that any asynchronous go commands are killed when we return.
parentCtx := cfg.Context
if parentCtx == nil {
@@ -144,19 +151,23 @@ func goListDriver(cfg *Config, patterns ...string) (*driverResponse, error) {
cfg: cfg,
ctx: ctx,
vendorDirs: map[string]bool{},
+ overlay: overlay,
+ runner: runner,
}
// Fill in response.Sizes asynchronously if necessary.
- var sizeserr error
- var sizeswg sync.WaitGroup
- if cfg.Mode&NeedTypesSizes != 0 || cfg.Mode&NeedTypes != 0 {
- sizeswg.Add(1)
+ if cfg.Mode&NeedTypesSizes != 0 || cfg.Mode&(NeedTypes|NeedTypesInfo) != 0 {
+ errCh := make(chan error)
go func() {
- compiler, arch, err := packagesdriver.GetSizesForArgsGolist(ctx, state.cfgInvocation(), cfg.gocmdRunner)
- sizeserr = err
+ compiler, arch, err := getSizesForArgs(ctx, state.cfgInvocation(), runner)
response.dr.Compiler = compiler
response.dr.Arch = arch
- sizeswg.Done()
+ errCh <- err
+ }()
+ defer func() {
+ if sizesErr := <-errCh; sizesErr != nil {
+ err = sizesErr
+ }
}()
}
@@ -209,87 +220,10 @@ extractQueries:
}
}
- // Only use go/packages' overlay processing if we're using a Go version
- // below 1.16. Otherwise, go list handles it.
- if goVersion, err := state.getGoVersion(); err == nil && goVersion < 16 {
- modifiedPkgs, needPkgs, err := state.processGolistOverlay(response)
- if err != nil {
- return nil, err
- }
-
- var containsCandidates []string
- if len(containFiles) > 0 {
- containsCandidates = append(containsCandidates, modifiedPkgs...)
- containsCandidates = append(containsCandidates, needPkgs...)
- }
- if err := state.addNeededOverlayPackages(response, needPkgs); err != nil {
- return nil, err
- }
- // Check candidate packages for containFiles.
- if len(containFiles) > 0 {
- for _, id := range containsCandidates {
- pkg, ok := response.seenPackages[id]
- if !ok {
- response.addPackage(&Package{
- ID: id,
- Errors: []Error{{
- Kind: ListError,
- Msg: fmt.Sprintf("package %s expected but not seen", id),
- }},
- })
- continue
- }
- for _, f := range containFiles {
- for _, g := range pkg.GoFiles {
- if sameFile(f, g) {
- response.addRoot(id)
- }
- }
- }
- }
- }
- // Add root for any package that matches a pattern. This applies only to
- // packages that are modified by overlays, since they are not added as
- // roots automatically.
- for _, pattern := range restPatterns {
- match := matchPattern(pattern)
- for _, pkgID := range modifiedPkgs {
- pkg, ok := response.seenPackages[pkgID]
- if !ok {
- continue
- }
- if match(pkg.PkgPath) {
- response.addRoot(pkg.ID)
- }
- }
- }
- }
-
- sizeswg.Wait()
- if sizeserr != nil {
- return nil, sizeserr
- }
+ // (We may yet return an error due to defer.)
return response.dr, nil
}
-func (state *golistState) addNeededOverlayPackages(response *responseDeduper, pkgs []string) error {
- if len(pkgs) == 0 {
- return nil
- }
- dr, err := state.createDriverResponse(pkgs...)
- if err != nil {
- return err
- }
- for _, pkg := range dr.Packages {
- response.addPackage(pkg)
- }
- _, needPkgs, err := state.processGolistOverlay(response)
- if err != nil {
- return err
- }
- return state.addNeededOverlayPackages(response, needPkgs)
-}
-
func (state *golistState) runContainsQueries(response *responseDeduper, queries []string) error {
for _, query := range queries {
// TODO(matloob): Do only one query per directory.
@@ -341,7 +275,7 @@ func (state *golistState) runContainsQueries(response *responseDeduper, queries
// adhocPackage attempts to load or construct an ad-hoc package for a given
// query, if the original call to the driver produced inadequate results.
-func (state *golistState) adhocPackage(pattern, query string) (*driverResponse, error) {
+func (state *golistState) adhocPackage(pattern, query string) (*DriverResponse, error) {
response, err := state.createDriverResponse(query)
if err != nil {
return nil, err
@@ -432,7 +366,7 @@ func otherFiles(p *jsonPackage) [][]string {
// createDriverResponse uses the "go list" command to expand the pattern
// words and return a response for the specified packages.
-func (state *golistState) createDriverResponse(words ...string) (*driverResponse, error) {
+func (state *golistState) createDriverResponse(words ...string) (*DriverResponse, error) {
// go list uses the following identifiers in ImportPath and Imports:
//
// "p" -- importable package or main (command)
@@ -459,7 +393,7 @@ func (state *golistState) createDriverResponse(words ...string) (*driverResponse
pkgs := make(map[string]*Package)
additionalErrors := make(map[string][]Error)
// Decode the JSON and convert it to Package form.
- response := &driverResponse{
+ response := &DriverResponse{
GoVersion: goVersion,
}
for dec := json.NewDecoder(buf); dec.More(); {
@@ -758,7 +692,7 @@ func (state *golistState) shouldAddFilenameFromError(p *jsonPackage) bool {
// getGoVersion returns the effective minor version of the go command.
func (state *golistState) getGoVersion() (int, error) {
state.goVersionOnce.Do(func() {
- state.goVersion, state.goVersionError = gocommand.GoVersion(state.ctx, state.cfgInvocation(), state.cfg.gocmdRunner)
+ state.goVersion, state.goVersionError = gocommand.GoVersion(state.ctx, state.cfgInvocation(), state.runner)
})
return state.goVersion, state.goVersionError
}
@@ -828,7 +762,7 @@ func jsonFlag(cfg *Config, goVersion int) string {
}
}
addFields("Name", "ImportPath", "Error") // These fields are always needed
- if cfg.Mode&NeedFiles != 0 || cfg.Mode&NeedTypes != 0 {
+ if cfg.Mode&NeedFiles != 0 || cfg.Mode&(NeedTypes|NeedTypesInfo) != 0 {
addFields("Dir", "GoFiles", "IgnoredGoFiles", "IgnoredOtherFiles", "CFiles",
"CgoFiles", "CXXFiles", "MFiles", "HFiles", "FFiles", "SFiles",
"SwigFiles", "SwigCXXFiles", "SysoFiles")
@@ -836,7 +770,7 @@ func jsonFlag(cfg *Config, goVersion int) string {
addFields("TestGoFiles", "XTestGoFiles")
}
}
- if cfg.Mode&NeedTypes != 0 {
+ if cfg.Mode&(NeedTypes|NeedTypesInfo) != 0 {
// CompiledGoFiles seems to be required for the test case TestCgoNoSyntax,
// even when -compiled isn't passed in.
// TODO(#52435): Should we make the test ask for -compiled, or automatically
@@ -917,6 +851,7 @@ func (state *golistState) cfgInvocation() gocommand.Invocation {
Env: cfg.Env,
Logf: cfg.Logf,
WorkingDir: cfg.Dir,
+ Overlay: state.overlay,
}
}
@@ -925,33 +860,10 @@ func (state *golistState) invokeGo(verb string, args ...string) (*bytes.Buffer,
cfg := state.cfg
inv := state.cfgInvocation()
-
- // For Go versions 1.16 and above, `go list` accepts overlays directly via
- // the -overlay flag. Set it, if it's available.
- //
- // The check for "list" is not necessarily required, but we should avoid
- // getting the go version if possible.
- if verb == "list" {
- goVersion, err := state.getGoVersion()
- if err != nil {
- return nil, err
- }
- if goVersion >= 16 {
- filename, cleanup, err := state.writeOverlays()
- if err != nil {
- return nil, err
- }
- defer cleanup()
- inv.Overlay = filename
- }
- }
inv.Verb = verb
inv.Args = args
- gocmdRunner := cfg.gocmdRunner
- if gocmdRunner == nil {
- gocmdRunner = &gocommand.Runner{}
- }
- stdout, stderr, friendlyErr, err := gocmdRunner.RunRaw(cfg.Context, inv)
+
+ stdout, stderr, friendlyErr, err := state.runner.RunRaw(cfg.Context, inv)
if err != nil {
// Check for 'go' executable not being found.
if ee, ok := err.(*exec.Error); ok && ee.Err == exec.ErrNotFound {
@@ -975,6 +887,12 @@ func (state *golistState) invokeGo(verb string, args ...string) (*bytes.Buffer,
return nil, friendlyErr
}
+ // Return an error if 'go list' failed due to missing tools in
+ // $GOROOT/pkg/tool/$GOOS_$GOARCH (#69606).
+ if len(stderr.String()) > 0 && strings.Contains(stderr.String(), `go: no such tool`) {
+ return nil, friendlyErr
+ }
+
// Is there an error running the C compiler in cgo? This will be reported in the "Error" field
// and should be suppressed by go list -e.
//
@@ -1091,67 +1009,6 @@ func (state *golistState) invokeGo(verb string, args ...string) (*bytes.Buffer,
return stdout, nil
}
-// OverlayJSON is the format overlay files are expected to be in.
-// The Replace map maps from overlaid paths to replacement paths:
-// the Go command will forward all reads trying to open
-// each overlaid path to its replacement path, or consider the overlaid
-// path not to exist if the replacement path is empty.
-//
-// From golang/go#39958.
-type OverlayJSON struct {
- Replace map[string]string `json:"replace,omitempty"`
-}
-
-// writeOverlays writes out files for go list's -overlay flag, as described
-// above.
-func (state *golistState) writeOverlays() (filename string, cleanup func(), err error) {
- // Do nothing if there are no overlays in the config.
- if len(state.cfg.Overlay) == 0 {
- return "", func() {}, nil
- }
- dir, err := ioutil.TempDir("", "gopackages-*")
- if err != nil {
- return "", nil, err
- }
- // The caller must clean up this directory, unless this function returns an
- // error.
- cleanup = func() {
- os.RemoveAll(dir)
- }
- defer func() {
- if err != nil {
- cleanup()
- }
- }()
- overlays := map[string]string{}
- for k, v := range state.cfg.Overlay {
- // Create a unique filename for the overlaid files, to avoid
- // creating nested directories.
- noSeparator := strings.Join(strings.Split(filepath.ToSlash(k), "/"), "")
- f, err := ioutil.TempFile(dir, fmt.Sprintf("*-%s", noSeparator))
- if err != nil {
- return "", func() {}, err
- }
- if _, err := f.Write(v); err != nil {
- return "", func() {}, err
- }
- if err := f.Close(); err != nil {
- return "", func() {}, err
- }
- overlays[k] = f.Name()
- }
- b, err := json.Marshal(OverlayJSON{Replace: overlays})
- if err != nil {
- return "", func() {}, err
- }
- // Write out the overlay file that contains the filepath mappings.
- filename = filepath.Join(dir, "overlay.json")
- if err := ioutil.WriteFile(filename, b, 0665); err != nil {
- return "", func() {}, err
- }
- return filename, cleanup, nil
-}
-
func containsGoFile(s []string) bool {
for _, f := range s {
if strings.HasSuffix(f, ".go") {
@@ -1180,3 +1037,44 @@ func cmdDebugStr(cmd *exec.Cmd) string {
}
return fmt.Sprintf("GOROOT=%v GOPATH=%v GO111MODULE=%v GOPROXY=%v PWD=%v %v", env["GOROOT"], env["GOPATH"], env["GO111MODULE"], env["GOPROXY"], env["PWD"], strings.Join(args, " "))
}
+
+// getSizesForArgs queries 'go list' for the appropriate
+// Compiler and GOARCH arguments to pass to [types.SizesFor].
+func getSizesForArgs(ctx context.Context, inv gocommand.Invocation, gocmdRunner *gocommand.Runner) (string, string, error) {
+ inv.Verb = "list"
+ inv.Args = []string{"-f", "{{context.GOARCH}} {{context.Compiler}}", "--", "unsafe"}
+ stdout, stderr, friendlyErr, rawErr := gocmdRunner.RunRaw(ctx, inv)
+ var goarch, compiler string
+ if rawErr != nil {
+ rawErrMsg := rawErr.Error()
+ if strings.Contains(rawErrMsg, "cannot find main module") ||
+ strings.Contains(rawErrMsg, "go.mod file not found") {
+ // User's running outside of a module.
+ // All bets are off. Get GOARCH and guess compiler is gc.
+ // TODO(matloob): Is this a problem in practice?
+ inv.Verb = "env"
+ inv.Args = []string{"GOARCH"}
+ envout, enverr := gocmdRunner.Run(ctx, inv)
+ if enverr != nil {
+ return "", "", enverr
+ }
+ goarch = strings.TrimSpace(envout.String())
+ compiler = "gc"
+ } else if friendlyErr != nil {
+ return "", "", friendlyErr
+ } else {
+ // This should be unreachable, but be defensive
+ // in case RunRaw's error results are inconsistent.
+ return "", "", rawErr
+ }
+ } else {
+ fields := strings.Fields(stdout.String())
+ if len(fields) < 2 {
+ return "", "", fmt.Errorf("could not parse GOARCH and Go compiler in format \" \":\nstdout: <<%s>>\nstderr: <<%s>>",
+ stdout.String(), stderr.String())
+ }
+ goarch = fields[0]
+ compiler = fields[1]
+ }
+ return compiler, goarch, nil
+}
diff --git a/vendor/golang.org/x/tools/go/packages/golist_overlay.go b/vendor/golang.org/x/tools/go/packages/golist_overlay.go
index 9576b472f9..d823c474ad 100644
--- a/vendor/golang.org/x/tools/go/packages/golist_overlay.go
+++ b/vendor/golang.org/x/tools/go/packages/golist_overlay.go
@@ -6,314 +6,11 @@ package packages
import (
"encoding/json"
- "fmt"
- "go/parser"
- "go/token"
- "os"
"path/filepath"
- "regexp"
- "sort"
- "strconv"
- "strings"
"golang.org/x/tools/internal/gocommand"
)
-// processGolistOverlay provides rudimentary support for adding
-// files that don't exist on disk to an overlay. The results can be
-// sometimes incorrect.
-// TODO(matloob): Handle unsupported cases, including the following:
-// - determining the correct package to add given a new import path
-func (state *golistState) processGolistOverlay(response *responseDeduper) (modifiedPkgs, needPkgs []string, err error) {
- havePkgs := make(map[string]string) // importPath -> non-test package ID
- needPkgsSet := make(map[string]bool)
- modifiedPkgsSet := make(map[string]bool)
-
- pkgOfDir := make(map[string][]*Package)
- for _, pkg := range response.dr.Packages {
- // This is an approximation of import path to id. This can be
- // wrong for tests, vendored packages, and a number of other cases.
- havePkgs[pkg.PkgPath] = pkg.ID
- dir, err := commonDir(pkg.GoFiles)
- if err != nil {
- return nil, nil, err
- }
- if dir != "" {
- pkgOfDir[dir] = append(pkgOfDir[dir], pkg)
- }
- }
-
- // If no new imports are added, it is safe to avoid loading any needPkgs.
- // Otherwise, it's hard to tell which package is actually being loaded
- // (due to vendoring) and whether any modified package will show up
- // in the transitive set of dependencies (because new imports are added,
- // potentially modifying the transitive set of dependencies).
- var overlayAddsImports bool
-
- // If both a package and its test package are created by the overlay, we
- // need the real package first. Process all non-test files before test
- // files, and make the whole process deterministic while we're at it.
- var overlayFiles []string
- for opath := range state.cfg.Overlay {
- overlayFiles = append(overlayFiles, opath)
- }
- sort.Slice(overlayFiles, func(i, j int) bool {
- iTest := strings.HasSuffix(overlayFiles[i], "_test.go")
- jTest := strings.HasSuffix(overlayFiles[j], "_test.go")
- if iTest != jTest {
- return !iTest // non-tests are before tests.
- }
- return overlayFiles[i] < overlayFiles[j]
- })
- for _, opath := range overlayFiles {
- contents := state.cfg.Overlay[opath]
- base := filepath.Base(opath)
- dir := filepath.Dir(opath)
- var pkg *Package // if opath belongs to both a package and its test variant, this will be the test variant
- var testVariantOf *Package // if opath is a test file, this is the package it is testing
- var fileExists bool
- isTestFile := strings.HasSuffix(opath, "_test.go")
- pkgName, ok := extractPackageName(opath, contents)
- if !ok {
- // Don't bother adding a file that doesn't even have a parsable package statement
- // to the overlay.
- continue
- }
- // If all the overlay files belong to a different package, change the
- // package name to that package.
- maybeFixPackageName(pkgName, isTestFile, pkgOfDir[dir])
- nextPackage:
- for _, p := range response.dr.Packages {
- if pkgName != p.Name && p.ID != "command-line-arguments" {
- continue
- }
- for _, f := range p.GoFiles {
- if !sameFile(filepath.Dir(f), dir) {
- continue
- }
- // Make sure to capture information on the package's test variant, if needed.
- if isTestFile && !hasTestFiles(p) {
- // TODO(matloob): Are there packages other than the 'production' variant
- // of a package that this can match? This shouldn't match the test main package
- // because the file is generated in another directory.
- testVariantOf = p
- continue nextPackage
- } else if !isTestFile && hasTestFiles(p) {
- // We're examining a test variant, but the overlaid file is
- // a non-test file. Because the overlay implementation
- // (currently) only adds a file to one package, skip this
- // package, so that we can add the file to the production
- // variant of the package. (https://golang.org/issue/36857
- // tracks handling overlays on both the production and test
- // variant of a package).
- continue nextPackage
- }
- if pkg != nil && p != pkg && pkg.PkgPath == p.PkgPath {
- // We have already seen the production version of the
- // for which p is a test variant.
- if hasTestFiles(p) {
- testVariantOf = pkg
- }
- }
- pkg = p
- if filepath.Base(f) == base {
- fileExists = true
- }
- }
- }
- // The overlay could have included an entirely new package or an
- // ad-hoc package. An ad-hoc package is one that we have manually
- // constructed from inadequate `go list` results for a file= query.
- // It will have the ID command-line-arguments.
- if pkg == nil || pkg.ID == "command-line-arguments" {
- // Try to find the module or gopath dir the file is contained in.
- // Then for modules, add the module opath to the beginning.
- pkgPath, ok, err := state.getPkgPath(dir)
- if err != nil {
- return nil, nil, err
- }
- if !ok {
- break
- }
- var forTest string // only set for x tests
- isXTest := strings.HasSuffix(pkgName, "_test")
- if isXTest {
- forTest = pkgPath
- pkgPath += "_test"
- }
- id := pkgPath
- if isTestFile {
- if isXTest {
- id = fmt.Sprintf("%s [%s.test]", pkgPath, forTest)
- } else {
- id = fmt.Sprintf("%s [%s.test]", pkgPath, pkgPath)
- }
- }
- if pkg != nil {
- // TODO(rstambler): We should change the package's path and ID
- // here. The only issue is that this messes with the roots.
- } else {
- // Try to reclaim a package with the same ID, if it exists in the response.
- for _, p := range response.dr.Packages {
- if reclaimPackage(p, id, opath, contents) {
- pkg = p
- break
- }
- }
- // Otherwise, create a new package.
- if pkg == nil {
- pkg = &Package{
- PkgPath: pkgPath,
- ID: id,
- Name: pkgName,
- Imports: make(map[string]*Package),
- }
- response.addPackage(pkg)
- havePkgs[pkg.PkgPath] = id
- // Add the production package's sources for a test variant.
- if isTestFile && !isXTest && testVariantOf != nil {
- pkg.GoFiles = append(pkg.GoFiles, testVariantOf.GoFiles...)
- pkg.CompiledGoFiles = append(pkg.CompiledGoFiles, testVariantOf.CompiledGoFiles...)
- // Add the package under test and its imports to the test variant.
- pkg.forTest = testVariantOf.PkgPath
- for k, v := range testVariantOf.Imports {
- pkg.Imports[k] = &Package{ID: v.ID}
- }
- }
- if isXTest {
- pkg.forTest = forTest
- }
- }
- }
- }
- if !fileExists {
- pkg.GoFiles = append(pkg.GoFiles, opath)
- // TODO(matloob): Adding the file to CompiledGoFiles can exhibit the wrong behavior
- // if the file will be ignored due to its build tags.
- pkg.CompiledGoFiles = append(pkg.CompiledGoFiles, opath)
- modifiedPkgsSet[pkg.ID] = true
- }
- imports, err := extractImports(opath, contents)
- if err != nil {
- // Let the parser or type checker report errors later.
- continue
- }
- for _, imp := range imports {
- // TODO(rstambler): If the package is an x test and the import has
- // a test variant, make sure to replace it.
- if _, found := pkg.Imports[imp]; found {
- continue
- }
- overlayAddsImports = true
- id, ok := havePkgs[imp]
- if !ok {
- var err error
- id, err = state.resolveImport(dir, imp)
- if err != nil {
- return nil, nil, err
- }
- }
- pkg.Imports[imp] = &Package{ID: id}
- // Add dependencies to the non-test variant version of this package as well.
- if testVariantOf != nil {
- testVariantOf.Imports[imp] = &Package{ID: id}
- }
- }
- }
-
- // toPkgPath guesses the package path given the id.
- toPkgPath := func(sourceDir, id string) (string, error) {
- if i := strings.IndexByte(id, ' '); i >= 0 {
- return state.resolveImport(sourceDir, id[:i])
- }
- return state.resolveImport(sourceDir, id)
- }
-
- // Now that new packages have been created, do another pass to determine
- // the new set of missing packages.
- for _, pkg := range response.dr.Packages {
- for _, imp := range pkg.Imports {
- if len(pkg.GoFiles) == 0 {
- return nil, nil, fmt.Errorf("cannot resolve imports for package %q with no Go files", pkg.PkgPath)
- }
- pkgPath, err := toPkgPath(filepath.Dir(pkg.GoFiles[0]), imp.ID)
- if err != nil {
- return nil, nil, err
- }
- if _, ok := havePkgs[pkgPath]; !ok {
- needPkgsSet[pkgPath] = true
- }
- }
- }
-
- if overlayAddsImports {
- needPkgs = make([]string, 0, len(needPkgsSet))
- for pkg := range needPkgsSet {
- needPkgs = append(needPkgs, pkg)
- }
- }
- modifiedPkgs = make([]string, 0, len(modifiedPkgsSet))
- for pkg := range modifiedPkgsSet {
- modifiedPkgs = append(modifiedPkgs, pkg)
- }
- return modifiedPkgs, needPkgs, err
-}
-
-// resolveImport finds the ID of a package given its import path.
-// In particular, it will find the right vendored copy when in GOPATH mode.
-func (state *golistState) resolveImport(sourceDir, importPath string) (string, error) {
- env, err := state.getEnv()
- if err != nil {
- return "", err
- }
- if env["GOMOD"] != "" {
- return importPath, nil
- }
-
- searchDir := sourceDir
- for {
- vendorDir := filepath.Join(searchDir, "vendor")
- exists, ok := state.vendorDirs[vendorDir]
- if !ok {
- info, err := os.Stat(vendorDir)
- exists = err == nil && info.IsDir()
- state.vendorDirs[vendorDir] = exists
- }
-
- if exists {
- vendoredPath := filepath.Join(vendorDir, importPath)
- if info, err := os.Stat(vendoredPath); err == nil && info.IsDir() {
- // We should probably check for .go files here, but shame on anyone who fools us.
- path, ok, err := state.getPkgPath(vendoredPath)
- if err != nil {
- return "", err
- }
- if ok {
- return path, nil
- }
- }
- }
-
- // We know we've hit the top of the filesystem when we Dir / and get /,
- // or C:\ and get C:\, etc.
- next := filepath.Dir(searchDir)
- if next == searchDir {
- break
- }
- searchDir = next
- }
- return importPath, nil
-}
-
-func hasTestFiles(p *Package) bool {
- for _, f := range p.GoFiles {
- if strings.HasSuffix(f, "_test.go") {
- return true
- }
- }
- return false
-}
-
// determineRootDirs returns a mapping from absolute directories that could
// contain code to their corresponding import path prefixes.
func (state *golistState) determineRootDirs() (map[string]string, error) {
@@ -384,192 +81,3 @@ func (state *golistState) determineRootDirsGOPATH() (map[string]string, error) {
}
return m, nil
}
-
-func extractImports(filename string, contents []byte) ([]string, error) {
- f, err := parser.ParseFile(token.NewFileSet(), filename, contents, parser.ImportsOnly) // TODO(matloob): reuse fileset?
- if err != nil {
- return nil, err
- }
- var res []string
- for _, imp := range f.Imports {
- quotedPath := imp.Path.Value
- path, err := strconv.Unquote(quotedPath)
- if err != nil {
- return nil, err
- }
- res = append(res, path)
- }
- return res, nil
-}
-
-// reclaimPackage attempts to reuse a package that failed to load in an overlay.
-//
-// If the package has errors and has no Name, GoFiles, or Imports,
-// then it's possible that it doesn't yet exist on disk.
-func reclaimPackage(pkg *Package, id string, filename string, contents []byte) bool {
- // TODO(rstambler): Check the message of the actual error?
- // It differs between $GOPATH and module mode.
- if pkg.ID != id {
- return false
- }
- if len(pkg.Errors) != 1 {
- return false
- }
- if pkg.Name != "" || pkg.ExportFile != "" {
- return false
- }
- if len(pkg.GoFiles) > 0 || len(pkg.CompiledGoFiles) > 0 || len(pkg.OtherFiles) > 0 {
- return false
- }
- if len(pkg.Imports) > 0 {
- return false
- }
- pkgName, ok := extractPackageName(filename, contents)
- if !ok {
- return false
- }
- pkg.Name = pkgName
- pkg.Errors = nil
- return true
-}
-
-func extractPackageName(filename string, contents []byte) (string, bool) {
- // TODO(rstambler): Check the message of the actual error?
- // It differs between $GOPATH and module mode.
- f, err := parser.ParseFile(token.NewFileSet(), filename, contents, parser.PackageClauseOnly) // TODO(matloob): reuse fileset?
- if err != nil {
- return "", false
- }
- return f.Name.Name, true
-}
-
-// commonDir returns the directory that all files are in, "" if files is empty,
-// or an error if they aren't in the same directory.
-func commonDir(files []string) (string, error) {
- seen := make(map[string]bool)
- for _, f := range files {
- seen[filepath.Dir(f)] = true
- }
- if len(seen) > 1 {
- return "", fmt.Errorf("files (%v) are in more than one directory: %v", files, seen)
- }
- for k := range seen {
- // seen has only one element; return it.
- return k, nil
- }
- return "", nil // no files
-}
-
-// It is possible that the files in the disk directory dir have a different package
-// name from newName, which is deduced from the overlays. If they all have a different
-// package name, and they all have the same package name, then that name becomes
-// the package name.
-// It returns true if it changes the package name, false otherwise.
-func maybeFixPackageName(newName string, isTestFile bool, pkgsOfDir []*Package) {
- names := make(map[string]int)
- for _, p := range pkgsOfDir {
- names[p.Name]++
- }
- if len(names) != 1 {
- // some files are in different packages
- return
- }
- var oldName string
- for k := range names {
- oldName = k
- }
- if newName == oldName {
- return
- }
- // We might have a case where all of the package names in the directory are
- // the same, but the overlay file is for an x test, which belongs to its
- // own package. If the x test does not yet exist on disk, we may not yet
- // have its package name on disk, but we should not rename the packages.
- //
- // We use a heuristic to determine if this file belongs to an x test:
- // The test file should have a package name whose package name has a _test
- // suffix or looks like "newName_test".
- maybeXTest := strings.HasPrefix(oldName+"_test", newName) || strings.HasSuffix(newName, "_test")
- if isTestFile && maybeXTest {
- return
- }
- for _, p := range pkgsOfDir {
- p.Name = newName
- }
-}
-
-// This function is copy-pasted from
-// https://github.com/golang/go/blob/9706f510a5e2754595d716bd64be8375997311fb/src/cmd/go/internal/search/search.go#L360.
-// It should be deleted when we remove support for overlays from go/packages.
-//
-// NOTE: This does not handle any ./... or ./ style queries, as this function
-// doesn't know the working directory.
-//
-// matchPattern(pattern)(name) reports whether
-// name matches pattern. Pattern is a limited glob
-// pattern in which '...' means 'any string' and there
-// is no other special syntax.
-// Unfortunately, there are two special cases. Quoting "go help packages":
-//
-// First, /... at the end of the pattern can match an empty string,
-// so that net/... matches both net and packages in its subdirectories, like net/http.
-// Second, any slash-separated pattern element containing a wildcard never
-// participates in a match of the "vendor" element in the path of a vendored
-// package, so that ./... does not match packages in subdirectories of
-// ./vendor or ./mycode/vendor, but ./vendor/... and ./mycode/vendor/... do.
-// Note, however, that a directory named vendor that itself contains code
-// is not a vendored package: cmd/vendor would be a command named vendor,
-// and the pattern cmd/... matches it.
-func matchPattern(pattern string) func(name string) bool {
- // Convert pattern to regular expression.
- // The strategy for the trailing /... is to nest it in an explicit ? expression.
- // The strategy for the vendor exclusion is to change the unmatchable
- // vendor strings to a disallowed code point (vendorChar) and to use
- // "(anything but that codepoint)*" as the implementation of the ... wildcard.
- // This is a bit complicated but the obvious alternative,
- // namely a hand-written search like in most shell glob matchers,
- // is too easy to make accidentally exponential.
- // Using package regexp guarantees linear-time matching.
-
- const vendorChar = "\x00"
-
- if strings.Contains(pattern, vendorChar) {
- return func(name string) bool { return false }
- }
-
- re := regexp.QuoteMeta(pattern)
- re = replaceVendor(re, vendorChar)
- switch {
- case strings.HasSuffix(re, `/`+vendorChar+`/\.\.\.`):
- re = strings.TrimSuffix(re, `/`+vendorChar+`/\.\.\.`) + `(/vendor|/` + vendorChar + `/\.\.\.)`
- case re == vendorChar+`/\.\.\.`:
- re = `(/vendor|/` + vendorChar + `/\.\.\.)`
- case strings.HasSuffix(re, `/\.\.\.`):
- re = strings.TrimSuffix(re, `/\.\.\.`) + `(/\.\.\.)?`
- }
- re = strings.ReplaceAll(re, `\.\.\.`, `[^`+vendorChar+`]*`)
-
- reg := regexp.MustCompile(`^` + re + `$`)
-
- return func(name string) bool {
- if strings.Contains(name, vendorChar) {
- return false
- }
- return reg.MatchString(replaceVendor(name, vendorChar))
- }
-}
-
-// replaceVendor returns the result of replacing
-// non-trailing vendor path elements in x with repl.
-func replaceVendor(x, repl string) string {
- if !strings.Contains(x, "vendor") {
- return x
- }
- elem := strings.Split(x, "/")
- for i := 0; i < len(elem)-1; i++ {
- if elem[i] == "vendor" {
- elem[i] = repl
- }
- }
- return strings.Join(elem, "/")
-}
diff --git a/vendor/golang.org/x/tools/go/packages/loadmode_string.go b/vendor/golang.org/x/tools/go/packages/loadmode_string.go
index 5c080d21b5..5fcad6ea6d 100644
--- a/vendor/golang.org/x/tools/go/packages/loadmode_string.go
+++ b/vendor/golang.org/x/tools/go/packages/loadmode_string.go
@@ -9,49 +9,46 @@ import (
"strings"
)
-var allModes = []LoadMode{
- NeedName,
- NeedFiles,
- NeedCompiledGoFiles,
- NeedImports,
- NeedDeps,
- NeedExportFile,
- NeedTypes,
- NeedSyntax,
- NeedTypesInfo,
- NeedTypesSizes,
+var modes = [...]struct {
+ mode LoadMode
+ name string
+}{
+ {NeedName, "NeedName"},
+ {NeedFiles, "NeedFiles"},
+ {NeedCompiledGoFiles, "NeedCompiledGoFiles"},
+ {NeedImports, "NeedImports"},
+ {NeedDeps, "NeedDeps"},
+ {NeedExportFile, "NeedExportFile"},
+ {NeedTypes, "NeedTypes"},
+ {NeedSyntax, "NeedSyntax"},
+ {NeedTypesInfo, "NeedTypesInfo"},
+ {NeedTypesSizes, "NeedTypesSizes"},
+ {NeedModule, "NeedModule"},
+ {NeedEmbedFiles, "NeedEmbedFiles"},
+ {NeedEmbedPatterns, "NeedEmbedPatterns"},
}
-var modeStrings = []string{
- "NeedName",
- "NeedFiles",
- "NeedCompiledGoFiles",
- "NeedImports",
- "NeedDeps",
- "NeedExportFile",
- "NeedTypes",
- "NeedSyntax",
- "NeedTypesInfo",
- "NeedTypesSizes",
-}
-
-func (mod LoadMode) String() string {
- m := mod
- if m == 0 {
+func (mode LoadMode) String() string {
+ if mode == 0 {
return "LoadMode(0)"
}
var out []string
- for i, x := range allModes {
- if x > m {
- break
+ // named bits
+ for _, item := range modes {
+ if (mode & item.mode) != 0 {
+ mode ^= item.mode
+ out = append(out, item.name)
}
- if (m & x) != 0 {
- out = append(out, modeStrings[i])
- m = m ^ x
+ }
+ // unnamed residue
+ if mode != 0 {
+ if out == nil {
+ return fmt.Sprintf("LoadMode(%#x)", int(mode))
}
+ out = append(out, fmt.Sprintf("%#x", int(mode)))
}
- if m != 0 {
- out = append(out, "Unknown")
+ if len(out) == 1 {
+ return out[0]
}
- return fmt.Sprintf("LoadMode(%s)", strings.Join(out, "|"))
+ return "(" + strings.Join(out, "|") + ")"
}
diff --git a/vendor/golang.org/x/tools/go/packages/packages.go b/vendor/golang.org/x/tools/go/packages/packages.go
index 124a6fe143..2ecc64238e 100644
--- a/vendor/golang.org/x/tools/go/packages/packages.go
+++ b/vendor/golang.org/x/tools/go/packages/packages.go
@@ -9,43 +9,53 @@ package packages
import (
"context"
"encoding/json"
+ "errors"
"fmt"
"go/ast"
"go/parser"
"go/scanner"
"go/token"
"go/types"
- "io"
- "io/ioutil"
"log"
"os"
"path/filepath"
"runtime"
"strings"
"sync"
+ "sync/atomic"
"time"
+ "golang.org/x/sync/errgroup"
+
"golang.org/x/tools/go/gcexportdata"
"golang.org/x/tools/internal/gocommand"
"golang.org/x/tools/internal/packagesinternal"
- "golang.org/x/tools/internal/typeparams"
"golang.org/x/tools/internal/typesinternal"
)
// A LoadMode controls the amount of detail to return when loading.
// The bits below can be combined to specify which fields should be
// filled in the result packages.
+//
// The zero value is a special case, equivalent to combining
// the NeedName, NeedFiles, and NeedCompiledGoFiles bits.
+//
// ID and Errors (if present) will always be filled.
-// Load may return more information than requested.
+// [Load] may return more information than requested.
+//
+// Unfortunately there are a number of open bugs related to
+// interactions among the LoadMode bits:
+// - https://github.com/golang/go/issues/56633
+// - https://github.com/golang/go/issues/56677
+// - https://github.com/golang/go/issues/58726
+// - https://github.com/golang/go/issues/63517
type LoadMode int
const (
// NeedName adds Name and PkgPath.
NeedName LoadMode = 1 << iota
- // NeedFiles adds GoFiles and OtherFiles.
+ // NeedFiles adds GoFiles, OtherFiles, and IgnoredFiles
NeedFiles
// NeedCompiledGoFiles adds CompiledGoFiles.
@@ -64,10 +74,10 @@ const (
// NeedTypes adds Types, Fset, and IllTyped.
NeedTypes
- // NeedSyntax adds Syntax.
+ // NeedSyntax adds Syntax and Fset.
NeedSyntax
- // NeedTypesInfo adds TypesInfo.
+ // NeedTypesInfo adds TypesInfo and Fset.
NeedTypesInfo
// NeedTypesSizes adds TypesSizes.
@@ -92,25 +102,37 @@ const (
// NeedEmbedPatterns adds EmbedPatterns.
NeedEmbedPatterns
+
+ // Be sure to update loadmode_string.go when adding new items!
)
const (
+ // LoadFiles loads the name and file names for the initial packages.
+ //
// Deprecated: LoadFiles exists for historical compatibility
// and should not be used. Please directly specify the needed fields using the Need values.
LoadFiles = NeedName | NeedFiles | NeedCompiledGoFiles
+ // LoadImports loads the name, file names, and import mapping for the initial packages.
+ //
// Deprecated: LoadImports exists for historical compatibility
// and should not be used. Please directly specify the needed fields using the Need values.
LoadImports = LoadFiles | NeedImports
+ // LoadTypes loads exported type information for the initial packages.
+ //
// Deprecated: LoadTypes exists for historical compatibility
// and should not be used. Please directly specify the needed fields using the Need values.
LoadTypes = LoadImports | NeedTypes | NeedTypesSizes
+ // LoadSyntax loads typed syntax for the initial packages.
+ //
// Deprecated: LoadSyntax exists for historical compatibility
// and should not be used. Please directly specify the needed fields using the Need values.
LoadSyntax = LoadTypes | NeedSyntax | NeedTypesInfo
+ // LoadAllSyntax loads typed syntax for the initial packages and all dependencies.
+ //
// Deprecated: LoadAllSyntax exists for historical compatibility
// and should not be used. Please directly specify the needed fields using the Need values.
LoadAllSyntax = LoadSyntax | NeedDeps
@@ -121,15 +143,15 @@ const (
// A Config specifies details about how packages should be loaded.
// The zero value is a valid configuration.
-// Calls to Load do not modify this struct.
+//
+// Calls to [Load] do not modify this struct.
type Config struct {
// Mode controls the level of information returned for each package.
Mode LoadMode
// Context specifies the context for the load operation.
- // If the context is cancelled, the loader may stop early
- // and return an ErrCancelled error.
- // If Context is nil, the load cannot be cancelled.
+ // Cancelling the context may cause [Load] to abort and
+ // return an error.
Context context.Context
// Logf is the logger for the config.
@@ -153,19 +175,10 @@ type Config struct {
//
Env []string
- // gocmdRunner guards go command calls from concurrency errors.
- gocmdRunner *gocommand.Runner
-
// BuildFlags is a list of command-line flags to be passed through to
// the build system's query tool.
BuildFlags []string
- // modFile will be used for -modfile in go command invocations.
- modFile string
-
- // modFlag will be used for -modfile in go command invocations.
- modFlag string
-
// Fset provides source position information for syntax trees and types.
// If Fset is nil, Load will use a new fileset, but preserve Fset's value.
Fset *token.FileSet
@@ -198,95 +211,214 @@ type Config struct {
// setting Tests may have no effect.
Tests bool
- // Overlay provides a mapping of absolute file paths to file contents.
- // If the file with the given path already exists, the parser will use the
- // alternative file contents provided by the map.
+ // Overlay is a mapping from absolute file paths to file contents.
//
- // Overlays provide incomplete support for when a given file doesn't
- // already exist on disk. See the package doc above for more details.
+ // For each map entry, [Load] uses the alternative file
+ // contents provided by the overlay mapping instead of reading
+ // from the file system. This mechanism can be used to enable
+ // editor-integrated tools to correctly analyze the contents
+ // of modified but unsaved buffers, for example.
+ //
+ // The overlay mapping is passed to the build system's driver
+ // (see "The driver protocol") so that it too can report
+ // consistent package metadata about unsaved files. However,
+ // drivers may vary in their level of support for overlays.
Overlay map[string][]byte
-}
-// driver is the type for functions that query the build system for the
-// packages named by the patterns.
-type driver func(cfg *Config, patterns ...string) (*driverResponse, error)
-
-// driverResponse contains the results for a driver query.
-type driverResponse struct {
- // NotHandled is returned if the request can't be handled by the current
- // driver. If an external driver returns a response with NotHandled, the
- // rest of the driverResponse is ignored, and go/packages will fallback
- // to the next driver. If go/packages is extended in the future to support
- // lists of multiple drivers, go/packages will fall back to the next driver.
- NotHandled bool
-
- // Compiler and Arch are the arguments pass of types.SizesFor
- // to get a types.Sizes to use when type checking.
- Compiler string
- Arch string
-
- // Roots is the set of package IDs that make up the root packages.
- // We have to encode this separately because when we encode a single package
- // we cannot know if it is one of the roots as that requires knowledge of the
- // graph it is part of.
- Roots []string `json:",omitempty"`
-
- // Packages is the full set of packages in the graph.
- // The packages are not connected into a graph.
- // The Imports if populated will be stubs that only have their ID set.
- // Imports will be connected and then type and syntax information added in a
- // later pass (see refine).
- Packages []*Package
-
- // GoVersion is the minor version number used by the driver
- // (e.g. the go command on the PATH) when selecting .go files.
- // Zero means unknown.
- GoVersion int
+ // -- Hidden configuration fields only for use in x/tools --
+
+ // modFile will be used for -modfile in go command invocations.
+ modFile string
+
+ // modFlag will be used for -modfile in go command invocations.
+ modFlag string
}
// Load loads and returns the Go packages named by the given patterns.
//
-// Config specifies loading options;
-// nil behaves the same as an empty Config.
+// The cfg parameter specifies loading options; nil behaves the same as an empty [Config].
+//
+// The [Config.Mode] field is a set of bits that determine what kinds
+// of information should be computed and returned. Modes that require
+// more information tend to be slower. See [LoadMode] for details
+// and important caveats. Its zero value is equivalent to
+// [NeedName] | [NeedFiles] | [NeedCompiledGoFiles].
+//
+// Each call to Load returns a new set of [Package] instances.
+// The Packages and their Imports form a directed acyclic graph.
//
-// Load returns an error if any of the patterns was invalid
-// as defined by the underlying build system.
+// If the [NeedTypes] mode flag was set, each call to Load uses a new
+// [types.Importer], so [types.Object] and [types.Type] values from
+// different calls to Load must not be mixed as they will have
+// inconsistent notions of type identity.
+//
+// If any of the patterns was invalid as defined by the
+// underlying build system, Load returns an error.
// It may return an empty list of packages without an error,
// for instance for an empty expansion of a valid wildcard.
// Errors associated with a particular package are recorded in the
// corresponding Package's Errors list, and do not cause Load to
// return an error. Clients may need to handle such errors before
-// proceeding with further analysis. The PrintErrors function is
+// proceeding with further analysis. The [PrintErrors] function is
// provided for convenient display of all errors.
func Load(cfg *Config, patterns ...string) ([]*Package, error) {
- l := newLoader(cfg)
- response, err := defaultDriver(&l.Config, patterns...)
+ ld := newLoader(cfg)
+ response, external, err := defaultDriver(&ld.Config, patterns...)
if err != nil {
return nil, err
}
- l.sizes = types.SizesFor(response.Compiler, response.Arch)
- return l.refine(response)
+
+ ld.sizes = types.SizesFor(response.Compiler, response.Arch)
+ if ld.sizes == nil && ld.Config.Mode&(NeedTypes|NeedTypesSizes|NeedTypesInfo) != 0 {
+ // Type size information is needed but unavailable.
+ if external {
+ // An external driver may fail to populate the Compiler/GOARCH fields,
+ // especially since they are relatively new (see #63700).
+ // Provide a sensible fallback in this case.
+ ld.sizes = types.SizesFor("gc", runtime.GOARCH)
+ if ld.sizes == nil { // gccgo-only arch
+ ld.sizes = types.SizesFor("gc", "amd64")
+ }
+ } else {
+ // Go list should never fail to deliver accurate size information.
+ // Reject the whole Load since the error is the same for every package.
+ return nil, fmt.Errorf("can't determine type sizes for compiler %q on GOARCH %q",
+ response.Compiler, response.Arch)
+ }
+ }
+
+ return ld.refine(response)
}
// defaultDriver is a driver that implements go/packages' fallback behavior.
// It will try to request to an external driver, if one exists. If there's
// no external driver, or the driver returns a response with NotHandled set,
// defaultDriver will fall back to the go list driver.
-func defaultDriver(cfg *Config, patterns ...string) (*driverResponse, error) {
- driver := findExternalDriver(cfg)
- if driver == nil {
- driver = goListDriver
+// The boolean result indicates that an external driver handled the request.
+func defaultDriver(cfg *Config, patterns ...string) (*DriverResponse, bool, error) {
+ const (
+ // windowsArgMax specifies the maximum command line length for
+ // the Windows' CreateProcess function.
+ windowsArgMax = 32767
+ // maxEnvSize is a very rough estimation of the maximum environment
+ // size of a user.
+ maxEnvSize = 16384
+ // safeArgMax specifies the maximum safe command line length to use
+ // by the underlying driver excl. the environment. We choose the Windows'
+ // ARG_MAX as the starting point because it's one of the lowest ARG_MAX
+ // constants out of the different supported platforms,
+ // e.g., https://www.in-ulm.de/~mascheck/various/argmax/#results.
+ safeArgMax = windowsArgMax - maxEnvSize
+ )
+ chunks, err := splitIntoChunks(patterns, safeArgMax)
+ if err != nil {
+ return nil, false, err
}
- response, err := driver(cfg, patterns...)
+
+ if driver := findExternalDriver(cfg); driver != nil {
+ response, err := callDriverOnChunks(driver, cfg, chunks)
+ if err != nil {
+ return nil, false, err
+ } else if !response.NotHandled {
+ return response, true, nil
+ }
+ // not handled: fall through
+ }
+
+ // go list fallback
+
+ // Write overlays once, as there are many calls
+ // to 'go list' (one per chunk plus others too).
+ overlayFile, cleanupOverlay, err := gocommand.WriteOverlays(cfg.Overlay)
if err != nil {
- return response, err
- } else if response.NotHandled {
- return goListDriver(cfg, patterns...)
+ return nil, false, err
+ }
+ defer cleanupOverlay()
+
+ var runner gocommand.Runner // (shared across many 'go list' calls)
+ driver := func(cfg *Config, patterns []string) (*DriverResponse, error) {
+ return goListDriver(cfg, &runner, overlayFile, patterns)
+ }
+ response, err := callDriverOnChunks(driver, cfg, chunks)
+ if err != nil {
+ return nil, false, err
+ }
+ return response, false, err
+}
+
+// splitIntoChunks chunks the slice so that the total number of characters
+// in a chunk is no longer than argMax.
+func splitIntoChunks(patterns []string, argMax int) ([][]string, error) {
+ if argMax <= 0 {
+ return nil, errors.New("failed to split patterns into chunks, negative safe argMax value")
+ }
+ var chunks [][]string
+ charsInChunk := 0
+ nextChunkStart := 0
+ for i, v := range patterns {
+ vChars := len(v)
+ if vChars > argMax {
+ // a single pattern is longer than the maximum safe ARG_MAX, hardly should happen
+ return nil, errors.New("failed to split patterns into chunks, a pattern is too long")
+ }
+ charsInChunk += vChars + 1 // +1 is for a whitespace between patterns that has to be counted too
+ if charsInChunk > argMax {
+ chunks = append(chunks, patterns[nextChunkStart:i])
+ nextChunkStart = i
+ charsInChunk = vChars
+ }
+ }
+ // add the last chunk
+ if nextChunkStart < len(patterns) {
+ chunks = append(chunks, patterns[nextChunkStart:])
+ }
+ return chunks, nil
+}
+
+func callDriverOnChunks(driver driver, cfg *Config, chunks [][]string) (*DriverResponse, error) {
+ if len(chunks) == 0 {
+ return driver(cfg, nil)
}
- return response, nil
+ responses := make([]*DriverResponse, len(chunks))
+ errNotHandled := errors.New("driver returned NotHandled")
+ var g errgroup.Group
+ for i, chunk := range chunks {
+ g.Go(func() (err error) {
+ responses[i], err = driver(cfg, chunk)
+ if responses[i] != nil && responses[i].NotHandled {
+ err = errNotHandled
+ }
+ return err
+ })
+ }
+ if err := g.Wait(); err != nil {
+ if errors.Is(err, errNotHandled) {
+ return &DriverResponse{NotHandled: true}, nil
+ }
+ return nil, err
+ }
+ return mergeResponses(responses...), nil
+}
+
+func mergeResponses(responses ...*DriverResponse) *DriverResponse {
+ if len(responses) == 0 {
+ return nil
+ }
+ response := newDeduper()
+ response.dr.NotHandled = false
+ response.dr.Compiler = responses[0].Compiler
+ response.dr.Arch = responses[0].Arch
+ response.dr.GoVersion = responses[0].GoVersion
+ for _, v := range responses {
+ response.addAll(v)
+ }
+ return response.dr
}
// A Package describes a loaded Go package.
+//
+// It also defines part of the JSON schema of [DriverResponse].
+// See the package documentation for an overview.
type Package struct {
// ID is a unique identifier for a package,
// in a syntax provided by the underlying build system.
@@ -345,19 +477,30 @@ type Package struct {
// to corresponding loaded Packages.
Imports map[string]*Package
+ // Module is the module information for the package if it exists.
+ //
+ // Note: it may be missing for std and cmd; see Go issue #65816.
+ Module *Module
+
+ // -- The following fields are not part of the driver JSON schema. --
+
// Types provides type information for the package.
// The NeedTypes LoadMode bit sets this field for packages matching the
// patterns; type information for dependencies may be missing or incomplete,
// unless NeedDeps and NeedImports are also set.
- Types *types.Package
+ //
+ // Each call to [Load] returns a consistent set of type
+ // symbols, as defined by the comment at [types.Identical].
+ // Avoid mixing type information from two or more calls to [Load].
+ Types *types.Package `json:"-"`
// Fset provides position information for Types, TypesInfo, and Syntax.
// It is set only when Types is set.
- Fset *token.FileSet
+ Fset *token.FileSet `json:"-"`
// IllTyped indicates whether the package or any dependency contains errors.
// It is set only when Types is set.
- IllTyped bool
+ IllTyped bool `json:"-"`
// Syntax is the package's syntax trees, for the files listed in CompiledGoFiles.
//
@@ -367,26 +510,28 @@ type Package struct {
//
// Syntax is kept in the same order as CompiledGoFiles, with the caveat that nils are
// removed. If parsing returned nil, Syntax may be shorter than CompiledGoFiles.
- Syntax []*ast.File
+ Syntax []*ast.File `json:"-"`
// TypesInfo provides type information about the package's syntax trees.
// It is set only when Syntax is set.
- TypesInfo *types.Info
+ TypesInfo *types.Info `json:"-"`
// TypesSizes provides the effective size function for types in TypesInfo.
- TypesSizes types.Sizes
+ TypesSizes types.Sizes `json:"-"`
+
+ // -- internal --
// forTest is the package under test, if any.
forTest string
// depsErrors is the DepsErrors field from the go list response, if any.
depsErrors []*packagesinternal.PackageError
-
- // module is the module information for the package if it exists.
- Module *Module
}
// Module provides module information for a package.
+//
+// It also defines part of the JSON schema of [DriverResponse].
+// See the package documentation for an overview.
type Module struct {
Path string // module path
Version string // module version
@@ -412,12 +557,6 @@ func init() {
packagesinternal.GetDepsErrors = func(p interface{}) []*packagesinternal.PackageError {
return p.(*Package).depsErrors
}
- packagesinternal.GetGoCmdRunner = func(config interface{}) *gocommand.Runner {
- return config.(*Config).gocmdRunner
- }
- packagesinternal.SetGoCmdRunner = func(config interface{}, runner *gocommand.Runner) {
- config.(*Config).gocmdRunner = runner
- }
packagesinternal.SetModFile = func(config interface{}, value string) {
config.(*Config).modFile = value
}
@@ -525,6 +664,7 @@ func (p *Package) UnmarshalJSON(b []byte) error {
OtherFiles: flat.OtherFiles,
EmbedFiles: flat.EmbedFiles,
EmbedPatterns: flat.EmbedPatterns,
+ IgnoredFiles: flat.IgnoredFiles,
ExportFile: flat.ExportFile,
}
if len(flat.Imports) > 0 {
@@ -541,20 +681,21 @@ func (p *Package) String() string { return p.ID }
// loaderPackage augments Package with state used during the loading phase
type loaderPackage struct {
*Package
- importErrors map[string]error // maps each bad import to its error
- loadOnce sync.Once
- color uint8 // for cycle detection
- needsrc bool // load from source (Mode >= LoadTypes)
- needtypes bool // type information is either requested or depended on
- initial bool // package was matched by a pattern
- goVersion int // minor version number of go command on PATH
+ importErrors map[string]error // maps each bad import to its error
+ preds []*loaderPackage // packages that import this one
+ unfinishedSuccs atomic.Int32 // number of direct imports not yet loaded
+ color uint8 // for cycle detection
+ needsrc bool // load from source (Mode >= LoadTypes)
+ needtypes bool // type information is either requested or depended on
+ initial bool // package was matched by a pattern
+ goVersion int // minor version number of go command on PATH
}
// loader holds the working state of a single call to load.
type loader struct {
- pkgs map[string]*loaderPackage
+ pkgs map[string]*loaderPackage // keyed by Package.ID
Config
- sizes types.Sizes
+ sizes types.Sizes // non-nil if needed by mode
parseCache map[string]*parseValue
parseCacheMu sync.Mutex
exportMu sync.Mutex // enforces mutual exclusion of exportdata operations
@@ -598,9 +739,6 @@ func newLoader(cfg *Config) *loader {
if ld.Config.Env == nil {
ld.Config.Env = os.Environ()
}
- if ld.Config.gocmdRunner == nil {
- ld.Config.gocmdRunner = &gocommand.Runner{}
- }
if ld.Context == nil {
ld.Context = context.Background()
}
@@ -614,7 +752,7 @@ func newLoader(cfg *Config) *loader {
ld.requestedMode = ld.Mode
ld.Mode = impliedLoadMode(ld.Mode)
- if ld.Mode&NeedTypes != 0 || ld.Mode&NeedSyntax != 0 {
+ if ld.Mode&(NeedSyntax|NeedTypes|NeedTypesInfo) != 0 {
if ld.Fset == nil {
ld.Fset = token.NewFileSet()
}
@@ -623,6 +761,7 @@ func newLoader(cfg *Config) *loader {
// because we load source if export data is missing.
if ld.ParseFile == nil {
ld.ParseFile = func(fset *token.FileSet, filename string, src []byte) (*ast.File, error) {
+ // We implicitly promise to keep doing ast.Object resolution. :(
const mode = parser.AllErrors | parser.ParseComments
return parser.ParseFile(fset, filename, src, mode)
}
@@ -634,7 +773,7 @@ func newLoader(cfg *Config) *loader {
// refine connects the supplied packages into a graph and then adds type
// and syntax information as requested by the LoadMode.
-func (ld *loader) refine(response *driverResponse) ([]*Package, error) {
+func (ld *loader) refine(response *DriverResponse) ([]*Package, error) {
roots := response.Roots
rootMap := make(map[string]int, len(roots))
for i, root := range roots {
@@ -654,7 +793,7 @@ func (ld *loader) refine(response *driverResponse) ([]*Package, error) {
exportDataInvalid := len(ld.Overlay) > 0 || pkg.ExportFile == "" && pkg.PkgPath != "unsafe"
// This package needs type information if the caller requested types and the package is
// either a root, or it's a non-root and the user requested dependencies ...
- needtypes := (ld.Mode&NeedTypes|NeedTypesInfo != 0 && (rootIndex >= 0 || ld.Mode&NeedDeps != 0))
+ needtypes := (ld.Mode&(NeedTypes|NeedTypesInfo) != 0 && (rootIndex >= 0 || ld.Mode&NeedDeps != 0))
// This package needs source if the call requested source (or types info, which implies source)
// and the package is either a root, or itas a non- root and the user requested dependencies...
needsrc := ((ld.Mode&(NeedSyntax|NeedTypesInfo) != 0 && (rootIndex >= 0 || ld.Mode&NeedDeps != 0)) ||
@@ -679,108 +818,155 @@ func (ld *loader) refine(response *driverResponse) ([]*Package, error) {
}
}
- // Materialize the import graph.
-
- const (
- white = 0 // new
- grey = 1 // in progress
- black = 2 // complete
- )
+ // Materialize the import graph if it is needed (NeedImports),
+ // or if we'll be using loadPackages (Need{Syntax|Types|TypesInfo}).
+ var leaves []*loaderPackage // packages with no unfinished successors
+ if ld.Mode&(NeedImports|NeedSyntax|NeedTypes|NeedTypesInfo) != 0 {
+ const (
+ white = 0 // new
+ grey = 1 // in progress
+ black = 2 // complete
+ )
+
+ // visit traverses the import graph, depth-first,
+ // and materializes the graph as Packages.Imports.
+ //
+ // Valid imports are saved in the Packages.Import map.
+ // Invalid imports (cycles and missing nodes) are saved in the importErrors map.
+ // Thus, even in the presence of both kinds of errors,
+ // the Import graph remains a DAG.
+ //
+ // visit returns whether the package needs src or has a transitive
+ // dependency on a package that does. These are the only packages
+ // for which we load source code.
+ var stack []*loaderPackage
+ var visit func(from, lpkg *loaderPackage) bool
+ visit = func(from, lpkg *loaderPackage) bool {
+ if lpkg.color == grey {
+ panic("internal error: grey node")
+ }
+ if lpkg.color == white {
+ lpkg.color = grey
+ stack = append(stack, lpkg) // push
+ stubs := lpkg.Imports // the structure form has only stubs with the ID in the Imports
+ lpkg.Imports = make(map[string]*Package, len(stubs))
+ for importPath, ipkg := range stubs {
+ var importErr error
+ imp := ld.pkgs[ipkg.ID]
+ if imp == nil {
+ // (includes package "C" when DisableCgo)
+ importErr = fmt.Errorf("missing package: %q", ipkg.ID)
+ } else if imp.color == grey {
+ importErr = fmt.Errorf("import cycle: %s", stack)
+ }
+ if importErr != nil {
+ if lpkg.importErrors == nil {
+ lpkg.importErrors = make(map[string]error)
+ }
+ lpkg.importErrors[importPath] = importErr
+ continue
+ }
- // visit traverses the import graph, depth-first,
- // and materializes the graph as Packages.Imports.
- //
- // Valid imports are saved in the Packages.Import map.
- // Invalid imports (cycles and missing nodes) are saved in the importErrors map.
- // Thus, even in the presence of both kinds of errors, the Import graph remains a DAG.
- //
- // visit returns whether the package needs src or has a transitive
- // dependency on a package that does. These are the only packages
- // for which we load source code.
- var stack []*loaderPackage
- var visit func(lpkg *loaderPackage) bool
- var srcPkgs []*loaderPackage
- visit = func(lpkg *loaderPackage) bool {
- switch lpkg.color {
- case black:
- return lpkg.needsrc
- case grey:
- panic("internal error: grey node")
- }
- lpkg.color = grey
- stack = append(stack, lpkg) // push
- stubs := lpkg.Imports // the structure form has only stubs with the ID in the Imports
- // If NeedImports isn't set, the imports fields will all be zeroed out.
- if ld.Mode&NeedImports != 0 {
- lpkg.Imports = make(map[string]*Package, len(stubs))
- for importPath, ipkg := range stubs {
- var importErr error
- imp := ld.pkgs[ipkg.ID]
- if imp == nil {
- // (includes package "C" when DisableCgo)
- importErr = fmt.Errorf("missing package: %q", ipkg.ID)
- } else if imp.color == grey {
- importErr = fmt.Errorf("import cycle: %s", stack)
+ if visit(lpkg, imp) {
+ lpkg.needsrc = true
+ }
+ lpkg.Imports[importPath] = imp.Package
}
- if importErr != nil {
- if lpkg.importErrors == nil {
- lpkg.importErrors = make(map[string]error)
+
+ // -- postorder --
+
+ // Complete type information is required for the
+ // immediate dependencies of each source package.
+ if lpkg.needsrc && ld.Mode&NeedTypes != 0 {
+ for _, ipkg := range lpkg.Imports {
+ ld.pkgs[ipkg.ID].needtypes = true
}
- lpkg.importErrors[importPath] = importErr
- continue
}
- if visit(imp) {
- lpkg.needsrc = true
+ // NeedTypeSizes causes TypeSizes to be set even
+ // on packages for which types aren't needed.
+ if ld.Mode&NeedTypesSizes != 0 {
+ lpkg.TypesSizes = ld.sizes
+ }
+
+ // Add packages with no imports directly to the queue of leaves.
+ if len(lpkg.Imports) == 0 {
+ leaves = append(leaves, lpkg)
}
- lpkg.Imports[importPath] = imp.Package
+
+ stack = stack[:len(stack)-1] // pop
+ lpkg.color = black
}
- }
- if lpkg.needsrc {
- srcPkgs = append(srcPkgs, lpkg)
- }
- if ld.Mode&NeedTypesSizes != 0 {
- lpkg.TypesSizes = ld.sizes
- }
- stack = stack[:len(stack)-1] // pop
- lpkg.color = black
- return lpkg.needsrc
- }
+ // Add edge from predecessor.
+ if from != nil {
+ from.unfinishedSuccs.Add(+1) // incref
+ lpkg.preds = append(lpkg.preds, from)
+ }
- if ld.Mode&NeedImports == 0 {
- // We do this to drop the stub import packages that we are not even going to try to resolve.
- for _, lpkg := range initial {
- lpkg.Imports = nil
+ return lpkg.needsrc
}
- } else {
+
// For each initial package, create its import DAG.
for _, lpkg := range initial {
- visit(lpkg)
+ visit(nil, lpkg)
}
- }
- if ld.Mode&NeedImports != 0 && ld.Mode&NeedTypes != 0 {
- for _, lpkg := range srcPkgs {
- // Complete type information is required for the
- // immediate dependencies of each source package.
- for _, ipkg := range lpkg.Imports {
- imp := ld.pkgs[ipkg.ID]
- imp.needtypes = true
- }
+
+ } else {
+ // !NeedImports: drop the stub (ID-only) import packages
+ // that we are not even going to try to resolve.
+ for _, lpkg := range initial {
+ lpkg.Imports = nil
}
}
+
// Load type data and syntax if needed, starting at
// the initial packages (roots of the import DAG).
- if ld.Mode&NeedTypes != 0 || ld.Mode&NeedSyntax != 0 {
- var wg sync.WaitGroup
- for _, lpkg := range initial {
- wg.Add(1)
- go func(lpkg *loaderPackage) {
- ld.loadRecursive(lpkg)
- wg.Done()
- }(lpkg)
+ if ld.Mode&(NeedSyntax|NeedTypes|NeedTypesInfo) != 0 {
+
+ // We avoid using g.SetLimit to limit concurrency as
+ // it makes g.Go stop accepting work, which prevents
+ // workers from enqeuing, and thus finishing, and thus
+ // allowing the group to make progress: deadlock.
+ //
+ // Instead we use the ioLimit and cpuLimit semaphores.
+ g, _ := errgroup.WithContext(ld.Context)
+
+ // enqueues adds a package to the type-checking queue.
+ // It must have no unfinished successors.
+ var enqueue func(*loaderPackage)
+ enqueue = func(lpkg *loaderPackage) {
+ g.Go(func() error {
+ // Parse and type-check.
+ ld.loadPackage(lpkg)
+
+ // Notify each waiting predecessor,
+ // and enqueue it when it becomes a leaf.
+ for _, pred := range lpkg.preds {
+ if pred.unfinishedSuccs.Add(-1) == 0 { // decref
+ enqueue(pred)
+ }
+ }
+
+ return nil
+ })
+ }
+
+ // Load leaves first, adding new packages
+ // to the queue as they become leaves.
+ for _, leaf := range leaves {
+ enqueue(leaf)
+ }
+
+ if err := g.Wait(); err != nil {
+ return nil, err // cancelled
}
- wg.Wait()
+ }
+
+ // If the context is done, return its error and
+ // throw out [likely] incomplete packages.
+ if err := ld.Context.Err(); err != nil {
+ return nil, err
}
result := make([]*Package, len(initial))
@@ -816,12 +1002,14 @@ func (ld *loader) refine(response *driverResponse) ([]*Package, error) {
}
if ld.requestedMode&NeedTypes == 0 {
ld.pkgs[i].Types = nil
- ld.pkgs[i].Fset = nil
ld.pkgs[i].IllTyped = false
}
if ld.requestedMode&NeedSyntax == 0 {
ld.pkgs[i].Syntax = nil
}
+ if ld.requestedMode&(NeedSyntax|NeedTypes|NeedTypesInfo) == 0 {
+ ld.pkgs[i].Fset = nil
+ }
if ld.requestedMode&NeedTypesInfo == 0 {
ld.pkgs[i].TypesInfo = nil
}
@@ -836,31 +1024,10 @@ func (ld *loader) refine(response *driverResponse) ([]*Package, error) {
return result, nil
}
-// loadRecursive loads the specified package and its dependencies,
-// recursively, in parallel, in topological order.
-// It is atomic and idempotent.
-// Precondition: ld.Mode&NeedTypes.
-func (ld *loader) loadRecursive(lpkg *loaderPackage) {
- lpkg.loadOnce.Do(func() {
- // Load the direct dependencies, in parallel.
- var wg sync.WaitGroup
- for _, ipkg := range lpkg.Imports {
- imp := ld.pkgs[ipkg.ID]
- wg.Add(1)
- go func(imp *loaderPackage) {
- ld.loadRecursive(imp)
- wg.Done()
- }(imp)
- }
- wg.Wait()
- ld.loadPackage(lpkg)
- })
-}
-
-// loadPackage loads the specified package.
+// loadPackage loads/parses/typechecks the specified package.
// It must be called only once per Package,
// after immediate dependencies are loaded.
-// Precondition: ld.Mode & NeedTypes.
+// Precondition: ld.Mode&(NeedSyntax|NeedTypes|NeedTypesInfo) != 0.
func (ld *loader) loadPackage(lpkg *loaderPackage) {
if lpkg.PkgPath == "unsafe" {
// Fill in the blanks to avoid surprises.
@@ -878,6 +1045,14 @@ func (ld *loader) loadPackage(lpkg *loaderPackage) {
lpkg.Types = types.NewPackage(lpkg.PkgPath, lpkg.Name)
lpkg.Fset = ld.Fset
+ // Start shutting down if the context is done and do not load
+ // source or export data files.
+ // Packages that import this one will have ld.Context.Err() != nil.
+ // ld.Context.Err() will be returned later by refine.
+ if ld.Context.Err() != nil {
+ return
+ }
+
// Subtle: we populate all Types fields with an empty Package
// before loading export data so that export data processing
// never has to create a types.Package for an indirect dependency,
@@ -888,6 +1063,10 @@ func (ld *loader) loadPackage(lpkg *loaderPackage) {
if !lpkg.needtypes && !lpkg.needsrc {
return
}
+
+ // TODO(adonovan): this condition looks wrong:
+ // I think it should be lpkg.needtypes && !lpg.needsrc,
+ // so that NeedSyntax without NeedTypes can be satisfied by export data.
if !lpkg.needsrc {
if err := ld.loadFromExportData(lpkg); err != nil {
lpkg.Errors = append(lpkg.Errors, Error{
@@ -993,19 +1172,31 @@ func (ld *loader) loadPackage(lpkg *loaderPackage) {
}
lpkg.Syntax = files
- if ld.Config.Mode&NeedTypes == 0 {
+ if ld.Config.Mode&(NeedTypes|NeedTypesInfo) == 0 {
+ return
+ }
+
+ // Start shutting down if the context is done and do not type check.
+ // Packages that import this one will have ld.Context.Err() != nil.
+ // ld.Context.Err() will be returned later by refine.
+ if ld.Context.Err() != nil {
return
}
- lpkg.TypesInfo = &types.Info{
- Types: make(map[ast.Expr]types.TypeAndValue),
- Defs: make(map[*ast.Ident]types.Object),
- Uses: make(map[*ast.Ident]types.Object),
- Implicits: make(map[ast.Node]types.Object),
- Scopes: make(map[ast.Node]*types.Scope),
- Selections: make(map[*ast.SelectorExpr]*types.Selection),
+ // Populate TypesInfo only if needed, as it
+ // causes the type checker to work much harder.
+ if ld.Config.Mode&NeedTypesInfo != 0 {
+ lpkg.TypesInfo = &types.Info{
+ Types: make(map[ast.Expr]types.TypeAndValue),
+ Defs: make(map[*ast.Ident]types.Object),
+ Uses: make(map[*ast.Ident]types.Object),
+ Implicits: make(map[ast.Node]types.Object),
+ Instances: make(map[*ast.Ident]types.Instance),
+ Scopes: make(map[ast.Node]*types.Scope),
+ Selections: make(map[*ast.SelectorExpr]*types.Selection),
+ FileVersions: make(map[*ast.File]string),
+ }
}
- typeparams.InitInstanceInfo(lpkg.TypesInfo)
lpkg.TypesSizes = ld.sizes
importer := importerFunc(func(path string) (*types.Package, error) {
@@ -1043,10 +1234,10 @@ func (ld *loader) loadPackage(lpkg *loaderPackage) {
IgnoreFuncBodies: ld.Mode&NeedDeps == 0 && !lpkg.initial,
Error: appendError,
- Sizes: ld.sizes,
+ Sizes: ld.sizes, // may be nil
}
if lpkg.Module != nil && lpkg.Module.GoVersion != "" {
- typesinternal.SetGoVersion(tc, "go"+lpkg.Module.GoVersion)
+ tc.GoVersion = "go" + lpkg.Module.GoVersion
}
if (ld.Mode & typecheckCgo) != 0 {
if !typesinternal.SetUsesCgo(tc) {
@@ -1057,10 +1248,28 @@ func (ld *loader) loadPackage(lpkg *loaderPackage) {
return
}
}
- types.NewChecker(tc, ld.Fset, lpkg.Types, lpkg.TypesInfo).Files(lpkg.Syntax)
+ // Type-checking is CPU intensive.
+ cpuLimit <- unit{} // acquire a token
+ defer func() { <-cpuLimit }() // release a token
+
+ typErr := types.NewChecker(tc, ld.Fset, lpkg.Types, lpkg.TypesInfo).Files(lpkg.Syntax)
lpkg.importErrors = nil // no longer needed
+ // In go/types go1.21 and go1.22, Checker.Files failed fast with a
+ // a "too new" error, without calling tc.Error and without
+ // proceeding to type-check the package (#66525).
+ // We rely on the runtimeVersion error to give the suggested remedy.
+ if typErr != nil && len(lpkg.Errors) == 0 && len(lpkg.Syntax) > 0 {
+ if msg := typErr.Error(); strings.HasPrefix(msg, "package requires newer Go version") {
+ appendError(types.Error{
+ Fset: ld.Fset,
+ Pos: lpkg.Syntax[0].Package,
+ Msg: msg,
+ })
+ }
+ }
+
// If !Cgo, the type-checker uses FakeImportC mode, so
// it doesn't invoke the importer for import "C",
// nor report an error for the import,
@@ -1082,6 +1291,12 @@ func (ld *loader) loadPackage(lpkg *loaderPackage) {
}
}
+ // If types.Checker.Files had an error that was unreported,
+ // make sure to report the unknown error so the package is illTyped.
+ if typErr != nil && len(lpkg.Errors) == 0 {
+ appendError(typErr)
+ }
+
// Record accumulated errors.
illTyped := len(lpkg.Errors) > 0
if !illTyped {
@@ -1102,8 +1317,11 @@ type importerFunc func(path string) (*types.Package, error)
func (f importerFunc) Import(path string) (*types.Package, error) { return f(path) }
// We use a counting semaphore to limit
-// the number of parallel I/O calls per process.
-var ioLimit = make(chan bool, 20)
+// the number of parallel I/O calls or CPU threads per process.
+var (
+ ioLimit = make(chan unit, 20)
+ cpuLimit = make(chan unit, runtime.GOMAXPROCS(0))
+)
func (ld *loader) parseFile(filename string) (*ast.File, error) {
ld.parseCacheMu.Lock()
@@ -1120,20 +1338,28 @@ func (ld *loader) parseFile(filename string) (*ast.File, error) {
var src []byte
for f, contents := range ld.Config.Overlay {
+ // TODO(adonovan): Inefficient for large overlays.
+ // Do an exact name-based map lookup
+ // (for nonexistent files) followed by a
+ // FileID-based map lookup (for existing ones).
if sameFile(f, filename) {
src = contents
+ break
}
}
var err error
if src == nil {
- ioLimit <- true // wait
- src, err = ioutil.ReadFile(filename)
- <-ioLimit // signal
+ ioLimit <- unit{} // acquire a token
+ src, err = os.ReadFile(filename)
+ <-ioLimit // release a token
}
if err != nil {
v.err = err
} else {
+ // Parsing is CPU intensive.
+ cpuLimit <- unit{} // acquire a token
v.f, v.err = ld.ParseFile(ld.Fset, filename, src)
+ <-cpuLimit // release a token
}
close(v.ready)
@@ -1148,23 +1374,21 @@ func (ld *loader) parseFile(filename string) (*ast.File, error) {
// Because files are scanned in parallel, the token.Pos
// positions of the resulting ast.Files are not ordered.
func (ld *loader) parseFiles(filenames []string) ([]*ast.File, []error) {
- var wg sync.WaitGroup
- n := len(filenames)
- parsed := make([]*ast.File, n)
- errors := make([]error, n)
- for i, file := range filenames {
- if ld.Config.Context.Err() != nil {
- parsed[i] = nil
- errors[i] = ld.Config.Context.Err()
- continue
- }
- wg.Add(1)
- go func(i int, filename string) {
+ var (
+ n = len(filenames)
+ parsed = make([]*ast.File, n)
+ errors = make([]error, n)
+ )
+ var g errgroup.Group
+ for i, filename := range filenames {
+ // This creates goroutines unnecessarily in the
+ // cache-hit case, but that case is uncommon.
+ g.Go(func() error {
parsed[i], errors[i] = ld.parseFile(filename)
- wg.Done()
- }(i, file)
+ return nil
+ })
}
- wg.Wait()
+ g.Wait()
// Eliminate nils, preserving order.
var o int
@@ -1323,6 +1547,10 @@ func impliedLoadMode(loadMode LoadMode) LoadMode {
// All these things require knowing the import graph.
loadMode |= NeedImports
}
+ if loadMode&NeedTypes != 0 {
+ // Types require the GoVersion from Module.
+ loadMode |= NeedModule
+ }
return loadMode
}
@@ -1331,4 +1559,4 @@ func usesExportData(cfg *Config) bool {
return cfg.Mode&NeedExportFile != 0 || cfg.Mode&NeedTypes != 0 && cfg.Mode&NeedDeps == 0
}
-var _ interface{} = io.Discard // assert build toolchain is go1.16 or later
+type unit struct{}
diff --git a/vendor/golang.org/x/tools/go/packages/visit.go b/vendor/golang.org/x/tools/go/packages/visit.go
index a1dcc40b72..df14ffd94d 100644
--- a/vendor/golang.org/x/tools/go/packages/visit.go
+++ b/vendor/golang.org/x/tools/go/packages/visit.go
@@ -49,11 +49,20 @@ func Visit(pkgs []*Package, pre func(*Package) bool, post func(*Package)) {
// PrintErrors returns the number of errors printed.
func PrintErrors(pkgs []*Package) int {
var n int
+ errModules := make(map[*Module]bool)
Visit(pkgs, nil, func(pkg *Package) {
for _, err := range pkg.Errors {
fmt.Fprintln(os.Stderr, err)
n++
}
+
+ // Print pkg.Module.Error once if present.
+ mod := pkg.Module
+ if mod != nil && mod.Error != nil && !errModules[mod] {
+ errModules[mod] = true
+ fmt.Fprintln(os.Stderr, mod.Error.Err)
+ n++
+ }
})
return n
}
diff --git a/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go b/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go
index fa5834baf7..16ed3c1780 100644
--- a/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go
+++ b/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go
@@ -26,15 +26,15 @@ package objectpath
import (
"fmt"
"go/types"
- "sort"
"strconv"
"strings"
- _ "unsafe"
- "golang.org/x/tools/internal/typeparams"
+ "golang.org/x/tools/internal/aliases"
"golang.org/x/tools/internal/typesinternal"
)
+// TODO(adonovan): think about generic aliases.
+
// A Path is an opaque name that identifies a types.Object
// relative to its package. Conceptually, the name consists of a
// sequence of destructuring operations applied to the package scope
@@ -51,7 +51,7 @@ type Path string
//
// PO package->object Package.Scope.Lookup
// OT object->type Object.Type
-// TT type->type Type.{Elem,Key,Params,Results,Underlying} [EKPRU]
+// TT type->type Type.{Elem,Key,{,{,Recv}Type}Params,Results,Underlying,Rhs} [EKPRUTrCa]
// TO type->object Type.{At,Field,Method,Obj} [AFMO]
//
// All valid paths start with a package and end at an object
@@ -63,8 +63,8 @@ type Path string
// - The only PO operator is Package.Scope.Lookup, which requires an identifier.
// - The only OT operator is Object.Type,
// which we encode as '.' because dot cannot appear in an identifier.
-// - The TT operators are encoded as [EKPRUTC];
-// one of these (TypeParam) requires an integer operand,
+// - The TT operators are encoded as [EKPRUTrCa];
+// two of these ({,Recv}TypeParams) require an integer operand,
// which is encoded as a string of decimal digits.
// - The TO operators are encoded as [AFMO];
// three of these (At,Field,Method) require an integer operand,
@@ -98,19 +98,21 @@ const (
opType = '.' // .Type() (Object)
// type->type operators
- opElem = 'E' // .Elem() (Pointer, Slice, Array, Chan, Map)
- opKey = 'K' // .Key() (Map)
- opParams = 'P' // .Params() (Signature)
- opResults = 'R' // .Results() (Signature)
- opUnderlying = 'U' // .Underlying() (Named)
- opTypeParam = 'T' // .TypeParams.At(i) (Named, Signature)
- opConstraint = 'C' // .Constraint() (TypeParam)
+ opElem = 'E' // .Elem() (Pointer, Slice, Array, Chan, Map)
+ opKey = 'K' // .Key() (Map)
+ opParams = 'P' // .Params() (Signature)
+ opResults = 'R' // .Results() (Signature)
+ opUnderlying = 'U' // .Underlying() (Named)
+ opTypeParam = 'T' // .TypeParams.At(i) (Named, Signature)
+ opRecvTypeParam = 'r' // .RecvTypeParams.At(i) (Signature)
+ opConstraint = 'C' // .Constraint() (TypeParam)
+ opRhs = 'a' // .Rhs() (Alias)
// type->object operators
- opAt = 'A' // .At(i) (Tuple)
- opField = 'F' // .Field(i) (Struct)
- opMethod = 'M' // .Method(i) (Named or Interface; not Struct: "promoted" names are ignored)
- opObj = 'O' // .Obj() (Named, TypeParam)
+ opAt = 'A' // .At(i) (Tuple)
+ opField = 'F' // .Field(i) (Struct)
+ opMethod = 'M' // .Method(i) (Named or Interface; not Struct: "promoted" names are ignored)
+ opObj = 'O' // .Obj() (Named, TypeParam)
)
// For is equivalent to new(Encoder).For(obj).
@@ -123,20 +125,7 @@ func For(obj types.Object) (Path, error) {
// An Encoder amortizes the cost of encoding the paths of multiple objects.
// The zero value of an Encoder is ready to use.
type Encoder struct {
- scopeMemo map[*types.Scope][]types.Object // memoization of scopeObjects
- namedMethodsMemo map[*types.Named][]*types.Func // memoization of namedMethods()
- skipMethodSorting bool
-}
-
-// Expose back doors so that gopls can avoid method sorting, which can dominate
-// analysis on certain repositories.
-//
-// TODO(golang/go#61443): remove this.
-func init() {
- typesinternal.SkipEncoderMethodSorting = func(enc interface{}) {
- enc.(*Encoder).skipMethodSorting = true
- }
- typesinternal.ObjectpathObject = object
+ scopeMemo map[*types.Scope][]types.Object // memoization of scopeObjects
}
// For returns the path to an object relative to its package,
@@ -239,7 +228,7 @@ func (enc *Encoder) For(obj types.Object) (Path, error) {
// Reject obviously non-viable cases.
switch obj := obj.(type) {
case *types.TypeName:
- if _, ok := obj.Type().(*typeparams.TypeParam); !ok {
+ if _, ok := types.Unalias(obj.Type()).(*types.TypeParam); !ok {
// With the exception of type parameters, only package-level type names
// have a path.
return "", fmt.Errorf("no path for %v", obj)
@@ -291,21 +280,26 @@ func (enc *Encoder) For(obj types.Object) (Path, error) {
path = append(path, opType)
T := o.Type()
-
- if tname.IsAlias() {
- // type alias
- if r := find(obj, T, path, nil); r != nil {
+ if alias, ok := T.(*types.Alias); ok {
+ if r := findTypeParam(obj, aliases.TypeParams(alias), path, opTypeParam); r != nil {
return Path(r), nil
}
- } else {
- if named, _ := T.(*types.Named); named != nil {
- if r := findTypeParam(obj, typeparams.ForNamed(named), path, nil); r != nil {
- // generic named type
- return Path(r), nil
- }
+ if r := find(obj, aliases.Rhs(alias), append(path, opRhs)); r != nil {
+ return Path(r), nil
+ }
+
+ } else if tname.IsAlias() {
+ // legacy alias
+ if r := find(obj, T, path); r != nil {
+ return Path(r), nil
}
+
+ } else if named, ok := T.(*types.Named); ok {
// defined (named) type
- if r := find(obj, T.Underlying(), append(path, opUnderlying), nil); r != nil {
+ if r := findTypeParam(obj, named.TypeParams(), path, opTypeParam); r != nil {
+ return Path(r), nil
+ }
+ if r := find(obj, named.Underlying(), append(path, opUnderlying)); r != nil {
return Path(r), nil
}
}
@@ -318,7 +312,7 @@ func (enc *Encoder) For(obj types.Object) (Path, error) {
if _, ok := o.(*types.TypeName); !ok {
if o.Exported() {
// exported non-type (const, var, func)
- if r := find(obj, o.Type(), append(path, opType), nil); r != nil {
+ if r := find(obj, o.Type(), append(path, opType)); r != nil {
return Path(r), nil
}
}
@@ -326,33 +320,20 @@ func (enc *Encoder) For(obj types.Object) (Path, error) {
}
// Inspect declared methods of defined types.
- if T, ok := o.Type().(*types.Named); ok {
+ if T, ok := types.Unalias(o.Type()).(*types.Named); ok {
path = append(path, opType)
- if !enc.skipMethodSorting {
- // Note that method index here is always with respect
- // to canonical ordering of methods, regardless of how
- // they appear in the underlying type.
- for i, m := range enc.namedMethods(T) {
- path2 := appendOpArg(path, opMethod, i)
- if m == obj {
- return Path(path2), nil // found declared method
- }
- if r := find(obj, m.Type(), append(path2, opType), nil); r != nil {
- return Path(r), nil
- }
+ // The method index here is always with respect
+ // to the underlying go/types data structures,
+ // which ultimately derives from source order
+ // and must be preserved by export data.
+ for i := 0; i < T.NumMethods(); i++ {
+ m := T.Method(i)
+ path2 := appendOpArg(path, opMethod, i)
+ if m == obj {
+ return Path(path2), nil // found declared method
}
- } else {
- // This branch must match the logic in the branch above, using go/types
- // APIs without sorting.
- for i := 0; i < T.NumMethods(); i++ {
- m := T.Method(i)
- path2 := appendOpArg(path, opMethod, i)
- if m == obj {
- return Path(path2), nil // found declared method
- }
- if r := find(obj, m.Type(), append(path2, opType), nil); r != nil {
- return Path(r), nil
- }
+ if r := find(obj, m.Type(), append(path2, opType)); r != nil {
+ return Path(r), nil
}
}
}
@@ -420,17 +401,12 @@ func (enc *Encoder) concreteMethod(meth *types.Func) (Path, bool) {
// of objectpath will only be giving us origin methods, anyway, as referring
// to instantiated methods is usually not useful.
- if typeparams.OriginMethod(meth) != meth {
+ if meth.Origin() != meth {
return "", false
}
- recvT := meth.Type().(*types.Signature).Recv().Type()
- if ptr, ok := recvT.(*types.Pointer); ok {
- recvT = ptr.Elem()
- }
-
- named, ok := recvT.(*types.Named)
- if !ok {
+ _, named := typesinternal.ReceiverNamed(meth.Type().(*types.Signature).Recv())
+ if named == nil {
return "", false
}
@@ -448,22 +424,13 @@ func (enc *Encoder) concreteMethod(meth *types.Func) (Path, bool) {
path = append(path, name...)
path = append(path, opType)
- if !enc.skipMethodSorting {
- for i, m := range enc.namedMethods(named) {
- if m == meth {
- path = appendOpArg(path, opMethod, i)
- return Path(path), true
- }
- }
- } else {
- // This branch must match the logic of the branch above, using go/types
- // APIs without sorting.
- for i := 0; i < named.NumMethods(); i++ {
- m := named.Method(i)
- if m == meth {
- path = appendOpArg(path, opMethod, i)
- return Path(path), true
- }
+ // Method indices are w.r.t. the go/types data structures,
+ // ultimately deriving from source order,
+ // which is preserved by export data.
+ for i := 0; i < named.NumMethods(); i++ {
+ if named.Method(i) == meth {
+ path = appendOpArg(path, opMethod, i)
+ return Path(path), true
}
}
@@ -480,41 +447,64 @@ func (enc *Encoder) concreteMethod(meth *types.Func) (Path, bool) {
//
// The seen map is used to short circuit cycles through type parameters. If
// nil, it will be allocated as necessary.
-func find(obj types.Object, T types.Type, path []byte, seen map[*types.TypeName]bool) []byte {
+//
+// The seenMethods map is used internally to short circuit cycles through
+// interface methods, such as occur in the following example:
+//
+// type I interface { f() interface{I} }
+//
+// See golang/go#68046 for details.
+func find(obj types.Object, T types.Type, path []byte) []byte {
+ return (&finder{obj: obj}).find(T, path)
+}
+
+// finder closes over search state for a call to find.
+type finder struct {
+ obj types.Object // the sought object
+ seenTParamNames map[*types.TypeName]bool // for cycle breaking through type parameters
+ seenMethods map[*types.Func]bool // for cycle breaking through recursive interfaces
+}
+
+func (f *finder) find(T types.Type, path []byte) []byte {
switch T := T.(type) {
+ case *types.Alias:
+ return f.find(types.Unalias(T), path)
case *types.Basic, *types.Named:
// Named types belonging to pkg were handled already,
// so T must belong to another package. No path.
return nil
case *types.Pointer:
- return find(obj, T.Elem(), append(path, opElem), seen)
+ return f.find(T.Elem(), append(path, opElem))
case *types.Slice:
- return find(obj, T.Elem(), append(path, opElem), seen)
+ return f.find(T.Elem(), append(path, opElem))
case *types.Array:
- return find(obj, T.Elem(), append(path, opElem), seen)
+ return f.find(T.Elem(), append(path, opElem))
case *types.Chan:
- return find(obj, T.Elem(), append(path, opElem), seen)
+ return f.find(T.Elem(), append(path, opElem))
case *types.Map:
- if r := find(obj, T.Key(), append(path, opKey), seen); r != nil {
+ if r := f.find(T.Key(), append(path, opKey)); r != nil {
return r
}
- return find(obj, T.Elem(), append(path, opElem), seen)
+ return f.find(T.Elem(), append(path, opElem))
case *types.Signature:
- if r := findTypeParam(obj, typeparams.ForSignature(T), path, seen); r != nil {
+ if r := f.findTypeParam(T.RecvTypeParams(), path, opRecvTypeParam); r != nil {
+ return r
+ }
+ if r := f.findTypeParam(T.TypeParams(), path, opTypeParam); r != nil {
return r
}
- if r := find(obj, T.Params(), append(path, opParams), seen); r != nil {
+ if r := f.find(T.Params(), append(path, opParams)); r != nil {
return r
}
- return find(obj, T.Results(), append(path, opResults), seen)
+ return f.find(T.Results(), append(path, opResults))
case *types.Struct:
for i := 0; i < T.NumFields(); i++ {
fld := T.Field(i)
path2 := appendOpArg(path, opField, i)
- if fld == obj {
+ if fld == f.obj {
return path2 // found field var
}
- if r := find(obj, fld.Type(), append(path2, opType), seen); r != nil {
+ if r := f.find(fld.Type(), append(path2, opType)); r != nil {
return r
}
}
@@ -523,10 +513,10 @@ func find(obj types.Object, T types.Type, path []byte, seen map[*types.TypeName]
for i := 0; i < T.Len(); i++ {
v := T.At(i)
path2 := appendOpArg(path, opAt, i)
- if v == obj {
+ if v == f.obj {
return path2 // found param/result var
}
- if r := find(obj, v.Type(), append(path2, opType), seen); r != nil {
+ if r := f.find(v.Type(), append(path2, opType)); r != nil {
return r
}
}
@@ -534,28 +524,35 @@ func find(obj types.Object, T types.Type, path []byte, seen map[*types.TypeName]
case *types.Interface:
for i := 0; i < T.NumMethods(); i++ {
m := T.Method(i)
+ if f.seenMethods[m] {
+ return nil
+ }
path2 := appendOpArg(path, opMethod, i)
- if m == obj {
+ if m == f.obj {
return path2 // found interface method
}
- if r := find(obj, m.Type(), append(path2, opType), seen); r != nil {
+ if f.seenMethods == nil {
+ f.seenMethods = make(map[*types.Func]bool)
+ }
+ f.seenMethods[m] = true
+ if r := f.find(m.Type(), append(path2, opType)); r != nil {
return r
}
}
return nil
- case *typeparams.TypeParam:
+ case *types.TypeParam:
name := T.Obj()
- if name == obj {
- return append(path, opObj)
- }
- if seen[name] {
+ if f.seenTParamNames[name] {
return nil
}
- if seen == nil {
- seen = make(map[*types.TypeName]bool)
+ if name == f.obj {
+ return append(path, opObj)
+ }
+ if f.seenTParamNames == nil {
+ f.seenTParamNames = make(map[*types.TypeName]bool)
}
- seen[name] = true
- if r := find(obj, T.Constraint(), append(path, opConstraint), seen); r != nil {
+ f.seenTParamNames[name] = true
+ if r := f.find(T.Constraint(), append(path, opConstraint)); r != nil {
return r
}
return nil
@@ -563,11 +560,15 @@ func find(obj types.Object, T types.Type, path []byte, seen map[*types.TypeName]
panic(T)
}
-func findTypeParam(obj types.Object, list *typeparams.TypeParamList, path []byte, seen map[*types.TypeName]bool) []byte {
+func findTypeParam(obj types.Object, list *types.TypeParamList, path []byte, op byte) []byte {
+ return (&finder{obj: obj}).findTypeParam(list, path, op)
+}
+
+func (f *finder) findTypeParam(list *types.TypeParamList, path []byte, op byte) []byte {
for i := 0; i < list.Len(); i++ {
tparam := list.At(i)
- path2 := appendOpArg(path, opTypeParam, i)
- if r := find(obj, tparam, path2, seen); r != nil {
+ path2 := appendOpArg(path, op, i)
+ if r := f.find(tparam, path2); r != nil {
return r
}
}
@@ -576,12 +577,7 @@ func findTypeParam(obj types.Object, list *typeparams.TypeParamList, path []byte
// Object returns the object denoted by path p within the package pkg.
func Object(pkg *types.Package, p Path) (types.Object, error) {
- return object(pkg, string(p), false)
-}
-
-// Note: the skipMethodSorting parameter must match the value of
-// Encoder.skipMethodSorting used during encoding.
-func object(pkg *types.Package, pathstr string, skipMethodSorting bool) (types.Object, error) {
+ pathstr := string(p)
if pathstr == "" {
return nil, fmt.Errorf("empty path")
}
@@ -605,7 +601,7 @@ func object(pkg *types.Package, pathstr string, skipMethodSorting bool) (types.O
}
// abstraction of *types.{Named,Signature}
type hasTypeParams interface {
- TypeParams() *typeparams.TypeParamList
+ TypeParams() *types.TypeParamList
}
// abstraction of *types.{Named,TypeParam}
type hasObj interface {
@@ -623,10 +619,10 @@ func object(pkg *types.Package, pathstr string, skipMethodSorting bool) (types.O
code := suffix[0]
suffix = suffix[1:]
- // Codes [AFM] have an integer operand.
+ // Codes [AFMTr] have an integer operand.
var index int
switch code {
- case opAt, opField, opMethod, opTypeParam:
+ case opAt, opField, opMethod, opTypeParam, opRecvTypeParam:
rest := strings.TrimLeft(suffix, "0123456789")
numerals := suffix[:len(suffix)-len(rest)]
suffix = rest
@@ -659,6 +655,7 @@ func object(pkg *types.Package, pathstr string, skipMethodSorting bool) (types.O
// Inv: t != nil, obj == nil
+ t = types.Unalias(t)
switch code {
case opElem:
hasElem, ok := t.(hasElem) // Pointer, Slice, Array, Chan, Map
@@ -695,6 +692,16 @@ func object(pkg *types.Package, pathstr string, skipMethodSorting bool) (types.O
}
t = named.Underlying()
+ case opRhs:
+ if alias, ok := t.(*types.Alias); ok {
+ t = aliases.Rhs(alias)
+ } else if false && aliases.Enabled() {
+ // The Enabled check is too expensive, so for now we
+ // simply assume that aliases are not enabled.
+ // TODO(adonovan): replace with "if true {" when go1.24 is assured.
+ return nil, fmt.Errorf("cannot apply %q to %s (got %T, want alias)", code, t, t)
+ }
+
case opTypeParam:
hasTypeParams, ok := t.(hasTypeParams) // Named, Signature
if !ok {
@@ -706,8 +713,19 @@ func object(pkg *types.Package, pathstr string, skipMethodSorting bool) (types.O
}
t = tparams.At(index)
+ case opRecvTypeParam:
+ sig, ok := t.(*types.Signature) // Signature
+ if !ok {
+ return nil, fmt.Errorf("cannot apply %q to %s (got %T, want signature)", code, t, t)
+ }
+ rtparams := sig.RecvTypeParams()
+ if n := rtparams.Len(); index >= n {
+ return nil, fmt.Errorf("tuple index %d out of range [0-%d)", index, n)
+ }
+ t = rtparams.At(index)
+
case opConstraint:
- tparam, ok := t.(*typeparams.TypeParam)
+ tparam, ok := t.(*types.TypeParam)
if !ok {
return nil, fmt.Errorf("cannot apply %q to %s (got %T, want type parameter)", code, t, t)
}
@@ -747,12 +765,7 @@ func object(pkg *types.Package, pathstr string, skipMethodSorting bool) (types.O
if index >= t.NumMethods() {
return nil, fmt.Errorf("method index %d out of range [0-%d)", index, t.NumMethods())
}
- if skipMethodSorting {
- obj = t.Method(index)
- } else {
- methods := namedMethods(t) // (unmemoized)
- obj = methods[index] // Id-ordered
- }
+ obj = t.Method(index)
default:
return nil, fmt.Errorf("cannot apply %q to %s (got %T, want interface or named)", code, t, t)
@@ -772,6 +785,10 @@ func object(pkg *types.Package, pathstr string, skipMethodSorting bool) (types.O
}
}
+ if obj == nil {
+ panic(p) // path does not end in an object-valued operator
+ }
+
if obj.Pkg() != pkg {
return nil, fmt.Errorf("path denotes %s, which belongs to a different package", obj)
}
@@ -779,33 +796,6 @@ func object(pkg *types.Package, pathstr string, skipMethodSorting bool) (types.O
return obj, nil // success
}
-// namedMethods returns the methods of a Named type in ascending Id order.
-func namedMethods(named *types.Named) []*types.Func {
- methods := make([]*types.Func, named.NumMethods())
- for i := range methods {
- methods[i] = named.Method(i)
- }
- sort.Slice(methods, func(i, j int) bool {
- return methods[i].Id() < methods[j].Id()
- })
- return methods
-}
-
-// namedMethods is a memoization of the namedMethods function. Callers must not modify the result.
-func (enc *Encoder) namedMethods(named *types.Named) []*types.Func {
- m := enc.namedMethodsMemo
- if m == nil {
- m = make(map[*types.Named][]*types.Func)
- enc.namedMethodsMemo = m
- }
- methods, ok := m[named]
- if !ok {
- methods = namedMethods(named) // allocates and sorts
- m[named] = methods
- }
- return methods
-}
-
// scopeObjects is a memoization of scope objects.
// Callers must not modify the result.
func (enc *Encoder) scopeObjects(scope *types.Scope) []types.Object {
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/callee.go b/vendor/golang.org/x/tools/go/types/typeutil/callee.go
new file mode 100644
index 0000000000..754380351e
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/types/typeutil/callee.go
@@ -0,0 +1,68 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typeutil
+
+import (
+ "go/ast"
+ "go/types"
+
+ "golang.org/x/tools/internal/typeparams"
+)
+
+// Callee returns the named target of a function call, if any:
+// a function, method, builtin, or variable.
+//
+// Functions and methods may potentially have type parameters.
+func Callee(info *types.Info, call *ast.CallExpr) types.Object {
+ fun := ast.Unparen(call.Fun)
+
+ // Look through type instantiation if necessary.
+ isInstance := false
+ switch fun.(type) {
+ case *ast.IndexExpr, *ast.IndexListExpr:
+ // When extracting the callee from an *IndexExpr, we need to check that
+ // it is a *types.Func and not a *types.Var.
+ // Example: Don't match a slice m within the expression `m[0]()`.
+ isInstance = true
+ fun, _, _, _ = typeparams.UnpackIndexExpr(fun)
+ }
+
+ var obj types.Object
+ switch fun := fun.(type) {
+ case *ast.Ident:
+ obj = info.Uses[fun] // type, var, builtin, or declared func
+ case *ast.SelectorExpr:
+ if sel, ok := info.Selections[fun]; ok {
+ obj = sel.Obj() // method or field
+ } else {
+ obj = info.Uses[fun.Sel] // qualified identifier?
+ }
+ }
+ if _, ok := obj.(*types.TypeName); ok {
+ return nil // T(x) is a conversion, not a call
+ }
+ // A Func is required to match instantiations.
+ if _, ok := obj.(*types.Func); isInstance && !ok {
+ return nil // Was not a Func.
+ }
+ return obj
+}
+
+// StaticCallee returns the target (function or method) of a static function
+// call, if any. It returns nil for calls to builtins.
+//
+// Note: for calls of instantiated functions and methods, StaticCallee returns
+// the corresponding generic function or method on the generic type.
+func StaticCallee(info *types.Info, call *ast.CallExpr) *types.Func {
+ if f, ok := Callee(info, call).(*types.Func); ok && !interfaceMethod(f) {
+ return f
+ }
+ return nil
+}
+
+func interfaceMethod(f *types.Func) bool {
+ recv := f.Type().(*types.Signature).Recv()
+ return recv != nil && types.IsInterface(recv.Type())
+}
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/imports.go b/vendor/golang.org/x/tools/go/types/typeutil/imports.go
new file mode 100644
index 0000000000..b81ce0c330
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/types/typeutil/imports.go
@@ -0,0 +1,30 @@
+// 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.
+
+package typeutil
+
+import "go/types"
+
+// Dependencies returns all dependencies of the specified packages.
+//
+// Dependent packages appear in topological order: if package P imports
+// package Q, Q appears earlier than P in the result.
+// The algorithm follows import statements in the order they
+// appear in the source code, so the result is a total order.
+func Dependencies(pkgs ...*types.Package) []*types.Package {
+ var result []*types.Package
+ seen := make(map[*types.Package]bool)
+ var visit func(pkgs []*types.Package)
+ visit = func(pkgs []*types.Package) {
+ for _, p := range pkgs {
+ if !seen[p] {
+ seen[p] = true
+ visit(p.Imports())
+ result = append(result, p)
+ }
+ }
+ }
+ visit(pkgs)
+ return result
+}
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/map.go b/vendor/golang.org/x/tools/go/types/typeutil/map.go
new file mode 100644
index 0000000000..8d824f7140
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/types/typeutil/map.go
@@ -0,0 +1,517 @@
+// 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.
+
+// Package typeutil defines various utilities for types, such as Map,
+// a mapping from types.Type to any values.
+package typeutil // import "golang.org/x/tools/go/types/typeutil"
+
+import (
+ "bytes"
+ "fmt"
+ "go/types"
+ "reflect"
+
+ "golang.org/x/tools/internal/typeparams"
+)
+
+// Map is a hash-table-based mapping from types (types.Type) to
+// arbitrary any values. The concrete types that implement
+// the Type interface are pointers. Since they are not canonicalized,
+// == cannot be used to check for equivalence, and thus we cannot
+// simply use a Go map.
+//
+// Just as with map[K]V, a nil *Map is a valid empty map.
+//
+// Not thread-safe.
+type Map struct {
+ hasher Hasher // shared by many Maps
+ table map[uint32][]entry // maps hash to bucket; entry.key==nil means unused
+ length int // number of map entries
+}
+
+// entry is an entry (key/value association) in a hash bucket.
+type entry struct {
+ key types.Type
+ value any
+}
+
+// SetHasher sets the hasher used by Map.
+//
+// All Hashers are functionally equivalent but contain internal state
+// used to cache the results of hashing previously seen types.
+//
+// A single Hasher created by MakeHasher() may be shared among many
+// Maps. This is recommended if the instances have many keys in
+// common, as it will amortize the cost of hash computation.
+//
+// A Hasher may grow without bound as new types are seen. Even when a
+// type is deleted from the map, the Hasher never shrinks, since other
+// types in the map may reference the deleted type indirectly.
+//
+// Hashers are not thread-safe, and read-only operations such as
+// Map.Lookup require updates to the hasher, so a full Mutex lock (not a
+// read-lock) is require around all Map operations if a shared
+// hasher is accessed from multiple threads.
+//
+// If SetHasher is not called, the Map will create a private hasher at
+// the first call to Insert.
+func (m *Map) SetHasher(hasher Hasher) {
+ m.hasher = hasher
+}
+
+// Delete removes the entry with the given key, if any.
+// It returns true if the entry was found.
+func (m *Map) Delete(key types.Type) bool {
+ if m != nil && m.table != nil {
+ hash := m.hasher.Hash(key)
+ bucket := m.table[hash]
+ for i, e := range bucket {
+ if e.key != nil && types.Identical(key, e.key) {
+ // We can't compact the bucket as it
+ // would disturb iterators.
+ bucket[i] = entry{}
+ m.length--
+ return true
+ }
+ }
+ }
+ return false
+}
+
+// At returns the map entry for the given key.
+// The result is nil if the entry is not present.
+func (m *Map) At(key types.Type) any {
+ if m != nil && m.table != nil {
+ for _, e := range m.table[m.hasher.Hash(key)] {
+ if e.key != nil && types.Identical(key, e.key) {
+ return e.value
+ }
+ }
+ }
+ return nil
+}
+
+// Set sets the map entry for key to val,
+// and returns the previous entry, if any.
+func (m *Map) Set(key types.Type, value any) (prev any) {
+ if m.table != nil {
+ hash := m.hasher.Hash(key)
+ bucket := m.table[hash]
+ var hole *entry
+ for i, e := range bucket {
+ if e.key == nil {
+ hole = &bucket[i]
+ } else if types.Identical(key, e.key) {
+ prev = e.value
+ bucket[i].value = value
+ return
+ }
+ }
+
+ if hole != nil {
+ *hole = entry{key, value} // overwrite deleted entry
+ } else {
+ m.table[hash] = append(bucket, entry{key, value})
+ }
+ } else {
+ if m.hasher.memo == nil {
+ m.hasher = MakeHasher()
+ }
+ hash := m.hasher.Hash(key)
+ m.table = map[uint32][]entry{hash: {entry{key, value}}}
+ }
+
+ m.length++
+ return
+}
+
+// Len returns the number of map entries.
+func (m *Map) Len() int {
+ if m != nil {
+ return m.length
+ }
+ return 0
+}
+
+// Iterate calls function f on each entry in the map in unspecified order.
+//
+// If f should mutate the map, Iterate provides the same guarantees as
+// Go maps: if f deletes a map entry that Iterate has not yet reached,
+// f will not be invoked for it, but if f inserts a map entry that
+// Iterate has not yet reached, whether or not f will be invoked for
+// it is unspecified.
+func (m *Map) Iterate(f func(key types.Type, value any)) {
+ if m != nil {
+ for _, bucket := range m.table {
+ for _, e := range bucket {
+ if e.key != nil {
+ f(e.key, e.value)
+ }
+ }
+ }
+ }
+}
+
+// Keys returns a new slice containing the set of map keys.
+// The order is unspecified.
+func (m *Map) Keys() []types.Type {
+ keys := make([]types.Type, 0, m.Len())
+ m.Iterate(func(key types.Type, _ any) {
+ keys = append(keys, key)
+ })
+ return keys
+}
+
+func (m *Map) toString(values bool) string {
+ if m == nil {
+ return "{}"
+ }
+ var buf bytes.Buffer
+ fmt.Fprint(&buf, "{")
+ sep := ""
+ m.Iterate(func(key types.Type, value any) {
+ fmt.Fprint(&buf, sep)
+ sep = ", "
+ fmt.Fprint(&buf, key)
+ if values {
+ fmt.Fprintf(&buf, ": %q", value)
+ }
+ })
+ fmt.Fprint(&buf, "}")
+ return buf.String()
+}
+
+// String returns a string representation of the map's entries.
+// Values are printed using fmt.Sprintf("%v", v).
+// Order is unspecified.
+func (m *Map) String() string {
+ return m.toString(true)
+}
+
+// KeysString returns a string representation of the map's key set.
+// Order is unspecified.
+func (m *Map) KeysString() string {
+ return m.toString(false)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Hasher
+
+// A Hasher maps each type to its hash value.
+// For efficiency, a hasher uses memoization; thus its memory
+// footprint grows monotonically over time.
+// Hashers are not thread-safe.
+// Hashers have reference semantics.
+// Call MakeHasher to create a Hasher.
+type Hasher struct {
+ memo map[types.Type]uint32
+
+ // ptrMap records pointer identity.
+ ptrMap map[any]uint32
+
+ // sigTParams holds type parameters from the signature being hashed.
+ // Signatures are considered identical modulo renaming of type parameters, so
+ // within the scope of a signature type the identity of the signature's type
+ // parameters is just their index.
+ //
+ // Since the language does not currently support referring to uninstantiated
+ // generic types or functions, and instantiated signatures do not have type
+ // parameter lists, we should never encounter a second non-empty type
+ // parameter list when hashing a generic signature.
+ sigTParams *types.TypeParamList
+}
+
+// MakeHasher returns a new Hasher instance.
+func MakeHasher() Hasher {
+ return Hasher{
+ memo: make(map[types.Type]uint32),
+ ptrMap: make(map[any]uint32),
+ sigTParams: nil,
+ }
+}
+
+// Hash computes a hash value for the given type t such that
+// Identical(t, t') => Hash(t) == Hash(t').
+func (h Hasher) Hash(t types.Type) uint32 {
+ hash, ok := h.memo[t]
+ if !ok {
+ hash = h.hashFor(t)
+ h.memo[t] = hash
+ }
+ return hash
+}
+
+// hashString computes the Fowler–Noll–Vo hash of s.
+func hashString(s string) uint32 {
+ var h uint32
+ for i := 0; i < len(s); i++ {
+ h ^= uint32(s[i])
+ h *= 16777619
+ }
+ return h
+}
+
+// hashFor computes the hash of t.
+func (h Hasher) hashFor(t types.Type) uint32 {
+ // See Identical for rationale.
+ switch t := t.(type) {
+ case *types.Basic:
+ return uint32(t.Kind())
+
+ case *types.Alias:
+ return h.Hash(types.Unalias(t))
+
+ case *types.Array:
+ return 9043 + 2*uint32(t.Len()) + 3*h.Hash(t.Elem())
+
+ case *types.Slice:
+ return 9049 + 2*h.Hash(t.Elem())
+
+ case *types.Struct:
+ var hash uint32 = 9059
+ for i, n := 0, t.NumFields(); i < n; i++ {
+ f := t.Field(i)
+ if f.Anonymous() {
+ hash += 8861
+ }
+ hash += hashString(t.Tag(i))
+ hash += hashString(f.Name()) // (ignore f.Pkg)
+ hash += h.Hash(f.Type())
+ }
+ return hash
+
+ case *types.Pointer:
+ return 9067 + 2*h.Hash(t.Elem())
+
+ case *types.Signature:
+ var hash uint32 = 9091
+ if t.Variadic() {
+ hash *= 8863
+ }
+
+ // Use a separate hasher for types inside of the signature, where type
+ // parameter identity is modified to be (index, constraint). We must use a
+ // new memo for this hasher as type identity may be affected by this
+ // masking. For example, in func[T any](*T), the identity of *T depends on
+ // whether we are mapping the argument in isolation, or recursively as part
+ // of hashing the signature.
+ //
+ // We should never encounter a generic signature while hashing another
+ // generic signature, but defensively set sigTParams only if h.mask is
+ // unset.
+ tparams := t.TypeParams()
+ if h.sigTParams == nil && tparams.Len() != 0 {
+ h = Hasher{
+ // There may be something more efficient than discarding the existing
+ // memo, but it would require detecting whether types are 'tainted' by
+ // references to type parameters.
+ memo: make(map[types.Type]uint32),
+ // Re-using ptrMap ensures that pointer identity is preserved in this
+ // hasher.
+ ptrMap: h.ptrMap,
+ sigTParams: tparams,
+ }
+ }
+
+ for i := 0; i < tparams.Len(); i++ {
+ tparam := tparams.At(i)
+ hash += 7 * h.Hash(tparam.Constraint())
+ }
+
+ return hash + 3*h.hashTuple(t.Params()) + 5*h.hashTuple(t.Results())
+
+ case *types.Union:
+ return h.hashUnion(t)
+
+ case *types.Interface:
+ // Interfaces are identical if they have the same set of methods, with
+ // identical names and types, and they have the same set of type
+ // restrictions. See go/types.identical for more details.
+ var hash uint32 = 9103
+
+ // Hash methods.
+ for i, n := 0, t.NumMethods(); i < n; i++ {
+ // Method order is not significant.
+ // Ignore m.Pkg().
+ m := t.Method(i)
+ // Use shallow hash on method signature to
+ // avoid anonymous interface cycles.
+ hash += 3*hashString(m.Name()) + 5*h.shallowHash(m.Type())
+ }
+
+ // Hash type restrictions.
+ terms, err := typeparams.InterfaceTermSet(t)
+ // if err != nil t has invalid type restrictions.
+ if err == nil {
+ hash += h.hashTermSet(terms)
+ }
+
+ return hash
+
+ case *types.Map:
+ return 9109 + 2*h.Hash(t.Key()) + 3*h.Hash(t.Elem())
+
+ case *types.Chan:
+ return 9127 + 2*uint32(t.Dir()) + 3*h.Hash(t.Elem())
+
+ case *types.Named:
+ hash := h.hashPtr(t.Obj())
+ targs := t.TypeArgs()
+ for i := 0; i < targs.Len(); i++ {
+ targ := targs.At(i)
+ hash += 2 * h.Hash(targ)
+ }
+ return hash
+
+ case *types.TypeParam:
+ return h.hashTypeParam(t)
+
+ case *types.Tuple:
+ return h.hashTuple(t)
+ }
+
+ panic(fmt.Sprintf("%T: %v", t, t))
+}
+
+func (h Hasher) hashTuple(tuple *types.Tuple) uint32 {
+ // See go/types.identicalTypes for rationale.
+ n := tuple.Len()
+ hash := 9137 + 2*uint32(n)
+ for i := 0; i < n; i++ {
+ hash += 3 * h.Hash(tuple.At(i).Type())
+ }
+ return hash
+}
+
+func (h Hasher) hashUnion(t *types.Union) uint32 {
+ // Hash type restrictions.
+ terms, err := typeparams.UnionTermSet(t)
+ // if err != nil t has invalid type restrictions. Fall back on a non-zero
+ // hash.
+ if err != nil {
+ return 9151
+ }
+ return h.hashTermSet(terms)
+}
+
+func (h Hasher) hashTermSet(terms []*types.Term) uint32 {
+ hash := 9157 + 2*uint32(len(terms))
+ for _, term := range terms {
+ // term order is not significant.
+ termHash := h.Hash(term.Type())
+ if term.Tilde() {
+ termHash *= 9161
+ }
+ hash += 3 * termHash
+ }
+ return hash
+}
+
+// hashTypeParam returns a hash of the type parameter t, with a hash value
+// depending on whether t is contained in h.sigTParams.
+//
+// If h.sigTParams is set and contains t, then we are in the process of hashing
+// a signature, and the hash value of t must depend only on t's index and
+// constraint: signatures are considered identical modulo type parameter
+// renaming. To avoid infinite recursion, we only hash the type parameter
+// index, and rely on types.Identical to handle signatures where constraints
+// are not identical.
+//
+// Otherwise the hash of t depends only on t's pointer identity.
+func (h Hasher) hashTypeParam(t *types.TypeParam) uint32 {
+ if h.sigTParams != nil {
+ i := t.Index()
+ if i >= 0 && i < h.sigTParams.Len() && t == h.sigTParams.At(i) {
+ return 9173 + 3*uint32(i)
+ }
+ }
+ return h.hashPtr(t.Obj())
+}
+
+// hashPtr hashes the pointer identity of ptr. It uses h.ptrMap to ensure that
+// pointers values are not dependent on the GC.
+func (h Hasher) hashPtr(ptr any) uint32 {
+ if hash, ok := h.ptrMap[ptr]; ok {
+ return hash
+ }
+ hash := uint32(reflect.ValueOf(ptr).Pointer())
+ h.ptrMap[ptr] = hash
+ return hash
+}
+
+// shallowHash computes a hash of t without looking at any of its
+// element Types, to avoid potential anonymous cycles in the types of
+// interface methods.
+//
+// When an unnamed non-empty interface type appears anywhere among the
+// arguments or results of an interface method, there is a potential
+// for endless recursion. Consider:
+//
+// type X interface { m() []*interface { X } }
+//
+// The problem is that the Methods of the interface in m's result type
+// include m itself; there is no mention of the named type X that
+// might help us break the cycle.
+// (See comment in go/types.identical, case *Interface, for more.)
+func (h Hasher) shallowHash(t types.Type) uint32 {
+ // t is the type of an interface method (Signature),
+ // its params or results (Tuples), or their immediate
+ // elements (mostly Slice, Pointer, Basic, Named),
+ // so there's no need to optimize anything else.
+ switch t := t.(type) {
+ case *types.Alias:
+ return h.shallowHash(types.Unalias(t))
+
+ case *types.Signature:
+ var hash uint32 = 604171
+ if t.Variadic() {
+ hash *= 971767
+ }
+ // The Signature/Tuple recursion is always finite
+ // and invariably shallow.
+ return hash + 1062599*h.shallowHash(t.Params()) + 1282529*h.shallowHash(t.Results())
+
+ case *types.Tuple:
+ n := t.Len()
+ hash := 9137 + 2*uint32(n)
+ for i := 0; i < n; i++ {
+ hash += 53471161 * h.shallowHash(t.At(i).Type())
+ }
+ return hash
+
+ case *types.Basic:
+ return 45212177 * uint32(t.Kind())
+
+ case *types.Array:
+ return 1524181 + 2*uint32(t.Len())
+
+ case *types.Slice:
+ return 2690201
+
+ case *types.Struct:
+ return 3326489
+
+ case *types.Pointer:
+ return 4393139
+
+ case *types.Union:
+ return 562448657
+
+ case *types.Interface:
+ return 2124679 // no recursion here
+
+ case *types.Map:
+ return 9109
+
+ case *types.Chan:
+ return 9127
+
+ case *types.Named:
+ return h.hashPtr(t.Obj())
+
+ case *types.TypeParam:
+ return h.hashPtr(t.Obj())
+ }
+ panic(fmt.Sprintf("shallowHash: %T: %v", t, t))
+}
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go b/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go
new file mode 100644
index 0000000000..f7666028fe
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go
@@ -0,0 +1,71 @@
+// 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.
+
+// This file implements a cache of method sets.
+
+package typeutil
+
+import (
+ "go/types"
+ "sync"
+)
+
+// A MethodSetCache records the method set of each type T for which
+// MethodSet(T) is called so that repeat queries are fast.
+// The zero value is a ready-to-use cache instance.
+type MethodSetCache struct {
+ mu sync.Mutex
+ named map[*types.Named]struct{ value, pointer *types.MethodSet } // method sets for named N and *N
+ others map[types.Type]*types.MethodSet // all other types
+}
+
+// MethodSet returns the method set of type T. It is thread-safe.
+//
+// If cache is nil, this function is equivalent to types.NewMethodSet(T).
+// Utility functions can thus expose an optional *MethodSetCache
+// parameter to clients that care about performance.
+func (cache *MethodSetCache) MethodSet(T types.Type) *types.MethodSet {
+ if cache == nil {
+ return types.NewMethodSet(T)
+ }
+ cache.mu.Lock()
+ defer cache.mu.Unlock()
+
+ switch T := types.Unalias(T).(type) {
+ case *types.Named:
+ return cache.lookupNamed(T).value
+
+ case *types.Pointer:
+ if N, ok := types.Unalias(T.Elem()).(*types.Named); ok {
+ return cache.lookupNamed(N).pointer
+ }
+ }
+
+ // all other types
+ // (The map uses pointer equivalence, not type identity.)
+ mset := cache.others[T]
+ if mset == nil {
+ mset = types.NewMethodSet(T)
+ if cache.others == nil {
+ cache.others = make(map[types.Type]*types.MethodSet)
+ }
+ cache.others[T] = mset
+ }
+ return mset
+}
+
+func (cache *MethodSetCache) lookupNamed(named *types.Named) struct{ value, pointer *types.MethodSet } {
+ if cache.named == nil {
+ cache.named = make(map[*types.Named]struct{ value, pointer *types.MethodSet })
+ }
+ // Avoid recomputing mset(*T) for each distinct Pointer
+ // instance whose underlying type is a named type.
+ msets, ok := cache.named[named]
+ if !ok {
+ msets.value = types.NewMethodSet(named)
+ msets.pointer = types.NewMethodSet(types.NewPointer(named))
+ cache.named[named] = msets
+ }
+ return msets
+}
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/ui.go b/vendor/golang.org/x/tools/go/types/typeutil/ui.go
new file mode 100644
index 0000000000..9dda6a25df
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/types/typeutil/ui.go
@@ -0,0 +1,53 @@
+// 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.
+
+package typeutil
+
+// This file defines utilities for user interfaces that display types.
+
+import (
+ "go/types"
+)
+
+// IntuitiveMethodSet returns the intuitive method set of a type T,
+// which is the set of methods you can call on an addressable value of
+// that type.
+//
+// The result always contains MethodSet(T), and is exactly MethodSet(T)
+// for interface types and for pointer-to-concrete types.
+// For all other concrete types T, the result additionally
+// contains each method belonging to *T if there is no identically
+// named method on T itself.
+//
+// This corresponds to user intuition about method sets;
+// this function is intended only for user interfaces.
+//
+// The order of the result is as for types.MethodSet(T).
+func IntuitiveMethodSet(T types.Type, msets *MethodSetCache) []*types.Selection {
+ isPointerToConcrete := func(T types.Type) bool {
+ ptr, ok := types.Unalias(T).(*types.Pointer)
+ return ok && !types.IsInterface(ptr.Elem())
+ }
+
+ var result []*types.Selection
+ mset := msets.MethodSet(T)
+ if types.IsInterface(T) || isPointerToConcrete(T) {
+ for i, n := 0, mset.Len(); i < n; i++ {
+ result = append(result, mset.At(i))
+ }
+ } else {
+ // T is some other concrete type.
+ // Report methods of T and *T, preferring those of T.
+ pmset := msets.MethodSet(types.NewPointer(T))
+ for i, n := 0, pmset.Len(); i < n; i++ {
+ meth := pmset.At(i)
+ if m := mset.Lookup(meth.Obj().Pkg(), meth.Obj().Name()); m != nil {
+ meth = m
+ }
+ result = append(result, meth)
+ }
+
+ }
+ return result
+}
diff --git a/vendor/golang.org/x/tools/internal/aliases/aliases.go b/vendor/golang.org/x/tools/internal/aliases/aliases.go
new file mode 100644
index 0000000000..b9425f5a20
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/aliases/aliases.go
@@ -0,0 +1,38 @@
+// Copyright 2024 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 aliases
+
+import (
+ "go/token"
+ "go/types"
+)
+
+// Package aliases defines backward compatible shims
+// for the types.Alias type representation added in 1.22.
+// This defines placeholders for x/tools until 1.26.
+
+// NewAlias creates a new TypeName in Package pkg that
+// is an alias for the type rhs.
+//
+// The enabled parameter determines whether the resulting [TypeName]'s
+// type is an [types.Alias]. Its value must be the result of a call to
+// [Enabled], which computes the effective value of
+// GODEBUG=gotypesalias=... by invoking the type checker. The Enabled
+// function is expensive and should be called once per task (e.g.
+// package import), not once per call to NewAlias.
+//
+// Precondition: enabled || len(tparams)==0.
+// If materialized aliases are disabled, there must not be any type parameters.
+func NewAlias(enabled bool, pos token.Pos, pkg *types.Package, name string, rhs types.Type, tparams []*types.TypeParam) *types.TypeName {
+ if enabled {
+ tname := types.NewTypeName(pos, pkg, name, nil)
+ SetTypeParams(types.NewAlias(tname, rhs), tparams)
+ return tname
+ }
+ if len(tparams) > 0 {
+ panic("cannot create an alias with type parameters when gotypesalias is not enabled")
+ }
+ return types.NewTypeName(pos, pkg, name, rhs)
+}
diff --git a/vendor/golang.org/x/tools/internal/aliases/aliases_go122.go b/vendor/golang.org/x/tools/internal/aliases/aliases_go122.go
new file mode 100644
index 0000000000..7716a3331d
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/aliases/aliases_go122.go
@@ -0,0 +1,80 @@
+// Copyright 2024 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 aliases
+
+import (
+ "go/ast"
+ "go/parser"
+ "go/token"
+ "go/types"
+)
+
+// Rhs returns the type on the right-hand side of the alias declaration.
+func Rhs(alias *types.Alias) types.Type {
+ if alias, ok := any(alias).(interface{ Rhs() types.Type }); ok {
+ return alias.Rhs() // go1.23+
+ }
+
+ // go1.22's Alias didn't have the Rhs method,
+ // so Unalias is the best we can do.
+ return types.Unalias(alias)
+}
+
+// TypeParams returns the type parameter list of the alias.
+func TypeParams(alias *types.Alias) *types.TypeParamList {
+ if alias, ok := any(alias).(interface{ TypeParams() *types.TypeParamList }); ok {
+ return alias.TypeParams() // go1.23+
+ }
+ return nil
+}
+
+// SetTypeParams sets the type parameters of the alias type.
+func SetTypeParams(alias *types.Alias, tparams []*types.TypeParam) {
+ if alias, ok := any(alias).(interface {
+ SetTypeParams(tparams []*types.TypeParam)
+ }); ok {
+ alias.SetTypeParams(tparams) // go1.23+
+ } else if len(tparams) > 0 {
+ panic("cannot set type parameters of an Alias type in go1.22")
+ }
+}
+
+// TypeArgs returns the type arguments used to instantiate the Alias type.
+func TypeArgs(alias *types.Alias) *types.TypeList {
+ if alias, ok := any(alias).(interface{ TypeArgs() *types.TypeList }); ok {
+ return alias.TypeArgs() // go1.23+
+ }
+ return nil // empty (go1.22)
+}
+
+// Origin returns the generic Alias type of which alias is an instance.
+// If alias is not an instance of a generic alias, Origin returns alias.
+func Origin(alias *types.Alias) *types.Alias {
+ if alias, ok := any(alias).(interface{ Origin() *types.Alias }); ok {
+ return alias.Origin() // go1.23+
+ }
+ return alias // not an instance of a generic alias (go1.22)
+}
+
+// Enabled reports whether [NewAlias] should create [types.Alias] types.
+//
+// This function is expensive! Call it sparingly.
+func Enabled() bool {
+ // The only reliable way to compute the answer is to invoke go/types.
+ // We don't parse the GODEBUG environment variable, because
+ // (a) it's tricky to do so in a manner that is consistent
+ // with the godebug package; in particular, a simple
+ // substring check is not good enough. The value is a
+ // rightmost-wins list of options. But more importantly:
+ // (b) it is impossible to detect changes to the effective
+ // setting caused by os.Setenv("GODEBUG"), as happens in
+ // many tests. Therefore any attempt to cache the result
+ // is just incorrect.
+ fset := token.NewFileSet()
+ f, _ := parser.ParseFile(fset, "a.go", "package p; type A = int", parser.SkipObjectResolution)
+ pkg, _ := new(types.Config).Check("p", fset, []*ast.File{f}, nil)
+ _, enabled := pkg.Scope().Lookup("A").Type().(*types.Alias)
+ return enabled
+}
diff --git a/vendor/golang.org/x/tools/internal/event/keys/util.go b/vendor/golang.org/x/tools/internal/event/keys/util.go
new file mode 100644
index 0000000000..c0e8e731c9
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/event/keys/util.go
@@ -0,0 +1,21 @@
+// 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.
+
+package keys
+
+import (
+ "sort"
+ "strings"
+)
+
+// Join returns a canonical join of the keys in S:
+// a sorted comma-separated string list.
+func Join[S ~[]T, T ~string](s S) string {
+ strs := make([]string, 0, len(s))
+ for _, v := range s {
+ strs = append(strs, string(v))
+ }
+ sort.Strings(strs)
+ return strings.Join(strs, ",")
+}
diff --git a/vendor/golang.org/x/tools/internal/event/tag/tag.go b/vendor/golang.org/x/tools/internal/event/tag/tag.go
deleted file mode 100644
index 581b26c204..0000000000
--- a/vendor/golang.org/x/tools/internal/event/tag/tag.go
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright 2019 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 tag provides the labels used for telemetry throughout gopls.
-package tag
-
-import (
- "golang.org/x/tools/internal/event/keys"
-)
-
-var (
- // create the label keys we use
- Method = keys.NewString("method", "")
- StatusCode = keys.NewString("status.code", "")
- StatusMessage = keys.NewString("status.message", "")
- RPCID = keys.NewString("id", "")
- RPCDirection = keys.NewString("direction", "")
- File = keys.NewString("file", "")
- Directory = keys.New("directory", "")
- URI = keys.New("URI", "")
- Package = keys.NewString("package", "") // sorted comma-separated list of Package IDs
- PackagePath = keys.NewString("package_path", "")
- Query = keys.New("query", "")
- Snapshot = keys.NewUInt64("snapshot", "")
- Operation = keys.NewString("operation", "")
-
- Position = keys.New("position", "")
- Category = keys.NewString("category", "")
- PackageCount = keys.NewInt("packages", "")
- Files = keys.New("files", "")
- Port = keys.NewInt("port", "")
- Type = keys.New("type", "")
- HoverKind = keys.NewString("hoverkind", "")
-
- NewServer = keys.NewString("new_server", "A new server was added")
- EndServer = keys.NewString("end_server", "A server was shut down")
-
- ServerID = keys.NewString("server", "The server ID an event is related to")
- Logfile = keys.NewString("logfile", "")
- DebugAddress = keys.NewString("debug_address", "")
- GoplsPath = keys.NewString("gopls_path", "")
- ClientID = keys.NewString("client_id", "")
-
- Level = keys.NewInt("level", "The logging level")
-)
-
-var (
- // create the stats we measure
- Started = keys.NewInt64("started", "Count of started RPCs.")
- ReceivedBytes = keys.NewInt64("received_bytes", "Bytes received.") //, unit.Bytes)
- SentBytes = keys.NewInt64("sent_bytes", "Bytes sent.") //, unit.Bytes)
- Latency = keys.NewFloat64("latency_ms", "Elapsed time in milliseconds") //, unit.Milliseconds)
-)
-
-const (
- Inbound = "in"
- Outbound = "out"
-)
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/bimport.go b/vendor/golang.org/x/tools/internal/gcimporter/bimport.go
index d98b0db2a9..d79a605ed1 100644
--- a/vendor/golang.org/x/tools/internal/gcimporter/bimport.go
+++ b/vendor/golang.org/x/tools/internal/gcimporter/bimport.go
@@ -87,64 +87,3 @@ func chanDir(d int) types.ChanDir {
return 0
}
}
-
-var predeclOnce sync.Once
-var predecl []types.Type // initialized lazily
-
-func predeclared() []types.Type {
- predeclOnce.Do(func() {
- // initialize lazily to be sure that all
- // elements have been initialized before
- predecl = []types.Type{ // basic types
- types.Typ[types.Bool],
- types.Typ[types.Int],
- types.Typ[types.Int8],
- types.Typ[types.Int16],
- types.Typ[types.Int32],
- types.Typ[types.Int64],
- types.Typ[types.Uint],
- types.Typ[types.Uint8],
- types.Typ[types.Uint16],
- types.Typ[types.Uint32],
- types.Typ[types.Uint64],
- types.Typ[types.Uintptr],
- types.Typ[types.Float32],
- types.Typ[types.Float64],
- types.Typ[types.Complex64],
- types.Typ[types.Complex128],
- types.Typ[types.String],
-
- // basic type aliases
- types.Universe.Lookup("byte").Type(),
- types.Universe.Lookup("rune").Type(),
-
- // error
- types.Universe.Lookup("error").Type(),
-
- // untyped types
- types.Typ[types.UntypedBool],
- types.Typ[types.UntypedInt],
- types.Typ[types.UntypedRune],
- types.Typ[types.UntypedFloat],
- types.Typ[types.UntypedComplex],
- types.Typ[types.UntypedString],
- types.Typ[types.UntypedNil],
-
- // package unsafe
- types.Typ[types.UnsafePointer],
-
- // invalid type
- types.Typ[types.Invalid], // only appears in packages with errors
-
- // used internally by gc; never used by this package or in .a files
- anyType{},
- }
- predecl = append(predecl, additionalPredeclared()...)
- })
- return predecl
-}
-
-type anyType struct{}
-
-func (t anyType) Underlying() types.Type { return t }
-func (t anyType) String() string { return "any" }
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/gcimporter.go b/vendor/golang.org/x/tools/internal/gcimporter/gcimporter.go
index b1223713b9..e6c5d51f8e 100644
--- a/vendor/golang.org/x/tools/internal/gcimporter/gcimporter.go
+++ b/vendor/golang.org/x/tools/internal/gcimporter/gcimporter.go
@@ -29,7 +29,6 @@ import (
"go/token"
"go/types"
"io"
- "io/ioutil"
"os"
"os/exec"
"path/filepath"
@@ -221,7 +220,7 @@ func Import(packages map[string]*types.Package, path, srcDir string, lookup func
switch hdr {
case "$$B\n":
var data []byte
- data, err = ioutil.ReadAll(buf)
+ data, err = io.ReadAll(buf)
if err != nil {
break
}
@@ -233,14 +232,19 @@ func Import(packages map[string]*types.Package, path, srcDir string, lookup func
// Select appropriate importer.
if len(data) > 0 {
switch data[0] {
- case 'v', 'c', 'd': // binary, till go1.10
+ case 'v', 'c', 'd':
+ // binary: emitted by cmd/compile till go1.10; obsolete.
return nil, fmt.Errorf("binary (%c) import format is no longer supported", data[0])
- case 'i': // indexed, till go1.19
+ case 'i':
+ // indexed: emitted by cmd/compile till go1.19;
+ // now used only for serializing go/types.
+ // See https://github.com/golang/go/issues/69491.
_, pkg, err := IImportData(fset, packages, data[1:], id)
return pkg, err
- case 'u': // unified, from go1.20
+ case 'u':
+ // unified: emitted by cmd/compile since go1.20.
_, pkg, err := UImportData(fset, packages, data[1:size], id)
return pkg, err
@@ -260,13 +264,6 @@ func Import(packages map[string]*types.Package, path, srcDir string, lookup func
return
}
-func deref(typ types.Type) types.Type {
- if p, _ := typ.(*types.Pointer); p != nil {
- return p.Elem()
- }
- return typ
-}
-
type byPath []*types.Package
func (a byPath) Len() int { return len(a) }
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/iexport.go b/vendor/golang.org/x/tools/internal/gcimporter/iexport.go
index 6103dd7102..7dfc31a37d 100644
--- a/vendor/golang.org/x/tools/internal/gcimporter/iexport.go
+++ b/vendor/golang.org/x/tools/internal/gcimporter/iexport.go
@@ -2,9 +2,227 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// Indexed binary package export.
-// This file was derived from $GOROOT/src/cmd/compile/internal/gc/iexport.go;
-// see that file for specification of the format.
+// Indexed package export.
+//
+// The indexed export data format is an evolution of the previous
+// binary export data format. Its chief contribution is introducing an
+// index table, which allows efficient random access of individual
+// declarations and inline function bodies. In turn, this allows
+// avoiding unnecessary work for compilation units that import large
+// packages.
+//
+//
+// The top-level data format is structured as:
+//
+// Header struct {
+// Tag byte // 'i'
+// Version uvarint
+// StringSize uvarint
+// DataSize uvarint
+// }
+//
+// Strings [StringSize]byte
+// Data [DataSize]byte
+//
+// MainIndex []struct{
+// PkgPath stringOff
+// PkgName stringOff
+// PkgHeight uvarint
+//
+// Decls []struct{
+// Name stringOff
+// Offset declOff
+// }
+// }
+//
+// Fingerprint [8]byte
+//
+// uvarint means a uint64 written out using uvarint encoding.
+//
+// []T means a uvarint followed by that many T objects. In other
+// words:
+//
+// Len uvarint
+// Elems [Len]T
+//
+// stringOff means a uvarint that indicates an offset within the
+// Strings section. At that offset is another uvarint, followed by
+// that many bytes, which form the string value.
+//
+// declOff means a uvarint that indicates an offset within the Data
+// section where the associated declaration can be found.
+//
+//
+// There are five kinds of declarations, distinguished by their first
+// byte:
+//
+// type Var struct {
+// Tag byte // 'V'
+// Pos Pos
+// Type typeOff
+// }
+//
+// type Func struct {
+// Tag byte // 'F' or 'G'
+// Pos Pos
+// TypeParams []typeOff // only present if Tag == 'G'
+// Signature Signature
+// }
+//
+// type Const struct {
+// Tag byte // 'C'
+// Pos Pos
+// Value Value
+// }
+//
+// type Type struct {
+// Tag byte // 'T' or 'U'
+// Pos Pos
+// TypeParams []typeOff // only present if Tag == 'U'
+// Underlying typeOff
+//
+// Methods []struct{ // omitted if Underlying is an interface type
+// Pos Pos
+// Name stringOff
+// Recv Param
+// Signature Signature
+// }
+// }
+//
+// type Alias struct {
+// Tag byte // 'A' or 'B'
+// Pos Pos
+// TypeParams []typeOff // only present if Tag == 'B'
+// Type typeOff
+// }
+//
+// // "Automatic" declaration of each typeparam
+// type TypeParam struct {
+// Tag byte // 'P'
+// Pos Pos
+// Implicit bool
+// Constraint typeOff
+// }
+//
+// typeOff means a uvarint that either indicates a predeclared type,
+// or an offset into the Data section. If the uvarint is less than
+// predeclReserved, then it indicates the index into the predeclared
+// types list (see predeclared in bexport.go for order). Otherwise,
+// subtracting predeclReserved yields the offset of a type descriptor.
+//
+// Value means a type, kind, and type-specific value. See
+// (*exportWriter).value for details.
+//
+//
+// There are twelve kinds of type descriptors, distinguished by an itag:
+//
+// type DefinedType struct {
+// Tag itag // definedType
+// Name stringOff
+// PkgPath stringOff
+// }
+//
+// type PointerType struct {
+// Tag itag // pointerType
+// Elem typeOff
+// }
+//
+// type SliceType struct {
+// Tag itag // sliceType
+// Elem typeOff
+// }
+//
+// type ArrayType struct {
+// Tag itag // arrayType
+// Len uint64
+// Elem typeOff
+// }
+//
+// type ChanType struct {
+// Tag itag // chanType
+// Dir uint64 // 1 RecvOnly; 2 SendOnly; 3 SendRecv
+// Elem typeOff
+// }
+//
+// type MapType struct {
+// Tag itag // mapType
+// Key typeOff
+// Elem typeOff
+// }
+//
+// type FuncType struct {
+// Tag itag // signatureType
+// PkgPath stringOff
+// Signature Signature
+// }
+//
+// type StructType struct {
+// Tag itag // structType
+// PkgPath stringOff
+// Fields []struct {
+// Pos Pos
+// Name stringOff
+// Type typeOff
+// Embedded bool
+// Note stringOff
+// }
+// }
+//
+// type InterfaceType struct {
+// Tag itag // interfaceType
+// PkgPath stringOff
+// Embeddeds []struct {
+// Pos Pos
+// Type typeOff
+// }
+// Methods []struct {
+// Pos Pos
+// Name stringOff
+// Signature Signature
+// }
+// }
+//
+// // Reference to a type param declaration
+// type TypeParamType struct {
+// Tag itag // typeParamType
+// Name stringOff
+// PkgPath stringOff
+// }
+//
+// // Instantiation of a generic type (like List[T2] or List[int])
+// type InstanceType struct {
+// Tag itag // instanceType
+// Pos pos
+// TypeArgs []typeOff
+// BaseType typeOff
+// }
+//
+// type UnionType struct {
+// Tag itag // interfaceType
+// Terms []struct {
+// tilde bool
+// Type typeOff
+// }
+// }
+//
+//
+//
+// type Signature struct {
+// Params []Param
+// Results []Param
+// Variadic bool // omitted if Results is empty
+// }
+//
+// type Param struct {
+// Pos Pos
+// Name stringOff
+// Type typOff
+// }
+//
+//
+// Pos encodes a file:line:column triple, incorporating a simple delta
+// encoding scheme within a data object. See exportWriter.pos for
+// details.
package gcimporter
@@ -23,12 +241,31 @@ import (
"strings"
"golang.org/x/tools/go/types/objectpath"
- "golang.org/x/tools/internal/tokeninternal"
- "golang.org/x/tools/internal/typeparams"
+ "golang.org/x/tools/internal/aliases"
)
// IExportShallow encodes "shallow" export data for the specified package.
//
+// For types, we use "shallow" export data. Historically, the Go
+// compiler always produced a summary of the types for a given package
+// that included types from other packages that it indirectly
+// referenced: "deep" export data. This had the advantage that the
+// compiler (and analogous tools such as gopls) need only load one
+// file per direct import. However, it meant that the files tended to
+// get larger based on the level of the package in the import
+// graph. For example, higher-level packages in the kubernetes module
+// have over 1MB of "deep" export data, even when they have almost no
+// content of their own, merely because they mention a major type that
+// references many others. In pathological cases the export data was
+// 300x larger than the source for a package due to this quadratic
+// growth.
+//
+// "Shallow" export data means that the serialized types describe only
+// a single package. If those types mention types from other packages,
+// the type checker may need to request additional packages beyond
+// just the direct imports. Type information for the entire transitive
+// closure of imports is provided (lazily) by the DAG.
+//
// No promises are made about the encoding other than that it can be decoded by
// the same version of IIExportShallow. If you plan to save export data in the
// file system, be sure to include a cryptographic digest of the executable in
@@ -51,8 +288,8 @@ func IExportShallow(fset *token.FileSet, pkg *types.Package, reportf ReportFunc)
}
// IImportShallow decodes "shallow" types.Package data encoded by
-// IExportShallow in the same executable. This function cannot import data from
-// cmd/compile or gcexportdata.Write.
+// [IExportShallow] in the same executable. This function cannot import data
+// from cmd/compile or gcexportdata.Write.
//
// The importer calls getPackages to obtain package symbols for all
// packages mentioned in the export data, including the one being
@@ -223,7 +460,7 @@ func (p *iexporter) encodeFile(w *intWriter, file *token.File, needed []uint64)
// Sort the set of needed offsets. Duplicates are harmless.
sort.Slice(needed, func(i, j int) bool { return needed[i] < needed[j] })
- lines := tokeninternal.GetLines(file) // byte offset of each line start
+ lines := file.Lines() // byte offset of each line start
w.uint64(uint64(len(lines)))
// Rather than record the entire array of line start offsets,
@@ -464,7 +701,7 @@ func (p *iexporter) doDecl(obj types.Object) {
switch obj := obj.(type) {
case *types.Var:
- w.tag('V')
+ w.tag(varTag)
w.pos(obj.Pos())
w.typ(obj.Type(), obj.Pkg())
@@ -481,10 +718,10 @@ func (p *iexporter) doDecl(obj types.Object) {
}
// Function.
- if typeparams.ForSignature(sig).Len() == 0 {
- w.tag('F')
+ if sig.TypeParams().Len() == 0 {
+ w.tag(funcTag)
} else {
- w.tag('G')
+ w.tag(genericFuncTag)
}
w.pos(obj.Pos())
// The tparam list of the function type is the declaration of the type
@@ -494,27 +731,27 @@ func (p *iexporter) doDecl(obj types.Object) {
//
// While importing the type parameters, tparamList computes and records
// their export name, so that it can be later used when writing the index.
- if tparams := typeparams.ForSignature(sig); tparams.Len() > 0 {
+ if tparams := sig.TypeParams(); tparams.Len() > 0 {
w.tparamList(obj.Name(), tparams, obj.Pkg())
}
w.signature(sig)
case *types.Const:
- w.tag('C')
+ w.tag(constTag)
w.pos(obj.Pos())
w.value(obj.Type(), obj.Val())
case *types.TypeName:
t := obj.Type()
- if tparam, ok := t.(*typeparams.TypeParam); ok {
- w.tag('P')
+ if tparam, ok := types.Unalias(t).(*types.TypeParam); ok {
+ w.tag(typeParamTag)
w.pos(obj.Pos())
constraint := tparam.Constraint()
if p.version >= iexportVersionGo1_18 {
implicit := false
- if iface, _ := constraint.(*types.Interface); iface != nil {
- implicit = typeparams.IsImplicit(iface)
+ if iface, _ := types.Unalias(constraint).(*types.Interface); iface != nil {
+ implicit = iface.IsImplicit()
}
w.bool(implicit)
}
@@ -523,8 +760,26 @@ func (p *iexporter) doDecl(obj types.Object) {
}
if obj.IsAlias() {
- w.tag('A')
+ alias, materialized := t.(*types.Alias) // may fail when aliases are not enabled
+
+ var tparams *types.TypeParamList
+ if materialized {
+ tparams = aliases.TypeParams(alias)
+ }
+ if tparams.Len() == 0 {
+ w.tag(aliasTag)
+ } else {
+ w.tag(genericAliasTag)
+ }
w.pos(obj.Pos())
+ if tparams.Len() > 0 {
+ w.tparamList(obj.Name(), tparams, obj.Pkg())
+ }
+ if materialized {
+ // Preserve materialized aliases,
+ // even of non-exported types.
+ t = aliases.Rhs(alias)
+ }
w.typ(t, obj.Pkg())
break
}
@@ -535,20 +790,20 @@ func (p *iexporter) doDecl(obj types.Object) {
panic(internalErrorf("%s is not a defined type", t))
}
- if typeparams.ForNamed(named).Len() == 0 {
- w.tag('T')
+ if named.TypeParams().Len() == 0 {
+ w.tag(typeTag)
} else {
- w.tag('U')
+ w.tag(genericTypeTag)
}
w.pos(obj.Pos())
- if typeparams.ForNamed(named).Len() > 0 {
+ if named.TypeParams().Len() > 0 {
// While importing the type parameters, tparamList computes and records
// their export name, so that it can be later used when writing the index.
- w.tparamList(obj.Name(), typeparams.ForNamed(named), obj.Pkg())
+ w.tparamList(obj.Name(), named.TypeParams(), obj.Pkg())
}
- underlying := obj.Type().Underlying()
+ underlying := named.Underlying()
w.typ(underlying, obj.Pkg())
if types.IsInterface(t) {
@@ -565,7 +820,7 @@ func (p *iexporter) doDecl(obj types.Object) {
// Receiver type parameters are type arguments of the receiver type, so
// their name must be qualified before exporting recv.
- if rparams := typeparams.RecvTypeParams(sig); rparams.Len() > 0 {
+ if rparams := sig.RecvTypeParams(); rparams.Len() > 0 {
prefix := obj.Name() + "." + m.Name()
for i := 0; i < rparams.Len(); i++ {
rparam := rparams.At(i)
@@ -739,20 +994,31 @@ func (w *exportWriter) doTyp(t types.Type, pkg *types.Package) {
}()
}
switch t := t.(type) {
+ case *types.Alias:
+ if targs := aliases.TypeArgs(t); targs.Len() > 0 {
+ w.startType(instanceType)
+ w.pos(t.Obj().Pos())
+ w.typeList(targs, pkg)
+ w.typ(aliases.Origin(t), pkg)
+ return
+ }
+ w.startType(aliasType)
+ w.qualifiedType(t.Obj())
+
case *types.Named:
- if targs := typeparams.NamedTypeArgs(t); targs.Len() > 0 {
+ if targs := t.TypeArgs(); targs.Len() > 0 {
w.startType(instanceType)
// TODO(rfindley): investigate if this position is correct, and if it
// matters.
w.pos(t.Obj().Pos())
w.typeList(targs, pkg)
- w.typ(typeparams.NamedTypeOrigin(t), pkg)
+ w.typ(t.Origin(), pkg)
return
}
w.startType(definedType)
w.qualifiedType(t.Obj())
- case *typeparams.TypeParam:
+ case *types.TypeParam:
w.startType(typeParamType)
w.qualifiedType(t.Obj())
@@ -844,7 +1110,7 @@ func (w *exportWriter) doTyp(t types.Type, pkg *types.Package) {
for i := 0; i < n; i++ {
ft := t.EmbeddedType(i)
tPkg := pkg
- if named, _ := ft.(*types.Named); named != nil {
+ if named, _ := types.Unalias(ft).(*types.Named); named != nil {
w.pos(named.Obj().Pos())
} else {
w.pos(token.NoPos)
@@ -868,7 +1134,7 @@ func (w *exportWriter) doTyp(t types.Type, pkg *types.Package) {
w.signature(sig)
}
- case *typeparams.Union:
+ case *types.Union:
w.startType(unionType)
nt := t.Len()
w.uint64(uint64(nt))
@@ -948,14 +1214,14 @@ func (w *exportWriter) signature(sig *types.Signature) {
}
}
-func (w *exportWriter) typeList(ts *typeparams.TypeList, pkg *types.Package) {
+func (w *exportWriter) typeList(ts *types.TypeList, pkg *types.Package) {
w.uint64(uint64(ts.Len()))
for i := 0; i < ts.Len(); i++ {
w.typ(ts.At(i), pkg)
}
}
-func (w *exportWriter) tparamList(prefix string, list *typeparams.TypeParamList, pkg *types.Package) {
+func (w *exportWriter) tparamList(prefix string, list *types.TypeParamList, pkg *types.Package) {
ll := uint64(list.Len())
w.uint64(ll)
for i := 0; i < list.Len(); i++ {
@@ -973,7 +1239,7 @@ const blankMarker = "$"
// differs from its actual object name: it is prefixed with a qualifier, and
// blank type parameter names are disambiguated by their index in the type
// parameter list.
-func tparamExportName(prefix string, tparam *typeparams.TypeParam) string {
+func tparamExportName(prefix string, tparam *types.TypeParam) string {
assert(prefix != "")
name := tparam.Obj().Name()
if name == "_" {
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/iimport.go b/vendor/golang.org/x/tools/internal/gcimporter/iimport.go
index 8e64cf644f..e260c0e8db 100644
--- a/vendor/golang.org/x/tools/internal/gcimporter/iimport.go
+++ b/vendor/golang.org/x/tools/internal/gcimporter/iimport.go
@@ -3,7 +3,7 @@
// license that can be found in the LICENSE file.
// Indexed package import.
-// See cmd/compile/internal/gc/iexport.go for the export data format.
+// See iexport.go for the export data format.
// This file is a copy of $GOROOT/src/go/internal/gcimporter/iimport.go.
@@ -22,7 +22,8 @@ import (
"strings"
"golang.org/x/tools/go/types/objectpath"
- "golang.org/x/tools/internal/typeparams"
+ "golang.org/x/tools/internal/aliases"
+ "golang.org/x/tools/internal/typesinternal"
)
type intReader struct {
@@ -52,6 +53,7 @@ const (
iexportVersionPosCol = 1
iexportVersionGo1_18 = 2
iexportVersionGenerics = 2
+ iexportVersion = iexportVersionGenerics
iexportVersionCurrent = 2
)
@@ -79,6 +81,20 @@ const (
typeParamType
instanceType
unionType
+ aliasType
+)
+
+// Object tags
+const (
+ varTag = 'V'
+ funcTag = 'F'
+ genericFuncTag = 'G'
+ constTag = 'C'
+ aliasTag = 'A'
+ genericAliasTag = 'B'
+ typeParamTag = 'P'
+ typeTag = 'T'
+ genericTypeTag = 'U'
)
// IImportData imports a package from the serialized package data
@@ -195,6 +211,7 @@ func iimportCommon(fset *token.FileSet, getPackages GetPackagesFunc, data []byte
p := iimporter{
version: int(version),
ipath: path,
+ aliases: aliases.Enabled(),
shallow: shallow,
reportf: reportf,
@@ -225,6 +242,7 @@ func iimportCommon(fset *token.FileSet, getPackages GetPackagesFunc, data []byte
// Gather the relevant packages from the manifest.
items := make([]GetPackagesItem, r.uint64())
+ uniquePkgPaths := make(map[string]bool)
for i := range items {
pkgPathOff := r.uint64()
pkgPath := p.stringAt(pkgPathOff)
@@ -249,6 +267,12 @@ func iimportCommon(fset *token.FileSet, getPackages GetPackagesFunc, data []byte
}
items[i].nameIndex = nameIndex
+
+ uniquePkgPaths[pkgPath] = true
+ }
+ // Debugging #63822; hypothesis: there are duplicate PkgPaths.
+ if len(uniquePkgPaths) != len(items) {
+ reportf("found duplicate PkgPaths while reading export data manifest: %v", items)
}
// Request packages all at once from the client,
@@ -316,12 +340,12 @@ func iimportCommon(fset *token.FileSet, getPackages GetPackagesFunc, data []byte
}
// SetConstraint can't be called if the constraint type is not yet complete.
- // When type params are created in the 'P' case of (*importReader).obj(),
+ // When type params are created in the typeParamTag case of (*importReader).obj(),
// the associated constraint type may not be complete due to recursion.
// Therefore, we defer calling SetConstraint there, and call it here instead
// after all types are complete.
for _, d := range p.later {
- typeparams.SetTypeParamConstraint(d.t, d.constraint)
+ d.t.SetConstraint(d.constraint)
}
for _, typ := range p.interfaceList {
@@ -339,7 +363,7 @@ func iimportCommon(fset *token.FileSet, getPackages GetPackagesFunc, data []byte
}
type setConstraintArgs struct {
- t *typeparams.TypeParam
+ t *types.TypeParam
constraint types.Type
}
@@ -347,6 +371,7 @@ type iimporter struct {
version int
ipath string
+ aliases bool
shallow bool
reportf ReportFunc // if non-nil, used to report bugs
@@ -516,7 +541,7 @@ func canReuse(def *types.Named, rhs types.Type) bool {
if def == nil {
return true
}
- iface, _ := rhs.(*types.Interface)
+ iface, _ := types.Unalias(rhs).(*types.Interface)
if iface == nil {
return true
}
@@ -533,40 +558,56 @@ type importReader struct {
prevColumn int64
}
+// markBlack is redefined in iimport_go123.go, to work around golang/go#69912.
+//
+// If TypeNames are not marked black (in the sense of go/types cycle
+// detection), they may be mutated when dot-imported. Fix this by punching a
+// hole through the type, when compiling with Go 1.23. (The bug has been fixed
+// for 1.24, but the fix was not worth back-porting).
+var markBlack = func(name *types.TypeName) {}
+
func (r *importReader) obj(name string) {
tag := r.byte()
pos := r.pos()
switch tag {
- case 'A':
+ case aliasTag, genericAliasTag:
+ var tparams []*types.TypeParam
+ if tag == genericAliasTag {
+ tparams = r.tparamList()
+ }
typ := r.typ()
+ obj := aliases.NewAlias(r.p.aliases, pos, r.currPkg, name, typ, tparams)
+ markBlack(obj) // workaround for golang/go#69912
+ r.declare(obj)
- r.declare(types.NewTypeName(pos, r.currPkg, name, typ))
-
- case 'C':
+ case constTag:
typ, val := r.value()
r.declare(types.NewConst(pos, r.currPkg, name, typ, val))
- case 'F', 'G':
- var tparams []*typeparams.TypeParam
- if tag == 'G' {
+ case funcTag, genericFuncTag:
+ var tparams []*types.TypeParam
+ if tag == genericFuncTag {
tparams = r.tparamList()
}
sig := r.signature(nil, nil, tparams)
r.declare(types.NewFunc(pos, r.currPkg, name, sig))
- case 'T', 'U':
+ case typeTag, genericTypeTag:
// Types can be recursive. We need to setup a stub
// declaration before recursing.
obj := types.NewTypeName(pos, r.currPkg, name, nil)
named := types.NewNamed(obj, nil, nil)
+
+ markBlack(obj) // workaround for golang/go#69912
+
// Declare obj before calling r.tparamList, so the new type name is recognized
// if used in the constraint of one of its own typeparams (see #48280).
r.declare(obj)
- if tag == 'U' {
+ if tag == genericTypeTag {
tparams := r.tparamList()
- typeparams.SetForNamed(named, tparams)
+ named.SetTypeParams(tparams)
}
underlying := r.p.typAt(r.uint64(), named).Underlying()
@@ -581,14 +622,13 @@ func (r *importReader) obj(name string) {
// If the receiver has any targs, set those as the
// rparams of the method (since those are the
// typeparams being used in the method sig/body).
- base := baseType(recv.Type())
- assert(base != nil)
- targs := typeparams.NamedTypeArgs(base)
- var rparams []*typeparams.TypeParam
+ _, recvNamed := typesinternal.ReceiverNamed(recv)
+ targs := recvNamed.TypeArgs()
+ var rparams []*types.TypeParam
if targs.Len() > 0 {
- rparams = make([]*typeparams.TypeParam, targs.Len())
+ rparams = make([]*types.TypeParam, targs.Len())
for i := range rparams {
- rparams[i] = targs.At(i).(*typeparams.TypeParam)
+ rparams[i] = types.Unalias(targs.At(i)).(*types.TypeParam)
}
}
msig := r.signature(recv, rparams, nil)
@@ -597,7 +637,7 @@ func (r *importReader) obj(name string) {
}
}
- case 'P':
+ case typeParamTag:
// We need to "declare" a typeparam in order to have a name that
// can be referenced recursively (if needed) in the type param's
// bound.
@@ -606,7 +646,7 @@ func (r *importReader) obj(name string) {
}
name0 := tparamName(name)
tn := types.NewTypeName(pos, r.currPkg, name0, nil)
- t := typeparams.NewTypeParam(tn, nil)
+ t := types.NewTypeParam(tn, nil)
// To handle recursive references to the typeparam within its
// bound, save the partial type in tparamIndex before reading the bounds.
@@ -618,11 +658,11 @@ func (r *importReader) obj(name string) {
}
constraint := r.typ()
if implicit {
- iface, _ := constraint.(*types.Interface)
+ iface, _ := types.Unalias(constraint).(*types.Interface)
if iface == nil {
errorf("non-interface constraint marked implicit")
}
- typeparams.MarkImplicit(iface)
+ iface.MarkImplicit()
}
// The constraint type may not be complete, if we
// are in the middle of a type recursion involving type
@@ -630,7 +670,7 @@ func (r *importReader) obj(name string) {
// completely set up all types in ImportData.
r.p.later = append(r.p.later, setConstraintArgs{t: t, constraint: constraint})
- case 'V':
+ case varTag:
typ := r.typ()
r.declare(types.NewVar(pos, r.currPkg, name, typ))
@@ -825,7 +865,7 @@ func (r *importReader) typ() types.Type {
}
func isInterface(t types.Type) bool {
- _, ok := t.(*types.Interface)
+ _, ok := types.Unalias(t).(*types.Interface)
return ok
}
@@ -835,7 +875,7 @@ func (r *importReader) string() string { return r.p.stringAt(r.uint64()) }
func (r *importReader) doType(base *types.Named) (res types.Type) {
k := r.kind()
if debug {
- r.p.trace("importing type %d (base: %s)", k, base)
+ r.p.trace("importing type %d (base: %v)", k, base)
r.p.indent++
defer func() {
r.p.indent--
@@ -847,7 +887,7 @@ func (r *importReader) doType(base *types.Named) (res types.Type) {
errorf("unexpected kind tag in %q: %v", r.p.ipath, k)
return nil
- case definedType:
+ case aliasType, definedType:
pkg, name := r.qualifiedIdent()
r.p.doDecl(pkg, name)
return pkg.Scope().Lookup(name).(*types.TypeName).Type()
@@ -932,7 +972,7 @@ func (r *importReader) doType(base *types.Named) (res types.Type) {
methods[i] = method
}
- typ := newInterface(methods, embeddeds)
+ typ := types.NewInterfaceType(methods, embeddeds)
r.p.interfaceList = append(r.p.interfaceList, typ)
return typ
@@ -966,7 +1006,7 @@ func (r *importReader) doType(base *types.Named) (res types.Type) {
// The imported instantiated type doesn't include any methods, so
// we must always use the methods of the base (orig) type.
// TODO provide a non-nil *Environment
- t, _ := typeparams.Instantiate(nil, baseType, targs, false)
+ t, _ := types.Instantiate(nil, baseType, targs, false)
// Workaround for golang/go#61561. See the doc for instanceList for details.
r.p.instanceList = append(r.p.instanceList, t)
@@ -976,11 +1016,11 @@ func (r *importReader) doType(base *types.Named) (res types.Type) {
if r.p.version < iexportVersionGenerics {
errorf("unexpected instantiation type")
}
- terms := make([]*typeparams.Term, r.uint64())
+ terms := make([]*types.Term, r.uint64())
for i := range terms {
- terms[i] = typeparams.NewTerm(r.bool(), r.typ())
+ terms[i] = types.NewTerm(r.bool(), r.typ())
}
- return typeparams.NewUnion(terms)
+ return types.NewUnion(terms)
}
}
@@ -1008,23 +1048,23 @@ func (r *importReader) objectPathObject() types.Object {
return obj
}
-func (r *importReader) signature(recv *types.Var, rparams []*typeparams.TypeParam, tparams []*typeparams.TypeParam) *types.Signature {
+func (r *importReader) signature(recv *types.Var, rparams []*types.TypeParam, tparams []*types.TypeParam) *types.Signature {
params := r.paramList()
results := r.paramList()
variadic := params.Len() > 0 && r.bool()
- return typeparams.NewSignatureType(recv, rparams, tparams, params, results, variadic)
+ return types.NewSignatureType(recv, rparams, tparams, params, results, variadic)
}
-func (r *importReader) tparamList() []*typeparams.TypeParam {
+func (r *importReader) tparamList() []*types.TypeParam {
n := r.uint64()
if n == 0 {
return nil
}
- xs := make([]*typeparams.TypeParam, n)
+ xs := make([]*types.TypeParam, n)
for i := range xs {
// Note: the standard library importer is tolerant of nil types here,
// though would panic in SetTypeParams.
- xs[i] = r.typ().(*typeparams.TypeParam)
+ xs[i] = types.Unalias(r.typ()).(*types.TypeParam)
}
return xs
}
@@ -1071,13 +1111,3 @@ func (r *importReader) byte() byte {
}
return x
}
-
-func baseType(typ types.Type) *types.Named {
- // pointer receivers are never types.Named types
- if p, _ := typ.(*types.Pointer); p != nil {
- typ = p.Elem()
- }
- // receiver base types are always (possibly generic) types.Named types
- n, _ := typ.(*types.Named)
- return n
-}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/iimport_go122.go b/vendor/golang.org/x/tools/internal/gcimporter/iimport_go122.go
new file mode 100644
index 0000000000..7586bfaca6
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gcimporter/iimport_go122.go
@@ -0,0 +1,53 @@
+// Copyright 2024 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 go1.22 && !go1.24
+
+package gcimporter
+
+import (
+ "go/token"
+ "go/types"
+ "unsafe"
+)
+
+// TODO(rfindley): delete this workaround once go1.24 is assured.
+
+func init() {
+ // Update markBlack so that it correctly sets the color
+ // of imported TypeNames.
+ //
+ // See the doc comment for markBlack for details.
+
+ type color uint32
+ const (
+ white color = iota
+ black
+ grey
+ )
+ type object struct {
+ _ *types.Scope
+ _ token.Pos
+ _ *types.Package
+ _ string
+ _ types.Type
+ _ uint32
+ color_ color
+ _ token.Pos
+ }
+ type typeName struct {
+ object
+ }
+
+ // If the size of types.TypeName changes, this will fail to compile.
+ const delta = int64(unsafe.Sizeof(typeName{})) - int64(unsafe.Sizeof(types.TypeName{}))
+ var _ [-delta * delta]int
+
+ markBlack = func(obj *types.TypeName) {
+ type uP = unsafe.Pointer
+ var ptr *typeName
+ *(*uP)(uP(&ptr)) = uP(obj)
+ ptr.color_ = black
+ }
+}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/newInterface10.go b/vendor/golang.org/x/tools/internal/gcimporter/newInterface10.go
deleted file mode 100644
index 8b163e3d05..0000000000
--- a/vendor/golang.org/x/tools/internal/gcimporter/newInterface10.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build !go1.11
-// +build !go1.11
-
-package gcimporter
-
-import "go/types"
-
-func newInterface(methods []*types.Func, embeddeds []types.Type) *types.Interface {
- named := make([]*types.Named, len(embeddeds))
- for i, e := range embeddeds {
- var ok bool
- named[i], ok = e.(*types.Named)
- if !ok {
- panic("embedding of non-defined interfaces in interfaces is not supported before Go 1.11")
- }
- }
- return types.NewInterface(methods, named)
-}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/newInterface11.go b/vendor/golang.org/x/tools/internal/gcimporter/newInterface11.go
deleted file mode 100644
index 49984f40fd..0000000000
--- a/vendor/golang.org/x/tools/internal/gcimporter/newInterface11.go
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build go1.11
-// +build go1.11
-
-package gcimporter
-
-import "go/types"
-
-func newInterface(methods []*types.Func, embeddeds []types.Type) *types.Interface {
- return types.NewInterfaceType(methods, embeddeds)
-}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/predeclared.go b/vendor/golang.org/x/tools/internal/gcimporter/predeclared.go
new file mode 100644
index 0000000000..907c8557a5
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gcimporter/predeclared.go
@@ -0,0 +1,91 @@
+// Copyright 2024 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 gcimporter
+
+import (
+ "go/types"
+ "sync"
+)
+
+// predecl is a cache for the predeclared types in types.Universe.
+//
+// Cache a distinct result based on the runtime value of any.
+// The pointer value of the any type varies based on GODEBUG settings.
+var predeclMu sync.Mutex
+var predecl map[types.Type][]types.Type
+
+func predeclared() []types.Type {
+ anyt := types.Universe.Lookup("any").Type()
+
+ predeclMu.Lock()
+ defer predeclMu.Unlock()
+
+ if pre, ok := predecl[anyt]; ok {
+ return pre
+ }
+
+ if predecl == nil {
+ predecl = make(map[types.Type][]types.Type)
+ }
+
+ decls := []types.Type{ // basic types
+ types.Typ[types.Bool],
+ types.Typ[types.Int],
+ types.Typ[types.Int8],
+ types.Typ[types.Int16],
+ types.Typ[types.Int32],
+ types.Typ[types.Int64],
+ types.Typ[types.Uint],
+ types.Typ[types.Uint8],
+ types.Typ[types.Uint16],
+ types.Typ[types.Uint32],
+ types.Typ[types.Uint64],
+ types.Typ[types.Uintptr],
+ types.Typ[types.Float32],
+ types.Typ[types.Float64],
+ types.Typ[types.Complex64],
+ types.Typ[types.Complex128],
+ types.Typ[types.String],
+
+ // basic type aliases
+ types.Universe.Lookup("byte").Type(),
+ types.Universe.Lookup("rune").Type(),
+
+ // error
+ types.Universe.Lookup("error").Type(),
+
+ // untyped types
+ types.Typ[types.UntypedBool],
+ types.Typ[types.UntypedInt],
+ types.Typ[types.UntypedRune],
+ types.Typ[types.UntypedFloat],
+ types.Typ[types.UntypedComplex],
+ types.Typ[types.UntypedString],
+ types.Typ[types.UntypedNil],
+
+ // package unsafe
+ types.Typ[types.UnsafePointer],
+
+ // invalid type
+ types.Typ[types.Invalid], // only appears in packages with errors
+
+ // used internally by gc; never used by this package or in .a files
+ anyType{},
+
+ // comparable
+ types.Universe.Lookup("comparable").Type(),
+
+ // any
+ anyt,
+ }
+
+ predecl[anyt] = decls
+ return decls
+}
+
+type anyType struct{}
+
+func (t anyType) Underlying() types.Type { return t }
+func (t anyType) String() string { return "any" }
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/support_go117.go b/vendor/golang.org/x/tools/internal/gcimporter/support_go117.go
deleted file mode 100644
index d892273efb..0000000000
--- a/vendor/golang.org/x/tools/internal/gcimporter/support_go117.go
+++ /dev/null
@@ -1,16 +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.
-
-//go:build !go1.18
-// +build !go1.18
-
-package gcimporter
-
-import "go/types"
-
-const iexportVersion = iexportVersionGo1_11
-
-func additionalPredeclared() []types.Type {
- return nil
-}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/support_go118.go b/vendor/golang.org/x/tools/internal/gcimporter/support_go118.go
deleted file mode 100644
index edbe6ea704..0000000000
--- a/vendor/golang.org/x/tools/internal/gcimporter/support_go118.go
+++ /dev/null
@@ -1,37 +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.
-
-//go:build go1.18
-// +build go1.18
-
-package gcimporter
-
-import "go/types"
-
-const iexportVersion = iexportVersionGenerics
-
-// additionalPredeclared returns additional predeclared types in go.1.18.
-func additionalPredeclared() []types.Type {
- return []types.Type{
- // comparable
- types.Universe.Lookup("comparable").Type(),
-
- // any
- types.Universe.Lookup("any").Type(),
- }
-}
-
-// See cmd/compile/internal/types.SplitVargenSuffix.
-func splitVargenSuffix(name string) (base, suffix string) {
- i := len(name)
- for i > 0 && name[i-1] >= '0' && name[i-1] <= '9' {
- i--
- }
- const dot = "·"
- if i >= len(dot) && name[i-len(dot):i] == dot {
- i -= len(dot)
- return name[:i], name[i:]
- }
- return name, ""
-}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/unified_no.go b/vendor/golang.org/x/tools/internal/gcimporter/unified_no.go
deleted file mode 100644
index 286bf44548..0000000000
--- a/vendor/golang.org/x/tools/internal/gcimporter/unified_no.go
+++ /dev/null
@@ -1,10 +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.
-
-//go:build !(go1.18 && goexperiment.unified)
-// +build !go1.18 !goexperiment.unified
-
-package gcimporter
-
-const unifiedIR = false
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/unified_yes.go b/vendor/golang.org/x/tools/internal/gcimporter/unified_yes.go
deleted file mode 100644
index b5d69ffbe6..0000000000
--- a/vendor/golang.org/x/tools/internal/gcimporter/unified_yes.go
+++ /dev/null
@@ -1,10 +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.
-
-//go:build go1.18 && goexperiment.unified
-// +build go1.18,goexperiment.unified
-
-package gcimporter
-
-const unifiedIR = true
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/ureader_no.go b/vendor/golang.org/x/tools/internal/gcimporter/ureader_no.go
deleted file mode 100644
index 8eb20729c2..0000000000
--- a/vendor/golang.org/x/tools/internal/gcimporter/ureader_no.go
+++ /dev/null
@@ -1,19 +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.
-
-//go:build !go1.18
-// +build !go1.18
-
-package gcimporter
-
-import (
- "fmt"
- "go/token"
- "go/types"
-)
-
-func UImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (_ int, pkg *types.Package, err error) {
- err = fmt.Errorf("go/tools compiled with a Go version earlier than 1.18 cannot read unified IR export data")
- return
-}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/ureader_yes.go b/vendor/golang.org/x/tools/internal/gcimporter/ureader_yes.go
index b977435f62..1db408613c 100644
--- a/vendor/golang.org/x/tools/internal/gcimporter/ureader_yes.go
+++ b/vendor/golang.org/x/tools/internal/gcimporter/ureader_yes.go
@@ -4,9 +4,6 @@
// Derived from go/internal/gcimporter/ureader.go
-//go:build go1.18
-// +build go1.18
-
package gcimporter
import (
@@ -16,6 +13,7 @@ import (
"sort"
"strings"
+ "golang.org/x/tools/internal/aliases"
"golang.org/x/tools/internal/pkgbits"
)
@@ -28,6 +26,7 @@ type pkgReader struct {
ctxt *types.Context
imports map[string]*types.Package // previously imported packages, indexed by path
+ aliases bool // create types.Alias nodes
// lazily initialized arrays corresponding to the unified IR
// PosBase, Pkg, and Type sections, respectively.
@@ -53,8 +52,7 @@ func (pr *pkgReader) later(fn func()) {
// See cmd/compile/internal/noder.derivedInfo.
type derivedInfo struct {
- idx pkgbits.Index
- needed bool
+ idx pkgbits.Index
}
// See cmd/compile/internal/noder.typeInfo.
@@ -101,6 +99,7 @@ func readUnifiedPackage(fset *token.FileSet, ctxt *types.Context, imports map[st
ctxt: ctxt,
imports: imports,
+ aliases: aliases.Enabled(),
posBases: make([]string, input.NumElems(pkgbits.RelocPosBase)),
pkgs: make([]*types.Package, input.NumElems(pkgbits.RelocPkg)),
@@ -110,13 +109,17 @@ func readUnifiedPackage(fset *token.FileSet, ctxt *types.Context, imports map[st
r := pr.newReader(pkgbits.RelocMeta, pkgbits.PublicRootIdx, pkgbits.SyncPublic)
pkg := r.pkg()
- r.Bool() // has init
+ if r.Version().Has(pkgbits.HasInit) {
+ r.Bool()
+ }
for i, n := 0, r.Len(); i < n; i++ {
// As if r.obj(), but avoiding the Scope.Lookup call,
// to avoid eager loading of imports.
r.Sync(pkgbits.SyncObject)
- assert(!r.Bool())
+ if r.Version().Has(pkgbits.DerivedFuncInstance) {
+ assert(!r.Bool())
+ }
r.p.objIdx(r.Reloc(pkgbits.RelocObj))
assert(r.Len() == 0)
}
@@ -165,7 +168,7 @@ type readerDict struct {
// tparams is a slice of the constructed TypeParams for the element.
tparams []*types.TypeParam
- // devived is a slice of types derived from tparams, which may be
+ // derived is a slice of types derived from tparams, which may be
// instantiated while reading the current element.
derived []derivedInfo
derivedTypes []types.Type // lazily instantiated from derived
@@ -471,7 +474,9 @@ func (r *reader) param() *types.Var {
func (r *reader) obj() (types.Object, []types.Type) {
r.Sync(pkgbits.SyncObject)
- assert(!r.Bool())
+ if r.Version().Has(pkgbits.DerivedFuncInstance) {
+ assert(!r.Bool())
+ }
pkg, name := r.p.objIdx(r.Reloc(pkgbits.RelocObj))
obj := pkgScope(pkg).Lookup(name)
@@ -525,8 +530,12 @@ func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
case pkgbits.ObjAlias:
pos := r.pos()
+ var tparams []*types.TypeParam
+ if r.Version().Has(pkgbits.AliasTypeParamNames) {
+ tparams = r.typeParamNames()
+ }
typ := r.typ()
- declare(types.NewTypeName(pos, objPkg, objName, typ))
+ declare(aliases.NewAlias(r.p.aliases, pos, objPkg, objName, typ, tparams))
case pkgbits.ObjConst:
pos := r.pos()
@@ -553,7 +562,7 @@ func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
// If the underlying type is an interface, we need to
// duplicate its methods so we can replace the receiver
// parameter's type (#49906).
- if iface, ok := underlying.(*types.Interface); ok && iface.NumExplicitMethods() != 0 {
+ if iface, ok := types.Unalias(underlying).(*types.Interface); ok && iface.NumExplicitMethods() != 0 {
methods := make([]*types.Func, iface.NumExplicitMethods())
for i := range methods {
fn := iface.ExplicitMethod(i)
@@ -632,7 +641,10 @@ func (pr *pkgReader) objDictIdx(idx pkgbits.Index) *readerDict {
dict.derived = make([]derivedInfo, r.Len())
dict.derivedTypes = make([]types.Type, len(dict.derived))
for i := range dict.derived {
- dict.derived[i] = derivedInfo{r.Reloc(pkgbits.RelocType), r.Bool()}
+ dict.derived[i] = derivedInfo{idx: r.Reloc(pkgbits.RelocType)}
+ if r.Version().Has(pkgbits.DerivedInfoNeeded) {
+ assert(!r.Bool())
+ }
}
pr.retireReader(r)
@@ -726,3 +738,17 @@ func pkgScope(pkg *types.Package) *types.Scope {
}
return types.Universe
}
+
+// See cmd/compile/internal/types.SplitVargenSuffix.
+func splitVargenSuffix(name string) (base, suffix string) {
+ i := len(name)
+ for i > 0 && name[i-1] >= '0' && name[i-1] <= '9' {
+ i--
+ }
+ const dot = "·"
+ if i >= len(dot) && name[i-len(dot):i] == dot {
+ i -= len(dot)
+ return name[:i], name[i:]
+ }
+ return name, ""
+}
diff --git a/vendor/golang.org/x/tools/internal/gocommand/invoke.go b/vendor/golang.org/x/tools/internal/gocommand/invoke.go
index 53cf66da01..e333efc87f 100644
--- a/vendor/golang.org/x/tools/internal/gocommand/invoke.go
+++ b/vendor/golang.org/x/tools/internal/gocommand/invoke.go
@@ -8,12 +8,14 @@ package gocommand
import (
"bytes"
"context"
+ "encoding/json"
"errors"
"fmt"
"io"
"log"
"os"
- "reflect"
+ "os/exec"
+ "path/filepath"
"regexp"
"runtime"
"strconv"
@@ -21,12 +23,9 @@ import (
"sync"
"time"
- exec "golang.org/x/sys/execabs"
-
"golang.org/x/tools/internal/event"
"golang.org/x/tools/internal/event/keys"
"golang.org/x/tools/internal/event/label"
- "golang.org/x/tools/internal/event/tag"
)
// An Runner will run go command invocations and serialize
@@ -56,11 +55,14 @@ func (runner *Runner) initialize() {
// 1.14: go: updating go.mod: existing contents have changed since last read
var modConcurrencyError = regexp.MustCompile(`go:.*go.mod.*contents have changed`)
-// verb is an event label for the go command verb.
-var verb = keys.NewString("verb", "go command verb")
+// event keys for go command invocations
+var (
+ verb = keys.NewString("verb", "go command verb")
+ directory = keys.NewString("directory", "")
+)
func invLabels(inv Invocation) []label.Label {
- return []label.Label{verb.Of(inv.Verb), tag.Directory.Of(inv.WorkingDir)}
+ return []label.Label{verb.Of(inv.Verb), directory.Of(inv.WorkingDir)}
}
// Run is a convenience wrapper around RunRaw.
@@ -85,6 +87,7 @@ func (runner *Runner) RunPiped(ctx context.Context, inv Invocation, stdout, stde
// RunRaw runs the invocation, serializing requests only if they fight over
// go.mod changes.
+// Postcondition: both error results have same nilness.
func (runner *Runner) RunRaw(ctx context.Context, inv Invocation) (*bytes.Buffer, *bytes.Buffer, error, error) {
ctx, done := event.Start(ctx, "gocommand.Runner.RunRaw", invLabels(inv)...)
defer done()
@@ -95,23 +98,24 @@ func (runner *Runner) RunRaw(ctx context.Context, inv Invocation) (*bytes.Buffer
stdout, stderr, friendlyErr, err := runner.runConcurrent(ctx, inv)
// If we encounter a load concurrency error, we need to retry serially.
- if friendlyErr == nil || !modConcurrencyError.MatchString(friendlyErr.Error()) {
- return stdout, stderr, friendlyErr, err
+ if friendlyErr != nil && modConcurrencyError.MatchString(friendlyErr.Error()) {
+ event.Error(ctx, "Load concurrency error, will retry serially", err)
+
+ // Run serially by calling runPiped.
+ stdout.Reset()
+ stderr.Reset()
+ friendlyErr, err = runner.runPiped(ctx, inv, stdout, stderr)
}
- event.Error(ctx, "Load concurrency error, will retry serially", err)
- // Run serially by calling runPiped.
- stdout.Reset()
- stderr.Reset()
- friendlyErr, err = runner.runPiped(ctx, inv, stdout, stderr)
return stdout, stderr, friendlyErr, err
}
+// Postcondition: both error results have same nilness.
func (runner *Runner) runConcurrent(ctx context.Context, inv Invocation) (*bytes.Buffer, *bytes.Buffer, error, error) {
// Wait for 1 worker to become available.
select {
case <-ctx.Done():
- return nil, nil, nil, ctx.Err()
+ return nil, nil, ctx.Err(), ctx.Err()
case runner.inFlight <- struct{}{}:
defer func() { <-runner.inFlight }()
}
@@ -121,6 +125,7 @@ func (runner *Runner) runConcurrent(ctx context.Context, inv Invocation) (*bytes
return stdout, stderr, friendlyErr, err
}
+// Postcondition: both error results have same nilness.
func (runner *Runner) runPiped(ctx context.Context, inv Invocation, stdout, stderr io.Writer) (error, error) {
// Make sure the runner is always initialized.
runner.initialize()
@@ -129,7 +134,7 @@ func (runner *Runner) runPiped(ctx context.Context, inv Invocation, stdout, stde
// runPiped commands.
select {
case <-ctx.Done():
- return nil, ctx.Err()
+ return ctx.Err(), ctx.Err()
case runner.serialized <- struct{}{}:
defer func() { <-runner.serialized }()
}
@@ -139,7 +144,7 @@ func (runner *Runner) runPiped(ctx context.Context, inv Invocation, stdout, stde
for i := 0; i < maxInFlight; i++ {
select {
case <-ctx.Done():
- return nil, ctx.Err()
+ return ctx.Err(), ctx.Err()
case runner.inFlight <- struct{}{}:
// Make sure we always "return" any workers we took.
defer func() { <-runner.inFlight }()
@@ -156,12 +161,17 @@ type Invocation struct {
BuildFlags []string
// If ModFlag is set, the go command is invoked with -mod=ModFlag.
+ // TODO(rfindley): remove, in favor of Args.
ModFlag string
// If ModFile is set, the go command is invoked with -modfile=ModFile.
+ // TODO(rfindley): remove, in favor of Args.
ModFile string
- // If Overlay is set, the go command is invoked with -overlay=Overlay.
+ // Overlay is the name of the JSON overlay file that describes
+ // unsaved editor buffers; see [WriteOverlays].
+ // If set, the go command is invoked with -overlay=Overlay.
+ // TODO(rfindley): remove, in favor of Args.
Overlay string
// If CleanEnv is set, the invocation will run only with the environment
@@ -172,6 +182,7 @@ type Invocation struct {
Logf func(format string, args ...interface{})
}
+// Postcondition: both error results have same nilness.
func (i *Invocation) runWithFriendlyError(ctx context.Context, stdout, stderr io.Writer) (friendlyError error, rawError error) {
rawError = i.run(ctx, stdout, stderr)
if rawError != nil {
@@ -188,12 +199,14 @@ func (i *Invocation) runWithFriendlyError(ctx context.Context, stdout, stderr io
return
}
-func (i *Invocation) run(ctx context.Context, stdout, stderr io.Writer) error {
- log := i.Logf
- if log == nil {
- log = func(string, ...interface{}) {}
+// logf logs if i.Logf is non-nil.
+func (i *Invocation) logf(format string, args ...any) {
+ if i.Logf != nil {
+ i.Logf(format, args...)
}
+}
+func (i *Invocation) run(ctx context.Context, stdout, stderr io.Writer) error {
goArgs := []string{i.Verb}
appendModFile := func() {
@@ -236,23 +249,23 @@ func (i *Invocation) run(ctx context.Context, stdout, stderr io.Writer) error {
cmd.Stdout = stdout
cmd.Stderr = stderr
- // cmd.WaitDelay was added only in go1.20 (see #50436).
- if waitDelay := reflect.ValueOf(cmd).Elem().FieldByName("WaitDelay"); waitDelay.IsValid() {
- // https://go.dev/issue/59541: don't wait forever copying stderr
- // after the command has exited.
- // After CL 484741 we copy stdout manually, so we we'll stop reading that as
- // soon as ctx is done. However, we also don't want to wait around forever
- // for stderr. Give a much-longer-than-reasonable delay and then assume that
- // something has wedged in the kernel or runtime.
- waitDelay.Set(reflect.ValueOf(30 * time.Second))
- }
-
- // On darwin the cwd gets resolved to the real path, which breaks anything that
- // expects the working directory to keep the original path, including the
+ // https://go.dev/issue/59541: don't wait forever copying stderr
+ // after the command has exited.
+ // After CL 484741 we copy stdout manually, so we we'll stop reading that as
+ // soon as ctx is done. However, we also don't want to wait around forever
+ // for stderr. Give a much-longer-than-reasonable delay and then assume that
+ // something has wedged in the kernel or runtime.
+ cmd.WaitDelay = 30 * time.Second
+
+ // The cwd gets resolved to the real path. On Darwin, where
+ // /tmp is a symlink, this breaks anything that expects the
+ // working directory to keep the original path, including the
// go command when dealing with modules.
- // The Go stdlib has a special feature where if the cwd and the PWD are the
- // same node then it trusts the PWD, so by setting it in the env for the child
- // process we fix up all the paths returned by the go command.
+ //
+ // os.Getwd has a special feature where if the cwd and the PWD
+ // are the same node then it trusts the PWD, so by setting it
+ // in the env for the child process we fix up all the paths
+ // returned by the go command.
if !i.CleanEnv {
cmd.Env = os.Environ()
}
@@ -262,7 +275,12 @@ func (i *Invocation) run(ctx context.Context, stdout, stderr io.Writer) error {
cmd.Dir = i.WorkingDir
}
- defer func(start time.Time) { log("%s for %v", time.Since(start), cmdDebugStr(cmd)) }(time.Now())
+ debugStr := cmdDebugStr(cmd)
+ i.logf("starting %v", debugStr)
+ start := time.Now()
+ defer func() {
+ i.logf("%s for %v", time.Since(start), debugStr)
+ }()
return runCmdContext(ctx, cmd)
}
@@ -343,6 +361,7 @@ func runCmdContext(ctx context.Context, cmd *exec.Cmd) (err error) {
}
}
+ startTime := time.Now()
err = cmd.Start()
if stdoutW != nil {
// The child process has inherited the pipe file,
@@ -369,7 +388,7 @@ func runCmdContext(ctx context.Context, cmd *exec.Cmd) (err error) {
case err := <-resChan:
return err
case <-timer.C:
- HandleHangingGoCommand(cmd.Process)
+ HandleHangingGoCommand(startTime, cmd)
case <-ctx.Done():
}
} else {
@@ -403,7 +422,7 @@ func runCmdContext(ctx context.Context, cmd *exec.Cmd) (err error) {
return <-resChan
}
-func HandleHangingGoCommand(proc *os.Process) {
+func HandleHangingGoCommand(start time.Time, cmd *exec.Cmd) {
switch runtime.GOOS {
case "linux", "darwin", "freebsd", "netbsd":
fmt.Fprintln(os.Stderr, `DETECTED A HANGING GO COMMAND
@@ -436,7 +455,7 @@ See golang/go#54461 for more details.`)
panic(fmt.Sprintf("running %s: %v", listFiles, err))
}
}
- panic(fmt.Sprintf("detected hanging go command (pid %d): see golang/go#54461 for more details", proc.Pid))
+ panic(fmt.Sprintf("detected hanging go command (golang/go#54461); waited %s\n\tcommand:%s\n\tpid:%d", time.Since(start), cmd, cmd.Process.Pid))
}
func cmdDebugStr(cmd *exec.Cmd) string {
@@ -460,3 +479,73 @@ func cmdDebugStr(cmd *exec.Cmd) string {
}
return fmt.Sprintf("GOROOT=%v GOPATH=%v GO111MODULE=%v GOPROXY=%v PWD=%v %v", env["GOROOT"], env["GOPATH"], env["GO111MODULE"], env["GOPROXY"], env["PWD"], strings.Join(args, " "))
}
+
+// WriteOverlays writes each value in the overlay (see the Overlay
+// field of go/packages.Config) to a temporary file and returns the name
+// of a JSON file describing the mapping that is suitable for the "go
+// list -overlay" flag.
+//
+// On success, the caller must call the cleanup function exactly once
+// when the files are no longer needed.
+func WriteOverlays(overlay map[string][]byte) (filename string, cleanup func(), err error) {
+ // Do nothing if there are no overlays in the config.
+ if len(overlay) == 0 {
+ return "", func() {}, nil
+ }
+
+ dir, err := os.MkdirTemp("", "gocommand-*")
+ if err != nil {
+ return "", nil, err
+ }
+
+ // The caller must clean up this directory,
+ // unless this function returns an error.
+ // (The cleanup operand of each return
+ // statement below is ignored.)
+ defer func() {
+ cleanup = func() {
+ os.RemoveAll(dir)
+ }
+ if err != nil {
+ cleanup()
+ cleanup = nil
+ }
+ }()
+
+ // Write each map entry to a temporary file.
+ overlays := make(map[string]string)
+ for k, v := range overlay {
+ // Use a unique basename for each file (001-foo.go),
+ // to avoid creating nested directories.
+ base := fmt.Sprintf("%d-%s", 1+len(overlays), filepath.Base(k))
+ filename := filepath.Join(dir, base)
+ err := os.WriteFile(filename, v, 0666)
+ if err != nil {
+ return "", nil, err
+ }
+ overlays[k] = filename
+ }
+
+ // Write the JSON overlay file that maps logical file names to temp files.
+ //
+ // OverlayJSON is the format overlay files are expected to be in.
+ // The Replace map maps from overlaid paths to replacement paths:
+ // the Go command will forward all reads trying to open
+ // each overlaid path to its replacement path, or consider the overlaid
+ // path not to exist if the replacement path is empty.
+ //
+ // From golang/go#39958.
+ type OverlayJSON struct {
+ Replace map[string]string `json:"replace,omitempty"`
+ }
+ b, err := json.Marshal(OverlayJSON{Replace: overlays})
+ if err != nil {
+ return "", nil, err
+ }
+ filename = filepath.Join(dir, "overlay.json")
+ if err := os.WriteFile(filename, b, 0666); err != nil {
+ return "", nil, err
+ }
+
+ return filename, nil, nil
+}
diff --git a/vendor/golang.org/x/tools/internal/gocommand/vendor.go b/vendor/golang.org/x/tools/internal/gocommand/vendor.go
index 2d3d408c0b..e38d1fb488 100644
--- a/vendor/golang.org/x/tools/internal/gocommand/vendor.go
+++ b/vendor/golang.org/x/tools/internal/gocommand/vendor.go
@@ -107,3 +107,57 @@ func getMainModuleAnd114(ctx context.Context, inv Invocation, r *Runner) (*Modul
}
return mod, lines[4] == "go1.14", nil
}
+
+// WorkspaceVendorEnabled reports whether workspace vendoring is enabled. It takes a *Runner to execute Go commands
+// with the supplied context.Context and Invocation. The Invocation can contain pre-defined fields,
+// of which only Verb and Args are modified to run the appropriate Go command.
+// Inspired by setDefaultBuildMod in modload/init.go
+func WorkspaceVendorEnabled(ctx context.Context, inv Invocation, r *Runner) (bool, []*ModuleJSON, error) {
+ inv.Verb = "env"
+ inv.Args = []string{"GOWORK"}
+ stdout, err := r.Run(ctx, inv)
+ if err != nil {
+ return false, nil, err
+ }
+ goWork := string(bytes.TrimSpace(stdout.Bytes()))
+ if fi, err := os.Stat(filepath.Join(filepath.Dir(goWork), "vendor")); err == nil && fi.IsDir() {
+ mainMods, err := getWorkspaceMainModules(ctx, inv, r)
+ if err != nil {
+ return false, nil, err
+ }
+ return true, mainMods, nil
+ }
+ return false, nil, nil
+}
+
+// getWorkspaceMainModules gets the main modules' information.
+// This is the information needed to figure out if vendoring should be enabled.
+func getWorkspaceMainModules(ctx context.Context, inv Invocation, r *Runner) ([]*ModuleJSON, error) {
+ const format = `{{.Path}}
+{{.Dir}}
+{{.GoMod}}
+{{.GoVersion}}
+`
+ inv.Verb = "list"
+ inv.Args = []string{"-m", "-f", format}
+ stdout, err := r.Run(ctx, inv)
+ if err != nil {
+ return nil, err
+ }
+
+ lines := strings.Split(strings.TrimSuffix(stdout.String(), "\n"), "\n")
+ if len(lines) < 4 {
+ return nil, fmt.Errorf("unexpected stdout: %q", stdout.String())
+ }
+ mods := make([]*ModuleJSON, 0, len(lines)/4)
+ for i := 0; i < len(lines); i += 4 {
+ mods = append(mods, &ModuleJSON{
+ Path: lines[i],
+ Dir: lines[i+1],
+ GoMod: lines[i+2],
+ GoVersion: lines[i+3],
+ Main: true,
+ })
+ }
+ return mods, nil
+}
diff --git a/vendor/golang.org/x/tools/internal/packagesinternal/packages.go b/vendor/golang.org/x/tools/internal/packagesinternal/packages.go
index d9950b1f0b..44719de173 100644
--- a/vendor/golang.org/x/tools/internal/packagesinternal/packages.go
+++ b/vendor/golang.org/x/tools/internal/packagesinternal/packages.go
@@ -5,10 +5,6 @@
// Package packagesinternal exposes internal-only fields from go/packages.
package packagesinternal
-import (
- "golang.org/x/tools/internal/gocommand"
-)
-
var GetForTest = func(p interface{}) string { return "" }
var GetDepsErrors = func(p interface{}) []*PackageError { return nil }
@@ -18,10 +14,6 @@ type PackageError struct {
Err string // the error itself
}
-var GetGoCmdRunner = func(config interface{}) *gocommand.Runner { return nil }
-
-var SetGoCmdRunner = func(config interface{}, runner *gocommand.Runner) {}
-
var TypecheckCgo int
var DepsErrors int // must be set as a LoadMode to call GetDepsErrors
var ForTest int // must be set as a LoadMode to call GetForTest
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/decoder.go b/vendor/golang.org/x/tools/internal/pkgbits/decoder.go
index b92e8e6eb3..f6cb37c5c3 100644
--- a/vendor/golang.org/x/tools/internal/pkgbits/decoder.go
+++ b/vendor/golang.org/x/tools/internal/pkgbits/decoder.go
@@ -21,7 +21,7 @@ import (
// export data.
type PkgDecoder struct {
// version is the file format version.
- version uint32
+ version Version
// sync indicates whether the file uses sync markers.
sync bool
@@ -68,8 +68,6 @@ func (pr *PkgDecoder) SyncMarkers() bool { return pr.sync }
// NewPkgDecoder returns a PkgDecoder initialized to read the Unified
// IR export data from input. pkgPath is the package path for the
// compilation unit that produced the export data.
-//
-// TODO(mdempsky): Remove pkgPath parameter; unneeded since CL 391014.
func NewPkgDecoder(pkgPath, input string) PkgDecoder {
pr := PkgDecoder{
pkgPath: pkgPath,
@@ -80,14 +78,15 @@ func NewPkgDecoder(pkgPath, input string) PkgDecoder {
r := strings.NewReader(input)
- assert(binary.Read(r, binary.LittleEndian, &pr.version) == nil)
+ var ver uint32
+ assert(binary.Read(r, binary.LittleEndian, &ver) == nil)
+ pr.version = Version(ver)
- switch pr.version {
- default:
- panic(fmt.Errorf("unsupported version: %v", pr.version))
- case 0:
- // no flags
- case 1:
+ if pr.version >= numVersions {
+ panic(fmt.Errorf("cannot decode %q, export data version %d is greater than maximum supported version %d", pkgPath, pr.version, numVersions-1))
+ }
+
+ if pr.version.Has(Flags) {
var flags uint32
assert(binary.Read(r, binary.LittleEndian, &flags) == nil)
pr.sync = flags&flagSyncMarkers != 0
@@ -102,7 +101,9 @@ func NewPkgDecoder(pkgPath, input string) PkgDecoder {
assert(err == nil)
pr.elemData = input[pos:]
- assert(len(pr.elemData)-8 == int(pr.elemEnds[len(pr.elemEnds)-1]))
+
+ const fingerprintSize = 8
+ assert(len(pr.elemData)-fingerprintSize == int(pr.elemEnds[len(pr.elemEnds)-1]))
return pr
}
@@ -136,7 +137,7 @@ func (pr *PkgDecoder) AbsIdx(k RelocKind, idx Index) int {
absIdx += int(pr.elemEndsEnds[k-1])
}
if absIdx >= int(pr.elemEndsEnds[k]) {
- errorf("%v:%v is out of bounds; %v", k, idx, pr.elemEndsEnds)
+ panicf("%v:%v is out of bounds; %v", k, idx, pr.elemEndsEnds)
}
return absIdx
}
@@ -193,9 +194,7 @@ func (pr *PkgDecoder) NewDecoderRaw(k RelocKind, idx Index) Decoder {
Idx: idx,
}
- // TODO(mdempsky) r.data.Reset(...) after #44505 is resolved.
- r.Data = *strings.NewReader(pr.DataIdx(k, idx))
-
+ r.Data.Reset(pr.DataIdx(k, idx))
r.Sync(SyncRelocs)
r.Relocs = make([]RelocEnt, r.Len())
for i := range r.Relocs {
@@ -244,7 +243,7 @@ type Decoder struct {
func (r *Decoder) checkErr(err error) {
if err != nil {
- errorf("unexpected decoding error: %w", err)
+ panicf("unexpected decoding error: %w", err)
}
}
@@ -515,3 +514,6 @@ func (pr *PkgDecoder) PeekObj(idx Index) (string, string, CodeObj) {
return path, name, tag
}
+
+// Version reports the version of the bitstream.
+func (w *Decoder) Version() Version { return w.common.version }
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/encoder.go b/vendor/golang.org/x/tools/internal/pkgbits/encoder.go
index 6482617a4f..c17a12399d 100644
--- a/vendor/golang.org/x/tools/internal/pkgbits/encoder.go
+++ b/vendor/golang.org/x/tools/internal/pkgbits/encoder.go
@@ -12,18 +12,15 @@ import (
"io"
"math/big"
"runtime"
+ "strings"
)
-// currentVersion is the current version number.
-//
-// - v0: initial prototype
-//
-// - v1: adds the flags uint32 word
-const currentVersion uint32 = 1
-
// A PkgEncoder provides methods for encoding a package's Unified IR
// export data.
type PkgEncoder struct {
+ // version of the bitstream.
+ version Version
+
// elems holds the bitstream for previously encoded elements.
elems [numRelocs][]string
@@ -47,8 +44,9 @@ func (pw *PkgEncoder) SyncMarkers() bool { return pw.syncFrames >= 0 }
// export data files, but can help diagnosing desync errors in
// higher-level Unified IR reader/writer code. If syncFrames is
// negative, then sync markers are omitted entirely.
-func NewPkgEncoder(syncFrames int) PkgEncoder {
+func NewPkgEncoder(version Version, syncFrames int) PkgEncoder {
return PkgEncoder{
+ version: version,
stringsIdx: make(map[string]Index),
syncFrames: syncFrames,
}
@@ -64,13 +62,15 @@ func (pw *PkgEncoder) DumpTo(out0 io.Writer) (fingerprint [8]byte) {
assert(binary.Write(out, binary.LittleEndian, x) == nil)
}
- writeUint32(currentVersion)
+ writeUint32(uint32(pw.version))
- var flags uint32
- if pw.SyncMarkers() {
- flags |= flagSyncMarkers
+ if pw.version.Has(Flags) {
+ var flags uint32
+ if pw.SyncMarkers() {
+ flags |= flagSyncMarkers
+ }
+ writeUint32(flags)
}
- writeUint32(flags)
// Write elemEndsEnds.
var sum uint32
@@ -159,7 +159,7 @@ type Encoder struct {
// Flush finalizes the element's bitstream and returns its Index.
func (w *Encoder) Flush() Index {
- var sb bytes.Buffer // TODO(mdempsky): strings.Builder after #44505 is resolved
+ var sb strings.Builder
// Backup the data so we write the relocations at the front.
var tmp bytes.Buffer
@@ -189,7 +189,7 @@ func (w *Encoder) Flush() Index {
func (w *Encoder) checkErr(err error) {
if err != nil {
- errorf("unexpected encoding error: %v", err)
+ panicf("unexpected encoding error: %v", err)
}
}
@@ -320,8 +320,14 @@ func (w *Encoder) Code(c Code) {
// section (if not already present), and then writing a relocation
// into the element bitstream.
func (w *Encoder) String(s string) {
+ w.StringRef(w.p.StringIdx(s))
+}
+
+// StringRef writes a reference to the given index, which must be a
+// previously encoded string value.
+func (w *Encoder) StringRef(idx Index) {
w.Sync(SyncString)
- w.Reloc(RelocString, w.p.StringIdx(s))
+ w.Reloc(RelocString, idx)
}
// Strings encodes and writes a variable-length slice of strings into
@@ -348,7 +354,7 @@ func (w *Encoder) Value(val constant.Value) {
func (w *Encoder) scalar(val constant.Value) {
switch v := constant.Val(val).(type) {
default:
- errorf("unhandled %v (%v)", val, val.Kind())
+ panicf("unhandled %v (%v)", val, val.Kind())
case bool:
w.Code(ValBool)
w.Bool(v)
@@ -381,3 +387,6 @@ func (w *Encoder) bigFloat(v *big.Float) {
b := v.Append(nil, 'p', -1)
w.String(string(b)) // TODO: More efficient encoding.
}
+
+// Version reports the version of the bitstream.
+func (w *Encoder) Version() Version { return w.p.version }
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/frames_go1.go b/vendor/golang.org/x/tools/internal/pkgbits/frames_go1.go
deleted file mode 100644
index 5294f6a63e..0000000000
--- a/vendor/golang.org/x/tools/internal/pkgbits/frames_go1.go
+++ /dev/null
@@ -1,21 +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.
-
-//go:build !go1.7
-// +build !go1.7
-
-// TODO(mdempsky): Remove after #44505 is resolved
-
-package pkgbits
-
-import "runtime"
-
-func walkFrames(pcs []uintptr, visit frameVisitor) {
- for _, pc := range pcs {
- fn := runtime.FuncForPC(pc)
- file, line := fn.FileLine(pc)
-
- visit(file, line, fn.Name(), pc-fn.Entry())
- }
-}
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/frames_go17.go b/vendor/golang.org/x/tools/internal/pkgbits/frames_go17.go
deleted file mode 100644
index 2324ae7adf..0000000000
--- a/vendor/golang.org/x/tools/internal/pkgbits/frames_go17.go
+++ /dev/null
@@ -1,28 +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.
-
-//go:build go1.7
-// +build go1.7
-
-package pkgbits
-
-import "runtime"
-
-// walkFrames calls visit for each call frame represented by pcs.
-//
-// pcs should be a slice of PCs, as returned by runtime.Callers.
-func walkFrames(pcs []uintptr, visit frameVisitor) {
- if len(pcs) == 0 {
- return
- }
-
- frames := runtime.CallersFrames(pcs)
- for {
- frame, more := frames.Next()
- visit(frame.File, frame.Line, frame.Function, frame.PC-frame.Entry)
- if !more {
- return
- }
- }
-}
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/support.go b/vendor/golang.org/x/tools/internal/pkgbits/support.go
index ad26d3b28c..50534a2955 100644
--- a/vendor/golang.org/x/tools/internal/pkgbits/support.go
+++ b/vendor/golang.org/x/tools/internal/pkgbits/support.go
@@ -12,6 +12,6 @@ func assert(b bool) {
}
}
-func errorf(format string, args ...interface{}) {
+func panicf(format string, args ...any) {
panic(fmt.Errorf(format, args...))
}
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/sync.go b/vendor/golang.org/x/tools/internal/pkgbits/sync.go
index 5bd51ef717..1520b73afb 100644
--- a/vendor/golang.org/x/tools/internal/pkgbits/sync.go
+++ b/vendor/golang.org/x/tools/internal/pkgbits/sync.go
@@ -6,6 +6,7 @@ package pkgbits
import (
"fmt"
+ "runtime"
"strings"
)
@@ -23,6 +24,24 @@ func fmtFrames(pcs ...uintptr) []string {
type frameVisitor func(file string, line int, name string, offset uintptr)
+// walkFrames calls visit for each call frame represented by pcs.
+//
+// pcs should be a slice of PCs, as returned by runtime.Callers.
+func walkFrames(pcs []uintptr, visit frameVisitor) {
+ if len(pcs) == 0 {
+ return
+ }
+
+ frames := runtime.CallersFrames(pcs)
+ for {
+ frame, more := frames.Next()
+ visit(frame.File, frame.Line, frame.Function, frame.PC-frame.Entry)
+ if !more {
+ return
+ }
+ }
+}
+
// SyncMarker is an enum type that represents markers that may be
// written to export data to ensure the reader and writer stay
// synchronized.
@@ -110,4 +129,8 @@ const (
SyncStmtsEnd
SyncLabel
SyncOptLabel
+
+ SyncMultiExpr
+ SyncRType
+ SyncConvRTTI
)
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/syncmarker_string.go b/vendor/golang.org/x/tools/internal/pkgbits/syncmarker_string.go
index 4a5b0ca5f2..582ad56d3e 100644
--- a/vendor/golang.org/x/tools/internal/pkgbits/syncmarker_string.go
+++ b/vendor/golang.org/x/tools/internal/pkgbits/syncmarker_string.go
@@ -74,11 +74,14 @@ func _() {
_ = x[SyncStmtsEnd-64]
_ = x[SyncLabel-65]
_ = x[SyncOptLabel-66]
+ _ = x[SyncMultiExpr-67]
+ _ = x[SyncRType-68]
+ _ = x[SyncConvRTTI-69]
}
-const _SyncMarker_name = "EOFBoolInt64Uint64StringValueValRelocsRelocUseRelocPublicPosPosBaseObjectObject1PkgPkgDefMethodTypeTypeIdxTypeParamNamesSignatureParamsParamCodeObjSymLocalIdentSelectorPrivateFuncExtVarExtTypeExtPragmaExprListExprsExprExprTypeAssignOpFuncLitCompLitDeclFuncBodyOpenScopeCloseScopeCloseAnotherScopeDeclNamesDeclNameStmtsBlockStmtIfStmtForStmtSwitchStmtRangeStmtCaseClauseCommClauseSelectStmtDeclsLabeledStmtUseObjLocalAddLocalLinknameStmt1StmtsEndLabelOptLabel"
+const _SyncMarker_name = "EOFBoolInt64Uint64StringValueValRelocsRelocUseRelocPublicPosPosBaseObjectObject1PkgPkgDefMethodTypeTypeIdxTypeParamNamesSignatureParamsParamCodeObjSymLocalIdentSelectorPrivateFuncExtVarExtTypeExtPragmaExprListExprsExprExprTypeAssignOpFuncLitCompLitDeclFuncBodyOpenScopeCloseScopeCloseAnotherScopeDeclNamesDeclNameStmtsBlockStmtIfStmtForStmtSwitchStmtRangeStmtCaseClauseCommClauseSelectStmtDeclsLabeledStmtUseObjLocalAddLocalLinknameStmt1StmtsEndLabelOptLabelMultiExprRTypeConvRTTI"
-var _SyncMarker_index = [...]uint16{0, 3, 7, 12, 18, 24, 29, 32, 38, 43, 51, 57, 60, 67, 73, 80, 83, 89, 95, 99, 106, 120, 129, 135, 140, 147, 150, 160, 168, 175, 182, 188, 195, 201, 209, 214, 218, 226, 232, 234, 241, 248, 252, 260, 269, 279, 296, 305, 313, 318, 327, 333, 340, 350, 359, 369, 379, 389, 394, 405, 416, 424, 432, 437, 445, 450, 458}
+var _SyncMarker_index = [...]uint16{0, 3, 7, 12, 18, 24, 29, 32, 38, 43, 51, 57, 60, 67, 73, 80, 83, 89, 95, 99, 106, 120, 129, 135, 140, 147, 150, 160, 168, 175, 182, 188, 195, 201, 209, 214, 218, 226, 232, 234, 241, 248, 252, 260, 269, 279, 296, 305, 313, 318, 327, 333, 340, 350, 359, 369, 379, 389, 394, 405, 416, 424, 432, 437, 445, 450, 458, 467, 472, 480}
func (i SyncMarker) String() string {
i -= 1
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/version.go b/vendor/golang.org/x/tools/internal/pkgbits/version.go
new file mode 100644
index 0000000000..53af9df22b
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/pkgbits/version.go
@@ -0,0 +1,85 @@
+// Copyright 2024 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 pkgbits
+
+// Version indicates a version of a unified IR bitstream.
+// Each Version indicates the addition, removal, or change of
+// new data in the bitstream.
+//
+// These are serialized to disk and the interpretation remains fixed.
+type Version uint32
+
+const (
+ // V0: initial prototype.
+ //
+ // All data that is not assigned a Field is in version V0
+ // and has not been deprecated.
+ V0 Version = iota
+
+ // V1: adds the Flags uint32 word
+ V1
+
+ // V2: removes unused legacy fields and supports type parameters for aliases.
+ // - remove the legacy "has init" bool from the public root
+ // - remove obj's "derived func instance" bool
+ // - add a TypeParamNames field to ObjAlias
+ // - remove derived info "needed" bool
+ V2
+
+ numVersions = iota
+)
+
+// Field denotes a unit of data in the serialized unified IR bitstream.
+// It is conceptually a like field in a structure.
+//
+// We only really need Fields when the data may or may not be present
+// in a stream based on the Version of the bitstream.
+//
+// Unlike much of pkgbits, Fields are not serialized and
+// can change values as needed.
+type Field int
+
+const (
+ // Flags in a uint32 in the header of a bitstream
+ // that is used to indicate whether optional features are enabled.
+ Flags Field = iota
+
+ // Deprecated: HasInit was a bool indicating whether a package
+ // has any init functions.
+ HasInit
+
+ // Deprecated: DerivedFuncInstance was a bool indicating
+ // whether an object was a function instance.
+ DerivedFuncInstance
+
+ // ObjAlias has a list of TypeParamNames.
+ AliasTypeParamNames
+
+ // Deprecated: DerivedInfoNeeded was a bool indicating
+ // whether a type was a derived type.
+ DerivedInfoNeeded
+
+ numFields = iota
+)
+
+// introduced is the version a field was added.
+var introduced = [numFields]Version{
+ Flags: V1,
+ AliasTypeParamNames: V2,
+}
+
+// removed is the version a field was removed in or 0 for fields
+// that have not yet been deprecated.
+// (So removed[f]-1 is the last version it is included in.)
+var removed = [numFields]Version{
+ HasInit: V2,
+ DerivedFuncInstance: V2,
+ DerivedInfoNeeded: V2,
+}
+
+// Has reports whether field f is present in a bitstream at version v.
+func (v Version) Has(f Field) bool {
+ return introduced[f] <= v && (v < removed[f] || removed[f] == V0)
+}
diff --git a/vendor/golang.org/x/tools/internal/stdlib/manifest.go b/vendor/golang.org/x/tools/internal/stdlib/manifest.go
new file mode 100644
index 0000000000..cdaac9ab34
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/stdlib/manifest.go
@@ -0,0 +1,17431 @@
+// Copyright 2024 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.
+
+// Code generated by generate.go. DO NOT EDIT.
+
+package stdlib
+
+var PackageSymbols = map[string][]Symbol{
+ "archive/tar": {
+ {"(*Header).FileInfo", Method, 1},
+ {"(*Reader).Next", Method, 0},
+ {"(*Reader).Read", Method, 0},
+ {"(*Writer).AddFS", Method, 22},
+ {"(*Writer).Close", Method, 0},
+ {"(*Writer).Flush", Method, 0},
+ {"(*Writer).Write", Method, 0},
+ {"(*Writer).WriteHeader", Method, 0},
+ {"(Format).String", Method, 10},
+ {"ErrFieldTooLong", Var, 0},
+ {"ErrHeader", Var, 0},
+ {"ErrInsecurePath", Var, 20},
+ {"ErrWriteAfterClose", Var, 0},
+ {"ErrWriteTooLong", Var, 0},
+ {"FileInfoHeader", Func, 1},
+ {"FileInfoNames", Type, 23},
+ {"Format", Type, 10},
+ {"FormatGNU", Const, 10},
+ {"FormatPAX", Const, 10},
+ {"FormatUSTAR", Const, 10},
+ {"FormatUnknown", Const, 10},
+ {"Header", Type, 0},
+ {"Header.AccessTime", Field, 0},
+ {"Header.ChangeTime", Field, 0},
+ {"Header.Devmajor", Field, 0},
+ {"Header.Devminor", Field, 0},
+ {"Header.Format", Field, 10},
+ {"Header.Gid", Field, 0},
+ {"Header.Gname", Field, 0},
+ {"Header.Linkname", Field, 0},
+ {"Header.ModTime", Field, 0},
+ {"Header.Mode", Field, 0},
+ {"Header.Name", Field, 0},
+ {"Header.PAXRecords", Field, 10},
+ {"Header.Size", Field, 0},
+ {"Header.Typeflag", Field, 0},
+ {"Header.Uid", Field, 0},
+ {"Header.Uname", Field, 0},
+ {"Header.Xattrs", Field, 3},
+ {"NewReader", Func, 0},
+ {"NewWriter", Func, 0},
+ {"Reader", Type, 0},
+ {"TypeBlock", Const, 0},
+ {"TypeChar", Const, 0},
+ {"TypeCont", Const, 0},
+ {"TypeDir", Const, 0},
+ {"TypeFifo", Const, 0},
+ {"TypeGNULongLink", Const, 1},
+ {"TypeGNULongName", Const, 1},
+ {"TypeGNUSparse", Const, 3},
+ {"TypeLink", Const, 0},
+ {"TypeReg", Const, 0},
+ {"TypeRegA", Const, 0},
+ {"TypeSymlink", Const, 0},
+ {"TypeXGlobalHeader", Const, 0},
+ {"TypeXHeader", Const, 0},
+ {"Writer", Type, 0},
+ },
+ "archive/zip": {
+ {"(*File).DataOffset", Method, 2},
+ {"(*File).FileInfo", Method, 0},
+ {"(*File).ModTime", Method, 0},
+ {"(*File).Mode", Method, 0},
+ {"(*File).Open", Method, 0},
+ {"(*File).OpenRaw", Method, 17},
+ {"(*File).SetModTime", Method, 0},
+ {"(*File).SetMode", Method, 0},
+ {"(*FileHeader).FileInfo", Method, 0},
+ {"(*FileHeader).ModTime", Method, 0},
+ {"(*FileHeader).Mode", Method, 0},
+ {"(*FileHeader).SetModTime", Method, 0},
+ {"(*FileHeader).SetMode", Method, 0},
+ {"(*ReadCloser).Close", Method, 0},
+ {"(*ReadCloser).Open", Method, 16},
+ {"(*ReadCloser).RegisterDecompressor", Method, 6},
+ {"(*Reader).Open", Method, 16},
+ {"(*Reader).RegisterDecompressor", Method, 6},
+ {"(*Writer).AddFS", Method, 22},
+ {"(*Writer).Close", Method, 0},
+ {"(*Writer).Copy", Method, 17},
+ {"(*Writer).Create", Method, 0},
+ {"(*Writer).CreateHeader", Method, 0},
+ {"(*Writer).CreateRaw", Method, 17},
+ {"(*Writer).Flush", Method, 4},
+ {"(*Writer).RegisterCompressor", Method, 6},
+ {"(*Writer).SetComment", Method, 10},
+ {"(*Writer).SetOffset", Method, 5},
+ {"Compressor", Type, 2},
+ {"Decompressor", Type, 2},
+ {"Deflate", Const, 0},
+ {"ErrAlgorithm", Var, 0},
+ {"ErrChecksum", Var, 0},
+ {"ErrFormat", Var, 0},
+ {"ErrInsecurePath", Var, 20},
+ {"File", Type, 0},
+ {"File.FileHeader", Field, 0},
+ {"FileHeader", Type, 0},
+ {"FileHeader.CRC32", Field, 0},
+ {"FileHeader.Comment", Field, 0},
+ {"FileHeader.CompressedSize", Field, 0},
+ {"FileHeader.CompressedSize64", Field, 1},
+ {"FileHeader.CreatorVersion", Field, 0},
+ {"FileHeader.ExternalAttrs", Field, 0},
+ {"FileHeader.Extra", Field, 0},
+ {"FileHeader.Flags", Field, 0},
+ {"FileHeader.Method", Field, 0},
+ {"FileHeader.Modified", Field, 10},
+ {"FileHeader.ModifiedDate", Field, 0},
+ {"FileHeader.ModifiedTime", Field, 0},
+ {"FileHeader.Name", Field, 0},
+ {"FileHeader.NonUTF8", Field, 10},
+ {"FileHeader.ReaderVersion", Field, 0},
+ {"FileHeader.UncompressedSize", Field, 0},
+ {"FileHeader.UncompressedSize64", Field, 1},
+ {"FileInfoHeader", Func, 0},
+ {"NewReader", Func, 0},
+ {"NewWriter", Func, 0},
+ {"OpenReader", Func, 0},
+ {"ReadCloser", Type, 0},
+ {"ReadCloser.Reader", Field, 0},
+ {"Reader", Type, 0},
+ {"Reader.Comment", Field, 0},
+ {"Reader.File", Field, 0},
+ {"RegisterCompressor", Func, 2},
+ {"RegisterDecompressor", Func, 2},
+ {"Store", Const, 0},
+ {"Writer", Type, 0},
+ },
+ "bufio": {
+ {"(*Reader).Buffered", Method, 0},
+ {"(*Reader).Discard", Method, 5},
+ {"(*Reader).Peek", Method, 0},
+ {"(*Reader).Read", Method, 0},
+ {"(*Reader).ReadByte", Method, 0},
+ {"(*Reader).ReadBytes", Method, 0},
+ {"(*Reader).ReadLine", Method, 0},
+ {"(*Reader).ReadRune", Method, 0},
+ {"(*Reader).ReadSlice", Method, 0},
+ {"(*Reader).ReadString", Method, 0},
+ {"(*Reader).Reset", Method, 2},
+ {"(*Reader).Size", Method, 10},
+ {"(*Reader).UnreadByte", Method, 0},
+ {"(*Reader).UnreadRune", Method, 0},
+ {"(*Reader).WriteTo", Method, 1},
+ {"(*Scanner).Buffer", Method, 6},
+ {"(*Scanner).Bytes", Method, 1},
+ {"(*Scanner).Err", Method, 1},
+ {"(*Scanner).Scan", Method, 1},
+ {"(*Scanner).Split", Method, 1},
+ {"(*Scanner).Text", Method, 1},
+ {"(*Writer).Available", Method, 0},
+ {"(*Writer).AvailableBuffer", Method, 18},
+ {"(*Writer).Buffered", Method, 0},
+ {"(*Writer).Flush", Method, 0},
+ {"(*Writer).ReadFrom", Method, 1},
+ {"(*Writer).Reset", Method, 2},
+ {"(*Writer).Size", Method, 10},
+ {"(*Writer).Write", Method, 0},
+ {"(*Writer).WriteByte", Method, 0},
+ {"(*Writer).WriteRune", Method, 0},
+ {"(*Writer).WriteString", Method, 0},
+ {"(ReadWriter).Available", Method, 0},
+ {"(ReadWriter).AvailableBuffer", Method, 18},
+ {"(ReadWriter).Discard", Method, 5},
+ {"(ReadWriter).Flush", Method, 0},
+ {"(ReadWriter).Peek", Method, 0},
+ {"(ReadWriter).Read", Method, 0},
+ {"(ReadWriter).ReadByte", Method, 0},
+ {"(ReadWriter).ReadBytes", Method, 0},
+ {"(ReadWriter).ReadFrom", Method, 1},
+ {"(ReadWriter).ReadLine", Method, 0},
+ {"(ReadWriter).ReadRune", Method, 0},
+ {"(ReadWriter).ReadSlice", Method, 0},
+ {"(ReadWriter).ReadString", Method, 0},
+ {"(ReadWriter).UnreadByte", Method, 0},
+ {"(ReadWriter).UnreadRune", Method, 0},
+ {"(ReadWriter).Write", Method, 0},
+ {"(ReadWriter).WriteByte", Method, 0},
+ {"(ReadWriter).WriteRune", Method, 0},
+ {"(ReadWriter).WriteString", Method, 0},
+ {"(ReadWriter).WriteTo", Method, 1},
+ {"ErrAdvanceTooFar", Var, 1},
+ {"ErrBadReadCount", Var, 15},
+ {"ErrBufferFull", Var, 0},
+ {"ErrFinalToken", Var, 6},
+ {"ErrInvalidUnreadByte", Var, 0},
+ {"ErrInvalidUnreadRune", Var, 0},
+ {"ErrNegativeAdvance", Var, 1},
+ {"ErrNegativeCount", Var, 0},
+ {"ErrTooLong", Var, 1},
+ {"MaxScanTokenSize", Const, 1},
+ {"NewReadWriter", Func, 0},
+ {"NewReader", Func, 0},
+ {"NewReaderSize", Func, 0},
+ {"NewScanner", Func, 1},
+ {"NewWriter", Func, 0},
+ {"NewWriterSize", Func, 0},
+ {"ReadWriter", Type, 0},
+ {"ReadWriter.Reader", Field, 0},
+ {"ReadWriter.Writer", Field, 0},
+ {"Reader", Type, 0},
+ {"ScanBytes", Func, 1},
+ {"ScanLines", Func, 1},
+ {"ScanRunes", Func, 1},
+ {"ScanWords", Func, 1},
+ {"Scanner", Type, 1},
+ {"SplitFunc", Type, 1},
+ {"Writer", Type, 0},
+ },
+ "bytes": {
+ {"(*Buffer).Available", Method, 21},
+ {"(*Buffer).AvailableBuffer", Method, 21},
+ {"(*Buffer).Bytes", Method, 0},
+ {"(*Buffer).Cap", Method, 5},
+ {"(*Buffer).Grow", Method, 1},
+ {"(*Buffer).Len", Method, 0},
+ {"(*Buffer).Next", Method, 0},
+ {"(*Buffer).Read", Method, 0},
+ {"(*Buffer).ReadByte", Method, 0},
+ {"(*Buffer).ReadBytes", Method, 0},
+ {"(*Buffer).ReadFrom", Method, 0},
+ {"(*Buffer).ReadRune", Method, 0},
+ {"(*Buffer).ReadString", Method, 0},
+ {"(*Buffer).Reset", Method, 0},
+ {"(*Buffer).String", Method, 0},
+ {"(*Buffer).Truncate", Method, 0},
+ {"(*Buffer).UnreadByte", Method, 0},
+ {"(*Buffer).UnreadRune", Method, 0},
+ {"(*Buffer).Write", Method, 0},
+ {"(*Buffer).WriteByte", Method, 0},
+ {"(*Buffer).WriteRune", Method, 0},
+ {"(*Buffer).WriteString", Method, 0},
+ {"(*Buffer).WriteTo", Method, 0},
+ {"(*Reader).Len", Method, 0},
+ {"(*Reader).Read", Method, 0},
+ {"(*Reader).ReadAt", Method, 0},
+ {"(*Reader).ReadByte", Method, 0},
+ {"(*Reader).ReadRune", Method, 0},
+ {"(*Reader).Reset", Method, 7},
+ {"(*Reader).Seek", Method, 0},
+ {"(*Reader).Size", Method, 5},
+ {"(*Reader).UnreadByte", Method, 0},
+ {"(*Reader).UnreadRune", Method, 0},
+ {"(*Reader).WriteTo", Method, 1},
+ {"Buffer", Type, 0},
+ {"Clone", Func, 20},
+ {"Compare", Func, 0},
+ {"Contains", Func, 0},
+ {"ContainsAny", Func, 7},
+ {"ContainsFunc", Func, 21},
+ {"ContainsRune", Func, 7},
+ {"Count", Func, 0},
+ {"Cut", Func, 18},
+ {"CutPrefix", Func, 20},
+ {"CutSuffix", Func, 20},
+ {"Equal", Func, 0},
+ {"EqualFold", Func, 0},
+ {"ErrTooLarge", Var, 0},
+ {"Fields", Func, 0},
+ {"FieldsFunc", Func, 0},
+ {"HasPrefix", Func, 0},
+ {"HasSuffix", Func, 0},
+ {"Index", Func, 0},
+ {"IndexAny", Func, 0},
+ {"IndexByte", Func, 0},
+ {"IndexFunc", Func, 0},
+ {"IndexRune", Func, 0},
+ {"Join", Func, 0},
+ {"LastIndex", Func, 0},
+ {"LastIndexAny", Func, 0},
+ {"LastIndexByte", Func, 5},
+ {"LastIndexFunc", Func, 0},
+ {"Map", Func, 0},
+ {"MinRead", Const, 0},
+ {"NewBuffer", Func, 0},
+ {"NewBufferString", Func, 0},
+ {"NewReader", Func, 0},
+ {"Reader", Type, 0},
+ {"Repeat", Func, 0},
+ {"Replace", Func, 0},
+ {"ReplaceAll", Func, 12},
+ {"Runes", Func, 0},
+ {"Split", Func, 0},
+ {"SplitAfter", Func, 0},
+ {"SplitAfterN", Func, 0},
+ {"SplitN", Func, 0},
+ {"Title", Func, 0},
+ {"ToLower", Func, 0},
+ {"ToLowerSpecial", Func, 0},
+ {"ToTitle", Func, 0},
+ {"ToTitleSpecial", Func, 0},
+ {"ToUpper", Func, 0},
+ {"ToUpperSpecial", Func, 0},
+ {"ToValidUTF8", Func, 13},
+ {"Trim", Func, 0},
+ {"TrimFunc", Func, 0},
+ {"TrimLeft", Func, 0},
+ {"TrimLeftFunc", Func, 0},
+ {"TrimPrefix", Func, 1},
+ {"TrimRight", Func, 0},
+ {"TrimRightFunc", Func, 0},
+ {"TrimSpace", Func, 0},
+ {"TrimSuffix", Func, 1},
+ },
+ "cmp": {
+ {"Compare", Func, 21},
+ {"Less", Func, 21},
+ {"Or", Func, 22},
+ {"Ordered", Type, 21},
+ },
+ "compress/bzip2": {
+ {"(StructuralError).Error", Method, 0},
+ {"NewReader", Func, 0},
+ {"StructuralError", Type, 0},
+ },
+ "compress/flate": {
+ {"(*ReadError).Error", Method, 0},
+ {"(*WriteError).Error", Method, 0},
+ {"(*Writer).Close", Method, 0},
+ {"(*Writer).Flush", Method, 0},
+ {"(*Writer).Reset", Method, 2},
+ {"(*Writer).Write", Method, 0},
+ {"(CorruptInputError).Error", Method, 0},
+ {"(InternalError).Error", Method, 0},
+ {"BestCompression", Const, 0},
+ {"BestSpeed", Const, 0},
+ {"CorruptInputError", Type, 0},
+ {"DefaultCompression", Const, 0},
+ {"HuffmanOnly", Const, 7},
+ {"InternalError", Type, 0},
+ {"NewReader", Func, 0},
+ {"NewReaderDict", Func, 0},
+ {"NewWriter", Func, 0},
+ {"NewWriterDict", Func, 0},
+ {"NoCompression", Const, 0},
+ {"ReadError", Type, 0},
+ {"ReadError.Err", Field, 0},
+ {"ReadError.Offset", Field, 0},
+ {"Reader", Type, 0},
+ {"Resetter", Type, 4},
+ {"WriteError", Type, 0},
+ {"WriteError.Err", Field, 0},
+ {"WriteError.Offset", Field, 0},
+ {"Writer", Type, 0},
+ },
+ "compress/gzip": {
+ {"(*Reader).Close", Method, 0},
+ {"(*Reader).Multistream", Method, 4},
+ {"(*Reader).Read", Method, 0},
+ {"(*Reader).Reset", Method, 3},
+ {"(*Writer).Close", Method, 0},
+ {"(*Writer).Flush", Method, 1},
+ {"(*Writer).Reset", Method, 2},
+ {"(*Writer).Write", Method, 0},
+ {"BestCompression", Const, 0},
+ {"BestSpeed", Const, 0},
+ {"DefaultCompression", Const, 0},
+ {"ErrChecksum", Var, 0},
+ {"ErrHeader", Var, 0},
+ {"Header", Type, 0},
+ {"Header.Comment", Field, 0},
+ {"Header.Extra", Field, 0},
+ {"Header.ModTime", Field, 0},
+ {"Header.Name", Field, 0},
+ {"Header.OS", Field, 0},
+ {"HuffmanOnly", Const, 8},
+ {"NewReader", Func, 0},
+ {"NewWriter", Func, 0},
+ {"NewWriterLevel", Func, 0},
+ {"NoCompression", Const, 0},
+ {"Reader", Type, 0},
+ {"Reader.Header", Field, 0},
+ {"Writer", Type, 0},
+ {"Writer.Header", Field, 0},
+ },
+ "compress/lzw": {
+ {"(*Reader).Close", Method, 17},
+ {"(*Reader).Read", Method, 17},
+ {"(*Reader).Reset", Method, 17},
+ {"(*Writer).Close", Method, 17},
+ {"(*Writer).Reset", Method, 17},
+ {"(*Writer).Write", Method, 17},
+ {"LSB", Const, 0},
+ {"MSB", Const, 0},
+ {"NewReader", Func, 0},
+ {"NewWriter", Func, 0},
+ {"Order", Type, 0},
+ {"Reader", Type, 17},
+ {"Writer", Type, 17},
+ },
+ "compress/zlib": {
+ {"(*Writer).Close", Method, 0},
+ {"(*Writer).Flush", Method, 0},
+ {"(*Writer).Reset", Method, 2},
+ {"(*Writer).Write", Method, 0},
+ {"BestCompression", Const, 0},
+ {"BestSpeed", Const, 0},
+ {"DefaultCompression", Const, 0},
+ {"ErrChecksum", Var, 0},
+ {"ErrDictionary", Var, 0},
+ {"ErrHeader", Var, 0},
+ {"HuffmanOnly", Const, 8},
+ {"NewReader", Func, 0},
+ {"NewReaderDict", Func, 0},
+ {"NewWriter", Func, 0},
+ {"NewWriterLevel", Func, 0},
+ {"NewWriterLevelDict", Func, 0},
+ {"NoCompression", Const, 0},
+ {"Resetter", Type, 4},
+ {"Writer", Type, 0},
+ },
+ "container/heap": {
+ {"Fix", Func, 2},
+ {"Init", Func, 0},
+ {"Interface", Type, 0},
+ {"Pop", Func, 0},
+ {"Push", Func, 0},
+ {"Remove", Func, 0},
+ },
+ "container/list": {
+ {"(*Element).Next", Method, 0},
+ {"(*Element).Prev", Method, 0},
+ {"(*List).Back", Method, 0},
+ {"(*List).Front", Method, 0},
+ {"(*List).Init", Method, 0},
+ {"(*List).InsertAfter", Method, 0},
+ {"(*List).InsertBefore", Method, 0},
+ {"(*List).Len", Method, 0},
+ {"(*List).MoveAfter", Method, 2},
+ {"(*List).MoveBefore", Method, 2},
+ {"(*List).MoveToBack", Method, 0},
+ {"(*List).MoveToFront", Method, 0},
+ {"(*List).PushBack", Method, 0},
+ {"(*List).PushBackList", Method, 0},
+ {"(*List).PushFront", Method, 0},
+ {"(*List).PushFrontList", Method, 0},
+ {"(*List).Remove", Method, 0},
+ {"Element", Type, 0},
+ {"Element.Value", Field, 0},
+ {"List", Type, 0},
+ {"New", Func, 0},
+ },
+ "container/ring": {
+ {"(*Ring).Do", Method, 0},
+ {"(*Ring).Len", Method, 0},
+ {"(*Ring).Link", Method, 0},
+ {"(*Ring).Move", Method, 0},
+ {"(*Ring).Next", Method, 0},
+ {"(*Ring).Prev", Method, 0},
+ {"(*Ring).Unlink", Method, 0},
+ {"New", Func, 0},
+ {"Ring", Type, 0},
+ {"Ring.Value", Field, 0},
+ },
+ "context": {
+ {"AfterFunc", Func, 21},
+ {"Background", Func, 7},
+ {"CancelCauseFunc", Type, 20},
+ {"CancelFunc", Type, 7},
+ {"Canceled", Var, 7},
+ {"Cause", Func, 20},
+ {"Context", Type, 7},
+ {"DeadlineExceeded", Var, 7},
+ {"TODO", Func, 7},
+ {"WithCancel", Func, 7},
+ {"WithCancelCause", Func, 20},
+ {"WithDeadline", Func, 7},
+ {"WithDeadlineCause", Func, 21},
+ {"WithTimeout", Func, 7},
+ {"WithTimeoutCause", Func, 21},
+ {"WithValue", Func, 7},
+ {"WithoutCancel", Func, 21},
+ },
+ "crypto": {
+ {"(Hash).Available", Method, 0},
+ {"(Hash).HashFunc", Method, 4},
+ {"(Hash).New", Method, 0},
+ {"(Hash).Size", Method, 0},
+ {"(Hash).String", Method, 15},
+ {"BLAKE2b_256", Const, 9},
+ {"BLAKE2b_384", Const, 9},
+ {"BLAKE2b_512", Const, 9},
+ {"BLAKE2s_256", Const, 9},
+ {"Decrypter", Type, 5},
+ {"DecrypterOpts", Type, 5},
+ {"Hash", Type, 0},
+ {"MD4", Const, 0},
+ {"MD5", Const, 0},
+ {"MD5SHA1", Const, 0},
+ {"PrivateKey", Type, 0},
+ {"PublicKey", Type, 2},
+ {"RIPEMD160", Const, 0},
+ {"RegisterHash", Func, 0},
+ {"SHA1", Const, 0},
+ {"SHA224", Const, 0},
+ {"SHA256", Const, 0},
+ {"SHA384", Const, 0},
+ {"SHA3_224", Const, 4},
+ {"SHA3_256", Const, 4},
+ {"SHA3_384", Const, 4},
+ {"SHA3_512", Const, 4},
+ {"SHA512", Const, 0},
+ {"SHA512_224", Const, 5},
+ {"SHA512_256", Const, 5},
+ {"Signer", Type, 4},
+ {"SignerOpts", Type, 4},
+ },
+ "crypto/aes": {
+ {"(KeySizeError).Error", Method, 0},
+ {"BlockSize", Const, 0},
+ {"KeySizeError", Type, 0},
+ {"NewCipher", Func, 0},
+ },
+ "crypto/cipher": {
+ {"(StreamReader).Read", Method, 0},
+ {"(StreamWriter).Close", Method, 0},
+ {"(StreamWriter).Write", Method, 0},
+ {"AEAD", Type, 2},
+ {"Block", Type, 0},
+ {"BlockMode", Type, 0},
+ {"NewCBCDecrypter", Func, 0},
+ {"NewCBCEncrypter", Func, 0},
+ {"NewCFBDecrypter", Func, 0},
+ {"NewCFBEncrypter", Func, 0},
+ {"NewCTR", Func, 0},
+ {"NewGCM", Func, 2},
+ {"NewGCMWithNonceSize", Func, 5},
+ {"NewGCMWithTagSize", Func, 11},
+ {"NewOFB", Func, 0},
+ {"Stream", Type, 0},
+ {"StreamReader", Type, 0},
+ {"StreamReader.R", Field, 0},
+ {"StreamReader.S", Field, 0},
+ {"StreamWriter", Type, 0},
+ {"StreamWriter.Err", Field, 0},
+ {"StreamWriter.S", Field, 0},
+ {"StreamWriter.W", Field, 0},
+ },
+ "crypto/des": {
+ {"(KeySizeError).Error", Method, 0},
+ {"BlockSize", Const, 0},
+ {"KeySizeError", Type, 0},
+ {"NewCipher", Func, 0},
+ {"NewTripleDESCipher", Func, 0},
+ },
+ "crypto/dsa": {
+ {"ErrInvalidPublicKey", Var, 0},
+ {"GenerateKey", Func, 0},
+ {"GenerateParameters", Func, 0},
+ {"L1024N160", Const, 0},
+ {"L2048N224", Const, 0},
+ {"L2048N256", Const, 0},
+ {"L3072N256", Const, 0},
+ {"ParameterSizes", Type, 0},
+ {"Parameters", Type, 0},
+ {"Parameters.G", Field, 0},
+ {"Parameters.P", Field, 0},
+ {"Parameters.Q", Field, 0},
+ {"PrivateKey", Type, 0},
+ {"PrivateKey.PublicKey", Field, 0},
+ {"PrivateKey.X", Field, 0},
+ {"PublicKey", Type, 0},
+ {"PublicKey.Parameters", Field, 0},
+ {"PublicKey.Y", Field, 0},
+ {"Sign", Func, 0},
+ {"Verify", Func, 0},
+ },
+ "crypto/ecdh": {
+ {"(*PrivateKey).Bytes", Method, 20},
+ {"(*PrivateKey).Curve", Method, 20},
+ {"(*PrivateKey).ECDH", Method, 20},
+ {"(*PrivateKey).Equal", Method, 20},
+ {"(*PrivateKey).Public", Method, 20},
+ {"(*PrivateKey).PublicKey", Method, 20},
+ {"(*PublicKey).Bytes", Method, 20},
+ {"(*PublicKey).Curve", Method, 20},
+ {"(*PublicKey).Equal", Method, 20},
+ {"Curve", Type, 20},
+ {"P256", Func, 20},
+ {"P384", Func, 20},
+ {"P521", Func, 20},
+ {"PrivateKey", Type, 20},
+ {"PublicKey", Type, 20},
+ {"X25519", Func, 20},
+ },
+ "crypto/ecdsa": {
+ {"(*PrivateKey).ECDH", Method, 20},
+ {"(*PrivateKey).Equal", Method, 15},
+ {"(*PrivateKey).Public", Method, 4},
+ {"(*PrivateKey).Sign", Method, 4},
+ {"(*PublicKey).ECDH", Method, 20},
+ {"(*PublicKey).Equal", Method, 15},
+ {"(PrivateKey).Add", Method, 0},
+ {"(PrivateKey).Double", Method, 0},
+ {"(PrivateKey).IsOnCurve", Method, 0},
+ {"(PrivateKey).Params", Method, 0},
+ {"(PrivateKey).ScalarBaseMult", Method, 0},
+ {"(PrivateKey).ScalarMult", Method, 0},
+ {"(PublicKey).Add", Method, 0},
+ {"(PublicKey).Double", Method, 0},
+ {"(PublicKey).IsOnCurve", Method, 0},
+ {"(PublicKey).Params", Method, 0},
+ {"(PublicKey).ScalarBaseMult", Method, 0},
+ {"(PublicKey).ScalarMult", Method, 0},
+ {"GenerateKey", Func, 0},
+ {"PrivateKey", Type, 0},
+ {"PrivateKey.D", Field, 0},
+ {"PrivateKey.PublicKey", Field, 0},
+ {"PublicKey", Type, 0},
+ {"PublicKey.Curve", Field, 0},
+ {"PublicKey.X", Field, 0},
+ {"PublicKey.Y", Field, 0},
+ {"Sign", Func, 0},
+ {"SignASN1", Func, 15},
+ {"Verify", Func, 0},
+ {"VerifyASN1", Func, 15},
+ },
+ "crypto/ed25519": {
+ {"(*Options).HashFunc", Method, 20},
+ {"(PrivateKey).Equal", Method, 15},
+ {"(PrivateKey).Public", Method, 13},
+ {"(PrivateKey).Seed", Method, 13},
+ {"(PrivateKey).Sign", Method, 13},
+ {"(PublicKey).Equal", Method, 15},
+ {"GenerateKey", Func, 13},
+ {"NewKeyFromSeed", Func, 13},
+ {"Options", Type, 20},
+ {"Options.Context", Field, 20},
+ {"Options.Hash", Field, 20},
+ {"PrivateKey", Type, 13},
+ {"PrivateKeySize", Const, 13},
+ {"PublicKey", Type, 13},
+ {"PublicKeySize", Const, 13},
+ {"SeedSize", Const, 13},
+ {"Sign", Func, 13},
+ {"SignatureSize", Const, 13},
+ {"Verify", Func, 13},
+ {"VerifyWithOptions", Func, 20},
+ },
+ "crypto/elliptic": {
+ {"(*CurveParams).Add", Method, 0},
+ {"(*CurveParams).Double", Method, 0},
+ {"(*CurveParams).IsOnCurve", Method, 0},
+ {"(*CurveParams).Params", Method, 0},
+ {"(*CurveParams).ScalarBaseMult", Method, 0},
+ {"(*CurveParams).ScalarMult", Method, 0},
+ {"Curve", Type, 0},
+ {"CurveParams", Type, 0},
+ {"CurveParams.B", Field, 0},
+ {"CurveParams.BitSize", Field, 0},
+ {"CurveParams.Gx", Field, 0},
+ {"CurveParams.Gy", Field, 0},
+ {"CurveParams.N", Field, 0},
+ {"CurveParams.Name", Field, 5},
+ {"CurveParams.P", Field, 0},
+ {"GenerateKey", Func, 0},
+ {"Marshal", Func, 0},
+ {"MarshalCompressed", Func, 15},
+ {"P224", Func, 0},
+ {"P256", Func, 0},
+ {"P384", Func, 0},
+ {"P521", Func, 0},
+ {"Unmarshal", Func, 0},
+ {"UnmarshalCompressed", Func, 15},
+ },
+ "crypto/hmac": {
+ {"Equal", Func, 1},
+ {"New", Func, 0},
+ },
+ "crypto/md5": {
+ {"BlockSize", Const, 0},
+ {"New", Func, 0},
+ {"Size", Const, 0},
+ {"Sum", Func, 2},
+ },
+ "crypto/rand": {
+ {"Int", Func, 0},
+ {"Prime", Func, 0},
+ {"Read", Func, 0},
+ {"Reader", Var, 0},
+ },
+ "crypto/rc4": {
+ {"(*Cipher).Reset", Method, 0},
+ {"(*Cipher).XORKeyStream", Method, 0},
+ {"(KeySizeError).Error", Method, 0},
+ {"Cipher", Type, 0},
+ {"KeySizeError", Type, 0},
+ {"NewCipher", Func, 0},
+ },
+ "crypto/rsa": {
+ {"(*PSSOptions).HashFunc", Method, 4},
+ {"(*PrivateKey).Decrypt", Method, 5},
+ {"(*PrivateKey).Equal", Method, 15},
+ {"(*PrivateKey).Precompute", Method, 0},
+ {"(*PrivateKey).Public", Method, 4},
+ {"(*PrivateKey).Sign", Method, 4},
+ {"(*PrivateKey).Size", Method, 11},
+ {"(*PrivateKey).Validate", Method, 0},
+ {"(*PublicKey).Equal", Method, 15},
+ {"(*PublicKey).Size", Method, 11},
+ {"CRTValue", Type, 0},
+ {"CRTValue.Coeff", Field, 0},
+ {"CRTValue.Exp", Field, 0},
+ {"CRTValue.R", Field, 0},
+ {"DecryptOAEP", Func, 0},
+ {"DecryptPKCS1v15", Func, 0},
+ {"DecryptPKCS1v15SessionKey", Func, 0},
+ {"EncryptOAEP", Func, 0},
+ {"EncryptPKCS1v15", Func, 0},
+ {"ErrDecryption", Var, 0},
+ {"ErrMessageTooLong", Var, 0},
+ {"ErrVerification", Var, 0},
+ {"GenerateKey", Func, 0},
+ {"GenerateMultiPrimeKey", Func, 0},
+ {"OAEPOptions", Type, 5},
+ {"OAEPOptions.Hash", Field, 5},
+ {"OAEPOptions.Label", Field, 5},
+ {"OAEPOptions.MGFHash", Field, 20},
+ {"PKCS1v15DecryptOptions", Type, 5},
+ {"PKCS1v15DecryptOptions.SessionKeyLen", Field, 5},
+ {"PSSOptions", Type, 2},
+ {"PSSOptions.Hash", Field, 4},
+ {"PSSOptions.SaltLength", Field, 2},
+ {"PSSSaltLengthAuto", Const, 2},
+ {"PSSSaltLengthEqualsHash", Const, 2},
+ {"PrecomputedValues", Type, 0},
+ {"PrecomputedValues.CRTValues", Field, 0},
+ {"PrecomputedValues.Dp", Field, 0},
+ {"PrecomputedValues.Dq", Field, 0},
+ {"PrecomputedValues.Qinv", Field, 0},
+ {"PrivateKey", Type, 0},
+ {"PrivateKey.D", Field, 0},
+ {"PrivateKey.Precomputed", Field, 0},
+ {"PrivateKey.Primes", Field, 0},
+ {"PrivateKey.PublicKey", Field, 0},
+ {"PublicKey", Type, 0},
+ {"PublicKey.E", Field, 0},
+ {"PublicKey.N", Field, 0},
+ {"SignPKCS1v15", Func, 0},
+ {"SignPSS", Func, 2},
+ {"VerifyPKCS1v15", Func, 0},
+ {"VerifyPSS", Func, 2},
+ },
+ "crypto/sha1": {
+ {"BlockSize", Const, 0},
+ {"New", Func, 0},
+ {"Size", Const, 0},
+ {"Sum", Func, 2},
+ },
+ "crypto/sha256": {
+ {"BlockSize", Const, 0},
+ {"New", Func, 0},
+ {"New224", Func, 0},
+ {"Size", Const, 0},
+ {"Size224", Const, 0},
+ {"Sum224", Func, 2},
+ {"Sum256", Func, 2},
+ },
+ "crypto/sha512": {
+ {"BlockSize", Const, 0},
+ {"New", Func, 0},
+ {"New384", Func, 0},
+ {"New512_224", Func, 5},
+ {"New512_256", Func, 5},
+ {"Size", Const, 0},
+ {"Size224", Const, 5},
+ {"Size256", Const, 5},
+ {"Size384", Const, 0},
+ {"Sum384", Func, 2},
+ {"Sum512", Func, 2},
+ {"Sum512_224", Func, 5},
+ {"Sum512_256", Func, 5},
+ },
+ "crypto/subtle": {
+ {"ConstantTimeByteEq", Func, 0},
+ {"ConstantTimeCompare", Func, 0},
+ {"ConstantTimeCopy", Func, 0},
+ {"ConstantTimeEq", Func, 0},
+ {"ConstantTimeLessOrEq", Func, 2},
+ {"ConstantTimeSelect", Func, 0},
+ {"XORBytes", Func, 20},
+ },
+ "crypto/tls": {
+ {"(*CertificateRequestInfo).Context", Method, 17},
+ {"(*CertificateRequestInfo).SupportsCertificate", Method, 14},
+ {"(*CertificateVerificationError).Error", Method, 20},
+ {"(*CertificateVerificationError).Unwrap", Method, 20},
+ {"(*ClientHelloInfo).Context", Method, 17},
+ {"(*ClientHelloInfo).SupportsCertificate", Method, 14},
+ {"(*ClientSessionState).ResumptionState", Method, 21},
+ {"(*Config).BuildNameToCertificate", Method, 0},
+ {"(*Config).Clone", Method, 8},
+ {"(*Config).DecryptTicket", Method, 21},
+ {"(*Config).EncryptTicket", Method, 21},
+ {"(*Config).SetSessionTicketKeys", Method, 5},
+ {"(*Conn).Close", Method, 0},
+ {"(*Conn).CloseWrite", Method, 8},
+ {"(*Conn).ConnectionState", Method, 0},
+ {"(*Conn).Handshake", Method, 0},
+ {"(*Conn).HandshakeContext", Method, 17},
+ {"(*Conn).LocalAddr", Method, 0},
+ {"(*Conn).NetConn", Method, 18},
+ {"(*Conn).OCSPResponse", Method, 0},
+ {"(*Conn).Read", Method, 0},
+ {"(*Conn).RemoteAddr", Method, 0},
+ {"(*Conn).SetDeadline", Method, 0},
+ {"(*Conn).SetReadDeadline", Method, 0},
+ {"(*Conn).SetWriteDeadline", Method, 0},
+ {"(*Conn).VerifyHostname", Method, 0},
+ {"(*Conn).Write", Method, 0},
+ {"(*ConnectionState).ExportKeyingMaterial", Method, 11},
+ {"(*Dialer).Dial", Method, 15},
+ {"(*Dialer).DialContext", Method, 15},
+ {"(*ECHRejectionError).Error", Method, 23},
+ {"(*QUICConn).Close", Method, 21},
+ {"(*QUICConn).ConnectionState", Method, 21},
+ {"(*QUICConn).HandleData", Method, 21},
+ {"(*QUICConn).NextEvent", Method, 21},
+ {"(*QUICConn).SendSessionTicket", Method, 21},
+ {"(*QUICConn).SetTransportParameters", Method, 21},
+ {"(*QUICConn).Start", Method, 21},
+ {"(*QUICConn).StoreSession", Method, 23},
+ {"(*SessionState).Bytes", Method, 21},
+ {"(AlertError).Error", Method, 21},
+ {"(ClientAuthType).String", Method, 15},
+ {"(CurveID).String", Method, 15},
+ {"(QUICEncryptionLevel).String", Method, 21},
+ {"(RecordHeaderError).Error", Method, 6},
+ {"(SignatureScheme).String", Method, 15},
+ {"AlertError", Type, 21},
+ {"Certificate", Type, 0},
+ {"Certificate.Certificate", Field, 0},
+ {"Certificate.Leaf", Field, 0},
+ {"Certificate.OCSPStaple", Field, 0},
+ {"Certificate.PrivateKey", Field, 0},
+ {"Certificate.SignedCertificateTimestamps", Field, 5},
+ {"Certificate.SupportedSignatureAlgorithms", Field, 14},
+ {"CertificateRequestInfo", Type, 8},
+ {"CertificateRequestInfo.AcceptableCAs", Field, 8},
+ {"CertificateRequestInfo.SignatureSchemes", Field, 8},
+ {"CertificateRequestInfo.Version", Field, 14},
+ {"CertificateVerificationError", Type, 20},
+ {"CertificateVerificationError.Err", Field, 20},
+ {"CertificateVerificationError.UnverifiedCertificates", Field, 20},
+ {"CipherSuite", Type, 14},
+ {"CipherSuite.ID", Field, 14},
+ {"CipherSuite.Insecure", Field, 14},
+ {"CipherSuite.Name", Field, 14},
+ {"CipherSuite.SupportedVersions", Field, 14},
+ {"CipherSuiteName", Func, 14},
+ {"CipherSuites", Func, 14},
+ {"Client", Func, 0},
+ {"ClientAuthType", Type, 0},
+ {"ClientHelloInfo", Type, 4},
+ {"ClientHelloInfo.CipherSuites", Field, 4},
+ {"ClientHelloInfo.Conn", Field, 8},
+ {"ClientHelloInfo.ServerName", Field, 4},
+ {"ClientHelloInfo.SignatureSchemes", Field, 8},
+ {"ClientHelloInfo.SupportedCurves", Field, 4},
+ {"ClientHelloInfo.SupportedPoints", Field, 4},
+ {"ClientHelloInfo.SupportedProtos", Field, 8},
+ {"ClientHelloInfo.SupportedVersions", Field, 8},
+ {"ClientSessionCache", Type, 3},
+ {"ClientSessionState", Type, 3},
+ {"Config", Type, 0},
+ {"Config.Certificates", Field, 0},
+ {"Config.CipherSuites", Field, 0},
+ {"Config.ClientAuth", Field, 0},
+ {"Config.ClientCAs", Field, 0},
+ {"Config.ClientSessionCache", Field, 3},
+ {"Config.CurvePreferences", Field, 3},
+ {"Config.DynamicRecordSizingDisabled", Field, 7},
+ {"Config.EncryptedClientHelloConfigList", Field, 23},
+ {"Config.EncryptedClientHelloRejectionVerify", Field, 23},
+ {"Config.GetCertificate", Field, 4},
+ {"Config.GetClientCertificate", Field, 8},
+ {"Config.GetConfigForClient", Field, 8},
+ {"Config.InsecureSkipVerify", Field, 0},
+ {"Config.KeyLogWriter", Field, 8},
+ {"Config.MaxVersion", Field, 2},
+ {"Config.MinVersion", Field, 2},
+ {"Config.NameToCertificate", Field, 0},
+ {"Config.NextProtos", Field, 0},
+ {"Config.PreferServerCipherSuites", Field, 1},
+ {"Config.Rand", Field, 0},
+ {"Config.Renegotiation", Field, 7},
+ {"Config.RootCAs", Field, 0},
+ {"Config.ServerName", Field, 0},
+ {"Config.SessionTicketKey", Field, 1},
+ {"Config.SessionTicketsDisabled", Field, 1},
+ {"Config.Time", Field, 0},
+ {"Config.UnwrapSession", Field, 21},
+ {"Config.VerifyConnection", Field, 15},
+ {"Config.VerifyPeerCertificate", Field, 8},
+ {"Config.WrapSession", Field, 21},
+ {"Conn", Type, 0},
+ {"ConnectionState", Type, 0},
+ {"ConnectionState.CipherSuite", Field, 0},
+ {"ConnectionState.DidResume", Field, 1},
+ {"ConnectionState.ECHAccepted", Field, 23},
+ {"ConnectionState.HandshakeComplete", Field, 0},
+ {"ConnectionState.NegotiatedProtocol", Field, 0},
+ {"ConnectionState.NegotiatedProtocolIsMutual", Field, 0},
+ {"ConnectionState.OCSPResponse", Field, 5},
+ {"ConnectionState.PeerCertificates", Field, 0},
+ {"ConnectionState.ServerName", Field, 0},
+ {"ConnectionState.SignedCertificateTimestamps", Field, 5},
+ {"ConnectionState.TLSUnique", Field, 4},
+ {"ConnectionState.VerifiedChains", Field, 0},
+ {"ConnectionState.Version", Field, 3},
+ {"CurveID", Type, 3},
+ {"CurveP256", Const, 3},
+ {"CurveP384", Const, 3},
+ {"CurveP521", Const, 3},
+ {"Dial", Func, 0},
+ {"DialWithDialer", Func, 3},
+ {"Dialer", Type, 15},
+ {"Dialer.Config", Field, 15},
+ {"Dialer.NetDialer", Field, 15},
+ {"ECDSAWithP256AndSHA256", Const, 8},
+ {"ECDSAWithP384AndSHA384", Const, 8},
+ {"ECDSAWithP521AndSHA512", Const, 8},
+ {"ECDSAWithSHA1", Const, 10},
+ {"ECHRejectionError", Type, 23},
+ {"ECHRejectionError.RetryConfigList", Field, 23},
+ {"Ed25519", Const, 13},
+ {"InsecureCipherSuites", Func, 14},
+ {"Listen", Func, 0},
+ {"LoadX509KeyPair", Func, 0},
+ {"NewLRUClientSessionCache", Func, 3},
+ {"NewListener", Func, 0},
+ {"NewResumptionState", Func, 21},
+ {"NoClientCert", Const, 0},
+ {"PKCS1WithSHA1", Const, 8},
+ {"PKCS1WithSHA256", Const, 8},
+ {"PKCS1WithSHA384", Const, 8},
+ {"PKCS1WithSHA512", Const, 8},
+ {"PSSWithSHA256", Const, 8},
+ {"PSSWithSHA384", Const, 8},
+ {"PSSWithSHA512", Const, 8},
+ {"ParseSessionState", Func, 21},
+ {"QUICClient", Func, 21},
+ {"QUICConfig", Type, 21},
+ {"QUICConfig.EnableSessionEvents", Field, 23},
+ {"QUICConfig.TLSConfig", Field, 21},
+ {"QUICConn", Type, 21},
+ {"QUICEncryptionLevel", Type, 21},
+ {"QUICEncryptionLevelApplication", Const, 21},
+ {"QUICEncryptionLevelEarly", Const, 21},
+ {"QUICEncryptionLevelHandshake", Const, 21},
+ {"QUICEncryptionLevelInitial", Const, 21},
+ {"QUICEvent", Type, 21},
+ {"QUICEvent.Data", Field, 21},
+ {"QUICEvent.Kind", Field, 21},
+ {"QUICEvent.Level", Field, 21},
+ {"QUICEvent.SessionState", Field, 23},
+ {"QUICEvent.Suite", Field, 21},
+ {"QUICEventKind", Type, 21},
+ {"QUICHandshakeDone", Const, 21},
+ {"QUICNoEvent", Const, 21},
+ {"QUICRejectedEarlyData", Const, 21},
+ {"QUICResumeSession", Const, 23},
+ {"QUICServer", Func, 21},
+ {"QUICSessionTicketOptions", Type, 21},
+ {"QUICSessionTicketOptions.EarlyData", Field, 21},
+ {"QUICSessionTicketOptions.Extra", Field, 23},
+ {"QUICSetReadSecret", Const, 21},
+ {"QUICSetWriteSecret", Const, 21},
+ {"QUICStoreSession", Const, 23},
+ {"QUICTransportParameters", Const, 21},
+ {"QUICTransportParametersRequired", Const, 21},
+ {"QUICWriteData", Const, 21},
+ {"RecordHeaderError", Type, 6},
+ {"RecordHeaderError.Conn", Field, 12},
+ {"RecordHeaderError.Msg", Field, 6},
+ {"RecordHeaderError.RecordHeader", Field, 6},
+ {"RenegotiateFreelyAsClient", Const, 7},
+ {"RenegotiateNever", Const, 7},
+ {"RenegotiateOnceAsClient", Const, 7},
+ {"RenegotiationSupport", Type, 7},
+ {"RequestClientCert", Const, 0},
+ {"RequireAndVerifyClientCert", Const, 0},
+ {"RequireAnyClientCert", Const, 0},
+ {"Server", Func, 0},
+ {"SessionState", Type, 21},
+ {"SessionState.EarlyData", Field, 21},
+ {"SessionState.Extra", Field, 21},
+ {"SignatureScheme", Type, 8},
+ {"TLS_AES_128_GCM_SHA256", Const, 12},
+ {"TLS_AES_256_GCM_SHA384", Const, 12},
+ {"TLS_CHACHA20_POLY1305_SHA256", Const, 12},
+ {"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA", Const, 2},
+ {"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256", Const, 8},
+ {"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256", Const, 2},
+ {"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA", Const, 2},
+ {"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384", Const, 5},
+ {"TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305", Const, 8},
+ {"TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256", Const, 14},
+ {"TLS_ECDHE_ECDSA_WITH_RC4_128_SHA", Const, 2},
+ {"TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA", Const, 0},
+ {"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA", Const, 0},
+ {"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256", Const, 8},
+ {"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256", Const, 2},
+ {"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA", Const, 1},
+ {"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384", Const, 5},
+ {"TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305", Const, 8},
+ {"TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256", Const, 14},
+ {"TLS_ECDHE_RSA_WITH_RC4_128_SHA", Const, 0},
+ {"TLS_FALLBACK_SCSV", Const, 4},
+ {"TLS_RSA_WITH_3DES_EDE_CBC_SHA", Const, 0},
+ {"TLS_RSA_WITH_AES_128_CBC_SHA", Const, 0},
+ {"TLS_RSA_WITH_AES_128_CBC_SHA256", Const, 8},
+ {"TLS_RSA_WITH_AES_128_GCM_SHA256", Const, 6},
+ {"TLS_RSA_WITH_AES_256_CBC_SHA", Const, 1},
+ {"TLS_RSA_WITH_AES_256_GCM_SHA384", Const, 6},
+ {"TLS_RSA_WITH_RC4_128_SHA", Const, 0},
+ {"VerifyClientCertIfGiven", Const, 0},
+ {"VersionName", Func, 21},
+ {"VersionSSL30", Const, 2},
+ {"VersionTLS10", Const, 2},
+ {"VersionTLS11", Const, 2},
+ {"VersionTLS12", Const, 2},
+ {"VersionTLS13", Const, 12},
+ {"X25519", Const, 8},
+ {"X509KeyPair", Func, 0},
+ },
+ "crypto/x509": {
+ {"(*CertPool).AddCert", Method, 0},
+ {"(*CertPool).AddCertWithConstraint", Method, 22},
+ {"(*CertPool).AppendCertsFromPEM", Method, 0},
+ {"(*CertPool).Clone", Method, 19},
+ {"(*CertPool).Equal", Method, 19},
+ {"(*CertPool).Subjects", Method, 0},
+ {"(*Certificate).CheckCRLSignature", Method, 0},
+ {"(*Certificate).CheckSignature", Method, 0},
+ {"(*Certificate).CheckSignatureFrom", Method, 0},
+ {"(*Certificate).CreateCRL", Method, 0},
+ {"(*Certificate).Equal", Method, 0},
+ {"(*Certificate).Verify", Method, 0},
+ {"(*Certificate).VerifyHostname", Method, 0},
+ {"(*CertificateRequest).CheckSignature", Method, 5},
+ {"(*OID).UnmarshalBinary", Method, 23},
+ {"(*OID).UnmarshalText", Method, 23},
+ {"(*RevocationList).CheckSignatureFrom", Method, 19},
+ {"(CertificateInvalidError).Error", Method, 0},
+ {"(ConstraintViolationError).Error", Method, 0},
+ {"(HostnameError).Error", Method, 0},
+ {"(InsecureAlgorithmError).Error", Method, 6},
+ {"(OID).Equal", Method, 22},
+ {"(OID).EqualASN1OID", Method, 22},
+ {"(OID).MarshalBinary", Method, 23},
+ {"(OID).MarshalText", Method, 23},
+ {"(OID).String", Method, 22},
+ {"(PublicKeyAlgorithm).String", Method, 10},
+ {"(SignatureAlgorithm).String", Method, 6},
+ {"(SystemRootsError).Error", Method, 1},
+ {"(SystemRootsError).Unwrap", Method, 16},
+ {"(UnhandledCriticalExtension).Error", Method, 0},
+ {"(UnknownAuthorityError).Error", Method, 0},
+ {"CANotAuthorizedForExtKeyUsage", Const, 10},
+ {"CANotAuthorizedForThisName", Const, 0},
+ {"CertPool", Type, 0},
+ {"Certificate", Type, 0},
+ {"Certificate.AuthorityKeyId", Field, 0},
+ {"Certificate.BasicConstraintsValid", Field, 0},
+ {"Certificate.CRLDistributionPoints", Field, 2},
+ {"Certificate.DNSNames", Field, 0},
+ {"Certificate.EmailAddresses", Field, 0},
+ {"Certificate.ExcludedDNSDomains", Field, 9},
+ {"Certificate.ExcludedEmailAddresses", Field, 10},
+ {"Certificate.ExcludedIPRanges", Field, 10},
+ {"Certificate.ExcludedURIDomains", Field, 10},
+ {"Certificate.ExtKeyUsage", Field, 0},
+ {"Certificate.Extensions", Field, 2},
+ {"Certificate.ExtraExtensions", Field, 2},
+ {"Certificate.IPAddresses", Field, 1},
+ {"Certificate.IsCA", Field, 0},
+ {"Certificate.Issuer", Field, 0},
+ {"Certificate.IssuingCertificateURL", Field, 2},
+ {"Certificate.KeyUsage", Field, 0},
+ {"Certificate.MaxPathLen", Field, 0},
+ {"Certificate.MaxPathLenZero", Field, 4},
+ {"Certificate.NotAfter", Field, 0},
+ {"Certificate.NotBefore", Field, 0},
+ {"Certificate.OCSPServer", Field, 2},
+ {"Certificate.PermittedDNSDomains", Field, 0},
+ {"Certificate.PermittedDNSDomainsCritical", Field, 0},
+ {"Certificate.PermittedEmailAddresses", Field, 10},
+ {"Certificate.PermittedIPRanges", Field, 10},
+ {"Certificate.PermittedURIDomains", Field, 10},
+ {"Certificate.Policies", Field, 22},
+ {"Certificate.PolicyIdentifiers", Field, 0},
+ {"Certificate.PublicKey", Field, 0},
+ {"Certificate.PublicKeyAlgorithm", Field, 0},
+ {"Certificate.Raw", Field, 0},
+ {"Certificate.RawIssuer", Field, 0},
+ {"Certificate.RawSubject", Field, 0},
+ {"Certificate.RawSubjectPublicKeyInfo", Field, 0},
+ {"Certificate.RawTBSCertificate", Field, 0},
+ {"Certificate.SerialNumber", Field, 0},
+ {"Certificate.Signature", Field, 0},
+ {"Certificate.SignatureAlgorithm", Field, 0},
+ {"Certificate.Subject", Field, 0},
+ {"Certificate.SubjectKeyId", Field, 0},
+ {"Certificate.URIs", Field, 10},
+ {"Certificate.UnhandledCriticalExtensions", Field, 5},
+ {"Certificate.UnknownExtKeyUsage", Field, 0},
+ {"Certificate.Version", Field, 0},
+ {"CertificateInvalidError", Type, 0},
+ {"CertificateInvalidError.Cert", Field, 0},
+ {"CertificateInvalidError.Detail", Field, 10},
+ {"CertificateInvalidError.Reason", Field, 0},
+ {"CertificateRequest", Type, 3},
+ {"CertificateRequest.Attributes", Field, 3},
+ {"CertificateRequest.DNSNames", Field, 3},
+ {"CertificateRequest.EmailAddresses", Field, 3},
+ {"CertificateRequest.Extensions", Field, 3},
+ {"CertificateRequest.ExtraExtensions", Field, 3},
+ {"CertificateRequest.IPAddresses", Field, 3},
+ {"CertificateRequest.PublicKey", Field, 3},
+ {"CertificateRequest.PublicKeyAlgorithm", Field, 3},
+ {"CertificateRequest.Raw", Field, 3},
+ {"CertificateRequest.RawSubject", Field, 3},
+ {"CertificateRequest.RawSubjectPublicKeyInfo", Field, 3},
+ {"CertificateRequest.RawTBSCertificateRequest", Field, 3},
+ {"CertificateRequest.Signature", Field, 3},
+ {"CertificateRequest.SignatureAlgorithm", Field, 3},
+ {"CertificateRequest.Subject", Field, 3},
+ {"CertificateRequest.URIs", Field, 10},
+ {"CertificateRequest.Version", Field, 3},
+ {"ConstraintViolationError", Type, 0},
+ {"CreateCertificate", Func, 0},
+ {"CreateCertificateRequest", Func, 3},
+ {"CreateRevocationList", Func, 15},
+ {"DSA", Const, 0},
+ {"DSAWithSHA1", Const, 0},
+ {"DSAWithSHA256", Const, 0},
+ {"DecryptPEMBlock", Func, 1},
+ {"ECDSA", Const, 1},
+ {"ECDSAWithSHA1", Const, 1},
+ {"ECDSAWithSHA256", Const, 1},
+ {"ECDSAWithSHA384", Const, 1},
+ {"ECDSAWithSHA512", Const, 1},
+ {"Ed25519", Const, 13},
+ {"EncryptPEMBlock", Func, 1},
+ {"ErrUnsupportedAlgorithm", Var, 0},
+ {"Expired", Const, 0},
+ {"ExtKeyUsage", Type, 0},
+ {"ExtKeyUsageAny", Const, 0},
+ {"ExtKeyUsageClientAuth", Const, 0},
+ {"ExtKeyUsageCodeSigning", Const, 0},
+ {"ExtKeyUsageEmailProtection", Const, 0},
+ {"ExtKeyUsageIPSECEndSystem", Const, 1},
+ {"ExtKeyUsageIPSECTunnel", Const, 1},
+ {"ExtKeyUsageIPSECUser", Const, 1},
+ {"ExtKeyUsageMicrosoftCommercialCodeSigning", Const, 10},
+ {"ExtKeyUsageMicrosoftKernelCodeSigning", Const, 10},
+ {"ExtKeyUsageMicrosoftServerGatedCrypto", Const, 1},
+ {"ExtKeyUsageNetscapeServerGatedCrypto", Const, 1},
+ {"ExtKeyUsageOCSPSigning", Const, 0},
+ {"ExtKeyUsageServerAuth", Const, 0},
+ {"ExtKeyUsageTimeStamping", Const, 0},
+ {"HostnameError", Type, 0},
+ {"HostnameError.Certificate", Field, 0},
+ {"HostnameError.Host", Field, 0},
+ {"IncompatibleUsage", Const, 1},
+ {"IncorrectPasswordError", Var, 1},
+ {"InsecureAlgorithmError", Type, 6},
+ {"InvalidReason", Type, 0},
+ {"IsEncryptedPEMBlock", Func, 1},
+ {"KeyUsage", Type, 0},
+ {"KeyUsageCRLSign", Const, 0},
+ {"KeyUsageCertSign", Const, 0},
+ {"KeyUsageContentCommitment", Const, 0},
+ {"KeyUsageDataEncipherment", Const, 0},
+ {"KeyUsageDecipherOnly", Const, 0},
+ {"KeyUsageDigitalSignature", Const, 0},
+ {"KeyUsageEncipherOnly", Const, 0},
+ {"KeyUsageKeyAgreement", Const, 0},
+ {"KeyUsageKeyEncipherment", Const, 0},
+ {"MD2WithRSA", Const, 0},
+ {"MD5WithRSA", Const, 0},
+ {"MarshalECPrivateKey", Func, 2},
+ {"MarshalPKCS1PrivateKey", Func, 0},
+ {"MarshalPKCS1PublicKey", Func, 10},
+ {"MarshalPKCS8PrivateKey", Func, 10},
+ {"MarshalPKIXPublicKey", Func, 0},
+ {"NameConstraintsWithoutSANs", Const, 10},
+ {"NameMismatch", Const, 8},
+ {"NewCertPool", Func, 0},
+ {"NotAuthorizedToSign", Const, 0},
+ {"OID", Type, 22},
+ {"OIDFromInts", Func, 22},
+ {"PEMCipher", Type, 1},
+ {"PEMCipher3DES", Const, 1},
+ {"PEMCipherAES128", Const, 1},
+ {"PEMCipherAES192", Const, 1},
+ {"PEMCipherAES256", Const, 1},
+ {"PEMCipherDES", Const, 1},
+ {"ParseCRL", Func, 0},
+ {"ParseCertificate", Func, 0},
+ {"ParseCertificateRequest", Func, 3},
+ {"ParseCertificates", Func, 0},
+ {"ParseDERCRL", Func, 0},
+ {"ParseECPrivateKey", Func, 1},
+ {"ParseOID", Func, 23},
+ {"ParsePKCS1PrivateKey", Func, 0},
+ {"ParsePKCS1PublicKey", Func, 10},
+ {"ParsePKCS8PrivateKey", Func, 0},
+ {"ParsePKIXPublicKey", Func, 0},
+ {"ParseRevocationList", Func, 19},
+ {"PublicKeyAlgorithm", Type, 0},
+ {"PureEd25519", Const, 13},
+ {"RSA", Const, 0},
+ {"RevocationList", Type, 15},
+ {"RevocationList.AuthorityKeyId", Field, 19},
+ {"RevocationList.Extensions", Field, 19},
+ {"RevocationList.ExtraExtensions", Field, 15},
+ {"RevocationList.Issuer", Field, 19},
+ {"RevocationList.NextUpdate", Field, 15},
+ {"RevocationList.Number", Field, 15},
+ {"RevocationList.Raw", Field, 19},
+ {"RevocationList.RawIssuer", Field, 19},
+ {"RevocationList.RawTBSRevocationList", Field, 19},
+ {"RevocationList.RevokedCertificateEntries", Field, 21},
+ {"RevocationList.RevokedCertificates", Field, 15},
+ {"RevocationList.Signature", Field, 19},
+ {"RevocationList.SignatureAlgorithm", Field, 15},
+ {"RevocationList.ThisUpdate", Field, 15},
+ {"RevocationListEntry", Type, 21},
+ {"RevocationListEntry.Extensions", Field, 21},
+ {"RevocationListEntry.ExtraExtensions", Field, 21},
+ {"RevocationListEntry.Raw", Field, 21},
+ {"RevocationListEntry.ReasonCode", Field, 21},
+ {"RevocationListEntry.RevocationTime", Field, 21},
+ {"RevocationListEntry.SerialNumber", Field, 21},
+ {"SHA1WithRSA", Const, 0},
+ {"SHA256WithRSA", Const, 0},
+ {"SHA256WithRSAPSS", Const, 8},
+ {"SHA384WithRSA", Const, 0},
+ {"SHA384WithRSAPSS", Const, 8},
+ {"SHA512WithRSA", Const, 0},
+ {"SHA512WithRSAPSS", Const, 8},
+ {"SetFallbackRoots", Func, 20},
+ {"SignatureAlgorithm", Type, 0},
+ {"SystemCertPool", Func, 7},
+ {"SystemRootsError", Type, 1},
+ {"SystemRootsError.Err", Field, 7},
+ {"TooManyConstraints", Const, 10},
+ {"TooManyIntermediates", Const, 0},
+ {"UnconstrainedName", Const, 10},
+ {"UnhandledCriticalExtension", Type, 0},
+ {"UnknownAuthorityError", Type, 0},
+ {"UnknownAuthorityError.Cert", Field, 8},
+ {"UnknownPublicKeyAlgorithm", Const, 0},
+ {"UnknownSignatureAlgorithm", Const, 0},
+ {"VerifyOptions", Type, 0},
+ {"VerifyOptions.CurrentTime", Field, 0},
+ {"VerifyOptions.DNSName", Field, 0},
+ {"VerifyOptions.Intermediates", Field, 0},
+ {"VerifyOptions.KeyUsages", Field, 1},
+ {"VerifyOptions.MaxConstraintComparisions", Field, 10},
+ {"VerifyOptions.Roots", Field, 0},
+ },
+ "crypto/x509/pkix": {
+ {"(*CertificateList).HasExpired", Method, 0},
+ {"(*Name).FillFromRDNSequence", Method, 0},
+ {"(Name).String", Method, 10},
+ {"(Name).ToRDNSequence", Method, 0},
+ {"(RDNSequence).String", Method, 10},
+ {"AlgorithmIdentifier", Type, 0},
+ {"AlgorithmIdentifier.Algorithm", Field, 0},
+ {"AlgorithmIdentifier.Parameters", Field, 0},
+ {"AttributeTypeAndValue", Type, 0},
+ {"AttributeTypeAndValue.Type", Field, 0},
+ {"AttributeTypeAndValue.Value", Field, 0},
+ {"AttributeTypeAndValueSET", Type, 3},
+ {"AttributeTypeAndValueSET.Type", Field, 3},
+ {"AttributeTypeAndValueSET.Value", Field, 3},
+ {"CertificateList", Type, 0},
+ {"CertificateList.SignatureAlgorithm", Field, 0},
+ {"CertificateList.SignatureValue", Field, 0},
+ {"CertificateList.TBSCertList", Field, 0},
+ {"Extension", Type, 0},
+ {"Extension.Critical", Field, 0},
+ {"Extension.Id", Field, 0},
+ {"Extension.Value", Field, 0},
+ {"Name", Type, 0},
+ {"Name.CommonName", Field, 0},
+ {"Name.Country", Field, 0},
+ {"Name.ExtraNames", Field, 5},
+ {"Name.Locality", Field, 0},
+ {"Name.Names", Field, 0},
+ {"Name.Organization", Field, 0},
+ {"Name.OrganizationalUnit", Field, 0},
+ {"Name.PostalCode", Field, 0},
+ {"Name.Province", Field, 0},
+ {"Name.SerialNumber", Field, 0},
+ {"Name.StreetAddress", Field, 0},
+ {"RDNSequence", Type, 0},
+ {"RelativeDistinguishedNameSET", Type, 0},
+ {"RevokedCertificate", Type, 0},
+ {"RevokedCertificate.Extensions", Field, 0},
+ {"RevokedCertificate.RevocationTime", Field, 0},
+ {"RevokedCertificate.SerialNumber", Field, 0},
+ {"TBSCertificateList", Type, 0},
+ {"TBSCertificateList.Extensions", Field, 0},
+ {"TBSCertificateList.Issuer", Field, 0},
+ {"TBSCertificateList.NextUpdate", Field, 0},
+ {"TBSCertificateList.Raw", Field, 0},
+ {"TBSCertificateList.RevokedCertificates", Field, 0},
+ {"TBSCertificateList.Signature", Field, 0},
+ {"TBSCertificateList.ThisUpdate", Field, 0},
+ {"TBSCertificateList.Version", Field, 0},
+ },
+ "database/sql": {
+ {"(*ColumnType).DatabaseTypeName", Method, 8},
+ {"(*ColumnType).DecimalSize", Method, 8},
+ {"(*ColumnType).Length", Method, 8},
+ {"(*ColumnType).Name", Method, 8},
+ {"(*ColumnType).Nullable", Method, 8},
+ {"(*ColumnType).ScanType", Method, 8},
+ {"(*Conn).BeginTx", Method, 9},
+ {"(*Conn).Close", Method, 9},
+ {"(*Conn).ExecContext", Method, 9},
+ {"(*Conn).PingContext", Method, 9},
+ {"(*Conn).PrepareContext", Method, 9},
+ {"(*Conn).QueryContext", Method, 9},
+ {"(*Conn).QueryRowContext", Method, 9},
+ {"(*Conn).Raw", Method, 13},
+ {"(*DB).Begin", Method, 0},
+ {"(*DB).BeginTx", Method, 8},
+ {"(*DB).Close", Method, 0},
+ {"(*DB).Conn", Method, 9},
+ {"(*DB).Driver", Method, 0},
+ {"(*DB).Exec", Method, 0},
+ {"(*DB).ExecContext", Method, 8},
+ {"(*DB).Ping", Method, 1},
+ {"(*DB).PingContext", Method, 8},
+ {"(*DB).Prepare", Method, 0},
+ {"(*DB).PrepareContext", Method, 8},
+ {"(*DB).Query", Method, 0},
+ {"(*DB).QueryContext", Method, 8},
+ {"(*DB).QueryRow", Method, 0},
+ {"(*DB).QueryRowContext", Method, 8},
+ {"(*DB).SetConnMaxIdleTime", Method, 15},
+ {"(*DB).SetConnMaxLifetime", Method, 6},
+ {"(*DB).SetMaxIdleConns", Method, 1},
+ {"(*DB).SetMaxOpenConns", Method, 2},
+ {"(*DB).Stats", Method, 5},
+ {"(*Null).Scan", Method, 22},
+ {"(*NullBool).Scan", Method, 0},
+ {"(*NullByte).Scan", Method, 17},
+ {"(*NullFloat64).Scan", Method, 0},
+ {"(*NullInt16).Scan", Method, 17},
+ {"(*NullInt32).Scan", Method, 13},
+ {"(*NullInt64).Scan", Method, 0},
+ {"(*NullString).Scan", Method, 0},
+ {"(*NullTime).Scan", Method, 13},
+ {"(*Row).Err", Method, 15},
+ {"(*Row).Scan", Method, 0},
+ {"(*Rows).Close", Method, 0},
+ {"(*Rows).ColumnTypes", Method, 8},
+ {"(*Rows).Columns", Method, 0},
+ {"(*Rows).Err", Method, 0},
+ {"(*Rows).Next", Method, 0},
+ {"(*Rows).NextResultSet", Method, 8},
+ {"(*Rows).Scan", Method, 0},
+ {"(*Stmt).Close", Method, 0},
+ {"(*Stmt).Exec", Method, 0},
+ {"(*Stmt).ExecContext", Method, 8},
+ {"(*Stmt).Query", Method, 0},
+ {"(*Stmt).QueryContext", Method, 8},
+ {"(*Stmt).QueryRow", Method, 0},
+ {"(*Stmt).QueryRowContext", Method, 8},
+ {"(*Tx).Commit", Method, 0},
+ {"(*Tx).Exec", Method, 0},
+ {"(*Tx).ExecContext", Method, 8},
+ {"(*Tx).Prepare", Method, 0},
+ {"(*Tx).PrepareContext", Method, 8},
+ {"(*Tx).Query", Method, 0},
+ {"(*Tx).QueryContext", Method, 8},
+ {"(*Tx).QueryRow", Method, 0},
+ {"(*Tx).QueryRowContext", Method, 8},
+ {"(*Tx).Rollback", Method, 0},
+ {"(*Tx).Stmt", Method, 0},
+ {"(*Tx).StmtContext", Method, 8},
+ {"(IsolationLevel).String", Method, 11},
+ {"(Null).Value", Method, 22},
+ {"(NullBool).Value", Method, 0},
+ {"(NullByte).Value", Method, 17},
+ {"(NullFloat64).Value", Method, 0},
+ {"(NullInt16).Value", Method, 17},
+ {"(NullInt32).Value", Method, 13},
+ {"(NullInt64).Value", Method, 0},
+ {"(NullString).Value", Method, 0},
+ {"(NullTime).Value", Method, 13},
+ {"ColumnType", Type, 8},
+ {"Conn", Type, 9},
+ {"DB", Type, 0},
+ {"DBStats", Type, 5},
+ {"DBStats.Idle", Field, 11},
+ {"DBStats.InUse", Field, 11},
+ {"DBStats.MaxIdleClosed", Field, 11},
+ {"DBStats.MaxIdleTimeClosed", Field, 15},
+ {"DBStats.MaxLifetimeClosed", Field, 11},
+ {"DBStats.MaxOpenConnections", Field, 11},
+ {"DBStats.OpenConnections", Field, 5},
+ {"DBStats.WaitCount", Field, 11},
+ {"DBStats.WaitDuration", Field, 11},
+ {"Drivers", Func, 4},
+ {"ErrConnDone", Var, 9},
+ {"ErrNoRows", Var, 0},
+ {"ErrTxDone", Var, 0},
+ {"IsolationLevel", Type, 8},
+ {"LevelDefault", Const, 8},
+ {"LevelLinearizable", Const, 8},
+ {"LevelReadCommitted", Const, 8},
+ {"LevelReadUncommitted", Const, 8},
+ {"LevelRepeatableRead", Const, 8},
+ {"LevelSerializable", Const, 8},
+ {"LevelSnapshot", Const, 8},
+ {"LevelWriteCommitted", Const, 8},
+ {"Named", Func, 8},
+ {"NamedArg", Type, 8},
+ {"NamedArg.Name", Field, 8},
+ {"NamedArg.Value", Field, 8},
+ {"Null", Type, 22},
+ {"Null.V", Field, 22},
+ {"Null.Valid", Field, 22},
+ {"NullBool", Type, 0},
+ {"NullBool.Bool", Field, 0},
+ {"NullBool.Valid", Field, 0},
+ {"NullByte", Type, 17},
+ {"NullByte.Byte", Field, 17},
+ {"NullByte.Valid", Field, 17},
+ {"NullFloat64", Type, 0},
+ {"NullFloat64.Float64", Field, 0},
+ {"NullFloat64.Valid", Field, 0},
+ {"NullInt16", Type, 17},
+ {"NullInt16.Int16", Field, 17},
+ {"NullInt16.Valid", Field, 17},
+ {"NullInt32", Type, 13},
+ {"NullInt32.Int32", Field, 13},
+ {"NullInt32.Valid", Field, 13},
+ {"NullInt64", Type, 0},
+ {"NullInt64.Int64", Field, 0},
+ {"NullInt64.Valid", Field, 0},
+ {"NullString", Type, 0},
+ {"NullString.String", Field, 0},
+ {"NullString.Valid", Field, 0},
+ {"NullTime", Type, 13},
+ {"NullTime.Time", Field, 13},
+ {"NullTime.Valid", Field, 13},
+ {"Open", Func, 0},
+ {"OpenDB", Func, 10},
+ {"Out", Type, 9},
+ {"Out.Dest", Field, 9},
+ {"Out.In", Field, 9},
+ {"RawBytes", Type, 0},
+ {"Register", Func, 0},
+ {"Result", Type, 0},
+ {"Row", Type, 0},
+ {"Rows", Type, 0},
+ {"Scanner", Type, 0},
+ {"Stmt", Type, 0},
+ {"Tx", Type, 0},
+ {"TxOptions", Type, 8},
+ {"TxOptions.Isolation", Field, 8},
+ {"TxOptions.ReadOnly", Field, 8},
+ },
+ "database/sql/driver": {
+ {"(NotNull).ConvertValue", Method, 0},
+ {"(Null).ConvertValue", Method, 0},
+ {"(RowsAffected).LastInsertId", Method, 0},
+ {"(RowsAffected).RowsAffected", Method, 0},
+ {"Bool", Var, 0},
+ {"ColumnConverter", Type, 0},
+ {"Conn", Type, 0},
+ {"ConnBeginTx", Type, 8},
+ {"ConnPrepareContext", Type, 8},
+ {"Connector", Type, 10},
+ {"DefaultParameterConverter", Var, 0},
+ {"Driver", Type, 0},
+ {"DriverContext", Type, 10},
+ {"ErrBadConn", Var, 0},
+ {"ErrRemoveArgument", Var, 9},
+ {"ErrSkip", Var, 0},
+ {"Execer", Type, 0},
+ {"ExecerContext", Type, 8},
+ {"Int32", Var, 0},
+ {"IsScanValue", Func, 0},
+ {"IsValue", Func, 0},
+ {"IsolationLevel", Type, 8},
+ {"NamedValue", Type, 8},
+ {"NamedValue.Name", Field, 8},
+ {"NamedValue.Ordinal", Field, 8},
+ {"NamedValue.Value", Field, 8},
+ {"NamedValueChecker", Type, 9},
+ {"NotNull", Type, 0},
+ {"NotNull.Converter", Field, 0},
+ {"Null", Type, 0},
+ {"Null.Converter", Field, 0},
+ {"Pinger", Type, 8},
+ {"Queryer", Type, 1},
+ {"QueryerContext", Type, 8},
+ {"Result", Type, 0},
+ {"ResultNoRows", Var, 0},
+ {"Rows", Type, 0},
+ {"RowsAffected", Type, 0},
+ {"RowsColumnTypeDatabaseTypeName", Type, 8},
+ {"RowsColumnTypeLength", Type, 8},
+ {"RowsColumnTypeNullable", Type, 8},
+ {"RowsColumnTypePrecisionScale", Type, 8},
+ {"RowsColumnTypeScanType", Type, 8},
+ {"RowsNextResultSet", Type, 8},
+ {"SessionResetter", Type, 10},
+ {"Stmt", Type, 0},
+ {"StmtExecContext", Type, 8},
+ {"StmtQueryContext", Type, 8},
+ {"String", Var, 0},
+ {"Tx", Type, 0},
+ {"TxOptions", Type, 8},
+ {"TxOptions.Isolation", Field, 8},
+ {"TxOptions.ReadOnly", Field, 8},
+ {"Validator", Type, 15},
+ {"Value", Type, 0},
+ {"ValueConverter", Type, 0},
+ {"Valuer", Type, 0},
+ },
+ "debug/buildinfo": {
+ {"BuildInfo", Type, 18},
+ {"Read", Func, 18},
+ {"ReadFile", Func, 18},
+ },
+ "debug/dwarf": {
+ {"(*AddrType).Basic", Method, 0},
+ {"(*AddrType).Common", Method, 0},
+ {"(*AddrType).Size", Method, 0},
+ {"(*AddrType).String", Method, 0},
+ {"(*ArrayType).Common", Method, 0},
+ {"(*ArrayType).Size", Method, 0},
+ {"(*ArrayType).String", Method, 0},
+ {"(*BasicType).Basic", Method, 0},
+ {"(*BasicType).Common", Method, 0},
+ {"(*BasicType).Size", Method, 0},
+ {"(*BasicType).String", Method, 0},
+ {"(*BoolType).Basic", Method, 0},
+ {"(*BoolType).Common", Method, 0},
+ {"(*BoolType).Size", Method, 0},
+ {"(*BoolType).String", Method, 0},
+ {"(*CharType).Basic", Method, 0},
+ {"(*CharType).Common", Method, 0},
+ {"(*CharType).Size", Method, 0},
+ {"(*CharType).String", Method, 0},
+ {"(*CommonType).Common", Method, 0},
+ {"(*CommonType).Size", Method, 0},
+ {"(*ComplexType).Basic", Method, 0},
+ {"(*ComplexType).Common", Method, 0},
+ {"(*ComplexType).Size", Method, 0},
+ {"(*ComplexType).String", Method, 0},
+ {"(*Data).AddSection", Method, 14},
+ {"(*Data).AddTypes", Method, 3},
+ {"(*Data).LineReader", Method, 5},
+ {"(*Data).Ranges", Method, 7},
+ {"(*Data).Reader", Method, 0},
+ {"(*Data).Type", Method, 0},
+ {"(*DotDotDotType).Common", Method, 0},
+ {"(*DotDotDotType).Size", Method, 0},
+ {"(*DotDotDotType).String", Method, 0},
+ {"(*Entry).AttrField", Method, 5},
+ {"(*Entry).Val", Method, 0},
+ {"(*EnumType).Common", Method, 0},
+ {"(*EnumType).Size", Method, 0},
+ {"(*EnumType).String", Method, 0},
+ {"(*FloatType).Basic", Method, 0},
+ {"(*FloatType).Common", Method, 0},
+ {"(*FloatType).Size", Method, 0},
+ {"(*FloatType).String", Method, 0},
+ {"(*FuncType).Common", Method, 0},
+ {"(*FuncType).Size", Method, 0},
+ {"(*FuncType).String", Method, 0},
+ {"(*IntType).Basic", Method, 0},
+ {"(*IntType).Common", Method, 0},
+ {"(*IntType).Size", Method, 0},
+ {"(*IntType).String", Method, 0},
+ {"(*LineReader).Files", Method, 14},
+ {"(*LineReader).Next", Method, 5},
+ {"(*LineReader).Reset", Method, 5},
+ {"(*LineReader).Seek", Method, 5},
+ {"(*LineReader).SeekPC", Method, 5},
+ {"(*LineReader).Tell", Method, 5},
+ {"(*PtrType).Common", Method, 0},
+ {"(*PtrType).Size", Method, 0},
+ {"(*PtrType).String", Method, 0},
+ {"(*QualType).Common", Method, 0},
+ {"(*QualType).Size", Method, 0},
+ {"(*QualType).String", Method, 0},
+ {"(*Reader).AddressSize", Method, 5},
+ {"(*Reader).ByteOrder", Method, 14},
+ {"(*Reader).Next", Method, 0},
+ {"(*Reader).Seek", Method, 0},
+ {"(*Reader).SeekPC", Method, 7},
+ {"(*Reader).SkipChildren", Method, 0},
+ {"(*StructType).Common", Method, 0},
+ {"(*StructType).Defn", Method, 0},
+ {"(*StructType).Size", Method, 0},
+ {"(*StructType).String", Method, 0},
+ {"(*TypedefType).Common", Method, 0},
+ {"(*TypedefType).Size", Method, 0},
+ {"(*TypedefType).String", Method, 0},
+ {"(*UcharType).Basic", Method, 0},
+ {"(*UcharType).Common", Method, 0},
+ {"(*UcharType).Size", Method, 0},
+ {"(*UcharType).String", Method, 0},
+ {"(*UintType).Basic", Method, 0},
+ {"(*UintType).Common", Method, 0},
+ {"(*UintType).Size", Method, 0},
+ {"(*UintType).String", Method, 0},
+ {"(*UnspecifiedType).Basic", Method, 4},
+ {"(*UnspecifiedType).Common", Method, 4},
+ {"(*UnspecifiedType).Size", Method, 4},
+ {"(*UnspecifiedType).String", Method, 4},
+ {"(*UnsupportedType).Common", Method, 13},
+ {"(*UnsupportedType).Size", Method, 13},
+ {"(*UnsupportedType).String", Method, 13},
+ {"(*VoidType).Common", Method, 0},
+ {"(*VoidType).Size", Method, 0},
+ {"(*VoidType).String", Method, 0},
+ {"(Attr).GoString", Method, 0},
+ {"(Attr).String", Method, 0},
+ {"(Class).GoString", Method, 5},
+ {"(Class).String", Method, 5},
+ {"(DecodeError).Error", Method, 0},
+ {"(Tag).GoString", Method, 0},
+ {"(Tag).String", Method, 0},
+ {"AddrType", Type, 0},
+ {"AddrType.BasicType", Field, 0},
+ {"ArrayType", Type, 0},
+ {"ArrayType.CommonType", Field, 0},
+ {"ArrayType.Count", Field, 0},
+ {"ArrayType.StrideBitSize", Field, 0},
+ {"ArrayType.Type", Field, 0},
+ {"Attr", Type, 0},
+ {"AttrAbstractOrigin", Const, 0},
+ {"AttrAccessibility", Const, 0},
+ {"AttrAddrBase", Const, 14},
+ {"AttrAddrClass", Const, 0},
+ {"AttrAlignment", Const, 14},
+ {"AttrAllocated", Const, 0},
+ {"AttrArtificial", Const, 0},
+ {"AttrAssociated", Const, 0},
+ {"AttrBaseTypes", Const, 0},
+ {"AttrBinaryScale", Const, 14},
+ {"AttrBitOffset", Const, 0},
+ {"AttrBitSize", Const, 0},
+ {"AttrByteSize", Const, 0},
+ {"AttrCallAllCalls", Const, 14},
+ {"AttrCallAllSourceCalls", Const, 14},
+ {"AttrCallAllTailCalls", Const, 14},
+ {"AttrCallColumn", Const, 0},
+ {"AttrCallDataLocation", Const, 14},
+ {"AttrCallDataValue", Const, 14},
+ {"AttrCallFile", Const, 0},
+ {"AttrCallLine", Const, 0},
+ {"AttrCallOrigin", Const, 14},
+ {"AttrCallPC", Const, 14},
+ {"AttrCallParameter", Const, 14},
+ {"AttrCallReturnPC", Const, 14},
+ {"AttrCallTailCall", Const, 14},
+ {"AttrCallTarget", Const, 14},
+ {"AttrCallTargetClobbered", Const, 14},
+ {"AttrCallValue", Const, 14},
+ {"AttrCalling", Const, 0},
+ {"AttrCommonRef", Const, 0},
+ {"AttrCompDir", Const, 0},
+ {"AttrConstExpr", Const, 14},
+ {"AttrConstValue", Const, 0},
+ {"AttrContainingType", Const, 0},
+ {"AttrCount", Const, 0},
+ {"AttrDataBitOffset", Const, 14},
+ {"AttrDataLocation", Const, 0},
+ {"AttrDataMemberLoc", Const, 0},
+ {"AttrDecimalScale", Const, 14},
+ {"AttrDecimalSign", Const, 14},
+ {"AttrDeclColumn", Const, 0},
+ {"AttrDeclFile", Const, 0},
+ {"AttrDeclLine", Const, 0},
+ {"AttrDeclaration", Const, 0},
+ {"AttrDefaultValue", Const, 0},
+ {"AttrDefaulted", Const, 14},
+ {"AttrDeleted", Const, 14},
+ {"AttrDescription", Const, 0},
+ {"AttrDigitCount", Const, 14},
+ {"AttrDiscr", Const, 0},
+ {"AttrDiscrList", Const, 0},
+ {"AttrDiscrValue", Const, 0},
+ {"AttrDwoName", Const, 14},
+ {"AttrElemental", Const, 14},
+ {"AttrEncoding", Const, 0},
+ {"AttrEndianity", Const, 14},
+ {"AttrEntrypc", Const, 0},
+ {"AttrEnumClass", Const, 14},
+ {"AttrExplicit", Const, 14},
+ {"AttrExportSymbols", Const, 14},
+ {"AttrExtension", Const, 0},
+ {"AttrExternal", Const, 0},
+ {"AttrFrameBase", Const, 0},
+ {"AttrFriend", Const, 0},
+ {"AttrHighpc", Const, 0},
+ {"AttrIdentifierCase", Const, 0},
+ {"AttrImport", Const, 0},
+ {"AttrInline", Const, 0},
+ {"AttrIsOptional", Const, 0},
+ {"AttrLanguage", Const, 0},
+ {"AttrLinkageName", Const, 14},
+ {"AttrLocation", Const, 0},
+ {"AttrLoclistsBase", Const, 14},
+ {"AttrLowerBound", Const, 0},
+ {"AttrLowpc", Const, 0},
+ {"AttrMacroInfo", Const, 0},
+ {"AttrMacros", Const, 14},
+ {"AttrMainSubprogram", Const, 14},
+ {"AttrMutable", Const, 14},
+ {"AttrName", Const, 0},
+ {"AttrNamelistItem", Const, 0},
+ {"AttrNoreturn", Const, 14},
+ {"AttrObjectPointer", Const, 14},
+ {"AttrOrdering", Const, 0},
+ {"AttrPictureString", Const, 14},
+ {"AttrPriority", Const, 0},
+ {"AttrProducer", Const, 0},
+ {"AttrPrototyped", Const, 0},
+ {"AttrPure", Const, 14},
+ {"AttrRanges", Const, 0},
+ {"AttrRank", Const, 14},
+ {"AttrRecursive", Const, 14},
+ {"AttrReference", Const, 14},
+ {"AttrReturnAddr", Const, 0},
+ {"AttrRnglistsBase", Const, 14},
+ {"AttrRvalueReference", Const, 14},
+ {"AttrSegment", Const, 0},
+ {"AttrSibling", Const, 0},
+ {"AttrSignature", Const, 14},
+ {"AttrSmall", Const, 14},
+ {"AttrSpecification", Const, 0},
+ {"AttrStartScope", Const, 0},
+ {"AttrStaticLink", Const, 0},
+ {"AttrStmtList", Const, 0},
+ {"AttrStrOffsetsBase", Const, 14},
+ {"AttrStride", Const, 0},
+ {"AttrStrideSize", Const, 0},
+ {"AttrStringLength", Const, 0},
+ {"AttrStringLengthBitSize", Const, 14},
+ {"AttrStringLengthByteSize", Const, 14},
+ {"AttrThreadsScaled", Const, 14},
+ {"AttrTrampoline", Const, 0},
+ {"AttrType", Const, 0},
+ {"AttrUpperBound", Const, 0},
+ {"AttrUseLocation", Const, 0},
+ {"AttrUseUTF8", Const, 0},
+ {"AttrVarParam", Const, 0},
+ {"AttrVirtuality", Const, 0},
+ {"AttrVisibility", Const, 0},
+ {"AttrVtableElemLoc", Const, 0},
+ {"BasicType", Type, 0},
+ {"BasicType.BitOffset", Field, 0},
+ {"BasicType.BitSize", Field, 0},
+ {"BasicType.CommonType", Field, 0},
+ {"BasicType.DataBitOffset", Field, 18},
+ {"BoolType", Type, 0},
+ {"BoolType.BasicType", Field, 0},
+ {"CharType", Type, 0},
+ {"CharType.BasicType", Field, 0},
+ {"Class", Type, 5},
+ {"ClassAddrPtr", Const, 14},
+ {"ClassAddress", Const, 5},
+ {"ClassBlock", Const, 5},
+ {"ClassConstant", Const, 5},
+ {"ClassExprLoc", Const, 5},
+ {"ClassFlag", Const, 5},
+ {"ClassLinePtr", Const, 5},
+ {"ClassLocList", Const, 14},
+ {"ClassLocListPtr", Const, 5},
+ {"ClassMacPtr", Const, 5},
+ {"ClassRangeListPtr", Const, 5},
+ {"ClassReference", Const, 5},
+ {"ClassReferenceAlt", Const, 5},
+ {"ClassReferenceSig", Const, 5},
+ {"ClassRngList", Const, 14},
+ {"ClassRngListsPtr", Const, 14},
+ {"ClassStrOffsetsPtr", Const, 14},
+ {"ClassString", Const, 5},
+ {"ClassStringAlt", Const, 5},
+ {"ClassUnknown", Const, 6},
+ {"CommonType", Type, 0},
+ {"CommonType.ByteSize", Field, 0},
+ {"CommonType.Name", Field, 0},
+ {"ComplexType", Type, 0},
+ {"ComplexType.BasicType", Field, 0},
+ {"Data", Type, 0},
+ {"DecodeError", Type, 0},
+ {"DecodeError.Err", Field, 0},
+ {"DecodeError.Name", Field, 0},
+ {"DecodeError.Offset", Field, 0},
+ {"DotDotDotType", Type, 0},
+ {"DotDotDotType.CommonType", Field, 0},
+ {"Entry", Type, 0},
+ {"Entry.Children", Field, 0},
+ {"Entry.Field", Field, 0},
+ {"Entry.Offset", Field, 0},
+ {"Entry.Tag", Field, 0},
+ {"EnumType", Type, 0},
+ {"EnumType.CommonType", Field, 0},
+ {"EnumType.EnumName", Field, 0},
+ {"EnumType.Val", Field, 0},
+ {"EnumValue", Type, 0},
+ {"EnumValue.Name", Field, 0},
+ {"EnumValue.Val", Field, 0},
+ {"ErrUnknownPC", Var, 5},
+ {"Field", Type, 0},
+ {"Field.Attr", Field, 0},
+ {"Field.Class", Field, 5},
+ {"Field.Val", Field, 0},
+ {"FloatType", Type, 0},
+ {"FloatType.BasicType", Field, 0},
+ {"FuncType", Type, 0},
+ {"FuncType.CommonType", Field, 0},
+ {"FuncType.ParamType", Field, 0},
+ {"FuncType.ReturnType", Field, 0},
+ {"IntType", Type, 0},
+ {"IntType.BasicType", Field, 0},
+ {"LineEntry", Type, 5},
+ {"LineEntry.Address", Field, 5},
+ {"LineEntry.BasicBlock", Field, 5},
+ {"LineEntry.Column", Field, 5},
+ {"LineEntry.Discriminator", Field, 5},
+ {"LineEntry.EndSequence", Field, 5},
+ {"LineEntry.EpilogueBegin", Field, 5},
+ {"LineEntry.File", Field, 5},
+ {"LineEntry.ISA", Field, 5},
+ {"LineEntry.IsStmt", Field, 5},
+ {"LineEntry.Line", Field, 5},
+ {"LineEntry.OpIndex", Field, 5},
+ {"LineEntry.PrologueEnd", Field, 5},
+ {"LineFile", Type, 5},
+ {"LineFile.Length", Field, 5},
+ {"LineFile.Mtime", Field, 5},
+ {"LineFile.Name", Field, 5},
+ {"LineReader", Type, 5},
+ {"LineReaderPos", Type, 5},
+ {"New", Func, 0},
+ {"Offset", Type, 0},
+ {"PtrType", Type, 0},
+ {"PtrType.CommonType", Field, 0},
+ {"PtrType.Type", Field, 0},
+ {"QualType", Type, 0},
+ {"QualType.CommonType", Field, 0},
+ {"QualType.Qual", Field, 0},
+ {"QualType.Type", Field, 0},
+ {"Reader", Type, 0},
+ {"StructField", Type, 0},
+ {"StructField.BitOffset", Field, 0},
+ {"StructField.BitSize", Field, 0},
+ {"StructField.ByteOffset", Field, 0},
+ {"StructField.ByteSize", Field, 0},
+ {"StructField.DataBitOffset", Field, 18},
+ {"StructField.Name", Field, 0},
+ {"StructField.Type", Field, 0},
+ {"StructType", Type, 0},
+ {"StructType.CommonType", Field, 0},
+ {"StructType.Field", Field, 0},
+ {"StructType.Incomplete", Field, 0},
+ {"StructType.Kind", Field, 0},
+ {"StructType.StructName", Field, 0},
+ {"Tag", Type, 0},
+ {"TagAccessDeclaration", Const, 0},
+ {"TagArrayType", Const, 0},
+ {"TagAtomicType", Const, 14},
+ {"TagBaseType", Const, 0},
+ {"TagCallSite", Const, 14},
+ {"TagCallSiteParameter", Const, 14},
+ {"TagCatchDwarfBlock", Const, 0},
+ {"TagClassType", Const, 0},
+ {"TagCoarrayType", Const, 14},
+ {"TagCommonDwarfBlock", Const, 0},
+ {"TagCommonInclusion", Const, 0},
+ {"TagCompileUnit", Const, 0},
+ {"TagCondition", Const, 3},
+ {"TagConstType", Const, 0},
+ {"TagConstant", Const, 0},
+ {"TagDwarfProcedure", Const, 0},
+ {"TagDynamicType", Const, 14},
+ {"TagEntryPoint", Const, 0},
+ {"TagEnumerationType", Const, 0},
+ {"TagEnumerator", Const, 0},
+ {"TagFileType", Const, 0},
+ {"TagFormalParameter", Const, 0},
+ {"TagFriend", Const, 0},
+ {"TagGenericSubrange", Const, 14},
+ {"TagImmutableType", Const, 14},
+ {"TagImportedDeclaration", Const, 0},
+ {"TagImportedModule", Const, 0},
+ {"TagImportedUnit", Const, 0},
+ {"TagInheritance", Const, 0},
+ {"TagInlinedSubroutine", Const, 0},
+ {"TagInterfaceType", Const, 0},
+ {"TagLabel", Const, 0},
+ {"TagLexDwarfBlock", Const, 0},
+ {"TagMember", Const, 0},
+ {"TagModule", Const, 0},
+ {"TagMutableType", Const, 0},
+ {"TagNamelist", Const, 0},
+ {"TagNamelistItem", Const, 0},
+ {"TagNamespace", Const, 0},
+ {"TagPackedType", Const, 0},
+ {"TagPartialUnit", Const, 0},
+ {"TagPointerType", Const, 0},
+ {"TagPtrToMemberType", Const, 0},
+ {"TagReferenceType", Const, 0},
+ {"TagRestrictType", Const, 0},
+ {"TagRvalueReferenceType", Const, 3},
+ {"TagSetType", Const, 0},
+ {"TagSharedType", Const, 3},
+ {"TagSkeletonUnit", Const, 14},
+ {"TagStringType", Const, 0},
+ {"TagStructType", Const, 0},
+ {"TagSubprogram", Const, 0},
+ {"TagSubrangeType", Const, 0},
+ {"TagSubroutineType", Const, 0},
+ {"TagTemplateAlias", Const, 3},
+ {"TagTemplateTypeParameter", Const, 0},
+ {"TagTemplateValueParameter", Const, 0},
+ {"TagThrownType", Const, 0},
+ {"TagTryDwarfBlock", Const, 0},
+ {"TagTypeUnit", Const, 3},
+ {"TagTypedef", Const, 0},
+ {"TagUnionType", Const, 0},
+ {"TagUnspecifiedParameters", Const, 0},
+ {"TagUnspecifiedType", Const, 0},
+ {"TagVariable", Const, 0},
+ {"TagVariant", Const, 0},
+ {"TagVariantPart", Const, 0},
+ {"TagVolatileType", Const, 0},
+ {"TagWithStmt", Const, 0},
+ {"Type", Type, 0},
+ {"TypedefType", Type, 0},
+ {"TypedefType.CommonType", Field, 0},
+ {"TypedefType.Type", Field, 0},
+ {"UcharType", Type, 0},
+ {"UcharType.BasicType", Field, 0},
+ {"UintType", Type, 0},
+ {"UintType.BasicType", Field, 0},
+ {"UnspecifiedType", Type, 4},
+ {"UnspecifiedType.BasicType", Field, 4},
+ {"UnsupportedType", Type, 13},
+ {"UnsupportedType.CommonType", Field, 13},
+ {"UnsupportedType.Tag", Field, 13},
+ {"VoidType", Type, 0},
+ {"VoidType.CommonType", Field, 0},
+ },
+ "debug/elf": {
+ {"(*File).Close", Method, 0},
+ {"(*File).DWARF", Method, 0},
+ {"(*File).DynString", Method, 1},
+ {"(*File).DynValue", Method, 21},
+ {"(*File).DynamicSymbols", Method, 4},
+ {"(*File).ImportedLibraries", Method, 0},
+ {"(*File).ImportedSymbols", Method, 0},
+ {"(*File).Section", Method, 0},
+ {"(*File).SectionByType", Method, 0},
+ {"(*File).Symbols", Method, 0},
+ {"(*FormatError).Error", Method, 0},
+ {"(*Prog).Open", Method, 0},
+ {"(*Section).Data", Method, 0},
+ {"(*Section).Open", Method, 0},
+ {"(Class).GoString", Method, 0},
+ {"(Class).String", Method, 0},
+ {"(CompressionType).GoString", Method, 6},
+ {"(CompressionType).String", Method, 6},
+ {"(Data).GoString", Method, 0},
+ {"(Data).String", Method, 0},
+ {"(DynFlag).GoString", Method, 0},
+ {"(DynFlag).String", Method, 0},
+ {"(DynFlag1).GoString", Method, 21},
+ {"(DynFlag1).String", Method, 21},
+ {"(DynTag).GoString", Method, 0},
+ {"(DynTag).String", Method, 0},
+ {"(Machine).GoString", Method, 0},
+ {"(Machine).String", Method, 0},
+ {"(NType).GoString", Method, 0},
+ {"(NType).String", Method, 0},
+ {"(OSABI).GoString", Method, 0},
+ {"(OSABI).String", Method, 0},
+ {"(Prog).ReadAt", Method, 0},
+ {"(ProgFlag).GoString", Method, 0},
+ {"(ProgFlag).String", Method, 0},
+ {"(ProgType).GoString", Method, 0},
+ {"(ProgType).String", Method, 0},
+ {"(R_386).GoString", Method, 0},
+ {"(R_386).String", Method, 0},
+ {"(R_390).GoString", Method, 7},
+ {"(R_390).String", Method, 7},
+ {"(R_AARCH64).GoString", Method, 4},
+ {"(R_AARCH64).String", Method, 4},
+ {"(R_ALPHA).GoString", Method, 0},
+ {"(R_ALPHA).String", Method, 0},
+ {"(R_ARM).GoString", Method, 0},
+ {"(R_ARM).String", Method, 0},
+ {"(R_LARCH).GoString", Method, 19},
+ {"(R_LARCH).String", Method, 19},
+ {"(R_MIPS).GoString", Method, 6},
+ {"(R_MIPS).String", Method, 6},
+ {"(R_PPC).GoString", Method, 0},
+ {"(R_PPC).String", Method, 0},
+ {"(R_PPC64).GoString", Method, 5},
+ {"(R_PPC64).String", Method, 5},
+ {"(R_RISCV).GoString", Method, 11},
+ {"(R_RISCV).String", Method, 11},
+ {"(R_SPARC).GoString", Method, 0},
+ {"(R_SPARC).String", Method, 0},
+ {"(R_X86_64).GoString", Method, 0},
+ {"(R_X86_64).String", Method, 0},
+ {"(Section).ReadAt", Method, 0},
+ {"(SectionFlag).GoString", Method, 0},
+ {"(SectionFlag).String", Method, 0},
+ {"(SectionIndex).GoString", Method, 0},
+ {"(SectionIndex).String", Method, 0},
+ {"(SectionType).GoString", Method, 0},
+ {"(SectionType).String", Method, 0},
+ {"(SymBind).GoString", Method, 0},
+ {"(SymBind).String", Method, 0},
+ {"(SymType).GoString", Method, 0},
+ {"(SymType).String", Method, 0},
+ {"(SymVis).GoString", Method, 0},
+ {"(SymVis).String", Method, 0},
+ {"(Type).GoString", Method, 0},
+ {"(Type).String", Method, 0},
+ {"(Version).GoString", Method, 0},
+ {"(Version).String", Method, 0},
+ {"ARM_MAGIC_TRAMP_NUMBER", Const, 0},
+ {"COMPRESS_HIOS", Const, 6},
+ {"COMPRESS_HIPROC", Const, 6},
+ {"COMPRESS_LOOS", Const, 6},
+ {"COMPRESS_LOPROC", Const, 6},
+ {"COMPRESS_ZLIB", Const, 6},
+ {"COMPRESS_ZSTD", Const, 21},
+ {"Chdr32", Type, 6},
+ {"Chdr32.Addralign", Field, 6},
+ {"Chdr32.Size", Field, 6},
+ {"Chdr32.Type", Field, 6},
+ {"Chdr64", Type, 6},
+ {"Chdr64.Addralign", Field, 6},
+ {"Chdr64.Size", Field, 6},
+ {"Chdr64.Type", Field, 6},
+ {"Class", Type, 0},
+ {"CompressionType", Type, 6},
+ {"DF_1_CONFALT", Const, 21},
+ {"DF_1_DIRECT", Const, 21},
+ {"DF_1_DISPRELDNE", Const, 21},
+ {"DF_1_DISPRELPND", Const, 21},
+ {"DF_1_EDITED", Const, 21},
+ {"DF_1_ENDFILTEE", Const, 21},
+ {"DF_1_GLOBAL", Const, 21},
+ {"DF_1_GLOBAUDIT", Const, 21},
+ {"DF_1_GROUP", Const, 21},
+ {"DF_1_IGNMULDEF", Const, 21},
+ {"DF_1_INITFIRST", Const, 21},
+ {"DF_1_INTERPOSE", Const, 21},
+ {"DF_1_KMOD", Const, 21},
+ {"DF_1_LOADFLTR", Const, 21},
+ {"DF_1_NOCOMMON", Const, 21},
+ {"DF_1_NODEFLIB", Const, 21},
+ {"DF_1_NODELETE", Const, 21},
+ {"DF_1_NODIRECT", Const, 21},
+ {"DF_1_NODUMP", Const, 21},
+ {"DF_1_NOHDR", Const, 21},
+ {"DF_1_NOKSYMS", Const, 21},
+ {"DF_1_NOOPEN", Const, 21},
+ {"DF_1_NORELOC", Const, 21},
+ {"DF_1_NOW", Const, 21},
+ {"DF_1_ORIGIN", Const, 21},
+ {"DF_1_PIE", Const, 21},
+ {"DF_1_SINGLETON", Const, 21},
+ {"DF_1_STUB", Const, 21},
+ {"DF_1_SYMINTPOSE", Const, 21},
+ {"DF_1_TRANS", Const, 21},
+ {"DF_1_WEAKFILTER", Const, 21},
+ {"DF_BIND_NOW", Const, 0},
+ {"DF_ORIGIN", Const, 0},
+ {"DF_STATIC_TLS", Const, 0},
+ {"DF_SYMBOLIC", Const, 0},
+ {"DF_TEXTREL", Const, 0},
+ {"DT_ADDRRNGHI", Const, 16},
+ {"DT_ADDRRNGLO", Const, 16},
+ {"DT_AUDIT", Const, 16},
+ {"DT_AUXILIARY", Const, 16},
+ {"DT_BIND_NOW", Const, 0},
+ {"DT_CHECKSUM", Const, 16},
+ {"DT_CONFIG", Const, 16},
+ {"DT_DEBUG", Const, 0},
+ {"DT_DEPAUDIT", Const, 16},
+ {"DT_ENCODING", Const, 0},
+ {"DT_FEATURE", Const, 16},
+ {"DT_FILTER", Const, 16},
+ {"DT_FINI", Const, 0},
+ {"DT_FINI_ARRAY", Const, 0},
+ {"DT_FINI_ARRAYSZ", Const, 0},
+ {"DT_FLAGS", Const, 0},
+ {"DT_FLAGS_1", Const, 16},
+ {"DT_GNU_CONFLICT", Const, 16},
+ {"DT_GNU_CONFLICTSZ", Const, 16},
+ {"DT_GNU_HASH", Const, 16},
+ {"DT_GNU_LIBLIST", Const, 16},
+ {"DT_GNU_LIBLISTSZ", Const, 16},
+ {"DT_GNU_PRELINKED", Const, 16},
+ {"DT_HASH", Const, 0},
+ {"DT_HIOS", Const, 0},
+ {"DT_HIPROC", Const, 0},
+ {"DT_INIT", Const, 0},
+ {"DT_INIT_ARRAY", Const, 0},
+ {"DT_INIT_ARRAYSZ", Const, 0},
+ {"DT_JMPREL", Const, 0},
+ {"DT_LOOS", Const, 0},
+ {"DT_LOPROC", Const, 0},
+ {"DT_MIPS_AUX_DYNAMIC", Const, 16},
+ {"DT_MIPS_BASE_ADDRESS", Const, 16},
+ {"DT_MIPS_COMPACT_SIZE", Const, 16},
+ {"DT_MIPS_CONFLICT", Const, 16},
+ {"DT_MIPS_CONFLICTNO", Const, 16},
+ {"DT_MIPS_CXX_FLAGS", Const, 16},
+ {"DT_MIPS_DELTA_CLASS", Const, 16},
+ {"DT_MIPS_DELTA_CLASSSYM", Const, 16},
+ {"DT_MIPS_DELTA_CLASSSYM_NO", Const, 16},
+ {"DT_MIPS_DELTA_CLASS_NO", Const, 16},
+ {"DT_MIPS_DELTA_INSTANCE", Const, 16},
+ {"DT_MIPS_DELTA_INSTANCE_NO", Const, 16},
+ {"DT_MIPS_DELTA_RELOC", Const, 16},
+ {"DT_MIPS_DELTA_RELOC_NO", Const, 16},
+ {"DT_MIPS_DELTA_SYM", Const, 16},
+ {"DT_MIPS_DELTA_SYM_NO", Const, 16},
+ {"DT_MIPS_DYNSTR_ALIGN", Const, 16},
+ {"DT_MIPS_FLAGS", Const, 16},
+ {"DT_MIPS_GOTSYM", Const, 16},
+ {"DT_MIPS_GP_VALUE", Const, 16},
+ {"DT_MIPS_HIDDEN_GOTIDX", Const, 16},
+ {"DT_MIPS_HIPAGENO", Const, 16},
+ {"DT_MIPS_ICHECKSUM", Const, 16},
+ {"DT_MIPS_INTERFACE", Const, 16},
+ {"DT_MIPS_INTERFACE_SIZE", Const, 16},
+ {"DT_MIPS_IVERSION", Const, 16},
+ {"DT_MIPS_LIBLIST", Const, 16},
+ {"DT_MIPS_LIBLISTNO", Const, 16},
+ {"DT_MIPS_LOCALPAGE_GOTIDX", Const, 16},
+ {"DT_MIPS_LOCAL_GOTIDX", Const, 16},
+ {"DT_MIPS_LOCAL_GOTNO", Const, 16},
+ {"DT_MIPS_MSYM", Const, 16},
+ {"DT_MIPS_OPTIONS", Const, 16},
+ {"DT_MIPS_PERF_SUFFIX", Const, 16},
+ {"DT_MIPS_PIXIE_INIT", Const, 16},
+ {"DT_MIPS_PLTGOT", Const, 16},
+ {"DT_MIPS_PROTECTED_GOTIDX", Const, 16},
+ {"DT_MIPS_RLD_MAP", Const, 16},
+ {"DT_MIPS_RLD_MAP_REL", Const, 16},
+ {"DT_MIPS_RLD_TEXT_RESOLVE_ADDR", Const, 16},
+ {"DT_MIPS_RLD_VERSION", Const, 16},
+ {"DT_MIPS_RWPLT", Const, 16},
+ {"DT_MIPS_SYMBOL_LIB", Const, 16},
+ {"DT_MIPS_SYMTABNO", Const, 16},
+ {"DT_MIPS_TIME_STAMP", Const, 16},
+ {"DT_MIPS_UNREFEXTNO", Const, 16},
+ {"DT_MOVEENT", Const, 16},
+ {"DT_MOVESZ", Const, 16},
+ {"DT_MOVETAB", Const, 16},
+ {"DT_NEEDED", Const, 0},
+ {"DT_NULL", Const, 0},
+ {"DT_PLTGOT", Const, 0},
+ {"DT_PLTPAD", Const, 16},
+ {"DT_PLTPADSZ", Const, 16},
+ {"DT_PLTREL", Const, 0},
+ {"DT_PLTRELSZ", Const, 0},
+ {"DT_POSFLAG_1", Const, 16},
+ {"DT_PPC64_GLINK", Const, 16},
+ {"DT_PPC64_OPD", Const, 16},
+ {"DT_PPC64_OPDSZ", Const, 16},
+ {"DT_PPC64_OPT", Const, 16},
+ {"DT_PPC_GOT", Const, 16},
+ {"DT_PPC_OPT", Const, 16},
+ {"DT_PREINIT_ARRAY", Const, 0},
+ {"DT_PREINIT_ARRAYSZ", Const, 0},
+ {"DT_REL", Const, 0},
+ {"DT_RELA", Const, 0},
+ {"DT_RELACOUNT", Const, 16},
+ {"DT_RELAENT", Const, 0},
+ {"DT_RELASZ", Const, 0},
+ {"DT_RELCOUNT", Const, 16},
+ {"DT_RELENT", Const, 0},
+ {"DT_RELSZ", Const, 0},
+ {"DT_RPATH", Const, 0},
+ {"DT_RUNPATH", Const, 0},
+ {"DT_SONAME", Const, 0},
+ {"DT_SPARC_REGISTER", Const, 16},
+ {"DT_STRSZ", Const, 0},
+ {"DT_STRTAB", Const, 0},
+ {"DT_SYMBOLIC", Const, 0},
+ {"DT_SYMENT", Const, 0},
+ {"DT_SYMINENT", Const, 16},
+ {"DT_SYMINFO", Const, 16},
+ {"DT_SYMINSZ", Const, 16},
+ {"DT_SYMTAB", Const, 0},
+ {"DT_SYMTAB_SHNDX", Const, 16},
+ {"DT_TEXTREL", Const, 0},
+ {"DT_TLSDESC_GOT", Const, 16},
+ {"DT_TLSDESC_PLT", Const, 16},
+ {"DT_USED", Const, 16},
+ {"DT_VALRNGHI", Const, 16},
+ {"DT_VALRNGLO", Const, 16},
+ {"DT_VERDEF", Const, 16},
+ {"DT_VERDEFNUM", Const, 16},
+ {"DT_VERNEED", Const, 0},
+ {"DT_VERNEEDNUM", Const, 0},
+ {"DT_VERSYM", Const, 0},
+ {"Data", Type, 0},
+ {"Dyn32", Type, 0},
+ {"Dyn32.Tag", Field, 0},
+ {"Dyn32.Val", Field, 0},
+ {"Dyn64", Type, 0},
+ {"Dyn64.Tag", Field, 0},
+ {"Dyn64.Val", Field, 0},
+ {"DynFlag", Type, 0},
+ {"DynFlag1", Type, 21},
+ {"DynTag", Type, 0},
+ {"EI_ABIVERSION", Const, 0},
+ {"EI_CLASS", Const, 0},
+ {"EI_DATA", Const, 0},
+ {"EI_NIDENT", Const, 0},
+ {"EI_OSABI", Const, 0},
+ {"EI_PAD", Const, 0},
+ {"EI_VERSION", Const, 0},
+ {"ELFCLASS32", Const, 0},
+ {"ELFCLASS64", Const, 0},
+ {"ELFCLASSNONE", Const, 0},
+ {"ELFDATA2LSB", Const, 0},
+ {"ELFDATA2MSB", Const, 0},
+ {"ELFDATANONE", Const, 0},
+ {"ELFMAG", Const, 0},
+ {"ELFOSABI_86OPEN", Const, 0},
+ {"ELFOSABI_AIX", Const, 0},
+ {"ELFOSABI_ARM", Const, 0},
+ {"ELFOSABI_AROS", Const, 11},
+ {"ELFOSABI_CLOUDABI", Const, 11},
+ {"ELFOSABI_FENIXOS", Const, 11},
+ {"ELFOSABI_FREEBSD", Const, 0},
+ {"ELFOSABI_HPUX", Const, 0},
+ {"ELFOSABI_HURD", Const, 0},
+ {"ELFOSABI_IRIX", Const, 0},
+ {"ELFOSABI_LINUX", Const, 0},
+ {"ELFOSABI_MODESTO", Const, 0},
+ {"ELFOSABI_NETBSD", Const, 0},
+ {"ELFOSABI_NONE", Const, 0},
+ {"ELFOSABI_NSK", Const, 0},
+ {"ELFOSABI_OPENBSD", Const, 0},
+ {"ELFOSABI_OPENVMS", Const, 0},
+ {"ELFOSABI_SOLARIS", Const, 0},
+ {"ELFOSABI_STANDALONE", Const, 0},
+ {"ELFOSABI_TRU64", Const, 0},
+ {"EM_386", Const, 0},
+ {"EM_486", Const, 0},
+ {"EM_56800EX", Const, 11},
+ {"EM_68HC05", Const, 11},
+ {"EM_68HC08", Const, 11},
+ {"EM_68HC11", Const, 11},
+ {"EM_68HC12", Const, 0},
+ {"EM_68HC16", Const, 11},
+ {"EM_68K", Const, 0},
+ {"EM_78KOR", Const, 11},
+ {"EM_8051", Const, 11},
+ {"EM_860", Const, 0},
+ {"EM_88K", Const, 0},
+ {"EM_960", Const, 0},
+ {"EM_AARCH64", Const, 4},
+ {"EM_ALPHA", Const, 0},
+ {"EM_ALPHA_STD", Const, 0},
+ {"EM_ALTERA_NIOS2", Const, 11},
+ {"EM_AMDGPU", Const, 11},
+ {"EM_ARC", Const, 0},
+ {"EM_ARCA", Const, 11},
+ {"EM_ARC_COMPACT", Const, 11},
+ {"EM_ARC_COMPACT2", Const, 11},
+ {"EM_ARM", Const, 0},
+ {"EM_AVR", Const, 11},
+ {"EM_AVR32", Const, 11},
+ {"EM_BA1", Const, 11},
+ {"EM_BA2", Const, 11},
+ {"EM_BLACKFIN", Const, 11},
+ {"EM_BPF", Const, 11},
+ {"EM_C166", Const, 11},
+ {"EM_CDP", Const, 11},
+ {"EM_CE", Const, 11},
+ {"EM_CLOUDSHIELD", Const, 11},
+ {"EM_COGE", Const, 11},
+ {"EM_COLDFIRE", Const, 0},
+ {"EM_COOL", Const, 11},
+ {"EM_COREA_1ST", Const, 11},
+ {"EM_COREA_2ND", Const, 11},
+ {"EM_CR", Const, 11},
+ {"EM_CR16", Const, 11},
+ {"EM_CRAYNV2", Const, 11},
+ {"EM_CRIS", Const, 11},
+ {"EM_CRX", Const, 11},
+ {"EM_CSR_KALIMBA", Const, 11},
+ {"EM_CUDA", Const, 11},
+ {"EM_CYPRESS_M8C", Const, 11},
+ {"EM_D10V", Const, 11},
+ {"EM_D30V", Const, 11},
+ {"EM_DSP24", Const, 11},
+ {"EM_DSPIC30F", Const, 11},
+ {"EM_DXP", Const, 11},
+ {"EM_ECOG1", Const, 11},
+ {"EM_ECOG16", Const, 11},
+ {"EM_ECOG1X", Const, 11},
+ {"EM_ECOG2", Const, 11},
+ {"EM_ETPU", Const, 11},
+ {"EM_EXCESS", Const, 11},
+ {"EM_F2MC16", Const, 11},
+ {"EM_FIREPATH", Const, 11},
+ {"EM_FR20", Const, 0},
+ {"EM_FR30", Const, 11},
+ {"EM_FT32", Const, 11},
+ {"EM_FX66", Const, 11},
+ {"EM_H8S", Const, 0},
+ {"EM_H8_300", Const, 0},
+ {"EM_H8_300H", Const, 0},
+ {"EM_H8_500", Const, 0},
+ {"EM_HUANY", Const, 11},
+ {"EM_IA_64", Const, 0},
+ {"EM_INTEL205", Const, 11},
+ {"EM_INTEL206", Const, 11},
+ {"EM_INTEL207", Const, 11},
+ {"EM_INTEL208", Const, 11},
+ {"EM_INTEL209", Const, 11},
+ {"EM_IP2K", Const, 11},
+ {"EM_JAVELIN", Const, 11},
+ {"EM_K10M", Const, 11},
+ {"EM_KM32", Const, 11},
+ {"EM_KMX16", Const, 11},
+ {"EM_KMX32", Const, 11},
+ {"EM_KMX8", Const, 11},
+ {"EM_KVARC", Const, 11},
+ {"EM_L10M", Const, 11},
+ {"EM_LANAI", Const, 11},
+ {"EM_LATTICEMICO32", Const, 11},
+ {"EM_LOONGARCH", Const, 19},
+ {"EM_M16C", Const, 11},
+ {"EM_M32", Const, 0},
+ {"EM_M32C", Const, 11},
+ {"EM_M32R", Const, 11},
+ {"EM_MANIK", Const, 11},
+ {"EM_MAX", Const, 11},
+ {"EM_MAXQ30", Const, 11},
+ {"EM_MCHP_PIC", Const, 11},
+ {"EM_MCST_ELBRUS", Const, 11},
+ {"EM_ME16", Const, 0},
+ {"EM_METAG", Const, 11},
+ {"EM_MICROBLAZE", Const, 11},
+ {"EM_MIPS", Const, 0},
+ {"EM_MIPS_RS3_LE", Const, 0},
+ {"EM_MIPS_RS4_BE", Const, 0},
+ {"EM_MIPS_X", Const, 0},
+ {"EM_MMA", Const, 0},
+ {"EM_MMDSP_PLUS", Const, 11},
+ {"EM_MMIX", Const, 11},
+ {"EM_MN10200", Const, 11},
+ {"EM_MN10300", Const, 11},
+ {"EM_MOXIE", Const, 11},
+ {"EM_MSP430", Const, 11},
+ {"EM_NCPU", Const, 0},
+ {"EM_NDR1", Const, 0},
+ {"EM_NDS32", Const, 11},
+ {"EM_NONE", Const, 0},
+ {"EM_NORC", Const, 11},
+ {"EM_NS32K", Const, 11},
+ {"EM_OPEN8", Const, 11},
+ {"EM_OPENRISC", Const, 11},
+ {"EM_PARISC", Const, 0},
+ {"EM_PCP", Const, 0},
+ {"EM_PDP10", Const, 11},
+ {"EM_PDP11", Const, 11},
+ {"EM_PDSP", Const, 11},
+ {"EM_PJ", Const, 11},
+ {"EM_PPC", Const, 0},
+ {"EM_PPC64", Const, 0},
+ {"EM_PRISM", Const, 11},
+ {"EM_QDSP6", Const, 11},
+ {"EM_R32C", Const, 11},
+ {"EM_RCE", Const, 0},
+ {"EM_RH32", Const, 0},
+ {"EM_RISCV", Const, 11},
+ {"EM_RL78", Const, 11},
+ {"EM_RS08", Const, 11},
+ {"EM_RX", Const, 11},
+ {"EM_S370", Const, 0},
+ {"EM_S390", Const, 0},
+ {"EM_SCORE7", Const, 11},
+ {"EM_SEP", Const, 11},
+ {"EM_SE_C17", Const, 11},
+ {"EM_SE_C33", Const, 11},
+ {"EM_SH", Const, 0},
+ {"EM_SHARC", Const, 11},
+ {"EM_SLE9X", Const, 11},
+ {"EM_SNP1K", Const, 11},
+ {"EM_SPARC", Const, 0},
+ {"EM_SPARC32PLUS", Const, 0},
+ {"EM_SPARCV9", Const, 0},
+ {"EM_ST100", Const, 0},
+ {"EM_ST19", Const, 11},
+ {"EM_ST200", Const, 11},
+ {"EM_ST7", Const, 11},
+ {"EM_ST9PLUS", Const, 11},
+ {"EM_STARCORE", Const, 0},
+ {"EM_STM8", Const, 11},
+ {"EM_STXP7X", Const, 11},
+ {"EM_SVX", Const, 11},
+ {"EM_TILE64", Const, 11},
+ {"EM_TILEGX", Const, 11},
+ {"EM_TILEPRO", Const, 11},
+ {"EM_TINYJ", Const, 0},
+ {"EM_TI_ARP32", Const, 11},
+ {"EM_TI_C2000", Const, 11},
+ {"EM_TI_C5500", Const, 11},
+ {"EM_TI_C6000", Const, 11},
+ {"EM_TI_PRU", Const, 11},
+ {"EM_TMM_GPP", Const, 11},
+ {"EM_TPC", Const, 11},
+ {"EM_TRICORE", Const, 0},
+ {"EM_TRIMEDIA", Const, 11},
+ {"EM_TSK3000", Const, 11},
+ {"EM_UNICORE", Const, 11},
+ {"EM_V800", Const, 0},
+ {"EM_V850", Const, 11},
+ {"EM_VAX", Const, 11},
+ {"EM_VIDEOCORE", Const, 11},
+ {"EM_VIDEOCORE3", Const, 11},
+ {"EM_VIDEOCORE5", Const, 11},
+ {"EM_VISIUM", Const, 11},
+ {"EM_VPP500", Const, 0},
+ {"EM_X86_64", Const, 0},
+ {"EM_XCORE", Const, 11},
+ {"EM_XGATE", Const, 11},
+ {"EM_XIMO16", Const, 11},
+ {"EM_XTENSA", Const, 11},
+ {"EM_Z80", Const, 11},
+ {"EM_ZSP", Const, 11},
+ {"ET_CORE", Const, 0},
+ {"ET_DYN", Const, 0},
+ {"ET_EXEC", Const, 0},
+ {"ET_HIOS", Const, 0},
+ {"ET_HIPROC", Const, 0},
+ {"ET_LOOS", Const, 0},
+ {"ET_LOPROC", Const, 0},
+ {"ET_NONE", Const, 0},
+ {"ET_REL", Const, 0},
+ {"EV_CURRENT", Const, 0},
+ {"EV_NONE", Const, 0},
+ {"ErrNoSymbols", Var, 4},
+ {"File", Type, 0},
+ {"File.FileHeader", Field, 0},
+ {"File.Progs", Field, 0},
+ {"File.Sections", Field, 0},
+ {"FileHeader", Type, 0},
+ {"FileHeader.ABIVersion", Field, 0},
+ {"FileHeader.ByteOrder", Field, 0},
+ {"FileHeader.Class", Field, 0},
+ {"FileHeader.Data", Field, 0},
+ {"FileHeader.Entry", Field, 1},
+ {"FileHeader.Machine", Field, 0},
+ {"FileHeader.OSABI", Field, 0},
+ {"FileHeader.Type", Field, 0},
+ {"FileHeader.Version", Field, 0},
+ {"FormatError", Type, 0},
+ {"Header32", Type, 0},
+ {"Header32.Ehsize", Field, 0},
+ {"Header32.Entry", Field, 0},
+ {"Header32.Flags", Field, 0},
+ {"Header32.Ident", Field, 0},
+ {"Header32.Machine", Field, 0},
+ {"Header32.Phentsize", Field, 0},
+ {"Header32.Phnum", Field, 0},
+ {"Header32.Phoff", Field, 0},
+ {"Header32.Shentsize", Field, 0},
+ {"Header32.Shnum", Field, 0},
+ {"Header32.Shoff", Field, 0},
+ {"Header32.Shstrndx", Field, 0},
+ {"Header32.Type", Field, 0},
+ {"Header32.Version", Field, 0},
+ {"Header64", Type, 0},
+ {"Header64.Ehsize", Field, 0},
+ {"Header64.Entry", Field, 0},
+ {"Header64.Flags", Field, 0},
+ {"Header64.Ident", Field, 0},
+ {"Header64.Machine", Field, 0},
+ {"Header64.Phentsize", Field, 0},
+ {"Header64.Phnum", Field, 0},
+ {"Header64.Phoff", Field, 0},
+ {"Header64.Shentsize", Field, 0},
+ {"Header64.Shnum", Field, 0},
+ {"Header64.Shoff", Field, 0},
+ {"Header64.Shstrndx", Field, 0},
+ {"Header64.Type", Field, 0},
+ {"Header64.Version", Field, 0},
+ {"ImportedSymbol", Type, 0},
+ {"ImportedSymbol.Library", Field, 0},
+ {"ImportedSymbol.Name", Field, 0},
+ {"ImportedSymbol.Version", Field, 0},
+ {"Machine", Type, 0},
+ {"NT_FPREGSET", Const, 0},
+ {"NT_PRPSINFO", Const, 0},
+ {"NT_PRSTATUS", Const, 0},
+ {"NType", Type, 0},
+ {"NewFile", Func, 0},
+ {"OSABI", Type, 0},
+ {"Open", Func, 0},
+ {"PF_MASKOS", Const, 0},
+ {"PF_MASKPROC", Const, 0},
+ {"PF_R", Const, 0},
+ {"PF_W", Const, 0},
+ {"PF_X", Const, 0},
+ {"PT_AARCH64_ARCHEXT", Const, 16},
+ {"PT_AARCH64_UNWIND", Const, 16},
+ {"PT_ARM_ARCHEXT", Const, 16},
+ {"PT_ARM_EXIDX", Const, 16},
+ {"PT_DYNAMIC", Const, 0},
+ {"PT_GNU_EH_FRAME", Const, 16},
+ {"PT_GNU_MBIND_HI", Const, 16},
+ {"PT_GNU_MBIND_LO", Const, 16},
+ {"PT_GNU_PROPERTY", Const, 16},
+ {"PT_GNU_RELRO", Const, 16},
+ {"PT_GNU_STACK", Const, 16},
+ {"PT_HIOS", Const, 0},
+ {"PT_HIPROC", Const, 0},
+ {"PT_INTERP", Const, 0},
+ {"PT_LOAD", Const, 0},
+ {"PT_LOOS", Const, 0},
+ {"PT_LOPROC", Const, 0},
+ {"PT_MIPS_ABIFLAGS", Const, 16},
+ {"PT_MIPS_OPTIONS", Const, 16},
+ {"PT_MIPS_REGINFO", Const, 16},
+ {"PT_MIPS_RTPROC", Const, 16},
+ {"PT_NOTE", Const, 0},
+ {"PT_NULL", Const, 0},
+ {"PT_OPENBSD_BOOTDATA", Const, 16},
+ {"PT_OPENBSD_NOBTCFI", Const, 23},
+ {"PT_OPENBSD_RANDOMIZE", Const, 16},
+ {"PT_OPENBSD_WXNEEDED", Const, 16},
+ {"PT_PAX_FLAGS", Const, 16},
+ {"PT_PHDR", Const, 0},
+ {"PT_S390_PGSTE", Const, 16},
+ {"PT_SHLIB", Const, 0},
+ {"PT_SUNWSTACK", Const, 16},
+ {"PT_SUNW_EH_FRAME", Const, 16},
+ {"PT_TLS", Const, 0},
+ {"Prog", Type, 0},
+ {"Prog.ProgHeader", Field, 0},
+ {"Prog.ReaderAt", Field, 0},
+ {"Prog32", Type, 0},
+ {"Prog32.Align", Field, 0},
+ {"Prog32.Filesz", Field, 0},
+ {"Prog32.Flags", Field, 0},
+ {"Prog32.Memsz", Field, 0},
+ {"Prog32.Off", Field, 0},
+ {"Prog32.Paddr", Field, 0},
+ {"Prog32.Type", Field, 0},
+ {"Prog32.Vaddr", Field, 0},
+ {"Prog64", Type, 0},
+ {"Prog64.Align", Field, 0},
+ {"Prog64.Filesz", Field, 0},
+ {"Prog64.Flags", Field, 0},
+ {"Prog64.Memsz", Field, 0},
+ {"Prog64.Off", Field, 0},
+ {"Prog64.Paddr", Field, 0},
+ {"Prog64.Type", Field, 0},
+ {"Prog64.Vaddr", Field, 0},
+ {"ProgFlag", Type, 0},
+ {"ProgHeader", Type, 0},
+ {"ProgHeader.Align", Field, 0},
+ {"ProgHeader.Filesz", Field, 0},
+ {"ProgHeader.Flags", Field, 0},
+ {"ProgHeader.Memsz", Field, 0},
+ {"ProgHeader.Off", Field, 0},
+ {"ProgHeader.Paddr", Field, 0},
+ {"ProgHeader.Type", Field, 0},
+ {"ProgHeader.Vaddr", Field, 0},
+ {"ProgType", Type, 0},
+ {"R_386", Type, 0},
+ {"R_386_16", Const, 10},
+ {"R_386_32", Const, 0},
+ {"R_386_32PLT", Const, 10},
+ {"R_386_8", Const, 10},
+ {"R_386_COPY", Const, 0},
+ {"R_386_GLOB_DAT", Const, 0},
+ {"R_386_GOT32", Const, 0},
+ {"R_386_GOT32X", Const, 10},
+ {"R_386_GOTOFF", Const, 0},
+ {"R_386_GOTPC", Const, 0},
+ {"R_386_IRELATIVE", Const, 10},
+ {"R_386_JMP_SLOT", Const, 0},
+ {"R_386_NONE", Const, 0},
+ {"R_386_PC16", Const, 10},
+ {"R_386_PC32", Const, 0},
+ {"R_386_PC8", Const, 10},
+ {"R_386_PLT32", Const, 0},
+ {"R_386_RELATIVE", Const, 0},
+ {"R_386_SIZE32", Const, 10},
+ {"R_386_TLS_DESC", Const, 10},
+ {"R_386_TLS_DESC_CALL", Const, 10},
+ {"R_386_TLS_DTPMOD32", Const, 0},
+ {"R_386_TLS_DTPOFF32", Const, 0},
+ {"R_386_TLS_GD", Const, 0},
+ {"R_386_TLS_GD_32", Const, 0},
+ {"R_386_TLS_GD_CALL", Const, 0},
+ {"R_386_TLS_GD_POP", Const, 0},
+ {"R_386_TLS_GD_PUSH", Const, 0},
+ {"R_386_TLS_GOTDESC", Const, 10},
+ {"R_386_TLS_GOTIE", Const, 0},
+ {"R_386_TLS_IE", Const, 0},
+ {"R_386_TLS_IE_32", Const, 0},
+ {"R_386_TLS_LDM", Const, 0},
+ {"R_386_TLS_LDM_32", Const, 0},
+ {"R_386_TLS_LDM_CALL", Const, 0},
+ {"R_386_TLS_LDM_POP", Const, 0},
+ {"R_386_TLS_LDM_PUSH", Const, 0},
+ {"R_386_TLS_LDO_32", Const, 0},
+ {"R_386_TLS_LE", Const, 0},
+ {"R_386_TLS_LE_32", Const, 0},
+ {"R_386_TLS_TPOFF", Const, 0},
+ {"R_386_TLS_TPOFF32", Const, 0},
+ {"R_390", Type, 7},
+ {"R_390_12", Const, 7},
+ {"R_390_16", Const, 7},
+ {"R_390_20", Const, 7},
+ {"R_390_32", Const, 7},
+ {"R_390_64", Const, 7},
+ {"R_390_8", Const, 7},
+ {"R_390_COPY", Const, 7},
+ {"R_390_GLOB_DAT", Const, 7},
+ {"R_390_GOT12", Const, 7},
+ {"R_390_GOT16", Const, 7},
+ {"R_390_GOT20", Const, 7},
+ {"R_390_GOT32", Const, 7},
+ {"R_390_GOT64", Const, 7},
+ {"R_390_GOTENT", Const, 7},
+ {"R_390_GOTOFF", Const, 7},
+ {"R_390_GOTOFF16", Const, 7},
+ {"R_390_GOTOFF64", Const, 7},
+ {"R_390_GOTPC", Const, 7},
+ {"R_390_GOTPCDBL", Const, 7},
+ {"R_390_GOTPLT12", Const, 7},
+ {"R_390_GOTPLT16", Const, 7},
+ {"R_390_GOTPLT20", Const, 7},
+ {"R_390_GOTPLT32", Const, 7},
+ {"R_390_GOTPLT64", Const, 7},
+ {"R_390_GOTPLTENT", Const, 7},
+ {"R_390_GOTPLTOFF16", Const, 7},
+ {"R_390_GOTPLTOFF32", Const, 7},
+ {"R_390_GOTPLTOFF64", Const, 7},
+ {"R_390_JMP_SLOT", Const, 7},
+ {"R_390_NONE", Const, 7},
+ {"R_390_PC16", Const, 7},
+ {"R_390_PC16DBL", Const, 7},
+ {"R_390_PC32", Const, 7},
+ {"R_390_PC32DBL", Const, 7},
+ {"R_390_PC64", Const, 7},
+ {"R_390_PLT16DBL", Const, 7},
+ {"R_390_PLT32", Const, 7},
+ {"R_390_PLT32DBL", Const, 7},
+ {"R_390_PLT64", Const, 7},
+ {"R_390_RELATIVE", Const, 7},
+ {"R_390_TLS_DTPMOD", Const, 7},
+ {"R_390_TLS_DTPOFF", Const, 7},
+ {"R_390_TLS_GD32", Const, 7},
+ {"R_390_TLS_GD64", Const, 7},
+ {"R_390_TLS_GDCALL", Const, 7},
+ {"R_390_TLS_GOTIE12", Const, 7},
+ {"R_390_TLS_GOTIE20", Const, 7},
+ {"R_390_TLS_GOTIE32", Const, 7},
+ {"R_390_TLS_GOTIE64", Const, 7},
+ {"R_390_TLS_IE32", Const, 7},
+ {"R_390_TLS_IE64", Const, 7},
+ {"R_390_TLS_IEENT", Const, 7},
+ {"R_390_TLS_LDCALL", Const, 7},
+ {"R_390_TLS_LDM32", Const, 7},
+ {"R_390_TLS_LDM64", Const, 7},
+ {"R_390_TLS_LDO32", Const, 7},
+ {"R_390_TLS_LDO64", Const, 7},
+ {"R_390_TLS_LE32", Const, 7},
+ {"R_390_TLS_LE64", Const, 7},
+ {"R_390_TLS_LOAD", Const, 7},
+ {"R_390_TLS_TPOFF", Const, 7},
+ {"R_AARCH64", Type, 4},
+ {"R_AARCH64_ABS16", Const, 4},
+ {"R_AARCH64_ABS32", Const, 4},
+ {"R_AARCH64_ABS64", Const, 4},
+ {"R_AARCH64_ADD_ABS_LO12_NC", Const, 4},
+ {"R_AARCH64_ADR_GOT_PAGE", Const, 4},
+ {"R_AARCH64_ADR_PREL_LO21", Const, 4},
+ {"R_AARCH64_ADR_PREL_PG_HI21", Const, 4},
+ {"R_AARCH64_ADR_PREL_PG_HI21_NC", Const, 4},
+ {"R_AARCH64_CALL26", Const, 4},
+ {"R_AARCH64_CONDBR19", Const, 4},
+ {"R_AARCH64_COPY", Const, 4},
+ {"R_AARCH64_GLOB_DAT", Const, 4},
+ {"R_AARCH64_GOT_LD_PREL19", Const, 4},
+ {"R_AARCH64_IRELATIVE", Const, 4},
+ {"R_AARCH64_JUMP26", Const, 4},
+ {"R_AARCH64_JUMP_SLOT", Const, 4},
+ {"R_AARCH64_LD64_GOTOFF_LO15", Const, 10},
+ {"R_AARCH64_LD64_GOTPAGE_LO15", Const, 10},
+ {"R_AARCH64_LD64_GOT_LO12_NC", Const, 4},
+ {"R_AARCH64_LDST128_ABS_LO12_NC", Const, 4},
+ {"R_AARCH64_LDST16_ABS_LO12_NC", Const, 4},
+ {"R_AARCH64_LDST32_ABS_LO12_NC", Const, 4},
+ {"R_AARCH64_LDST64_ABS_LO12_NC", Const, 4},
+ {"R_AARCH64_LDST8_ABS_LO12_NC", Const, 4},
+ {"R_AARCH64_LD_PREL_LO19", Const, 4},
+ {"R_AARCH64_MOVW_SABS_G0", Const, 4},
+ {"R_AARCH64_MOVW_SABS_G1", Const, 4},
+ {"R_AARCH64_MOVW_SABS_G2", Const, 4},
+ {"R_AARCH64_MOVW_UABS_G0", Const, 4},
+ {"R_AARCH64_MOVW_UABS_G0_NC", Const, 4},
+ {"R_AARCH64_MOVW_UABS_G1", Const, 4},
+ {"R_AARCH64_MOVW_UABS_G1_NC", Const, 4},
+ {"R_AARCH64_MOVW_UABS_G2", Const, 4},
+ {"R_AARCH64_MOVW_UABS_G2_NC", Const, 4},
+ {"R_AARCH64_MOVW_UABS_G3", Const, 4},
+ {"R_AARCH64_NONE", Const, 4},
+ {"R_AARCH64_NULL", Const, 4},
+ {"R_AARCH64_P32_ABS16", Const, 4},
+ {"R_AARCH64_P32_ABS32", Const, 4},
+ {"R_AARCH64_P32_ADD_ABS_LO12_NC", Const, 4},
+ {"R_AARCH64_P32_ADR_GOT_PAGE", Const, 4},
+ {"R_AARCH64_P32_ADR_PREL_LO21", Const, 4},
+ {"R_AARCH64_P32_ADR_PREL_PG_HI21", Const, 4},
+ {"R_AARCH64_P32_CALL26", Const, 4},
+ {"R_AARCH64_P32_CONDBR19", Const, 4},
+ {"R_AARCH64_P32_COPY", Const, 4},
+ {"R_AARCH64_P32_GLOB_DAT", Const, 4},
+ {"R_AARCH64_P32_GOT_LD_PREL19", Const, 4},
+ {"R_AARCH64_P32_IRELATIVE", Const, 4},
+ {"R_AARCH64_P32_JUMP26", Const, 4},
+ {"R_AARCH64_P32_JUMP_SLOT", Const, 4},
+ {"R_AARCH64_P32_LD32_GOT_LO12_NC", Const, 4},
+ {"R_AARCH64_P32_LDST128_ABS_LO12_NC", Const, 4},
+ {"R_AARCH64_P32_LDST16_ABS_LO12_NC", Const, 4},
+ {"R_AARCH64_P32_LDST32_ABS_LO12_NC", Const, 4},
+ {"R_AARCH64_P32_LDST64_ABS_LO12_NC", Const, 4},
+ {"R_AARCH64_P32_LDST8_ABS_LO12_NC", Const, 4},
+ {"R_AARCH64_P32_LD_PREL_LO19", Const, 4},
+ {"R_AARCH64_P32_MOVW_SABS_G0", Const, 4},
+ {"R_AARCH64_P32_MOVW_UABS_G0", Const, 4},
+ {"R_AARCH64_P32_MOVW_UABS_G0_NC", Const, 4},
+ {"R_AARCH64_P32_MOVW_UABS_G1", Const, 4},
+ {"R_AARCH64_P32_PREL16", Const, 4},
+ {"R_AARCH64_P32_PREL32", Const, 4},
+ {"R_AARCH64_P32_RELATIVE", Const, 4},
+ {"R_AARCH64_P32_TLSDESC", Const, 4},
+ {"R_AARCH64_P32_TLSDESC_ADD_LO12_NC", Const, 4},
+ {"R_AARCH64_P32_TLSDESC_ADR_PAGE21", Const, 4},
+ {"R_AARCH64_P32_TLSDESC_ADR_PREL21", Const, 4},
+ {"R_AARCH64_P32_TLSDESC_CALL", Const, 4},
+ {"R_AARCH64_P32_TLSDESC_LD32_LO12_NC", Const, 4},
+ {"R_AARCH64_P32_TLSDESC_LD_PREL19", Const, 4},
+ {"R_AARCH64_P32_TLSGD_ADD_LO12_NC", Const, 4},
+ {"R_AARCH64_P32_TLSGD_ADR_PAGE21", Const, 4},
+ {"R_AARCH64_P32_TLSIE_ADR_GOTTPREL_PAGE21", Const, 4},
+ {"R_AARCH64_P32_TLSIE_LD32_GOTTPREL_LO12_NC", Const, 4},
+ {"R_AARCH64_P32_TLSIE_LD_GOTTPREL_PREL19", Const, 4},
+ {"R_AARCH64_P32_TLSLE_ADD_TPREL_HI12", Const, 4},
+ {"R_AARCH64_P32_TLSLE_ADD_TPREL_LO12", Const, 4},
+ {"R_AARCH64_P32_TLSLE_ADD_TPREL_LO12_NC", Const, 4},
+ {"R_AARCH64_P32_TLSLE_MOVW_TPREL_G0", Const, 4},
+ {"R_AARCH64_P32_TLSLE_MOVW_TPREL_G0_NC", Const, 4},
+ {"R_AARCH64_P32_TLSLE_MOVW_TPREL_G1", Const, 4},
+ {"R_AARCH64_P32_TLS_DTPMOD", Const, 4},
+ {"R_AARCH64_P32_TLS_DTPREL", Const, 4},
+ {"R_AARCH64_P32_TLS_TPREL", Const, 4},
+ {"R_AARCH64_P32_TSTBR14", Const, 4},
+ {"R_AARCH64_PREL16", Const, 4},
+ {"R_AARCH64_PREL32", Const, 4},
+ {"R_AARCH64_PREL64", Const, 4},
+ {"R_AARCH64_RELATIVE", Const, 4},
+ {"R_AARCH64_TLSDESC", Const, 4},
+ {"R_AARCH64_TLSDESC_ADD", Const, 4},
+ {"R_AARCH64_TLSDESC_ADD_LO12_NC", Const, 4},
+ {"R_AARCH64_TLSDESC_ADR_PAGE21", Const, 4},
+ {"R_AARCH64_TLSDESC_ADR_PREL21", Const, 4},
+ {"R_AARCH64_TLSDESC_CALL", Const, 4},
+ {"R_AARCH64_TLSDESC_LD64_LO12_NC", Const, 4},
+ {"R_AARCH64_TLSDESC_LDR", Const, 4},
+ {"R_AARCH64_TLSDESC_LD_PREL19", Const, 4},
+ {"R_AARCH64_TLSDESC_OFF_G0_NC", Const, 4},
+ {"R_AARCH64_TLSDESC_OFF_G1", Const, 4},
+ {"R_AARCH64_TLSGD_ADD_LO12_NC", Const, 4},
+ {"R_AARCH64_TLSGD_ADR_PAGE21", Const, 4},
+ {"R_AARCH64_TLSGD_ADR_PREL21", Const, 10},
+ {"R_AARCH64_TLSGD_MOVW_G0_NC", Const, 10},
+ {"R_AARCH64_TLSGD_MOVW_G1", Const, 10},
+ {"R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21", Const, 4},
+ {"R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC", Const, 4},
+ {"R_AARCH64_TLSIE_LD_GOTTPREL_PREL19", Const, 4},
+ {"R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC", Const, 4},
+ {"R_AARCH64_TLSIE_MOVW_GOTTPREL_G1", Const, 4},
+ {"R_AARCH64_TLSLD_ADR_PAGE21", Const, 10},
+ {"R_AARCH64_TLSLD_ADR_PREL21", Const, 10},
+ {"R_AARCH64_TLSLD_LDST128_DTPREL_LO12", Const, 10},
+ {"R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC", Const, 10},
+ {"R_AARCH64_TLSLE_ADD_TPREL_HI12", Const, 4},
+ {"R_AARCH64_TLSLE_ADD_TPREL_LO12", Const, 4},
+ {"R_AARCH64_TLSLE_ADD_TPREL_LO12_NC", Const, 4},
+ {"R_AARCH64_TLSLE_LDST128_TPREL_LO12", Const, 10},
+ {"R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC", Const, 10},
+ {"R_AARCH64_TLSLE_MOVW_TPREL_G0", Const, 4},
+ {"R_AARCH64_TLSLE_MOVW_TPREL_G0_NC", Const, 4},
+ {"R_AARCH64_TLSLE_MOVW_TPREL_G1", Const, 4},
+ {"R_AARCH64_TLSLE_MOVW_TPREL_G1_NC", Const, 4},
+ {"R_AARCH64_TLSLE_MOVW_TPREL_G2", Const, 4},
+ {"R_AARCH64_TLS_DTPMOD64", Const, 4},
+ {"R_AARCH64_TLS_DTPREL64", Const, 4},
+ {"R_AARCH64_TLS_TPREL64", Const, 4},
+ {"R_AARCH64_TSTBR14", Const, 4},
+ {"R_ALPHA", Type, 0},
+ {"R_ALPHA_BRADDR", Const, 0},
+ {"R_ALPHA_COPY", Const, 0},
+ {"R_ALPHA_GLOB_DAT", Const, 0},
+ {"R_ALPHA_GPDISP", Const, 0},
+ {"R_ALPHA_GPREL32", Const, 0},
+ {"R_ALPHA_GPRELHIGH", Const, 0},
+ {"R_ALPHA_GPRELLOW", Const, 0},
+ {"R_ALPHA_GPVALUE", Const, 0},
+ {"R_ALPHA_HINT", Const, 0},
+ {"R_ALPHA_IMMED_BR_HI32", Const, 0},
+ {"R_ALPHA_IMMED_GP_16", Const, 0},
+ {"R_ALPHA_IMMED_GP_HI32", Const, 0},
+ {"R_ALPHA_IMMED_LO32", Const, 0},
+ {"R_ALPHA_IMMED_SCN_HI32", Const, 0},
+ {"R_ALPHA_JMP_SLOT", Const, 0},
+ {"R_ALPHA_LITERAL", Const, 0},
+ {"R_ALPHA_LITUSE", Const, 0},
+ {"R_ALPHA_NONE", Const, 0},
+ {"R_ALPHA_OP_PRSHIFT", Const, 0},
+ {"R_ALPHA_OP_PSUB", Const, 0},
+ {"R_ALPHA_OP_PUSH", Const, 0},
+ {"R_ALPHA_OP_STORE", Const, 0},
+ {"R_ALPHA_REFLONG", Const, 0},
+ {"R_ALPHA_REFQUAD", Const, 0},
+ {"R_ALPHA_RELATIVE", Const, 0},
+ {"R_ALPHA_SREL16", Const, 0},
+ {"R_ALPHA_SREL32", Const, 0},
+ {"R_ALPHA_SREL64", Const, 0},
+ {"R_ARM", Type, 0},
+ {"R_ARM_ABS12", Const, 0},
+ {"R_ARM_ABS16", Const, 0},
+ {"R_ARM_ABS32", Const, 0},
+ {"R_ARM_ABS32_NOI", Const, 10},
+ {"R_ARM_ABS8", Const, 0},
+ {"R_ARM_ALU_PCREL_15_8", Const, 10},
+ {"R_ARM_ALU_PCREL_23_15", Const, 10},
+ {"R_ARM_ALU_PCREL_7_0", Const, 10},
+ {"R_ARM_ALU_PC_G0", Const, 10},
+ {"R_ARM_ALU_PC_G0_NC", Const, 10},
+ {"R_ARM_ALU_PC_G1", Const, 10},
+ {"R_ARM_ALU_PC_G1_NC", Const, 10},
+ {"R_ARM_ALU_PC_G2", Const, 10},
+ {"R_ARM_ALU_SBREL_19_12_NC", Const, 10},
+ {"R_ARM_ALU_SBREL_27_20_CK", Const, 10},
+ {"R_ARM_ALU_SB_G0", Const, 10},
+ {"R_ARM_ALU_SB_G0_NC", Const, 10},
+ {"R_ARM_ALU_SB_G1", Const, 10},
+ {"R_ARM_ALU_SB_G1_NC", Const, 10},
+ {"R_ARM_ALU_SB_G2", Const, 10},
+ {"R_ARM_AMP_VCALL9", Const, 0},
+ {"R_ARM_BASE_ABS", Const, 10},
+ {"R_ARM_CALL", Const, 10},
+ {"R_ARM_COPY", Const, 0},
+ {"R_ARM_GLOB_DAT", Const, 0},
+ {"R_ARM_GNU_VTENTRY", Const, 0},
+ {"R_ARM_GNU_VTINHERIT", Const, 0},
+ {"R_ARM_GOT32", Const, 0},
+ {"R_ARM_GOTOFF", Const, 0},
+ {"R_ARM_GOTOFF12", Const, 10},
+ {"R_ARM_GOTPC", Const, 0},
+ {"R_ARM_GOTRELAX", Const, 10},
+ {"R_ARM_GOT_ABS", Const, 10},
+ {"R_ARM_GOT_BREL12", Const, 10},
+ {"R_ARM_GOT_PREL", Const, 10},
+ {"R_ARM_IRELATIVE", Const, 10},
+ {"R_ARM_JUMP24", Const, 10},
+ {"R_ARM_JUMP_SLOT", Const, 0},
+ {"R_ARM_LDC_PC_G0", Const, 10},
+ {"R_ARM_LDC_PC_G1", Const, 10},
+ {"R_ARM_LDC_PC_G2", Const, 10},
+ {"R_ARM_LDC_SB_G0", Const, 10},
+ {"R_ARM_LDC_SB_G1", Const, 10},
+ {"R_ARM_LDC_SB_G2", Const, 10},
+ {"R_ARM_LDRS_PC_G0", Const, 10},
+ {"R_ARM_LDRS_PC_G1", Const, 10},
+ {"R_ARM_LDRS_PC_G2", Const, 10},
+ {"R_ARM_LDRS_SB_G0", Const, 10},
+ {"R_ARM_LDRS_SB_G1", Const, 10},
+ {"R_ARM_LDRS_SB_G2", Const, 10},
+ {"R_ARM_LDR_PC_G1", Const, 10},
+ {"R_ARM_LDR_PC_G2", Const, 10},
+ {"R_ARM_LDR_SBREL_11_10_NC", Const, 10},
+ {"R_ARM_LDR_SB_G0", Const, 10},
+ {"R_ARM_LDR_SB_G1", Const, 10},
+ {"R_ARM_LDR_SB_G2", Const, 10},
+ {"R_ARM_ME_TOO", Const, 10},
+ {"R_ARM_MOVT_ABS", Const, 10},
+ {"R_ARM_MOVT_BREL", Const, 10},
+ {"R_ARM_MOVT_PREL", Const, 10},
+ {"R_ARM_MOVW_ABS_NC", Const, 10},
+ {"R_ARM_MOVW_BREL", Const, 10},
+ {"R_ARM_MOVW_BREL_NC", Const, 10},
+ {"R_ARM_MOVW_PREL_NC", Const, 10},
+ {"R_ARM_NONE", Const, 0},
+ {"R_ARM_PC13", Const, 0},
+ {"R_ARM_PC24", Const, 0},
+ {"R_ARM_PLT32", Const, 0},
+ {"R_ARM_PLT32_ABS", Const, 10},
+ {"R_ARM_PREL31", Const, 10},
+ {"R_ARM_PRIVATE_0", Const, 10},
+ {"R_ARM_PRIVATE_1", Const, 10},
+ {"R_ARM_PRIVATE_10", Const, 10},
+ {"R_ARM_PRIVATE_11", Const, 10},
+ {"R_ARM_PRIVATE_12", Const, 10},
+ {"R_ARM_PRIVATE_13", Const, 10},
+ {"R_ARM_PRIVATE_14", Const, 10},
+ {"R_ARM_PRIVATE_15", Const, 10},
+ {"R_ARM_PRIVATE_2", Const, 10},
+ {"R_ARM_PRIVATE_3", Const, 10},
+ {"R_ARM_PRIVATE_4", Const, 10},
+ {"R_ARM_PRIVATE_5", Const, 10},
+ {"R_ARM_PRIVATE_6", Const, 10},
+ {"R_ARM_PRIVATE_7", Const, 10},
+ {"R_ARM_PRIVATE_8", Const, 10},
+ {"R_ARM_PRIVATE_9", Const, 10},
+ {"R_ARM_RABS32", Const, 0},
+ {"R_ARM_RBASE", Const, 0},
+ {"R_ARM_REL32", Const, 0},
+ {"R_ARM_REL32_NOI", Const, 10},
+ {"R_ARM_RELATIVE", Const, 0},
+ {"R_ARM_RPC24", Const, 0},
+ {"R_ARM_RREL32", Const, 0},
+ {"R_ARM_RSBREL32", Const, 0},
+ {"R_ARM_RXPC25", Const, 10},
+ {"R_ARM_SBREL31", Const, 10},
+ {"R_ARM_SBREL32", Const, 0},
+ {"R_ARM_SWI24", Const, 0},
+ {"R_ARM_TARGET1", Const, 10},
+ {"R_ARM_TARGET2", Const, 10},
+ {"R_ARM_THM_ABS5", Const, 0},
+ {"R_ARM_THM_ALU_ABS_G0_NC", Const, 10},
+ {"R_ARM_THM_ALU_ABS_G1_NC", Const, 10},
+ {"R_ARM_THM_ALU_ABS_G2_NC", Const, 10},
+ {"R_ARM_THM_ALU_ABS_G3", Const, 10},
+ {"R_ARM_THM_ALU_PREL_11_0", Const, 10},
+ {"R_ARM_THM_GOT_BREL12", Const, 10},
+ {"R_ARM_THM_JUMP11", Const, 10},
+ {"R_ARM_THM_JUMP19", Const, 10},
+ {"R_ARM_THM_JUMP24", Const, 10},
+ {"R_ARM_THM_JUMP6", Const, 10},
+ {"R_ARM_THM_JUMP8", Const, 10},
+ {"R_ARM_THM_MOVT_ABS", Const, 10},
+ {"R_ARM_THM_MOVT_BREL", Const, 10},
+ {"R_ARM_THM_MOVT_PREL", Const, 10},
+ {"R_ARM_THM_MOVW_ABS_NC", Const, 10},
+ {"R_ARM_THM_MOVW_BREL", Const, 10},
+ {"R_ARM_THM_MOVW_BREL_NC", Const, 10},
+ {"R_ARM_THM_MOVW_PREL_NC", Const, 10},
+ {"R_ARM_THM_PC12", Const, 10},
+ {"R_ARM_THM_PC22", Const, 0},
+ {"R_ARM_THM_PC8", Const, 0},
+ {"R_ARM_THM_RPC22", Const, 0},
+ {"R_ARM_THM_SWI8", Const, 0},
+ {"R_ARM_THM_TLS_CALL", Const, 10},
+ {"R_ARM_THM_TLS_DESCSEQ16", Const, 10},
+ {"R_ARM_THM_TLS_DESCSEQ32", Const, 10},
+ {"R_ARM_THM_XPC22", Const, 0},
+ {"R_ARM_TLS_CALL", Const, 10},
+ {"R_ARM_TLS_DESCSEQ", Const, 10},
+ {"R_ARM_TLS_DTPMOD32", Const, 10},
+ {"R_ARM_TLS_DTPOFF32", Const, 10},
+ {"R_ARM_TLS_GD32", Const, 10},
+ {"R_ARM_TLS_GOTDESC", Const, 10},
+ {"R_ARM_TLS_IE12GP", Const, 10},
+ {"R_ARM_TLS_IE32", Const, 10},
+ {"R_ARM_TLS_LDM32", Const, 10},
+ {"R_ARM_TLS_LDO12", Const, 10},
+ {"R_ARM_TLS_LDO32", Const, 10},
+ {"R_ARM_TLS_LE12", Const, 10},
+ {"R_ARM_TLS_LE32", Const, 10},
+ {"R_ARM_TLS_TPOFF32", Const, 10},
+ {"R_ARM_V4BX", Const, 10},
+ {"R_ARM_XPC25", Const, 0},
+ {"R_INFO", Func, 0},
+ {"R_INFO32", Func, 0},
+ {"R_LARCH", Type, 19},
+ {"R_LARCH_32", Const, 19},
+ {"R_LARCH_32_PCREL", Const, 20},
+ {"R_LARCH_64", Const, 19},
+ {"R_LARCH_64_PCREL", Const, 22},
+ {"R_LARCH_ABS64_HI12", Const, 20},
+ {"R_LARCH_ABS64_LO20", Const, 20},
+ {"R_LARCH_ABS_HI20", Const, 20},
+ {"R_LARCH_ABS_LO12", Const, 20},
+ {"R_LARCH_ADD16", Const, 19},
+ {"R_LARCH_ADD24", Const, 19},
+ {"R_LARCH_ADD32", Const, 19},
+ {"R_LARCH_ADD6", Const, 22},
+ {"R_LARCH_ADD64", Const, 19},
+ {"R_LARCH_ADD8", Const, 19},
+ {"R_LARCH_ADD_ULEB128", Const, 22},
+ {"R_LARCH_ALIGN", Const, 22},
+ {"R_LARCH_B16", Const, 20},
+ {"R_LARCH_B21", Const, 20},
+ {"R_LARCH_B26", Const, 20},
+ {"R_LARCH_CFA", Const, 22},
+ {"R_LARCH_COPY", Const, 19},
+ {"R_LARCH_DELETE", Const, 22},
+ {"R_LARCH_GNU_VTENTRY", Const, 20},
+ {"R_LARCH_GNU_VTINHERIT", Const, 20},
+ {"R_LARCH_GOT64_HI12", Const, 20},
+ {"R_LARCH_GOT64_LO20", Const, 20},
+ {"R_LARCH_GOT64_PC_HI12", Const, 20},
+ {"R_LARCH_GOT64_PC_LO20", Const, 20},
+ {"R_LARCH_GOT_HI20", Const, 20},
+ {"R_LARCH_GOT_LO12", Const, 20},
+ {"R_LARCH_GOT_PC_HI20", Const, 20},
+ {"R_LARCH_GOT_PC_LO12", Const, 20},
+ {"R_LARCH_IRELATIVE", Const, 19},
+ {"R_LARCH_JUMP_SLOT", Const, 19},
+ {"R_LARCH_MARK_LA", Const, 19},
+ {"R_LARCH_MARK_PCREL", Const, 19},
+ {"R_LARCH_NONE", Const, 19},
+ {"R_LARCH_PCALA64_HI12", Const, 20},
+ {"R_LARCH_PCALA64_LO20", Const, 20},
+ {"R_LARCH_PCALA_HI20", Const, 20},
+ {"R_LARCH_PCALA_LO12", Const, 20},
+ {"R_LARCH_PCREL20_S2", Const, 22},
+ {"R_LARCH_RELATIVE", Const, 19},
+ {"R_LARCH_RELAX", Const, 20},
+ {"R_LARCH_SOP_ADD", Const, 19},
+ {"R_LARCH_SOP_AND", Const, 19},
+ {"R_LARCH_SOP_ASSERT", Const, 19},
+ {"R_LARCH_SOP_IF_ELSE", Const, 19},
+ {"R_LARCH_SOP_NOT", Const, 19},
+ {"R_LARCH_SOP_POP_32_S_0_10_10_16_S2", Const, 19},
+ {"R_LARCH_SOP_POP_32_S_0_5_10_16_S2", Const, 19},
+ {"R_LARCH_SOP_POP_32_S_10_12", Const, 19},
+ {"R_LARCH_SOP_POP_32_S_10_16", Const, 19},
+ {"R_LARCH_SOP_POP_32_S_10_16_S2", Const, 19},
+ {"R_LARCH_SOP_POP_32_S_10_5", Const, 19},
+ {"R_LARCH_SOP_POP_32_S_5_20", Const, 19},
+ {"R_LARCH_SOP_POP_32_U", Const, 19},
+ {"R_LARCH_SOP_POP_32_U_10_12", Const, 19},
+ {"R_LARCH_SOP_PUSH_ABSOLUTE", Const, 19},
+ {"R_LARCH_SOP_PUSH_DUP", Const, 19},
+ {"R_LARCH_SOP_PUSH_GPREL", Const, 19},
+ {"R_LARCH_SOP_PUSH_PCREL", Const, 19},
+ {"R_LARCH_SOP_PUSH_PLT_PCREL", Const, 19},
+ {"R_LARCH_SOP_PUSH_TLS_GD", Const, 19},
+ {"R_LARCH_SOP_PUSH_TLS_GOT", Const, 19},
+ {"R_LARCH_SOP_PUSH_TLS_TPREL", Const, 19},
+ {"R_LARCH_SOP_SL", Const, 19},
+ {"R_LARCH_SOP_SR", Const, 19},
+ {"R_LARCH_SOP_SUB", Const, 19},
+ {"R_LARCH_SUB16", Const, 19},
+ {"R_LARCH_SUB24", Const, 19},
+ {"R_LARCH_SUB32", Const, 19},
+ {"R_LARCH_SUB6", Const, 22},
+ {"R_LARCH_SUB64", Const, 19},
+ {"R_LARCH_SUB8", Const, 19},
+ {"R_LARCH_SUB_ULEB128", Const, 22},
+ {"R_LARCH_TLS_DTPMOD32", Const, 19},
+ {"R_LARCH_TLS_DTPMOD64", Const, 19},
+ {"R_LARCH_TLS_DTPREL32", Const, 19},
+ {"R_LARCH_TLS_DTPREL64", Const, 19},
+ {"R_LARCH_TLS_GD_HI20", Const, 20},
+ {"R_LARCH_TLS_GD_PC_HI20", Const, 20},
+ {"R_LARCH_TLS_IE64_HI12", Const, 20},
+ {"R_LARCH_TLS_IE64_LO20", Const, 20},
+ {"R_LARCH_TLS_IE64_PC_HI12", Const, 20},
+ {"R_LARCH_TLS_IE64_PC_LO20", Const, 20},
+ {"R_LARCH_TLS_IE_HI20", Const, 20},
+ {"R_LARCH_TLS_IE_LO12", Const, 20},
+ {"R_LARCH_TLS_IE_PC_HI20", Const, 20},
+ {"R_LARCH_TLS_IE_PC_LO12", Const, 20},
+ {"R_LARCH_TLS_LD_HI20", Const, 20},
+ {"R_LARCH_TLS_LD_PC_HI20", Const, 20},
+ {"R_LARCH_TLS_LE64_HI12", Const, 20},
+ {"R_LARCH_TLS_LE64_LO20", Const, 20},
+ {"R_LARCH_TLS_LE_HI20", Const, 20},
+ {"R_LARCH_TLS_LE_LO12", Const, 20},
+ {"R_LARCH_TLS_TPREL32", Const, 19},
+ {"R_LARCH_TLS_TPREL64", Const, 19},
+ {"R_MIPS", Type, 6},
+ {"R_MIPS_16", Const, 6},
+ {"R_MIPS_26", Const, 6},
+ {"R_MIPS_32", Const, 6},
+ {"R_MIPS_64", Const, 6},
+ {"R_MIPS_ADD_IMMEDIATE", Const, 6},
+ {"R_MIPS_CALL16", Const, 6},
+ {"R_MIPS_CALL_HI16", Const, 6},
+ {"R_MIPS_CALL_LO16", Const, 6},
+ {"R_MIPS_DELETE", Const, 6},
+ {"R_MIPS_GOT16", Const, 6},
+ {"R_MIPS_GOT_DISP", Const, 6},
+ {"R_MIPS_GOT_HI16", Const, 6},
+ {"R_MIPS_GOT_LO16", Const, 6},
+ {"R_MIPS_GOT_OFST", Const, 6},
+ {"R_MIPS_GOT_PAGE", Const, 6},
+ {"R_MIPS_GPREL16", Const, 6},
+ {"R_MIPS_GPREL32", Const, 6},
+ {"R_MIPS_HI16", Const, 6},
+ {"R_MIPS_HIGHER", Const, 6},
+ {"R_MIPS_HIGHEST", Const, 6},
+ {"R_MIPS_INSERT_A", Const, 6},
+ {"R_MIPS_INSERT_B", Const, 6},
+ {"R_MIPS_JALR", Const, 6},
+ {"R_MIPS_LITERAL", Const, 6},
+ {"R_MIPS_LO16", Const, 6},
+ {"R_MIPS_NONE", Const, 6},
+ {"R_MIPS_PC16", Const, 6},
+ {"R_MIPS_PC32", Const, 22},
+ {"R_MIPS_PJUMP", Const, 6},
+ {"R_MIPS_REL16", Const, 6},
+ {"R_MIPS_REL32", Const, 6},
+ {"R_MIPS_RELGOT", Const, 6},
+ {"R_MIPS_SCN_DISP", Const, 6},
+ {"R_MIPS_SHIFT5", Const, 6},
+ {"R_MIPS_SHIFT6", Const, 6},
+ {"R_MIPS_SUB", Const, 6},
+ {"R_MIPS_TLS_DTPMOD32", Const, 6},
+ {"R_MIPS_TLS_DTPMOD64", Const, 6},
+ {"R_MIPS_TLS_DTPREL32", Const, 6},
+ {"R_MIPS_TLS_DTPREL64", Const, 6},
+ {"R_MIPS_TLS_DTPREL_HI16", Const, 6},
+ {"R_MIPS_TLS_DTPREL_LO16", Const, 6},
+ {"R_MIPS_TLS_GD", Const, 6},
+ {"R_MIPS_TLS_GOTTPREL", Const, 6},
+ {"R_MIPS_TLS_LDM", Const, 6},
+ {"R_MIPS_TLS_TPREL32", Const, 6},
+ {"R_MIPS_TLS_TPREL64", Const, 6},
+ {"R_MIPS_TLS_TPREL_HI16", Const, 6},
+ {"R_MIPS_TLS_TPREL_LO16", Const, 6},
+ {"R_PPC", Type, 0},
+ {"R_PPC64", Type, 5},
+ {"R_PPC64_ADDR14", Const, 5},
+ {"R_PPC64_ADDR14_BRNTAKEN", Const, 5},
+ {"R_PPC64_ADDR14_BRTAKEN", Const, 5},
+ {"R_PPC64_ADDR16", Const, 5},
+ {"R_PPC64_ADDR16_DS", Const, 5},
+ {"R_PPC64_ADDR16_HA", Const, 5},
+ {"R_PPC64_ADDR16_HI", Const, 5},
+ {"R_PPC64_ADDR16_HIGH", Const, 10},
+ {"R_PPC64_ADDR16_HIGHA", Const, 10},
+ {"R_PPC64_ADDR16_HIGHER", Const, 5},
+ {"R_PPC64_ADDR16_HIGHER34", Const, 20},
+ {"R_PPC64_ADDR16_HIGHERA", Const, 5},
+ {"R_PPC64_ADDR16_HIGHERA34", Const, 20},
+ {"R_PPC64_ADDR16_HIGHEST", Const, 5},
+ {"R_PPC64_ADDR16_HIGHEST34", Const, 20},
+ {"R_PPC64_ADDR16_HIGHESTA", Const, 5},
+ {"R_PPC64_ADDR16_HIGHESTA34", Const, 20},
+ {"R_PPC64_ADDR16_LO", Const, 5},
+ {"R_PPC64_ADDR16_LO_DS", Const, 5},
+ {"R_PPC64_ADDR24", Const, 5},
+ {"R_PPC64_ADDR32", Const, 5},
+ {"R_PPC64_ADDR64", Const, 5},
+ {"R_PPC64_ADDR64_LOCAL", Const, 10},
+ {"R_PPC64_COPY", Const, 20},
+ {"R_PPC64_D28", Const, 20},
+ {"R_PPC64_D34", Const, 20},
+ {"R_PPC64_D34_HA30", Const, 20},
+ {"R_PPC64_D34_HI30", Const, 20},
+ {"R_PPC64_D34_LO", Const, 20},
+ {"R_PPC64_DTPMOD64", Const, 5},
+ {"R_PPC64_DTPREL16", Const, 5},
+ {"R_PPC64_DTPREL16_DS", Const, 5},
+ {"R_PPC64_DTPREL16_HA", Const, 5},
+ {"R_PPC64_DTPREL16_HI", Const, 5},
+ {"R_PPC64_DTPREL16_HIGH", Const, 10},
+ {"R_PPC64_DTPREL16_HIGHA", Const, 10},
+ {"R_PPC64_DTPREL16_HIGHER", Const, 5},
+ {"R_PPC64_DTPREL16_HIGHERA", Const, 5},
+ {"R_PPC64_DTPREL16_HIGHEST", Const, 5},
+ {"R_PPC64_DTPREL16_HIGHESTA", Const, 5},
+ {"R_PPC64_DTPREL16_LO", Const, 5},
+ {"R_PPC64_DTPREL16_LO_DS", Const, 5},
+ {"R_PPC64_DTPREL34", Const, 20},
+ {"R_PPC64_DTPREL64", Const, 5},
+ {"R_PPC64_ENTRY", Const, 10},
+ {"R_PPC64_GLOB_DAT", Const, 20},
+ {"R_PPC64_GNU_VTENTRY", Const, 20},
+ {"R_PPC64_GNU_VTINHERIT", Const, 20},
+ {"R_PPC64_GOT16", Const, 5},
+ {"R_PPC64_GOT16_DS", Const, 5},
+ {"R_PPC64_GOT16_HA", Const, 5},
+ {"R_PPC64_GOT16_HI", Const, 5},
+ {"R_PPC64_GOT16_LO", Const, 5},
+ {"R_PPC64_GOT16_LO_DS", Const, 5},
+ {"R_PPC64_GOT_DTPREL16_DS", Const, 5},
+ {"R_PPC64_GOT_DTPREL16_HA", Const, 5},
+ {"R_PPC64_GOT_DTPREL16_HI", Const, 5},
+ {"R_PPC64_GOT_DTPREL16_LO_DS", Const, 5},
+ {"R_PPC64_GOT_DTPREL_PCREL34", Const, 20},
+ {"R_PPC64_GOT_PCREL34", Const, 20},
+ {"R_PPC64_GOT_TLSGD16", Const, 5},
+ {"R_PPC64_GOT_TLSGD16_HA", Const, 5},
+ {"R_PPC64_GOT_TLSGD16_HI", Const, 5},
+ {"R_PPC64_GOT_TLSGD16_LO", Const, 5},
+ {"R_PPC64_GOT_TLSGD_PCREL34", Const, 20},
+ {"R_PPC64_GOT_TLSLD16", Const, 5},
+ {"R_PPC64_GOT_TLSLD16_HA", Const, 5},
+ {"R_PPC64_GOT_TLSLD16_HI", Const, 5},
+ {"R_PPC64_GOT_TLSLD16_LO", Const, 5},
+ {"R_PPC64_GOT_TLSLD_PCREL34", Const, 20},
+ {"R_PPC64_GOT_TPREL16_DS", Const, 5},
+ {"R_PPC64_GOT_TPREL16_HA", Const, 5},
+ {"R_PPC64_GOT_TPREL16_HI", Const, 5},
+ {"R_PPC64_GOT_TPREL16_LO_DS", Const, 5},
+ {"R_PPC64_GOT_TPREL_PCREL34", Const, 20},
+ {"R_PPC64_IRELATIVE", Const, 10},
+ {"R_PPC64_JMP_IREL", Const, 10},
+ {"R_PPC64_JMP_SLOT", Const, 5},
+ {"R_PPC64_NONE", Const, 5},
+ {"R_PPC64_PCREL28", Const, 20},
+ {"R_PPC64_PCREL34", Const, 20},
+ {"R_PPC64_PCREL_OPT", Const, 20},
+ {"R_PPC64_PLT16_HA", Const, 20},
+ {"R_PPC64_PLT16_HI", Const, 20},
+ {"R_PPC64_PLT16_LO", Const, 20},
+ {"R_PPC64_PLT16_LO_DS", Const, 10},
+ {"R_PPC64_PLT32", Const, 20},
+ {"R_PPC64_PLT64", Const, 20},
+ {"R_PPC64_PLTCALL", Const, 20},
+ {"R_PPC64_PLTCALL_NOTOC", Const, 20},
+ {"R_PPC64_PLTGOT16", Const, 10},
+ {"R_PPC64_PLTGOT16_DS", Const, 10},
+ {"R_PPC64_PLTGOT16_HA", Const, 10},
+ {"R_PPC64_PLTGOT16_HI", Const, 10},
+ {"R_PPC64_PLTGOT16_LO", Const, 10},
+ {"R_PPC64_PLTGOT_LO_DS", Const, 10},
+ {"R_PPC64_PLTREL32", Const, 20},
+ {"R_PPC64_PLTREL64", Const, 20},
+ {"R_PPC64_PLTSEQ", Const, 20},
+ {"R_PPC64_PLTSEQ_NOTOC", Const, 20},
+ {"R_PPC64_PLT_PCREL34", Const, 20},
+ {"R_PPC64_PLT_PCREL34_NOTOC", Const, 20},
+ {"R_PPC64_REL14", Const, 5},
+ {"R_PPC64_REL14_BRNTAKEN", Const, 5},
+ {"R_PPC64_REL14_BRTAKEN", Const, 5},
+ {"R_PPC64_REL16", Const, 5},
+ {"R_PPC64_REL16DX_HA", Const, 10},
+ {"R_PPC64_REL16_HA", Const, 5},
+ {"R_PPC64_REL16_HI", Const, 5},
+ {"R_PPC64_REL16_HIGH", Const, 20},
+ {"R_PPC64_REL16_HIGHA", Const, 20},
+ {"R_PPC64_REL16_HIGHER", Const, 20},
+ {"R_PPC64_REL16_HIGHER34", Const, 20},
+ {"R_PPC64_REL16_HIGHERA", Const, 20},
+ {"R_PPC64_REL16_HIGHERA34", Const, 20},
+ {"R_PPC64_REL16_HIGHEST", Const, 20},
+ {"R_PPC64_REL16_HIGHEST34", Const, 20},
+ {"R_PPC64_REL16_HIGHESTA", Const, 20},
+ {"R_PPC64_REL16_HIGHESTA34", Const, 20},
+ {"R_PPC64_REL16_LO", Const, 5},
+ {"R_PPC64_REL24", Const, 5},
+ {"R_PPC64_REL24_NOTOC", Const, 10},
+ {"R_PPC64_REL24_P9NOTOC", Const, 21},
+ {"R_PPC64_REL30", Const, 20},
+ {"R_PPC64_REL32", Const, 5},
+ {"R_PPC64_REL64", Const, 5},
+ {"R_PPC64_RELATIVE", Const, 18},
+ {"R_PPC64_SECTOFF", Const, 20},
+ {"R_PPC64_SECTOFF_DS", Const, 10},
+ {"R_PPC64_SECTOFF_HA", Const, 20},
+ {"R_PPC64_SECTOFF_HI", Const, 20},
+ {"R_PPC64_SECTOFF_LO", Const, 20},
+ {"R_PPC64_SECTOFF_LO_DS", Const, 10},
+ {"R_PPC64_TLS", Const, 5},
+ {"R_PPC64_TLSGD", Const, 5},
+ {"R_PPC64_TLSLD", Const, 5},
+ {"R_PPC64_TOC", Const, 5},
+ {"R_PPC64_TOC16", Const, 5},
+ {"R_PPC64_TOC16_DS", Const, 5},
+ {"R_PPC64_TOC16_HA", Const, 5},
+ {"R_PPC64_TOC16_HI", Const, 5},
+ {"R_PPC64_TOC16_LO", Const, 5},
+ {"R_PPC64_TOC16_LO_DS", Const, 5},
+ {"R_PPC64_TOCSAVE", Const, 10},
+ {"R_PPC64_TPREL16", Const, 5},
+ {"R_PPC64_TPREL16_DS", Const, 5},
+ {"R_PPC64_TPREL16_HA", Const, 5},
+ {"R_PPC64_TPREL16_HI", Const, 5},
+ {"R_PPC64_TPREL16_HIGH", Const, 10},
+ {"R_PPC64_TPREL16_HIGHA", Const, 10},
+ {"R_PPC64_TPREL16_HIGHER", Const, 5},
+ {"R_PPC64_TPREL16_HIGHERA", Const, 5},
+ {"R_PPC64_TPREL16_HIGHEST", Const, 5},
+ {"R_PPC64_TPREL16_HIGHESTA", Const, 5},
+ {"R_PPC64_TPREL16_LO", Const, 5},
+ {"R_PPC64_TPREL16_LO_DS", Const, 5},
+ {"R_PPC64_TPREL34", Const, 20},
+ {"R_PPC64_TPREL64", Const, 5},
+ {"R_PPC64_UADDR16", Const, 20},
+ {"R_PPC64_UADDR32", Const, 20},
+ {"R_PPC64_UADDR64", Const, 20},
+ {"R_PPC_ADDR14", Const, 0},
+ {"R_PPC_ADDR14_BRNTAKEN", Const, 0},
+ {"R_PPC_ADDR14_BRTAKEN", Const, 0},
+ {"R_PPC_ADDR16", Const, 0},
+ {"R_PPC_ADDR16_HA", Const, 0},
+ {"R_PPC_ADDR16_HI", Const, 0},
+ {"R_PPC_ADDR16_LO", Const, 0},
+ {"R_PPC_ADDR24", Const, 0},
+ {"R_PPC_ADDR32", Const, 0},
+ {"R_PPC_COPY", Const, 0},
+ {"R_PPC_DTPMOD32", Const, 0},
+ {"R_PPC_DTPREL16", Const, 0},
+ {"R_PPC_DTPREL16_HA", Const, 0},
+ {"R_PPC_DTPREL16_HI", Const, 0},
+ {"R_PPC_DTPREL16_LO", Const, 0},
+ {"R_PPC_DTPREL32", Const, 0},
+ {"R_PPC_EMB_BIT_FLD", Const, 0},
+ {"R_PPC_EMB_MRKREF", Const, 0},
+ {"R_PPC_EMB_NADDR16", Const, 0},
+ {"R_PPC_EMB_NADDR16_HA", Const, 0},
+ {"R_PPC_EMB_NADDR16_HI", Const, 0},
+ {"R_PPC_EMB_NADDR16_LO", Const, 0},
+ {"R_PPC_EMB_NADDR32", Const, 0},
+ {"R_PPC_EMB_RELSDA", Const, 0},
+ {"R_PPC_EMB_RELSEC16", Const, 0},
+ {"R_PPC_EMB_RELST_HA", Const, 0},
+ {"R_PPC_EMB_RELST_HI", Const, 0},
+ {"R_PPC_EMB_RELST_LO", Const, 0},
+ {"R_PPC_EMB_SDA21", Const, 0},
+ {"R_PPC_EMB_SDA2I16", Const, 0},
+ {"R_PPC_EMB_SDA2REL", Const, 0},
+ {"R_PPC_EMB_SDAI16", Const, 0},
+ {"R_PPC_GLOB_DAT", Const, 0},
+ {"R_PPC_GOT16", Const, 0},
+ {"R_PPC_GOT16_HA", Const, 0},
+ {"R_PPC_GOT16_HI", Const, 0},
+ {"R_PPC_GOT16_LO", Const, 0},
+ {"R_PPC_GOT_TLSGD16", Const, 0},
+ {"R_PPC_GOT_TLSGD16_HA", Const, 0},
+ {"R_PPC_GOT_TLSGD16_HI", Const, 0},
+ {"R_PPC_GOT_TLSGD16_LO", Const, 0},
+ {"R_PPC_GOT_TLSLD16", Const, 0},
+ {"R_PPC_GOT_TLSLD16_HA", Const, 0},
+ {"R_PPC_GOT_TLSLD16_HI", Const, 0},
+ {"R_PPC_GOT_TLSLD16_LO", Const, 0},
+ {"R_PPC_GOT_TPREL16", Const, 0},
+ {"R_PPC_GOT_TPREL16_HA", Const, 0},
+ {"R_PPC_GOT_TPREL16_HI", Const, 0},
+ {"R_PPC_GOT_TPREL16_LO", Const, 0},
+ {"R_PPC_JMP_SLOT", Const, 0},
+ {"R_PPC_LOCAL24PC", Const, 0},
+ {"R_PPC_NONE", Const, 0},
+ {"R_PPC_PLT16_HA", Const, 0},
+ {"R_PPC_PLT16_HI", Const, 0},
+ {"R_PPC_PLT16_LO", Const, 0},
+ {"R_PPC_PLT32", Const, 0},
+ {"R_PPC_PLTREL24", Const, 0},
+ {"R_PPC_PLTREL32", Const, 0},
+ {"R_PPC_REL14", Const, 0},
+ {"R_PPC_REL14_BRNTAKEN", Const, 0},
+ {"R_PPC_REL14_BRTAKEN", Const, 0},
+ {"R_PPC_REL24", Const, 0},
+ {"R_PPC_REL32", Const, 0},
+ {"R_PPC_RELATIVE", Const, 0},
+ {"R_PPC_SDAREL16", Const, 0},
+ {"R_PPC_SECTOFF", Const, 0},
+ {"R_PPC_SECTOFF_HA", Const, 0},
+ {"R_PPC_SECTOFF_HI", Const, 0},
+ {"R_PPC_SECTOFF_LO", Const, 0},
+ {"R_PPC_TLS", Const, 0},
+ {"R_PPC_TPREL16", Const, 0},
+ {"R_PPC_TPREL16_HA", Const, 0},
+ {"R_PPC_TPREL16_HI", Const, 0},
+ {"R_PPC_TPREL16_LO", Const, 0},
+ {"R_PPC_TPREL32", Const, 0},
+ {"R_PPC_UADDR16", Const, 0},
+ {"R_PPC_UADDR32", Const, 0},
+ {"R_RISCV", Type, 11},
+ {"R_RISCV_32", Const, 11},
+ {"R_RISCV_32_PCREL", Const, 12},
+ {"R_RISCV_64", Const, 11},
+ {"R_RISCV_ADD16", Const, 11},
+ {"R_RISCV_ADD32", Const, 11},
+ {"R_RISCV_ADD64", Const, 11},
+ {"R_RISCV_ADD8", Const, 11},
+ {"R_RISCV_ALIGN", Const, 11},
+ {"R_RISCV_BRANCH", Const, 11},
+ {"R_RISCV_CALL", Const, 11},
+ {"R_RISCV_CALL_PLT", Const, 11},
+ {"R_RISCV_COPY", Const, 11},
+ {"R_RISCV_GNU_VTENTRY", Const, 11},
+ {"R_RISCV_GNU_VTINHERIT", Const, 11},
+ {"R_RISCV_GOT_HI20", Const, 11},
+ {"R_RISCV_GPREL_I", Const, 11},
+ {"R_RISCV_GPREL_S", Const, 11},
+ {"R_RISCV_HI20", Const, 11},
+ {"R_RISCV_JAL", Const, 11},
+ {"R_RISCV_JUMP_SLOT", Const, 11},
+ {"R_RISCV_LO12_I", Const, 11},
+ {"R_RISCV_LO12_S", Const, 11},
+ {"R_RISCV_NONE", Const, 11},
+ {"R_RISCV_PCREL_HI20", Const, 11},
+ {"R_RISCV_PCREL_LO12_I", Const, 11},
+ {"R_RISCV_PCREL_LO12_S", Const, 11},
+ {"R_RISCV_RELATIVE", Const, 11},
+ {"R_RISCV_RELAX", Const, 11},
+ {"R_RISCV_RVC_BRANCH", Const, 11},
+ {"R_RISCV_RVC_JUMP", Const, 11},
+ {"R_RISCV_RVC_LUI", Const, 11},
+ {"R_RISCV_SET16", Const, 11},
+ {"R_RISCV_SET32", Const, 11},
+ {"R_RISCV_SET6", Const, 11},
+ {"R_RISCV_SET8", Const, 11},
+ {"R_RISCV_SUB16", Const, 11},
+ {"R_RISCV_SUB32", Const, 11},
+ {"R_RISCV_SUB6", Const, 11},
+ {"R_RISCV_SUB64", Const, 11},
+ {"R_RISCV_SUB8", Const, 11},
+ {"R_RISCV_TLS_DTPMOD32", Const, 11},
+ {"R_RISCV_TLS_DTPMOD64", Const, 11},
+ {"R_RISCV_TLS_DTPREL32", Const, 11},
+ {"R_RISCV_TLS_DTPREL64", Const, 11},
+ {"R_RISCV_TLS_GD_HI20", Const, 11},
+ {"R_RISCV_TLS_GOT_HI20", Const, 11},
+ {"R_RISCV_TLS_TPREL32", Const, 11},
+ {"R_RISCV_TLS_TPREL64", Const, 11},
+ {"R_RISCV_TPREL_ADD", Const, 11},
+ {"R_RISCV_TPREL_HI20", Const, 11},
+ {"R_RISCV_TPREL_I", Const, 11},
+ {"R_RISCV_TPREL_LO12_I", Const, 11},
+ {"R_RISCV_TPREL_LO12_S", Const, 11},
+ {"R_RISCV_TPREL_S", Const, 11},
+ {"R_SPARC", Type, 0},
+ {"R_SPARC_10", Const, 0},
+ {"R_SPARC_11", Const, 0},
+ {"R_SPARC_13", Const, 0},
+ {"R_SPARC_16", Const, 0},
+ {"R_SPARC_22", Const, 0},
+ {"R_SPARC_32", Const, 0},
+ {"R_SPARC_5", Const, 0},
+ {"R_SPARC_6", Const, 0},
+ {"R_SPARC_64", Const, 0},
+ {"R_SPARC_7", Const, 0},
+ {"R_SPARC_8", Const, 0},
+ {"R_SPARC_COPY", Const, 0},
+ {"R_SPARC_DISP16", Const, 0},
+ {"R_SPARC_DISP32", Const, 0},
+ {"R_SPARC_DISP64", Const, 0},
+ {"R_SPARC_DISP8", Const, 0},
+ {"R_SPARC_GLOB_DAT", Const, 0},
+ {"R_SPARC_GLOB_JMP", Const, 0},
+ {"R_SPARC_GOT10", Const, 0},
+ {"R_SPARC_GOT13", Const, 0},
+ {"R_SPARC_GOT22", Const, 0},
+ {"R_SPARC_H44", Const, 0},
+ {"R_SPARC_HH22", Const, 0},
+ {"R_SPARC_HI22", Const, 0},
+ {"R_SPARC_HIPLT22", Const, 0},
+ {"R_SPARC_HIX22", Const, 0},
+ {"R_SPARC_HM10", Const, 0},
+ {"R_SPARC_JMP_SLOT", Const, 0},
+ {"R_SPARC_L44", Const, 0},
+ {"R_SPARC_LM22", Const, 0},
+ {"R_SPARC_LO10", Const, 0},
+ {"R_SPARC_LOPLT10", Const, 0},
+ {"R_SPARC_LOX10", Const, 0},
+ {"R_SPARC_M44", Const, 0},
+ {"R_SPARC_NONE", Const, 0},
+ {"R_SPARC_OLO10", Const, 0},
+ {"R_SPARC_PC10", Const, 0},
+ {"R_SPARC_PC22", Const, 0},
+ {"R_SPARC_PCPLT10", Const, 0},
+ {"R_SPARC_PCPLT22", Const, 0},
+ {"R_SPARC_PCPLT32", Const, 0},
+ {"R_SPARC_PC_HH22", Const, 0},
+ {"R_SPARC_PC_HM10", Const, 0},
+ {"R_SPARC_PC_LM22", Const, 0},
+ {"R_SPARC_PLT32", Const, 0},
+ {"R_SPARC_PLT64", Const, 0},
+ {"R_SPARC_REGISTER", Const, 0},
+ {"R_SPARC_RELATIVE", Const, 0},
+ {"R_SPARC_UA16", Const, 0},
+ {"R_SPARC_UA32", Const, 0},
+ {"R_SPARC_UA64", Const, 0},
+ {"R_SPARC_WDISP16", Const, 0},
+ {"R_SPARC_WDISP19", Const, 0},
+ {"R_SPARC_WDISP22", Const, 0},
+ {"R_SPARC_WDISP30", Const, 0},
+ {"R_SPARC_WPLT30", Const, 0},
+ {"R_SYM32", Func, 0},
+ {"R_SYM64", Func, 0},
+ {"R_TYPE32", Func, 0},
+ {"R_TYPE64", Func, 0},
+ {"R_X86_64", Type, 0},
+ {"R_X86_64_16", Const, 0},
+ {"R_X86_64_32", Const, 0},
+ {"R_X86_64_32S", Const, 0},
+ {"R_X86_64_64", Const, 0},
+ {"R_X86_64_8", Const, 0},
+ {"R_X86_64_COPY", Const, 0},
+ {"R_X86_64_DTPMOD64", Const, 0},
+ {"R_X86_64_DTPOFF32", Const, 0},
+ {"R_X86_64_DTPOFF64", Const, 0},
+ {"R_X86_64_GLOB_DAT", Const, 0},
+ {"R_X86_64_GOT32", Const, 0},
+ {"R_X86_64_GOT64", Const, 10},
+ {"R_X86_64_GOTOFF64", Const, 10},
+ {"R_X86_64_GOTPC32", Const, 10},
+ {"R_X86_64_GOTPC32_TLSDESC", Const, 10},
+ {"R_X86_64_GOTPC64", Const, 10},
+ {"R_X86_64_GOTPCREL", Const, 0},
+ {"R_X86_64_GOTPCREL64", Const, 10},
+ {"R_X86_64_GOTPCRELX", Const, 10},
+ {"R_X86_64_GOTPLT64", Const, 10},
+ {"R_X86_64_GOTTPOFF", Const, 0},
+ {"R_X86_64_IRELATIVE", Const, 10},
+ {"R_X86_64_JMP_SLOT", Const, 0},
+ {"R_X86_64_NONE", Const, 0},
+ {"R_X86_64_PC16", Const, 0},
+ {"R_X86_64_PC32", Const, 0},
+ {"R_X86_64_PC32_BND", Const, 10},
+ {"R_X86_64_PC64", Const, 10},
+ {"R_X86_64_PC8", Const, 0},
+ {"R_X86_64_PLT32", Const, 0},
+ {"R_X86_64_PLT32_BND", Const, 10},
+ {"R_X86_64_PLTOFF64", Const, 10},
+ {"R_X86_64_RELATIVE", Const, 0},
+ {"R_X86_64_RELATIVE64", Const, 10},
+ {"R_X86_64_REX_GOTPCRELX", Const, 10},
+ {"R_X86_64_SIZE32", Const, 10},
+ {"R_X86_64_SIZE64", Const, 10},
+ {"R_X86_64_TLSDESC", Const, 10},
+ {"R_X86_64_TLSDESC_CALL", Const, 10},
+ {"R_X86_64_TLSGD", Const, 0},
+ {"R_X86_64_TLSLD", Const, 0},
+ {"R_X86_64_TPOFF32", Const, 0},
+ {"R_X86_64_TPOFF64", Const, 0},
+ {"Rel32", Type, 0},
+ {"Rel32.Info", Field, 0},
+ {"Rel32.Off", Field, 0},
+ {"Rel64", Type, 0},
+ {"Rel64.Info", Field, 0},
+ {"Rel64.Off", Field, 0},
+ {"Rela32", Type, 0},
+ {"Rela32.Addend", Field, 0},
+ {"Rela32.Info", Field, 0},
+ {"Rela32.Off", Field, 0},
+ {"Rela64", Type, 0},
+ {"Rela64.Addend", Field, 0},
+ {"Rela64.Info", Field, 0},
+ {"Rela64.Off", Field, 0},
+ {"SHF_ALLOC", Const, 0},
+ {"SHF_COMPRESSED", Const, 6},
+ {"SHF_EXECINSTR", Const, 0},
+ {"SHF_GROUP", Const, 0},
+ {"SHF_INFO_LINK", Const, 0},
+ {"SHF_LINK_ORDER", Const, 0},
+ {"SHF_MASKOS", Const, 0},
+ {"SHF_MASKPROC", Const, 0},
+ {"SHF_MERGE", Const, 0},
+ {"SHF_OS_NONCONFORMING", Const, 0},
+ {"SHF_STRINGS", Const, 0},
+ {"SHF_TLS", Const, 0},
+ {"SHF_WRITE", Const, 0},
+ {"SHN_ABS", Const, 0},
+ {"SHN_COMMON", Const, 0},
+ {"SHN_HIOS", Const, 0},
+ {"SHN_HIPROC", Const, 0},
+ {"SHN_HIRESERVE", Const, 0},
+ {"SHN_LOOS", Const, 0},
+ {"SHN_LOPROC", Const, 0},
+ {"SHN_LORESERVE", Const, 0},
+ {"SHN_UNDEF", Const, 0},
+ {"SHN_XINDEX", Const, 0},
+ {"SHT_DYNAMIC", Const, 0},
+ {"SHT_DYNSYM", Const, 0},
+ {"SHT_FINI_ARRAY", Const, 0},
+ {"SHT_GNU_ATTRIBUTES", Const, 0},
+ {"SHT_GNU_HASH", Const, 0},
+ {"SHT_GNU_LIBLIST", Const, 0},
+ {"SHT_GNU_VERDEF", Const, 0},
+ {"SHT_GNU_VERNEED", Const, 0},
+ {"SHT_GNU_VERSYM", Const, 0},
+ {"SHT_GROUP", Const, 0},
+ {"SHT_HASH", Const, 0},
+ {"SHT_HIOS", Const, 0},
+ {"SHT_HIPROC", Const, 0},
+ {"SHT_HIUSER", Const, 0},
+ {"SHT_INIT_ARRAY", Const, 0},
+ {"SHT_LOOS", Const, 0},
+ {"SHT_LOPROC", Const, 0},
+ {"SHT_LOUSER", Const, 0},
+ {"SHT_MIPS_ABIFLAGS", Const, 17},
+ {"SHT_NOBITS", Const, 0},
+ {"SHT_NOTE", Const, 0},
+ {"SHT_NULL", Const, 0},
+ {"SHT_PREINIT_ARRAY", Const, 0},
+ {"SHT_PROGBITS", Const, 0},
+ {"SHT_REL", Const, 0},
+ {"SHT_RELA", Const, 0},
+ {"SHT_SHLIB", Const, 0},
+ {"SHT_STRTAB", Const, 0},
+ {"SHT_SYMTAB", Const, 0},
+ {"SHT_SYMTAB_SHNDX", Const, 0},
+ {"STB_GLOBAL", Const, 0},
+ {"STB_HIOS", Const, 0},
+ {"STB_HIPROC", Const, 0},
+ {"STB_LOCAL", Const, 0},
+ {"STB_LOOS", Const, 0},
+ {"STB_LOPROC", Const, 0},
+ {"STB_WEAK", Const, 0},
+ {"STT_COMMON", Const, 0},
+ {"STT_FILE", Const, 0},
+ {"STT_FUNC", Const, 0},
+ {"STT_GNU_IFUNC", Const, 23},
+ {"STT_HIOS", Const, 0},
+ {"STT_HIPROC", Const, 0},
+ {"STT_LOOS", Const, 0},
+ {"STT_LOPROC", Const, 0},
+ {"STT_NOTYPE", Const, 0},
+ {"STT_OBJECT", Const, 0},
+ {"STT_RELC", Const, 23},
+ {"STT_SECTION", Const, 0},
+ {"STT_SRELC", Const, 23},
+ {"STT_TLS", Const, 0},
+ {"STV_DEFAULT", Const, 0},
+ {"STV_HIDDEN", Const, 0},
+ {"STV_INTERNAL", Const, 0},
+ {"STV_PROTECTED", Const, 0},
+ {"ST_BIND", Func, 0},
+ {"ST_INFO", Func, 0},
+ {"ST_TYPE", Func, 0},
+ {"ST_VISIBILITY", Func, 0},
+ {"Section", Type, 0},
+ {"Section.ReaderAt", Field, 0},
+ {"Section.SectionHeader", Field, 0},
+ {"Section32", Type, 0},
+ {"Section32.Addr", Field, 0},
+ {"Section32.Addralign", Field, 0},
+ {"Section32.Entsize", Field, 0},
+ {"Section32.Flags", Field, 0},
+ {"Section32.Info", Field, 0},
+ {"Section32.Link", Field, 0},
+ {"Section32.Name", Field, 0},
+ {"Section32.Off", Field, 0},
+ {"Section32.Size", Field, 0},
+ {"Section32.Type", Field, 0},
+ {"Section64", Type, 0},
+ {"Section64.Addr", Field, 0},
+ {"Section64.Addralign", Field, 0},
+ {"Section64.Entsize", Field, 0},
+ {"Section64.Flags", Field, 0},
+ {"Section64.Info", Field, 0},
+ {"Section64.Link", Field, 0},
+ {"Section64.Name", Field, 0},
+ {"Section64.Off", Field, 0},
+ {"Section64.Size", Field, 0},
+ {"Section64.Type", Field, 0},
+ {"SectionFlag", Type, 0},
+ {"SectionHeader", Type, 0},
+ {"SectionHeader.Addr", Field, 0},
+ {"SectionHeader.Addralign", Field, 0},
+ {"SectionHeader.Entsize", Field, 0},
+ {"SectionHeader.FileSize", Field, 6},
+ {"SectionHeader.Flags", Field, 0},
+ {"SectionHeader.Info", Field, 0},
+ {"SectionHeader.Link", Field, 0},
+ {"SectionHeader.Name", Field, 0},
+ {"SectionHeader.Offset", Field, 0},
+ {"SectionHeader.Size", Field, 0},
+ {"SectionHeader.Type", Field, 0},
+ {"SectionIndex", Type, 0},
+ {"SectionType", Type, 0},
+ {"Sym32", Type, 0},
+ {"Sym32.Info", Field, 0},
+ {"Sym32.Name", Field, 0},
+ {"Sym32.Other", Field, 0},
+ {"Sym32.Shndx", Field, 0},
+ {"Sym32.Size", Field, 0},
+ {"Sym32.Value", Field, 0},
+ {"Sym32Size", Const, 0},
+ {"Sym64", Type, 0},
+ {"Sym64.Info", Field, 0},
+ {"Sym64.Name", Field, 0},
+ {"Sym64.Other", Field, 0},
+ {"Sym64.Shndx", Field, 0},
+ {"Sym64.Size", Field, 0},
+ {"Sym64.Value", Field, 0},
+ {"Sym64Size", Const, 0},
+ {"SymBind", Type, 0},
+ {"SymType", Type, 0},
+ {"SymVis", Type, 0},
+ {"Symbol", Type, 0},
+ {"Symbol.Info", Field, 0},
+ {"Symbol.Library", Field, 13},
+ {"Symbol.Name", Field, 0},
+ {"Symbol.Other", Field, 0},
+ {"Symbol.Section", Field, 0},
+ {"Symbol.Size", Field, 0},
+ {"Symbol.Value", Field, 0},
+ {"Symbol.Version", Field, 13},
+ {"Type", Type, 0},
+ {"Version", Type, 0},
+ },
+ "debug/gosym": {
+ {"(*DecodingError).Error", Method, 0},
+ {"(*LineTable).LineToPC", Method, 0},
+ {"(*LineTable).PCToLine", Method, 0},
+ {"(*Sym).BaseName", Method, 0},
+ {"(*Sym).PackageName", Method, 0},
+ {"(*Sym).ReceiverName", Method, 0},
+ {"(*Sym).Static", Method, 0},
+ {"(*Table).LineToPC", Method, 0},
+ {"(*Table).LookupFunc", Method, 0},
+ {"(*Table).LookupSym", Method, 0},
+ {"(*Table).PCToFunc", Method, 0},
+ {"(*Table).PCToLine", Method, 0},
+ {"(*Table).SymByAddr", Method, 0},
+ {"(*UnknownLineError).Error", Method, 0},
+ {"(Func).BaseName", Method, 0},
+ {"(Func).PackageName", Method, 0},
+ {"(Func).ReceiverName", Method, 0},
+ {"(Func).Static", Method, 0},
+ {"(UnknownFileError).Error", Method, 0},
+ {"DecodingError", Type, 0},
+ {"Func", Type, 0},
+ {"Func.End", Field, 0},
+ {"Func.Entry", Field, 0},
+ {"Func.FrameSize", Field, 0},
+ {"Func.LineTable", Field, 0},
+ {"Func.Locals", Field, 0},
+ {"Func.Obj", Field, 0},
+ {"Func.Params", Field, 0},
+ {"Func.Sym", Field, 0},
+ {"LineTable", Type, 0},
+ {"LineTable.Data", Field, 0},
+ {"LineTable.Line", Field, 0},
+ {"LineTable.PC", Field, 0},
+ {"NewLineTable", Func, 0},
+ {"NewTable", Func, 0},
+ {"Obj", Type, 0},
+ {"Obj.Funcs", Field, 0},
+ {"Obj.Paths", Field, 0},
+ {"Sym", Type, 0},
+ {"Sym.Func", Field, 0},
+ {"Sym.GoType", Field, 0},
+ {"Sym.Name", Field, 0},
+ {"Sym.Type", Field, 0},
+ {"Sym.Value", Field, 0},
+ {"Table", Type, 0},
+ {"Table.Files", Field, 0},
+ {"Table.Funcs", Field, 0},
+ {"Table.Objs", Field, 0},
+ {"Table.Syms", Field, 0},
+ {"UnknownFileError", Type, 0},
+ {"UnknownLineError", Type, 0},
+ {"UnknownLineError.File", Field, 0},
+ {"UnknownLineError.Line", Field, 0},
+ },
+ "debug/macho": {
+ {"(*FatFile).Close", Method, 3},
+ {"(*File).Close", Method, 0},
+ {"(*File).DWARF", Method, 0},
+ {"(*File).ImportedLibraries", Method, 0},
+ {"(*File).ImportedSymbols", Method, 0},
+ {"(*File).Section", Method, 0},
+ {"(*File).Segment", Method, 0},
+ {"(*FormatError).Error", Method, 0},
+ {"(*Section).Data", Method, 0},
+ {"(*Section).Open", Method, 0},
+ {"(*Segment).Data", Method, 0},
+ {"(*Segment).Open", Method, 0},
+ {"(Cpu).GoString", Method, 0},
+ {"(Cpu).String", Method, 0},
+ {"(Dylib).Raw", Method, 0},
+ {"(Dysymtab).Raw", Method, 0},
+ {"(FatArch).Close", Method, 3},
+ {"(FatArch).DWARF", Method, 3},
+ {"(FatArch).ImportedLibraries", Method, 3},
+ {"(FatArch).ImportedSymbols", Method, 3},
+ {"(FatArch).Section", Method, 3},
+ {"(FatArch).Segment", Method, 3},
+ {"(LoadBytes).Raw", Method, 0},
+ {"(LoadCmd).GoString", Method, 0},
+ {"(LoadCmd).String", Method, 0},
+ {"(RelocTypeARM).GoString", Method, 10},
+ {"(RelocTypeARM).String", Method, 10},
+ {"(RelocTypeARM64).GoString", Method, 10},
+ {"(RelocTypeARM64).String", Method, 10},
+ {"(RelocTypeGeneric).GoString", Method, 10},
+ {"(RelocTypeGeneric).String", Method, 10},
+ {"(RelocTypeX86_64).GoString", Method, 10},
+ {"(RelocTypeX86_64).String", Method, 10},
+ {"(Rpath).Raw", Method, 10},
+ {"(Section).ReadAt", Method, 0},
+ {"(Segment).Raw", Method, 0},
+ {"(Segment).ReadAt", Method, 0},
+ {"(Symtab).Raw", Method, 0},
+ {"(Type).GoString", Method, 10},
+ {"(Type).String", Method, 10},
+ {"ARM64_RELOC_ADDEND", Const, 10},
+ {"ARM64_RELOC_BRANCH26", Const, 10},
+ {"ARM64_RELOC_GOT_LOAD_PAGE21", Const, 10},
+ {"ARM64_RELOC_GOT_LOAD_PAGEOFF12", Const, 10},
+ {"ARM64_RELOC_PAGE21", Const, 10},
+ {"ARM64_RELOC_PAGEOFF12", Const, 10},
+ {"ARM64_RELOC_POINTER_TO_GOT", Const, 10},
+ {"ARM64_RELOC_SUBTRACTOR", Const, 10},
+ {"ARM64_RELOC_TLVP_LOAD_PAGE21", Const, 10},
+ {"ARM64_RELOC_TLVP_LOAD_PAGEOFF12", Const, 10},
+ {"ARM64_RELOC_UNSIGNED", Const, 10},
+ {"ARM_RELOC_BR24", Const, 10},
+ {"ARM_RELOC_HALF", Const, 10},
+ {"ARM_RELOC_HALF_SECTDIFF", Const, 10},
+ {"ARM_RELOC_LOCAL_SECTDIFF", Const, 10},
+ {"ARM_RELOC_PAIR", Const, 10},
+ {"ARM_RELOC_PB_LA_PTR", Const, 10},
+ {"ARM_RELOC_SECTDIFF", Const, 10},
+ {"ARM_RELOC_VANILLA", Const, 10},
+ {"ARM_THUMB_32BIT_BRANCH", Const, 10},
+ {"ARM_THUMB_RELOC_BR22", Const, 10},
+ {"Cpu", Type, 0},
+ {"Cpu386", Const, 0},
+ {"CpuAmd64", Const, 0},
+ {"CpuArm", Const, 3},
+ {"CpuArm64", Const, 11},
+ {"CpuPpc", Const, 3},
+ {"CpuPpc64", Const, 3},
+ {"Dylib", Type, 0},
+ {"Dylib.CompatVersion", Field, 0},
+ {"Dylib.CurrentVersion", Field, 0},
+ {"Dylib.LoadBytes", Field, 0},
+ {"Dylib.Name", Field, 0},
+ {"Dylib.Time", Field, 0},
+ {"DylibCmd", Type, 0},
+ {"DylibCmd.Cmd", Field, 0},
+ {"DylibCmd.CompatVersion", Field, 0},
+ {"DylibCmd.CurrentVersion", Field, 0},
+ {"DylibCmd.Len", Field, 0},
+ {"DylibCmd.Name", Field, 0},
+ {"DylibCmd.Time", Field, 0},
+ {"Dysymtab", Type, 0},
+ {"Dysymtab.DysymtabCmd", Field, 0},
+ {"Dysymtab.IndirectSyms", Field, 0},
+ {"Dysymtab.LoadBytes", Field, 0},
+ {"DysymtabCmd", Type, 0},
+ {"DysymtabCmd.Cmd", Field, 0},
+ {"DysymtabCmd.Extrefsymoff", Field, 0},
+ {"DysymtabCmd.Extreloff", Field, 0},
+ {"DysymtabCmd.Iextdefsym", Field, 0},
+ {"DysymtabCmd.Ilocalsym", Field, 0},
+ {"DysymtabCmd.Indirectsymoff", Field, 0},
+ {"DysymtabCmd.Iundefsym", Field, 0},
+ {"DysymtabCmd.Len", Field, 0},
+ {"DysymtabCmd.Locreloff", Field, 0},
+ {"DysymtabCmd.Modtaboff", Field, 0},
+ {"DysymtabCmd.Nextdefsym", Field, 0},
+ {"DysymtabCmd.Nextrefsyms", Field, 0},
+ {"DysymtabCmd.Nextrel", Field, 0},
+ {"DysymtabCmd.Nindirectsyms", Field, 0},
+ {"DysymtabCmd.Nlocalsym", Field, 0},
+ {"DysymtabCmd.Nlocrel", Field, 0},
+ {"DysymtabCmd.Nmodtab", Field, 0},
+ {"DysymtabCmd.Ntoc", Field, 0},
+ {"DysymtabCmd.Nundefsym", Field, 0},
+ {"DysymtabCmd.Tocoffset", Field, 0},
+ {"ErrNotFat", Var, 3},
+ {"FatArch", Type, 3},
+ {"FatArch.FatArchHeader", Field, 3},
+ {"FatArch.File", Field, 3},
+ {"FatArchHeader", Type, 3},
+ {"FatArchHeader.Align", Field, 3},
+ {"FatArchHeader.Cpu", Field, 3},
+ {"FatArchHeader.Offset", Field, 3},
+ {"FatArchHeader.Size", Field, 3},
+ {"FatArchHeader.SubCpu", Field, 3},
+ {"FatFile", Type, 3},
+ {"FatFile.Arches", Field, 3},
+ {"FatFile.Magic", Field, 3},
+ {"File", Type, 0},
+ {"File.ByteOrder", Field, 0},
+ {"File.Dysymtab", Field, 0},
+ {"File.FileHeader", Field, 0},
+ {"File.Loads", Field, 0},
+ {"File.Sections", Field, 0},
+ {"File.Symtab", Field, 0},
+ {"FileHeader", Type, 0},
+ {"FileHeader.Cmdsz", Field, 0},
+ {"FileHeader.Cpu", Field, 0},
+ {"FileHeader.Flags", Field, 0},
+ {"FileHeader.Magic", Field, 0},
+ {"FileHeader.Ncmd", Field, 0},
+ {"FileHeader.SubCpu", Field, 0},
+ {"FileHeader.Type", Field, 0},
+ {"FlagAllModsBound", Const, 10},
+ {"FlagAllowStackExecution", Const, 10},
+ {"FlagAppExtensionSafe", Const, 10},
+ {"FlagBindAtLoad", Const, 10},
+ {"FlagBindsToWeak", Const, 10},
+ {"FlagCanonical", Const, 10},
+ {"FlagDeadStrippableDylib", Const, 10},
+ {"FlagDyldLink", Const, 10},
+ {"FlagForceFlat", Const, 10},
+ {"FlagHasTLVDescriptors", Const, 10},
+ {"FlagIncrLink", Const, 10},
+ {"FlagLazyInit", Const, 10},
+ {"FlagNoFixPrebinding", Const, 10},
+ {"FlagNoHeapExecution", Const, 10},
+ {"FlagNoMultiDefs", Const, 10},
+ {"FlagNoReexportedDylibs", Const, 10},
+ {"FlagNoUndefs", Const, 10},
+ {"FlagPIE", Const, 10},
+ {"FlagPrebindable", Const, 10},
+ {"FlagPrebound", Const, 10},
+ {"FlagRootSafe", Const, 10},
+ {"FlagSetuidSafe", Const, 10},
+ {"FlagSplitSegs", Const, 10},
+ {"FlagSubsectionsViaSymbols", Const, 10},
+ {"FlagTwoLevel", Const, 10},
+ {"FlagWeakDefines", Const, 10},
+ {"FormatError", Type, 0},
+ {"GENERIC_RELOC_LOCAL_SECTDIFF", Const, 10},
+ {"GENERIC_RELOC_PAIR", Const, 10},
+ {"GENERIC_RELOC_PB_LA_PTR", Const, 10},
+ {"GENERIC_RELOC_SECTDIFF", Const, 10},
+ {"GENERIC_RELOC_TLV", Const, 10},
+ {"GENERIC_RELOC_VANILLA", Const, 10},
+ {"Load", Type, 0},
+ {"LoadBytes", Type, 0},
+ {"LoadCmd", Type, 0},
+ {"LoadCmdDylib", Const, 0},
+ {"LoadCmdDylinker", Const, 0},
+ {"LoadCmdDysymtab", Const, 0},
+ {"LoadCmdRpath", Const, 10},
+ {"LoadCmdSegment", Const, 0},
+ {"LoadCmdSegment64", Const, 0},
+ {"LoadCmdSymtab", Const, 0},
+ {"LoadCmdThread", Const, 0},
+ {"LoadCmdUnixThread", Const, 0},
+ {"Magic32", Const, 0},
+ {"Magic64", Const, 0},
+ {"MagicFat", Const, 3},
+ {"NewFatFile", Func, 3},
+ {"NewFile", Func, 0},
+ {"Nlist32", Type, 0},
+ {"Nlist32.Desc", Field, 0},
+ {"Nlist32.Name", Field, 0},
+ {"Nlist32.Sect", Field, 0},
+ {"Nlist32.Type", Field, 0},
+ {"Nlist32.Value", Field, 0},
+ {"Nlist64", Type, 0},
+ {"Nlist64.Desc", Field, 0},
+ {"Nlist64.Name", Field, 0},
+ {"Nlist64.Sect", Field, 0},
+ {"Nlist64.Type", Field, 0},
+ {"Nlist64.Value", Field, 0},
+ {"Open", Func, 0},
+ {"OpenFat", Func, 3},
+ {"Regs386", Type, 0},
+ {"Regs386.AX", Field, 0},
+ {"Regs386.BP", Field, 0},
+ {"Regs386.BX", Field, 0},
+ {"Regs386.CS", Field, 0},
+ {"Regs386.CX", Field, 0},
+ {"Regs386.DI", Field, 0},
+ {"Regs386.DS", Field, 0},
+ {"Regs386.DX", Field, 0},
+ {"Regs386.ES", Field, 0},
+ {"Regs386.FLAGS", Field, 0},
+ {"Regs386.FS", Field, 0},
+ {"Regs386.GS", Field, 0},
+ {"Regs386.IP", Field, 0},
+ {"Regs386.SI", Field, 0},
+ {"Regs386.SP", Field, 0},
+ {"Regs386.SS", Field, 0},
+ {"RegsAMD64", Type, 0},
+ {"RegsAMD64.AX", Field, 0},
+ {"RegsAMD64.BP", Field, 0},
+ {"RegsAMD64.BX", Field, 0},
+ {"RegsAMD64.CS", Field, 0},
+ {"RegsAMD64.CX", Field, 0},
+ {"RegsAMD64.DI", Field, 0},
+ {"RegsAMD64.DX", Field, 0},
+ {"RegsAMD64.FLAGS", Field, 0},
+ {"RegsAMD64.FS", Field, 0},
+ {"RegsAMD64.GS", Field, 0},
+ {"RegsAMD64.IP", Field, 0},
+ {"RegsAMD64.R10", Field, 0},
+ {"RegsAMD64.R11", Field, 0},
+ {"RegsAMD64.R12", Field, 0},
+ {"RegsAMD64.R13", Field, 0},
+ {"RegsAMD64.R14", Field, 0},
+ {"RegsAMD64.R15", Field, 0},
+ {"RegsAMD64.R8", Field, 0},
+ {"RegsAMD64.R9", Field, 0},
+ {"RegsAMD64.SI", Field, 0},
+ {"RegsAMD64.SP", Field, 0},
+ {"Reloc", Type, 10},
+ {"Reloc.Addr", Field, 10},
+ {"Reloc.Extern", Field, 10},
+ {"Reloc.Len", Field, 10},
+ {"Reloc.Pcrel", Field, 10},
+ {"Reloc.Scattered", Field, 10},
+ {"Reloc.Type", Field, 10},
+ {"Reloc.Value", Field, 10},
+ {"RelocTypeARM", Type, 10},
+ {"RelocTypeARM64", Type, 10},
+ {"RelocTypeGeneric", Type, 10},
+ {"RelocTypeX86_64", Type, 10},
+ {"Rpath", Type, 10},
+ {"Rpath.LoadBytes", Field, 10},
+ {"Rpath.Path", Field, 10},
+ {"RpathCmd", Type, 10},
+ {"RpathCmd.Cmd", Field, 10},
+ {"RpathCmd.Len", Field, 10},
+ {"RpathCmd.Path", Field, 10},
+ {"Section", Type, 0},
+ {"Section.ReaderAt", Field, 0},
+ {"Section.Relocs", Field, 10},
+ {"Section.SectionHeader", Field, 0},
+ {"Section32", Type, 0},
+ {"Section32.Addr", Field, 0},
+ {"Section32.Align", Field, 0},
+ {"Section32.Flags", Field, 0},
+ {"Section32.Name", Field, 0},
+ {"Section32.Nreloc", Field, 0},
+ {"Section32.Offset", Field, 0},
+ {"Section32.Reloff", Field, 0},
+ {"Section32.Reserve1", Field, 0},
+ {"Section32.Reserve2", Field, 0},
+ {"Section32.Seg", Field, 0},
+ {"Section32.Size", Field, 0},
+ {"Section64", Type, 0},
+ {"Section64.Addr", Field, 0},
+ {"Section64.Align", Field, 0},
+ {"Section64.Flags", Field, 0},
+ {"Section64.Name", Field, 0},
+ {"Section64.Nreloc", Field, 0},
+ {"Section64.Offset", Field, 0},
+ {"Section64.Reloff", Field, 0},
+ {"Section64.Reserve1", Field, 0},
+ {"Section64.Reserve2", Field, 0},
+ {"Section64.Reserve3", Field, 0},
+ {"Section64.Seg", Field, 0},
+ {"Section64.Size", Field, 0},
+ {"SectionHeader", Type, 0},
+ {"SectionHeader.Addr", Field, 0},
+ {"SectionHeader.Align", Field, 0},
+ {"SectionHeader.Flags", Field, 0},
+ {"SectionHeader.Name", Field, 0},
+ {"SectionHeader.Nreloc", Field, 0},
+ {"SectionHeader.Offset", Field, 0},
+ {"SectionHeader.Reloff", Field, 0},
+ {"SectionHeader.Seg", Field, 0},
+ {"SectionHeader.Size", Field, 0},
+ {"Segment", Type, 0},
+ {"Segment.LoadBytes", Field, 0},
+ {"Segment.ReaderAt", Field, 0},
+ {"Segment.SegmentHeader", Field, 0},
+ {"Segment32", Type, 0},
+ {"Segment32.Addr", Field, 0},
+ {"Segment32.Cmd", Field, 0},
+ {"Segment32.Filesz", Field, 0},
+ {"Segment32.Flag", Field, 0},
+ {"Segment32.Len", Field, 0},
+ {"Segment32.Maxprot", Field, 0},
+ {"Segment32.Memsz", Field, 0},
+ {"Segment32.Name", Field, 0},
+ {"Segment32.Nsect", Field, 0},
+ {"Segment32.Offset", Field, 0},
+ {"Segment32.Prot", Field, 0},
+ {"Segment64", Type, 0},
+ {"Segment64.Addr", Field, 0},
+ {"Segment64.Cmd", Field, 0},
+ {"Segment64.Filesz", Field, 0},
+ {"Segment64.Flag", Field, 0},
+ {"Segment64.Len", Field, 0},
+ {"Segment64.Maxprot", Field, 0},
+ {"Segment64.Memsz", Field, 0},
+ {"Segment64.Name", Field, 0},
+ {"Segment64.Nsect", Field, 0},
+ {"Segment64.Offset", Field, 0},
+ {"Segment64.Prot", Field, 0},
+ {"SegmentHeader", Type, 0},
+ {"SegmentHeader.Addr", Field, 0},
+ {"SegmentHeader.Cmd", Field, 0},
+ {"SegmentHeader.Filesz", Field, 0},
+ {"SegmentHeader.Flag", Field, 0},
+ {"SegmentHeader.Len", Field, 0},
+ {"SegmentHeader.Maxprot", Field, 0},
+ {"SegmentHeader.Memsz", Field, 0},
+ {"SegmentHeader.Name", Field, 0},
+ {"SegmentHeader.Nsect", Field, 0},
+ {"SegmentHeader.Offset", Field, 0},
+ {"SegmentHeader.Prot", Field, 0},
+ {"Symbol", Type, 0},
+ {"Symbol.Desc", Field, 0},
+ {"Symbol.Name", Field, 0},
+ {"Symbol.Sect", Field, 0},
+ {"Symbol.Type", Field, 0},
+ {"Symbol.Value", Field, 0},
+ {"Symtab", Type, 0},
+ {"Symtab.LoadBytes", Field, 0},
+ {"Symtab.Syms", Field, 0},
+ {"Symtab.SymtabCmd", Field, 0},
+ {"SymtabCmd", Type, 0},
+ {"SymtabCmd.Cmd", Field, 0},
+ {"SymtabCmd.Len", Field, 0},
+ {"SymtabCmd.Nsyms", Field, 0},
+ {"SymtabCmd.Stroff", Field, 0},
+ {"SymtabCmd.Strsize", Field, 0},
+ {"SymtabCmd.Symoff", Field, 0},
+ {"Thread", Type, 0},
+ {"Thread.Cmd", Field, 0},
+ {"Thread.Data", Field, 0},
+ {"Thread.Len", Field, 0},
+ {"Thread.Type", Field, 0},
+ {"Type", Type, 0},
+ {"TypeBundle", Const, 3},
+ {"TypeDylib", Const, 3},
+ {"TypeExec", Const, 0},
+ {"TypeObj", Const, 0},
+ {"X86_64_RELOC_BRANCH", Const, 10},
+ {"X86_64_RELOC_GOT", Const, 10},
+ {"X86_64_RELOC_GOT_LOAD", Const, 10},
+ {"X86_64_RELOC_SIGNED", Const, 10},
+ {"X86_64_RELOC_SIGNED_1", Const, 10},
+ {"X86_64_RELOC_SIGNED_2", Const, 10},
+ {"X86_64_RELOC_SIGNED_4", Const, 10},
+ {"X86_64_RELOC_SUBTRACTOR", Const, 10},
+ {"X86_64_RELOC_TLV", Const, 10},
+ {"X86_64_RELOC_UNSIGNED", Const, 10},
+ },
+ "debug/pe": {
+ {"(*COFFSymbol).FullName", Method, 8},
+ {"(*File).COFFSymbolReadSectionDefAux", Method, 19},
+ {"(*File).Close", Method, 0},
+ {"(*File).DWARF", Method, 0},
+ {"(*File).ImportedLibraries", Method, 0},
+ {"(*File).ImportedSymbols", Method, 0},
+ {"(*File).Section", Method, 0},
+ {"(*FormatError).Error", Method, 0},
+ {"(*Section).Data", Method, 0},
+ {"(*Section).Open", Method, 0},
+ {"(Section).ReadAt", Method, 0},
+ {"(StringTable).String", Method, 8},
+ {"COFFSymbol", Type, 1},
+ {"COFFSymbol.Name", Field, 1},
+ {"COFFSymbol.NumberOfAuxSymbols", Field, 1},
+ {"COFFSymbol.SectionNumber", Field, 1},
+ {"COFFSymbol.StorageClass", Field, 1},
+ {"COFFSymbol.Type", Field, 1},
+ {"COFFSymbol.Value", Field, 1},
+ {"COFFSymbolAuxFormat5", Type, 19},
+ {"COFFSymbolAuxFormat5.Checksum", Field, 19},
+ {"COFFSymbolAuxFormat5.NumLineNumbers", Field, 19},
+ {"COFFSymbolAuxFormat5.NumRelocs", Field, 19},
+ {"COFFSymbolAuxFormat5.SecNum", Field, 19},
+ {"COFFSymbolAuxFormat5.Selection", Field, 19},
+ {"COFFSymbolAuxFormat5.Size", Field, 19},
+ {"COFFSymbolSize", Const, 1},
+ {"DataDirectory", Type, 3},
+ {"DataDirectory.Size", Field, 3},
+ {"DataDirectory.VirtualAddress", Field, 3},
+ {"File", Type, 0},
+ {"File.COFFSymbols", Field, 8},
+ {"File.FileHeader", Field, 0},
+ {"File.OptionalHeader", Field, 3},
+ {"File.Sections", Field, 0},
+ {"File.StringTable", Field, 8},
+ {"File.Symbols", Field, 1},
+ {"FileHeader", Type, 0},
+ {"FileHeader.Characteristics", Field, 0},
+ {"FileHeader.Machine", Field, 0},
+ {"FileHeader.NumberOfSections", Field, 0},
+ {"FileHeader.NumberOfSymbols", Field, 0},
+ {"FileHeader.PointerToSymbolTable", Field, 0},
+ {"FileHeader.SizeOfOptionalHeader", Field, 0},
+ {"FileHeader.TimeDateStamp", Field, 0},
+ {"FormatError", Type, 0},
+ {"IMAGE_COMDAT_SELECT_ANY", Const, 19},
+ {"IMAGE_COMDAT_SELECT_ASSOCIATIVE", Const, 19},
+ {"IMAGE_COMDAT_SELECT_EXACT_MATCH", Const, 19},
+ {"IMAGE_COMDAT_SELECT_LARGEST", Const, 19},
+ {"IMAGE_COMDAT_SELECT_NODUPLICATES", Const, 19},
+ {"IMAGE_COMDAT_SELECT_SAME_SIZE", Const, 19},
+ {"IMAGE_DIRECTORY_ENTRY_ARCHITECTURE", Const, 11},
+ {"IMAGE_DIRECTORY_ENTRY_BASERELOC", Const, 11},
+ {"IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT", Const, 11},
+ {"IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR", Const, 11},
+ {"IMAGE_DIRECTORY_ENTRY_DEBUG", Const, 11},
+ {"IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT", Const, 11},
+ {"IMAGE_DIRECTORY_ENTRY_EXCEPTION", Const, 11},
+ {"IMAGE_DIRECTORY_ENTRY_EXPORT", Const, 11},
+ {"IMAGE_DIRECTORY_ENTRY_GLOBALPTR", Const, 11},
+ {"IMAGE_DIRECTORY_ENTRY_IAT", Const, 11},
+ {"IMAGE_DIRECTORY_ENTRY_IMPORT", Const, 11},
+ {"IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG", Const, 11},
+ {"IMAGE_DIRECTORY_ENTRY_RESOURCE", Const, 11},
+ {"IMAGE_DIRECTORY_ENTRY_SECURITY", Const, 11},
+ {"IMAGE_DIRECTORY_ENTRY_TLS", Const, 11},
+ {"IMAGE_DLLCHARACTERISTICS_APPCONTAINER", Const, 15},
+ {"IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE", Const, 15},
+ {"IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY", Const, 15},
+ {"IMAGE_DLLCHARACTERISTICS_GUARD_CF", Const, 15},
+ {"IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA", Const, 15},
+ {"IMAGE_DLLCHARACTERISTICS_NO_BIND", Const, 15},
+ {"IMAGE_DLLCHARACTERISTICS_NO_ISOLATION", Const, 15},
+ {"IMAGE_DLLCHARACTERISTICS_NO_SEH", Const, 15},
+ {"IMAGE_DLLCHARACTERISTICS_NX_COMPAT", Const, 15},
+ {"IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE", Const, 15},
+ {"IMAGE_DLLCHARACTERISTICS_WDM_DRIVER", Const, 15},
+ {"IMAGE_FILE_32BIT_MACHINE", Const, 15},
+ {"IMAGE_FILE_AGGRESIVE_WS_TRIM", Const, 15},
+ {"IMAGE_FILE_BYTES_REVERSED_HI", Const, 15},
+ {"IMAGE_FILE_BYTES_REVERSED_LO", Const, 15},
+ {"IMAGE_FILE_DEBUG_STRIPPED", Const, 15},
+ {"IMAGE_FILE_DLL", Const, 15},
+ {"IMAGE_FILE_EXECUTABLE_IMAGE", Const, 15},
+ {"IMAGE_FILE_LARGE_ADDRESS_AWARE", Const, 15},
+ {"IMAGE_FILE_LINE_NUMS_STRIPPED", Const, 15},
+ {"IMAGE_FILE_LOCAL_SYMS_STRIPPED", Const, 15},
+ {"IMAGE_FILE_MACHINE_AM33", Const, 0},
+ {"IMAGE_FILE_MACHINE_AMD64", Const, 0},
+ {"IMAGE_FILE_MACHINE_ARM", Const, 0},
+ {"IMAGE_FILE_MACHINE_ARM64", Const, 11},
+ {"IMAGE_FILE_MACHINE_ARMNT", Const, 12},
+ {"IMAGE_FILE_MACHINE_EBC", Const, 0},
+ {"IMAGE_FILE_MACHINE_I386", Const, 0},
+ {"IMAGE_FILE_MACHINE_IA64", Const, 0},
+ {"IMAGE_FILE_MACHINE_LOONGARCH32", Const, 19},
+ {"IMAGE_FILE_MACHINE_LOONGARCH64", Const, 19},
+ {"IMAGE_FILE_MACHINE_M32R", Const, 0},
+ {"IMAGE_FILE_MACHINE_MIPS16", Const, 0},
+ {"IMAGE_FILE_MACHINE_MIPSFPU", Const, 0},
+ {"IMAGE_FILE_MACHINE_MIPSFPU16", Const, 0},
+ {"IMAGE_FILE_MACHINE_POWERPC", Const, 0},
+ {"IMAGE_FILE_MACHINE_POWERPCFP", Const, 0},
+ {"IMAGE_FILE_MACHINE_R4000", Const, 0},
+ {"IMAGE_FILE_MACHINE_RISCV128", Const, 20},
+ {"IMAGE_FILE_MACHINE_RISCV32", Const, 20},
+ {"IMAGE_FILE_MACHINE_RISCV64", Const, 20},
+ {"IMAGE_FILE_MACHINE_SH3", Const, 0},
+ {"IMAGE_FILE_MACHINE_SH3DSP", Const, 0},
+ {"IMAGE_FILE_MACHINE_SH4", Const, 0},
+ {"IMAGE_FILE_MACHINE_SH5", Const, 0},
+ {"IMAGE_FILE_MACHINE_THUMB", Const, 0},
+ {"IMAGE_FILE_MACHINE_UNKNOWN", Const, 0},
+ {"IMAGE_FILE_MACHINE_WCEMIPSV2", Const, 0},
+ {"IMAGE_FILE_NET_RUN_FROM_SWAP", Const, 15},
+ {"IMAGE_FILE_RELOCS_STRIPPED", Const, 15},
+ {"IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP", Const, 15},
+ {"IMAGE_FILE_SYSTEM", Const, 15},
+ {"IMAGE_FILE_UP_SYSTEM_ONLY", Const, 15},
+ {"IMAGE_SCN_CNT_CODE", Const, 19},
+ {"IMAGE_SCN_CNT_INITIALIZED_DATA", Const, 19},
+ {"IMAGE_SCN_CNT_UNINITIALIZED_DATA", Const, 19},
+ {"IMAGE_SCN_LNK_COMDAT", Const, 19},
+ {"IMAGE_SCN_MEM_DISCARDABLE", Const, 19},
+ {"IMAGE_SCN_MEM_EXECUTE", Const, 19},
+ {"IMAGE_SCN_MEM_READ", Const, 19},
+ {"IMAGE_SCN_MEM_WRITE", Const, 19},
+ {"IMAGE_SUBSYSTEM_EFI_APPLICATION", Const, 15},
+ {"IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER", Const, 15},
+ {"IMAGE_SUBSYSTEM_EFI_ROM", Const, 15},
+ {"IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER", Const, 15},
+ {"IMAGE_SUBSYSTEM_NATIVE", Const, 15},
+ {"IMAGE_SUBSYSTEM_NATIVE_WINDOWS", Const, 15},
+ {"IMAGE_SUBSYSTEM_OS2_CUI", Const, 15},
+ {"IMAGE_SUBSYSTEM_POSIX_CUI", Const, 15},
+ {"IMAGE_SUBSYSTEM_UNKNOWN", Const, 15},
+ {"IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION", Const, 15},
+ {"IMAGE_SUBSYSTEM_WINDOWS_CE_GUI", Const, 15},
+ {"IMAGE_SUBSYSTEM_WINDOWS_CUI", Const, 15},
+ {"IMAGE_SUBSYSTEM_WINDOWS_GUI", Const, 15},
+ {"IMAGE_SUBSYSTEM_XBOX", Const, 15},
+ {"ImportDirectory", Type, 0},
+ {"ImportDirectory.FirstThunk", Field, 0},
+ {"ImportDirectory.ForwarderChain", Field, 0},
+ {"ImportDirectory.Name", Field, 0},
+ {"ImportDirectory.OriginalFirstThunk", Field, 0},
+ {"ImportDirectory.TimeDateStamp", Field, 0},
+ {"NewFile", Func, 0},
+ {"Open", Func, 0},
+ {"OptionalHeader32", Type, 3},
+ {"OptionalHeader32.AddressOfEntryPoint", Field, 3},
+ {"OptionalHeader32.BaseOfCode", Field, 3},
+ {"OptionalHeader32.BaseOfData", Field, 3},
+ {"OptionalHeader32.CheckSum", Field, 3},
+ {"OptionalHeader32.DataDirectory", Field, 3},
+ {"OptionalHeader32.DllCharacteristics", Field, 3},
+ {"OptionalHeader32.FileAlignment", Field, 3},
+ {"OptionalHeader32.ImageBase", Field, 3},
+ {"OptionalHeader32.LoaderFlags", Field, 3},
+ {"OptionalHeader32.Magic", Field, 3},
+ {"OptionalHeader32.MajorImageVersion", Field, 3},
+ {"OptionalHeader32.MajorLinkerVersion", Field, 3},
+ {"OptionalHeader32.MajorOperatingSystemVersion", Field, 3},
+ {"OptionalHeader32.MajorSubsystemVersion", Field, 3},
+ {"OptionalHeader32.MinorImageVersion", Field, 3},
+ {"OptionalHeader32.MinorLinkerVersion", Field, 3},
+ {"OptionalHeader32.MinorOperatingSystemVersion", Field, 3},
+ {"OptionalHeader32.MinorSubsystemVersion", Field, 3},
+ {"OptionalHeader32.NumberOfRvaAndSizes", Field, 3},
+ {"OptionalHeader32.SectionAlignment", Field, 3},
+ {"OptionalHeader32.SizeOfCode", Field, 3},
+ {"OptionalHeader32.SizeOfHeaders", Field, 3},
+ {"OptionalHeader32.SizeOfHeapCommit", Field, 3},
+ {"OptionalHeader32.SizeOfHeapReserve", Field, 3},
+ {"OptionalHeader32.SizeOfImage", Field, 3},
+ {"OptionalHeader32.SizeOfInitializedData", Field, 3},
+ {"OptionalHeader32.SizeOfStackCommit", Field, 3},
+ {"OptionalHeader32.SizeOfStackReserve", Field, 3},
+ {"OptionalHeader32.SizeOfUninitializedData", Field, 3},
+ {"OptionalHeader32.Subsystem", Field, 3},
+ {"OptionalHeader32.Win32VersionValue", Field, 3},
+ {"OptionalHeader64", Type, 3},
+ {"OptionalHeader64.AddressOfEntryPoint", Field, 3},
+ {"OptionalHeader64.BaseOfCode", Field, 3},
+ {"OptionalHeader64.CheckSum", Field, 3},
+ {"OptionalHeader64.DataDirectory", Field, 3},
+ {"OptionalHeader64.DllCharacteristics", Field, 3},
+ {"OptionalHeader64.FileAlignment", Field, 3},
+ {"OptionalHeader64.ImageBase", Field, 3},
+ {"OptionalHeader64.LoaderFlags", Field, 3},
+ {"OptionalHeader64.Magic", Field, 3},
+ {"OptionalHeader64.MajorImageVersion", Field, 3},
+ {"OptionalHeader64.MajorLinkerVersion", Field, 3},
+ {"OptionalHeader64.MajorOperatingSystemVersion", Field, 3},
+ {"OptionalHeader64.MajorSubsystemVersion", Field, 3},
+ {"OptionalHeader64.MinorImageVersion", Field, 3},
+ {"OptionalHeader64.MinorLinkerVersion", Field, 3},
+ {"OptionalHeader64.MinorOperatingSystemVersion", Field, 3},
+ {"OptionalHeader64.MinorSubsystemVersion", Field, 3},
+ {"OptionalHeader64.NumberOfRvaAndSizes", Field, 3},
+ {"OptionalHeader64.SectionAlignment", Field, 3},
+ {"OptionalHeader64.SizeOfCode", Field, 3},
+ {"OptionalHeader64.SizeOfHeaders", Field, 3},
+ {"OptionalHeader64.SizeOfHeapCommit", Field, 3},
+ {"OptionalHeader64.SizeOfHeapReserve", Field, 3},
+ {"OptionalHeader64.SizeOfImage", Field, 3},
+ {"OptionalHeader64.SizeOfInitializedData", Field, 3},
+ {"OptionalHeader64.SizeOfStackCommit", Field, 3},
+ {"OptionalHeader64.SizeOfStackReserve", Field, 3},
+ {"OptionalHeader64.SizeOfUninitializedData", Field, 3},
+ {"OptionalHeader64.Subsystem", Field, 3},
+ {"OptionalHeader64.Win32VersionValue", Field, 3},
+ {"Reloc", Type, 8},
+ {"Reloc.SymbolTableIndex", Field, 8},
+ {"Reloc.Type", Field, 8},
+ {"Reloc.VirtualAddress", Field, 8},
+ {"Section", Type, 0},
+ {"Section.ReaderAt", Field, 0},
+ {"Section.Relocs", Field, 8},
+ {"Section.SectionHeader", Field, 0},
+ {"SectionHeader", Type, 0},
+ {"SectionHeader.Characteristics", Field, 0},
+ {"SectionHeader.Name", Field, 0},
+ {"SectionHeader.NumberOfLineNumbers", Field, 0},
+ {"SectionHeader.NumberOfRelocations", Field, 0},
+ {"SectionHeader.Offset", Field, 0},
+ {"SectionHeader.PointerToLineNumbers", Field, 0},
+ {"SectionHeader.PointerToRelocations", Field, 0},
+ {"SectionHeader.Size", Field, 0},
+ {"SectionHeader.VirtualAddress", Field, 0},
+ {"SectionHeader.VirtualSize", Field, 0},
+ {"SectionHeader32", Type, 0},
+ {"SectionHeader32.Characteristics", Field, 0},
+ {"SectionHeader32.Name", Field, 0},
+ {"SectionHeader32.NumberOfLineNumbers", Field, 0},
+ {"SectionHeader32.NumberOfRelocations", Field, 0},
+ {"SectionHeader32.PointerToLineNumbers", Field, 0},
+ {"SectionHeader32.PointerToRawData", Field, 0},
+ {"SectionHeader32.PointerToRelocations", Field, 0},
+ {"SectionHeader32.SizeOfRawData", Field, 0},
+ {"SectionHeader32.VirtualAddress", Field, 0},
+ {"SectionHeader32.VirtualSize", Field, 0},
+ {"StringTable", Type, 8},
+ {"Symbol", Type, 1},
+ {"Symbol.Name", Field, 1},
+ {"Symbol.SectionNumber", Field, 1},
+ {"Symbol.StorageClass", Field, 1},
+ {"Symbol.Type", Field, 1},
+ {"Symbol.Value", Field, 1},
+ },
+ "debug/plan9obj": {
+ {"(*File).Close", Method, 3},
+ {"(*File).Section", Method, 3},
+ {"(*File).Symbols", Method, 3},
+ {"(*Section).Data", Method, 3},
+ {"(*Section).Open", Method, 3},
+ {"(Section).ReadAt", Method, 3},
+ {"ErrNoSymbols", Var, 18},
+ {"File", Type, 3},
+ {"File.FileHeader", Field, 3},
+ {"File.Sections", Field, 3},
+ {"FileHeader", Type, 3},
+ {"FileHeader.Bss", Field, 3},
+ {"FileHeader.Entry", Field, 3},
+ {"FileHeader.HdrSize", Field, 4},
+ {"FileHeader.LoadAddress", Field, 4},
+ {"FileHeader.Magic", Field, 3},
+ {"FileHeader.PtrSize", Field, 3},
+ {"Magic386", Const, 3},
+ {"Magic64", Const, 3},
+ {"MagicAMD64", Const, 3},
+ {"MagicARM", Const, 3},
+ {"NewFile", Func, 3},
+ {"Open", Func, 3},
+ {"Section", Type, 3},
+ {"Section.ReaderAt", Field, 3},
+ {"Section.SectionHeader", Field, 3},
+ {"SectionHeader", Type, 3},
+ {"SectionHeader.Name", Field, 3},
+ {"SectionHeader.Offset", Field, 3},
+ {"SectionHeader.Size", Field, 3},
+ {"Sym", Type, 3},
+ {"Sym.Name", Field, 3},
+ {"Sym.Type", Field, 3},
+ {"Sym.Value", Field, 3},
+ },
+ "embed": {
+ {"(FS).Open", Method, 16},
+ {"(FS).ReadDir", Method, 16},
+ {"(FS).ReadFile", Method, 16},
+ {"FS", Type, 16},
+ },
+ "encoding": {
+ {"BinaryMarshaler", Type, 2},
+ {"BinaryUnmarshaler", Type, 2},
+ {"TextMarshaler", Type, 2},
+ {"TextUnmarshaler", Type, 2},
+ },
+ "encoding/ascii85": {
+ {"(CorruptInputError).Error", Method, 0},
+ {"CorruptInputError", Type, 0},
+ {"Decode", Func, 0},
+ {"Encode", Func, 0},
+ {"MaxEncodedLen", Func, 0},
+ {"NewDecoder", Func, 0},
+ {"NewEncoder", Func, 0},
+ },
+ "encoding/asn1": {
+ {"(BitString).At", Method, 0},
+ {"(BitString).RightAlign", Method, 0},
+ {"(ObjectIdentifier).Equal", Method, 0},
+ {"(ObjectIdentifier).String", Method, 3},
+ {"(StructuralError).Error", Method, 0},
+ {"(SyntaxError).Error", Method, 0},
+ {"BitString", Type, 0},
+ {"BitString.BitLength", Field, 0},
+ {"BitString.Bytes", Field, 0},
+ {"ClassApplication", Const, 6},
+ {"ClassContextSpecific", Const, 6},
+ {"ClassPrivate", Const, 6},
+ {"ClassUniversal", Const, 6},
+ {"Enumerated", Type, 0},
+ {"Flag", Type, 0},
+ {"Marshal", Func, 0},
+ {"MarshalWithParams", Func, 10},
+ {"NullBytes", Var, 9},
+ {"NullRawValue", Var, 9},
+ {"ObjectIdentifier", Type, 0},
+ {"RawContent", Type, 0},
+ {"RawValue", Type, 0},
+ {"RawValue.Bytes", Field, 0},
+ {"RawValue.Class", Field, 0},
+ {"RawValue.FullBytes", Field, 0},
+ {"RawValue.IsCompound", Field, 0},
+ {"RawValue.Tag", Field, 0},
+ {"StructuralError", Type, 0},
+ {"StructuralError.Msg", Field, 0},
+ {"SyntaxError", Type, 0},
+ {"SyntaxError.Msg", Field, 0},
+ {"TagBMPString", Const, 14},
+ {"TagBitString", Const, 6},
+ {"TagBoolean", Const, 6},
+ {"TagEnum", Const, 6},
+ {"TagGeneralString", Const, 6},
+ {"TagGeneralizedTime", Const, 6},
+ {"TagIA5String", Const, 6},
+ {"TagInteger", Const, 6},
+ {"TagNull", Const, 9},
+ {"TagNumericString", Const, 10},
+ {"TagOID", Const, 6},
+ {"TagOctetString", Const, 6},
+ {"TagPrintableString", Const, 6},
+ {"TagSequence", Const, 6},
+ {"TagSet", Const, 6},
+ {"TagT61String", Const, 6},
+ {"TagUTCTime", Const, 6},
+ {"TagUTF8String", Const, 6},
+ {"Unmarshal", Func, 0},
+ {"UnmarshalWithParams", Func, 0},
+ },
+ "encoding/base32": {
+ {"(*Encoding).AppendDecode", Method, 22},
+ {"(*Encoding).AppendEncode", Method, 22},
+ {"(*Encoding).Decode", Method, 0},
+ {"(*Encoding).DecodeString", Method, 0},
+ {"(*Encoding).DecodedLen", Method, 0},
+ {"(*Encoding).Encode", Method, 0},
+ {"(*Encoding).EncodeToString", Method, 0},
+ {"(*Encoding).EncodedLen", Method, 0},
+ {"(CorruptInputError).Error", Method, 0},
+ {"(Encoding).WithPadding", Method, 9},
+ {"CorruptInputError", Type, 0},
+ {"Encoding", Type, 0},
+ {"HexEncoding", Var, 0},
+ {"NewDecoder", Func, 0},
+ {"NewEncoder", Func, 0},
+ {"NewEncoding", Func, 0},
+ {"NoPadding", Const, 9},
+ {"StdEncoding", Var, 0},
+ {"StdPadding", Const, 9},
+ },
+ "encoding/base64": {
+ {"(*Encoding).AppendDecode", Method, 22},
+ {"(*Encoding).AppendEncode", Method, 22},
+ {"(*Encoding).Decode", Method, 0},
+ {"(*Encoding).DecodeString", Method, 0},
+ {"(*Encoding).DecodedLen", Method, 0},
+ {"(*Encoding).Encode", Method, 0},
+ {"(*Encoding).EncodeToString", Method, 0},
+ {"(*Encoding).EncodedLen", Method, 0},
+ {"(CorruptInputError).Error", Method, 0},
+ {"(Encoding).Strict", Method, 8},
+ {"(Encoding).WithPadding", Method, 5},
+ {"CorruptInputError", Type, 0},
+ {"Encoding", Type, 0},
+ {"NewDecoder", Func, 0},
+ {"NewEncoder", Func, 0},
+ {"NewEncoding", Func, 0},
+ {"NoPadding", Const, 5},
+ {"RawStdEncoding", Var, 5},
+ {"RawURLEncoding", Var, 5},
+ {"StdEncoding", Var, 0},
+ {"StdPadding", Const, 5},
+ {"URLEncoding", Var, 0},
+ },
+ "encoding/binary": {
+ {"Append", Func, 23},
+ {"AppendByteOrder", Type, 19},
+ {"AppendUvarint", Func, 19},
+ {"AppendVarint", Func, 19},
+ {"BigEndian", Var, 0},
+ {"ByteOrder", Type, 0},
+ {"Decode", Func, 23},
+ {"Encode", Func, 23},
+ {"LittleEndian", Var, 0},
+ {"MaxVarintLen16", Const, 0},
+ {"MaxVarintLen32", Const, 0},
+ {"MaxVarintLen64", Const, 0},
+ {"NativeEndian", Var, 21},
+ {"PutUvarint", Func, 0},
+ {"PutVarint", Func, 0},
+ {"Read", Func, 0},
+ {"ReadUvarint", Func, 0},
+ {"ReadVarint", Func, 0},
+ {"Size", Func, 0},
+ {"Uvarint", Func, 0},
+ {"Varint", Func, 0},
+ {"Write", Func, 0},
+ },
+ "encoding/csv": {
+ {"(*ParseError).Error", Method, 0},
+ {"(*ParseError).Unwrap", Method, 13},
+ {"(*Reader).FieldPos", Method, 17},
+ {"(*Reader).InputOffset", Method, 19},
+ {"(*Reader).Read", Method, 0},
+ {"(*Reader).ReadAll", Method, 0},
+ {"(*Writer).Error", Method, 1},
+ {"(*Writer).Flush", Method, 0},
+ {"(*Writer).Write", Method, 0},
+ {"(*Writer).WriteAll", Method, 0},
+ {"ErrBareQuote", Var, 0},
+ {"ErrFieldCount", Var, 0},
+ {"ErrQuote", Var, 0},
+ {"ErrTrailingComma", Var, 0},
+ {"NewReader", Func, 0},
+ {"NewWriter", Func, 0},
+ {"ParseError", Type, 0},
+ {"ParseError.Column", Field, 0},
+ {"ParseError.Err", Field, 0},
+ {"ParseError.Line", Field, 0},
+ {"ParseError.StartLine", Field, 10},
+ {"Reader", Type, 0},
+ {"Reader.Comma", Field, 0},
+ {"Reader.Comment", Field, 0},
+ {"Reader.FieldsPerRecord", Field, 0},
+ {"Reader.LazyQuotes", Field, 0},
+ {"Reader.ReuseRecord", Field, 9},
+ {"Reader.TrailingComma", Field, 0},
+ {"Reader.TrimLeadingSpace", Field, 0},
+ {"Writer", Type, 0},
+ {"Writer.Comma", Field, 0},
+ {"Writer.UseCRLF", Field, 0},
+ },
+ "encoding/gob": {
+ {"(*Decoder).Decode", Method, 0},
+ {"(*Decoder).DecodeValue", Method, 0},
+ {"(*Encoder).Encode", Method, 0},
+ {"(*Encoder).EncodeValue", Method, 0},
+ {"CommonType", Type, 0},
+ {"CommonType.Id", Field, 0},
+ {"CommonType.Name", Field, 0},
+ {"Decoder", Type, 0},
+ {"Encoder", Type, 0},
+ {"GobDecoder", Type, 0},
+ {"GobEncoder", Type, 0},
+ {"NewDecoder", Func, 0},
+ {"NewEncoder", Func, 0},
+ {"Register", Func, 0},
+ {"RegisterName", Func, 0},
+ },
+ "encoding/hex": {
+ {"(InvalidByteError).Error", Method, 0},
+ {"AppendDecode", Func, 22},
+ {"AppendEncode", Func, 22},
+ {"Decode", Func, 0},
+ {"DecodeString", Func, 0},
+ {"DecodedLen", Func, 0},
+ {"Dump", Func, 0},
+ {"Dumper", Func, 0},
+ {"Encode", Func, 0},
+ {"EncodeToString", Func, 0},
+ {"EncodedLen", Func, 0},
+ {"ErrLength", Var, 0},
+ {"InvalidByteError", Type, 0},
+ {"NewDecoder", Func, 10},
+ {"NewEncoder", Func, 10},
+ },
+ "encoding/json": {
+ {"(*Decoder).Buffered", Method, 1},
+ {"(*Decoder).Decode", Method, 0},
+ {"(*Decoder).DisallowUnknownFields", Method, 10},
+ {"(*Decoder).InputOffset", Method, 14},
+ {"(*Decoder).More", Method, 5},
+ {"(*Decoder).Token", Method, 5},
+ {"(*Decoder).UseNumber", Method, 1},
+ {"(*Encoder).Encode", Method, 0},
+ {"(*Encoder).SetEscapeHTML", Method, 7},
+ {"(*Encoder).SetIndent", Method, 7},
+ {"(*InvalidUTF8Error).Error", Method, 0},
+ {"(*InvalidUnmarshalError).Error", Method, 0},
+ {"(*MarshalerError).Error", Method, 0},
+ {"(*MarshalerError).Unwrap", Method, 13},
+ {"(*RawMessage).MarshalJSON", Method, 0},
+ {"(*RawMessage).UnmarshalJSON", Method, 0},
+ {"(*SyntaxError).Error", Method, 0},
+ {"(*UnmarshalFieldError).Error", Method, 0},
+ {"(*UnmarshalTypeError).Error", Method, 0},
+ {"(*UnsupportedTypeError).Error", Method, 0},
+ {"(*UnsupportedValueError).Error", Method, 0},
+ {"(Delim).String", Method, 5},
+ {"(Number).Float64", Method, 1},
+ {"(Number).Int64", Method, 1},
+ {"(Number).String", Method, 1},
+ {"(RawMessage).MarshalJSON", Method, 8},
+ {"Compact", Func, 0},
+ {"Decoder", Type, 0},
+ {"Delim", Type, 5},
+ {"Encoder", Type, 0},
+ {"HTMLEscape", Func, 0},
+ {"Indent", Func, 0},
+ {"InvalidUTF8Error", Type, 0},
+ {"InvalidUTF8Error.S", Field, 0},
+ {"InvalidUnmarshalError", Type, 0},
+ {"InvalidUnmarshalError.Type", Field, 0},
+ {"Marshal", Func, 0},
+ {"MarshalIndent", Func, 0},
+ {"Marshaler", Type, 0},
+ {"MarshalerError", Type, 0},
+ {"MarshalerError.Err", Field, 0},
+ {"MarshalerError.Type", Field, 0},
+ {"NewDecoder", Func, 0},
+ {"NewEncoder", Func, 0},
+ {"Number", Type, 1},
+ {"RawMessage", Type, 0},
+ {"SyntaxError", Type, 0},
+ {"SyntaxError.Offset", Field, 0},
+ {"Token", Type, 5},
+ {"Unmarshal", Func, 0},
+ {"UnmarshalFieldError", Type, 0},
+ {"UnmarshalFieldError.Field", Field, 0},
+ {"UnmarshalFieldError.Key", Field, 0},
+ {"UnmarshalFieldError.Type", Field, 0},
+ {"UnmarshalTypeError", Type, 0},
+ {"UnmarshalTypeError.Field", Field, 8},
+ {"UnmarshalTypeError.Offset", Field, 5},
+ {"UnmarshalTypeError.Struct", Field, 8},
+ {"UnmarshalTypeError.Type", Field, 0},
+ {"UnmarshalTypeError.Value", Field, 0},
+ {"Unmarshaler", Type, 0},
+ {"UnsupportedTypeError", Type, 0},
+ {"UnsupportedTypeError.Type", Field, 0},
+ {"UnsupportedValueError", Type, 0},
+ {"UnsupportedValueError.Str", Field, 0},
+ {"UnsupportedValueError.Value", Field, 0},
+ {"Valid", Func, 9},
+ },
+ "encoding/pem": {
+ {"Block", Type, 0},
+ {"Block.Bytes", Field, 0},
+ {"Block.Headers", Field, 0},
+ {"Block.Type", Field, 0},
+ {"Decode", Func, 0},
+ {"Encode", Func, 0},
+ {"EncodeToMemory", Func, 0},
+ },
+ "encoding/xml": {
+ {"(*Decoder).Decode", Method, 0},
+ {"(*Decoder).DecodeElement", Method, 0},
+ {"(*Decoder).InputOffset", Method, 4},
+ {"(*Decoder).InputPos", Method, 19},
+ {"(*Decoder).RawToken", Method, 0},
+ {"(*Decoder).Skip", Method, 0},
+ {"(*Decoder).Token", Method, 0},
+ {"(*Encoder).Close", Method, 20},
+ {"(*Encoder).Encode", Method, 0},
+ {"(*Encoder).EncodeElement", Method, 2},
+ {"(*Encoder).EncodeToken", Method, 2},
+ {"(*Encoder).Flush", Method, 2},
+ {"(*Encoder).Indent", Method, 1},
+ {"(*SyntaxError).Error", Method, 0},
+ {"(*TagPathError).Error", Method, 0},
+ {"(*UnsupportedTypeError).Error", Method, 0},
+ {"(CharData).Copy", Method, 0},
+ {"(Comment).Copy", Method, 0},
+ {"(Directive).Copy", Method, 0},
+ {"(ProcInst).Copy", Method, 0},
+ {"(StartElement).Copy", Method, 0},
+ {"(StartElement).End", Method, 2},
+ {"(UnmarshalError).Error", Method, 0},
+ {"Attr", Type, 0},
+ {"Attr.Name", Field, 0},
+ {"Attr.Value", Field, 0},
+ {"CharData", Type, 0},
+ {"Comment", Type, 0},
+ {"CopyToken", Func, 0},
+ {"Decoder", Type, 0},
+ {"Decoder.AutoClose", Field, 0},
+ {"Decoder.CharsetReader", Field, 0},
+ {"Decoder.DefaultSpace", Field, 1},
+ {"Decoder.Entity", Field, 0},
+ {"Decoder.Strict", Field, 0},
+ {"Directive", Type, 0},
+ {"Encoder", Type, 0},
+ {"EndElement", Type, 0},
+ {"EndElement.Name", Field, 0},
+ {"Escape", Func, 0},
+ {"EscapeText", Func, 1},
+ {"HTMLAutoClose", Var, 0},
+ {"HTMLEntity", Var, 0},
+ {"Header", Const, 0},
+ {"Marshal", Func, 0},
+ {"MarshalIndent", Func, 0},
+ {"Marshaler", Type, 2},
+ {"MarshalerAttr", Type, 2},
+ {"Name", Type, 0},
+ {"Name.Local", Field, 0},
+ {"Name.Space", Field, 0},
+ {"NewDecoder", Func, 0},
+ {"NewEncoder", Func, 0},
+ {"NewTokenDecoder", Func, 10},
+ {"ProcInst", Type, 0},
+ {"ProcInst.Inst", Field, 0},
+ {"ProcInst.Target", Field, 0},
+ {"StartElement", Type, 0},
+ {"StartElement.Attr", Field, 0},
+ {"StartElement.Name", Field, 0},
+ {"SyntaxError", Type, 0},
+ {"SyntaxError.Line", Field, 0},
+ {"SyntaxError.Msg", Field, 0},
+ {"TagPathError", Type, 0},
+ {"TagPathError.Field1", Field, 0},
+ {"TagPathError.Field2", Field, 0},
+ {"TagPathError.Struct", Field, 0},
+ {"TagPathError.Tag1", Field, 0},
+ {"TagPathError.Tag2", Field, 0},
+ {"Token", Type, 0},
+ {"TokenReader", Type, 10},
+ {"Unmarshal", Func, 0},
+ {"UnmarshalError", Type, 0},
+ {"Unmarshaler", Type, 2},
+ {"UnmarshalerAttr", Type, 2},
+ {"UnsupportedTypeError", Type, 0},
+ {"UnsupportedTypeError.Type", Field, 0},
+ },
+ "errors": {
+ {"As", Func, 13},
+ {"ErrUnsupported", Var, 21},
+ {"Is", Func, 13},
+ {"Join", Func, 20},
+ {"New", Func, 0},
+ {"Unwrap", Func, 13},
+ },
+ "expvar": {
+ {"(*Float).Add", Method, 0},
+ {"(*Float).Set", Method, 0},
+ {"(*Float).String", Method, 0},
+ {"(*Float).Value", Method, 8},
+ {"(*Int).Add", Method, 0},
+ {"(*Int).Set", Method, 0},
+ {"(*Int).String", Method, 0},
+ {"(*Int).Value", Method, 8},
+ {"(*Map).Add", Method, 0},
+ {"(*Map).AddFloat", Method, 0},
+ {"(*Map).Delete", Method, 12},
+ {"(*Map).Do", Method, 0},
+ {"(*Map).Get", Method, 0},
+ {"(*Map).Init", Method, 0},
+ {"(*Map).Set", Method, 0},
+ {"(*Map).String", Method, 0},
+ {"(*String).Set", Method, 0},
+ {"(*String).String", Method, 0},
+ {"(*String).Value", Method, 8},
+ {"(Func).String", Method, 0},
+ {"(Func).Value", Method, 8},
+ {"Do", Func, 0},
+ {"Float", Type, 0},
+ {"Func", Type, 0},
+ {"Get", Func, 0},
+ {"Handler", Func, 8},
+ {"Int", Type, 0},
+ {"KeyValue", Type, 0},
+ {"KeyValue.Key", Field, 0},
+ {"KeyValue.Value", Field, 0},
+ {"Map", Type, 0},
+ {"NewFloat", Func, 0},
+ {"NewInt", Func, 0},
+ {"NewMap", Func, 0},
+ {"NewString", Func, 0},
+ {"Publish", Func, 0},
+ {"String", Type, 0},
+ {"Var", Type, 0},
+ },
+ "flag": {
+ {"(*FlagSet).Arg", Method, 0},
+ {"(*FlagSet).Args", Method, 0},
+ {"(*FlagSet).Bool", Method, 0},
+ {"(*FlagSet).BoolFunc", Method, 21},
+ {"(*FlagSet).BoolVar", Method, 0},
+ {"(*FlagSet).Duration", Method, 0},
+ {"(*FlagSet).DurationVar", Method, 0},
+ {"(*FlagSet).ErrorHandling", Method, 10},
+ {"(*FlagSet).Float64", Method, 0},
+ {"(*FlagSet).Float64Var", Method, 0},
+ {"(*FlagSet).Func", Method, 16},
+ {"(*FlagSet).Init", Method, 0},
+ {"(*FlagSet).Int", Method, 0},
+ {"(*FlagSet).Int64", Method, 0},
+ {"(*FlagSet).Int64Var", Method, 0},
+ {"(*FlagSet).IntVar", Method, 0},
+ {"(*FlagSet).Lookup", Method, 0},
+ {"(*FlagSet).NArg", Method, 0},
+ {"(*FlagSet).NFlag", Method, 0},
+ {"(*FlagSet).Name", Method, 10},
+ {"(*FlagSet).Output", Method, 10},
+ {"(*FlagSet).Parse", Method, 0},
+ {"(*FlagSet).Parsed", Method, 0},
+ {"(*FlagSet).PrintDefaults", Method, 0},
+ {"(*FlagSet).Set", Method, 0},
+ {"(*FlagSet).SetOutput", Method, 0},
+ {"(*FlagSet).String", Method, 0},
+ {"(*FlagSet).StringVar", Method, 0},
+ {"(*FlagSet).TextVar", Method, 19},
+ {"(*FlagSet).Uint", Method, 0},
+ {"(*FlagSet).Uint64", Method, 0},
+ {"(*FlagSet).Uint64Var", Method, 0},
+ {"(*FlagSet).UintVar", Method, 0},
+ {"(*FlagSet).Var", Method, 0},
+ {"(*FlagSet).Visit", Method, 0},
+ {"(*FlagSet).VisitAll", Method, 0},
+ {"Arg", Func, 0},
+ {"Args", Func, 0},
+ {"Bool", Func, 0},
+ {"BoolFunc", Func, 21},
+ {"BoolVar", Func, 0},
+ {"CommandLine", Var, 2},
+ {"ContinueOnError", Const, 0},
+ {"Duration", Func, 0},
+ {"DurationVar", Func, 0},
+ {"ErrHelp", Var, 0},
+ {"ErrorHandling", Type, 0},
+ {"ExitOnError", Const, 0},
+ {"Flag", Type, 0},
+ {"Flag.DefValue", Field, 0},
+ {"Flag.Name", Field, 0},
+ {"Flag.Usage", Field, 0},
+ {"Flag.Value", Field, 0},
+ {"FlagSet", Type, 0},
+ {"FlagSet.Usage", Field, 0},
+ {"Float64", Func, 0},
+ {"Float64Var", Func, 0},
+ {"Func", Func, 16},
+ {"Getter", Type, 2},
+ {"Int", Func, 0},
+ {"Int64", Func, 0},
+ {"Int64Var", Func, 0},
+ {"IntVar", Func, 0},
+ {"Lookup", Func, 0},
+ {"NArg", Func, 0},
+ {"NFlag", Func, 0},
+ {"NewFlagSet", Func, 0},
+ {"PanicOnError", Const, 0},
+ {"Parse", Func, 0},
+ {"Parsed", Func, 0},
+ {"PrintDefaults", Func, 0},
+ {"Set", Func, 0},
+ {"String", Func, 0},
+ {"StringVar", Func, 0},
+ {"TextVar", Func, 19},
+ {"Uint", Func, 0},
+ {"Uint64", Func, 0},
+ {"Uint64Var", Func, 0},
+ {"UintVar", Func, 0},
+ {"UnquoteUsage", Func, 5},
+ {"Usage", Var, 0},
+ {"Value", Type, 0},
+ {"Var", Func, 0},
+ {"Visit", Func, 0},
+ {"VisitAll", Func, 0},
+ },
+ "fmt": {
+ {"Append", Func, 19},
+ {"Appendf", Func, 19},
+ {"Appendln", Func, 19},
+ {"Errorf", Func, 0},
+ {"FormatString", Func, 20},
+ {"Formatter", Type, 0},
+ {"Fprint", Func, 0},
+ {"Fprintf", Func, 0},
+ {"Fprintln", Func, 0},
+ {"Fscan", Func, 0},
+ {"Fscanf", Func, 0},
+ {"Fscanln", Func, 0},
+ {"GoStringer", Type, 0},
+ {"Print", Func, 0},
+ {"Printf", Func, 0},
+ {"Println", Func, 0},
+ {"Scan", Func, 0},
+ {"ScanState", Type, 0},
+ {"Scanf", Func, 0},
+ {"Scanln", Func, 0},
+ {"Scanner", Type, 0},
+ {"Sprint", Func, 0},
+ {"Sprintf", Func, 0},
+ {"Sprintln", Func, 0},
+ {"Sscan", Func, 0},
+ {"Sscanf", Func, 0},
+ {"Sscanln", Func, 0},
+ {"State", Type, 0},
+ {"Stringer", Type, 0},
+ },
+ "go/ast": {
+ {"(*ArrayType).End", Method, 0},
+ {"(*ArrayType).Pos", Method, 0},
+ {"(*AssignStmt).End", Method, 0},
+ {"(*AssignStmt).Pos", Method, 0},
+ {"(*BadDecl).End", Method, 0},
+ {"(*BadDecl).Pos", Method, 0},
+ {"(*BadExpr).End", Method, 0},
+ {"(*BadExpr).Pos", Method, 0},
+ {"(*BadStmt).End", Method, 0},
+ {"(*BadStmt).Pos", Method, 0},
+ {"(*BasicLit).End", Method, 0},
+ {"(*BasicLit).Pos", Method, 0},
+ {"(*BinaryExpr).End", Method, 0},
+ {"(*BinaryExpr).Pos", Method, 0},
+ {"(*BlockStmt).End", Method, 0},
+ {"(*BlockStmt).Pos", Method, 0},
+ {"(*BranchStmt).End", Method, 0},
+ {"(*BranchStmt).Pos", Method, 0},
+ {"(*CallExpr).End", Method, 0},
+ {"(*CallExpr).Pos", Method, 0},
+ {"(*CaseClause).End", Method, 0},
+ {"(*CaseClause).Pos", Method, 0},
+ {"(*ChanType).End", Method, 0},
+ {"(*ChanType).Pos", Method, 0},
+ {"(*CommClause).End", Method, 0},
+ {"(*CommClause).Pos", Method, 0},
+ {"(*Comment).End", Method, 0},
+ {"(*Comment).Pos", Method, 0},
+ {"(*CommentGroup).End", Method, 0},
+ {"(*CommentGroup).Pos", Method, 0},
+ {"(*CommentGroup).Text", Method, 0},
+ {"(*CompositeLit).End", Method, 0},
+ {"(*CompositeLit).Pos", Method, 0},
+ {"(*DeclStmt).End", Method, 0},
+ {"(*DeclStmt).Pos", Method, 0},
+ {"(*DeferStmt).End", Method, 0},
+ {"(*DeferStmt).Pos", Method, 0},
+ {"(*Ellipsis).End", Method, 0},
+ {"(*Ellipsis).Pos", Method, 0},
+ {"(*EmptyStmt).End", Method, 0},
+ {"(*EmptyStmt).Pos", Method, 0},
+ {"(*ExprStmt).End", Method, 0},
+ {"(*ExprStmt).Pos", Method, 0},
+ {"(*Field).End", Method, 0},
+ {"(*Field).Pos", Method, 0},
+ {"(*FieldList).End", Method, 0},
+ {"(*FieldList).NumFields", Method, 0},
+ {"(*FieldList).Pos", Method, 0},
+ {"(*File).End", Method, 0},
+ {"(*File).Pos", Method, 0},
+ {"(*ForStmt).End", Method, 0},
+ {"(*ForStmt).Pos", Method, 0},
+ {"(*FuncDecl).End", Method, 0},
+ {"(*FuncDecl).Pos", Method, 0},
+ {"(*FuncLit).End", Method, 0},
+ {"(*FuncLit).Pos", Method, 0},
+ {"(*FuncType).End", Method, 0},
+ {"(*FuncType).Pos", Method, 0},
+ {"(*GenDecl).End", Method, 0},
+ {"(*GenDecl).Pos", Method, 0},
+ {"(*GoStmt).End", Method, 0},
+ {"(*GoStmt).Pos", Method, 0},
+ {"(*Ident).End", Method, 0},
+ {"(*Ident).IsExported", Method, 0},
+ {"(*Ident).Pos", Method, 0},
+ {"(*Ident).String", Method, 0},
+ {"(*IfStmt).End", Method, 0},
+ {"(*IfStmt).Pos", Method, 0},
+ {"(*ImportSpec).End", Method, 0},
+ {"(*ImportSpec).Pos", Method, 0},
+ {"(*IncDecStmt).End", Method, 0},
+ {"(*IncDecStmt).Pos", Method, 0},
+ {"(*IndexExpr).End", Method, 0},
+ {"(*IndexExpr).Pos", Method, 0},
+ {"(*IndexListExpr).End", Method, 18},
+ {"(*IndexListExpr).Pos", Method, 18},
+ {"(*InterfaceType).End", Method, 0},
+ {"(*InterfaceType).Pos", Method, 0},
+ {"(*KeyValueExpr).End", Method, 0},
+ {"(*KeyValueExpr).Pos", Method, 0},
+ {"(*LabeledStmt).End", Method, 0},
+ {"(*LabeledStmt).Pos", Method, 0},
+ {"(*MapType).End", Method, 0},
+ {"(*MapType).Pos", Method, 0},
+ {"(*Object).Pos", Method, 0},
+ {"(*Package).End", Method, 0},
+ {"(*Package).Pos", Method, 0},
+ {"(*ParenExpr).End", Method, 0},
+ {"(*ParenExpr).Pos", Method, 0},
+ {"(*RangeStmt).End", Method, 0},
+ {"(*RangeStmt).Pos", Method, 0},
+ {"(*ReturnStmt).End", Method, 0},
+ {"(*ReturnStmt).Pos", Method, 0},
+ {"(*Scope).Insert", Method, 0},
+ {"(*Scope).Lookup", Method, 0},
+ {"(*Scope).String", Method, 0},
+ {"(*SelectStmt).End", Method, 0},
+ {"(*SelectStmt).Pos", Method, 0},
+ {"(*SelectorExpr).End", Method, 0},
+ {"(*SelectorExpr).Pos", Method, 0},
+ {"(*SendStmt).End", Method, 0},
+ {"(*SendStmt).Pos", Method, 0},
+ {"(*SliceExpr).End", Method, 0},
+ {"(*SliceExpr).Pos", Method, 0},
+ {"(*StarExpr).End", Method, 0},
+ {"(*StarExpr).Pos", Method, 0},
+ {"(*StructType).End", Method, 0},
+ {"(*StructType).Pos", Method, 0},
+ {"(*SwitchStmt).End", Method, 0},
+ {"(*SwitchStmt).Pos", Method, 0},
+ {"(*TypeAssertExpr).End", Method, 0},
+ {"(*TypeAssertExpr).Pos", Method, 0},
+ {"(*TypeSpec).End", Method, 0},
+ {"(*TypeSpec).Pos", Method, 0},
+ {"(*TypeSwitchStmt).End", Method, 0},
+ {"(*TypeSwitchStmt).Pos", Method, 0},
+ {"(*UnaryExpr).End", Method, 0},
+ {"(*UnaryExpr).Pos", Method, 0},
+ {"(*ValueSpec).End", Method, 0},
+ {"(*ValueSpec).Pos", Method, 0},
+ {"(CommentMap).Comments", Method, 1},
+ {"(CommentMap).Filter", Method, 1},
+ {"(CommentMap).String", Method, 1},
+ {"(CommentMap).Update", Method, 1},
+ {"(ObjKind).String", Method, 0},
+ {"ArrayType", Type, 0},
+ {"ArrayType.Elt", Field, 0},
+ {"ArrayType.Lbrack", Field, 0},
+ {"ArrayType.Len", Field, 0},
+ {"AssignStmt", Type, 0},
+ {"AssignStmt.Lhs", Field, 0},
+ {"AssignStmt.Rhs", Field, 0},
+ {"AssignStmt.Tok", Field, 0},
+ {"AssignStmt.TokPos", Field, 0},
+ {"Bad", Const, 0},
+ {"BadDecl", Type, 0},
+ {"BadDecl.From", Field, 0},
+ {"BadDecl.To", Field, 0},
+ {"BadExpr", Type, 0},
+ {"BadExpr.From", Field, 0},
+ {"BadExpr.To", Field, 0},
+ {"BadStmt", Type, 0},
+ {"BadStmt.From", Field, 0},
+ {"BadStmt.To", Field, 0},
+ {"BasicLit", Type, 0},
+ {"BasicLit.Kind", Field, 0},
+ {"BasicLit.Value", Field, 0},
+ {"BasicLit.ValuePos", Field, 0},
+ {"BinaryExpr", Type, 0},
+ {"BinaryExpr.Op", Field, 0},
+ {"BinaryExpr.OpPos", Field, 0},
+ {"BinaryExpr.X", Field, 0},
+ {"BinaryExpr.Y", Field, 0},
+ {"BlockStmt", Type, 0},
+ {"BlockStmt.Lbrace", Field, 0},
+ {"BlockStmt.List", Field, 0},
+ {"BlockStmt.Rbrace", Field, 0},
+ {"BranchStmt", Type, 0},
+ {"BranchStmt.Label", Field, 0},
+ {"BranchStmt.Tok", Field, 0},
+ {"BranchStmt.TokPos", Field, 0},
+ {"CallExpr", Type, 0},
+ {"CallExpr.Args", Field, 0},
+ {"CallExpr.Ellipsis", Field, 0},
+ {"CallExpr.Fun", Field, 0},
+ {"CallExpr.Lparen", Field, 0},
+ {"CallExpr.Rparen", Field, 0},
+ {"CaseClause", Type, 0},
+ {"CaseClause.Body", Field, 0},
+ {"CaseClause.Case", Field, 0},
+ {"CaseClause.Colon", Field, 0},
+ {"CaseClause.List", Field, 0},
+ {"ChanDir", Type, 0},
+ {"ChanType", Type, 0},
+ {"ChanType.Arrow", Field, 1},
+ {"ChanType.Begin", Field, 0},
+ {"ChanType.Dir", Field, 0},
+ {"ChanType.Value", Field, 0},
+ {"CommClause", Type, 0},
+ {"CommClause.Body", Field, 0},
+ {"CommClause.Case", Field, 0},
+ {"CommClause.Colon", Field, 0},
+ {"CommClause.Comm", Field, 0},
+ {"Comment", Type, 0},
+ {"Comment.Slash", Field, 0},
+ {"Comment.Text", Field, 0},
+ {"CommentGroup", Type, 0},
+ {"CommentGroup.List", Field, 0},
+ {"CommentMap", Type, 1},
+ {"CompositeLit", Type, 0},
+ {"CompositeLit.Elts", Field, 0},
+ {"CompositeLit.Incomplete", Field, 11},
+ {"CompositeLit.Lbrace", Field, 0},
+ {"CompositeLit.Rbrace", Field, 0},
+ {"CompositeLit.Type", Field, 0},
+ {"Con", Const, 0},
+ {"Decl", Type, 0},
+ {"DeclStmt", Type, 0},
+ {"DeclStmt.Decl", Field, 0},
+ {"DeferStmt", Type, 0},
+ {"DeferStmt.Call", Field, 0},
+ {"DeferStmt.Defer", Field, 0},
+ {"Ellipsis", Type, 0},
+ {"Ellipsis.Ellipsis", Field, 0},
+ {"Ellipsis.Elt", Field, 0},
+ {"EmptyStmt", Type, 0},
+ {"EmptyStmt.Implicit", Field, 5},
+ {"EmptyStmt.Semicolon", Field, 0},
+ {"Expr", Type, 0},
+ {"ExprStmt", Type, 0},
+ {"ExprStmt.X", Field, 0},
+ {"Field", Type, 0},
+ {"Field.Comment", Field, 0},
+ {"Field.Doc", Field, 0},
+ {"Field.Names", Field, 0},
+ {"Field.Tag", Field, 0},
+ {"Field.Type", Field, 0},
+ {"FieldFilter", Type, 0},
+ {"FieldList", Type, 0},
+ {"FieldList.Closing", Field, 0},
+ {"FieldList.List", Field, 0},
+ {"FieldList.Opening", Field, 0},
+ {"File", Type, 0},
+ {"File.Comments", Field, 0},
+ {"File.Decls", Field, 0},
+ {"File.Doc", Field, 0},
+ {"File.FileEnd", Field, 20},
+ {"File.FileStart", Field, 20},
+ {"File.GoVersion", Field, 21},
+ {"File.Imports", Field, 0},
+ {"File.Name", Field, 0},
+ {"File.Package", Field, 0},
+ {"File.Scope", Field, 0},
+ {"File.Unresolved", Field, 0},
+ {"FileExports", Func, 0},
+ {"Filter", Type, 0},
+ {"FilterDecl", Func, 0},
+ {"FilterFile", Func, 0},
+ {"FilterFuncDuplicates", Const, 0},
+ {"FilterImportDuplicates", Const, 0},
+ {"FilterPackage", Func, 0},
+ {"FilterUnassociatedComments", Const, 0},
+ {"ForStmt", Type, 0},
+ {"ForStmt.Body", Field, 0},
+ {"ForStmt.Cond", Field, 0},
+ {"ForStmt.For", Field, 0},
+ {"ForStmt.Init", Field, 0},
+ {"ForStmt.Post", Field, 0},
+ {"Fprint", Func, 0},
+ {"Fun", Const, 0},
+ {"FuncDecl", Type, 0},
+ {"FuncDecl.Body", Field, 0},
+ {"FuncDecl.Doc", Field, 0},
+ {"FuncDecl.Name", Field, 0},
+ {"FuncDecl.Recv", Field, 0},
+ {"FuncDecl.Type", Field, 0},
+ {"FuncLit", Type, 0},
+ {"FuncLit.Body", Field, 0},
+ {"FuncLit.Type", Field, 0},
+ {"FuncType", Type, 0},
+ {"FuncType.Func", Field, 0},
+ {"FuncType.Params", Field, 0},
+ {"FuncType.Results", Field, 0},
+ {"FuncType.TypeParams", Field, 18},
+ {"GenDecl", Type, 0},
+ {"GenDecl.Doc", Field, 0},
+ {"GenDecl.Lparen", Field, 0},
+ {"GenDecl.Rparen", Field, 0},
+ {"GenDecl.Specs", Field, 0},
+ {"GenDecl.Tok", Field, 0},
+ {"GenDecl.TokPos", Field, 0},
+ {"GoStmt", Type, 0},
+ {"GoStmt.Call", Field, 0},
+ {"GoStmt.Go", Field, 0},
+ {"Ident", Type, 0},
+ {"Ident.Name", Field, 0},
+ {"Ident.NamePos", Field, 0},
+ {"Ident.Obj", Field, 0},
+ {"IfStmt", Type, 0},
+ {"IfStmt.Body", Field, 0},
+ {"IfStmt.Cond", Field, 0},
+ {"IfStmt.Else", Field, 0},
+ {"IfStmt.If", Field, 0},
+ {"IfStmt.Init", Field, 0},
+ {"ImportSpec", Type, 0},
+ {"ImportSpec.Comment", Field, 0},
+ {"ImportSpec.Doc", Field, 0},
+ {"ImportSpec.EndPos", Field, 0},
+ {"ImportSpec.Name", Field, 0},
+ {"ImportSpec.Path", Field, 0},
+ {"Importer", Type, 0},
+ {"IncDecStmt", Type, 0},
+ {"IncDecStmt.Tok", Field, 0},
+ {"IncDecStmt.TokPos", Field, 0},
+ {"IncDecStmt.X", Field, 0},
+ {"IndexExpr", Type, 0},
+ {"IndexExpr.Index", Field, 0},
+ {"IndexExpr.Lbrack", Field, 0},
+ {"IndexExpr.Rbrack", Field, 0},
+ {"IndexExpr.X", Field, 0},
+ {"IndexListExpr", Type, 18},
+ {"IndexListExpr.Indices", Field, 18},
+ {"IndexListExpr.Lbrack", Field, 18},
+ {"IndexListExpr.Rbrack", Field, 18},
+ {"IndexListExpr.X", Field, 18},
+ {"Inspect", Func, 0},
+ {"InterfaceType", Type, 0},
+ {"InterfaceType.Incomplete", Field, 0},
+ {"InterfaceType.Interface", Field, 0},
+ {"InterfaceType.Methods", Field, 0},
+ {"IsExported", Func, 0},
+ {"IsGenerated", Func, 21},
+ {"KeyValueExpr", Type, 0},
+ {"KeyValueExpr.Colon", Field, 0},
+ {"KeyValueExpr.Key", Field, 0},
+ {"KeyValueExpr.Value", Field, 0},
+ {"LabeledStmt", Type, 0},
+ {"LabeledStmt.Colon", Field, 0},
+ {"LabeledStmt.Label", Field, 0},
+ {"LabeledStmt.Stmt", Field, 0},
+ {"Lbl", Const, 0},
+ {"MapType", Type, 0},
+ {"MapType.Key", Field, 0},
+ {"MapType.Map", Field, 0},
+ {"MapType.Value", Field, 0},
+ {"MergeMode", Type, 0},
+ {"MergePackageFiles", Func, 0},
+ {"NewCommentMap", Func, 1},
+ {"NewIdent", Func, 0},
+ {"NewObj", Func, 0},
+ {"NewPackage", Func, 0},
+ {"NewScope", Func, 0},
+ {"Node", Type, 0},
+ {"NotNilFilter", Func, 0},
+ {"ObjKind", Type, 0},
+ {"Object", Type, 0},
+ {"Object.Data", Field, 0},
+ {"Object.Decl", Field, 0},
+ {"Object.Kind", Field, 0},
+ {"Object.Name", Field, 0},
+ {"Object.Type", Field, 0},
+ {"Package", Type, 0},
+ {"Package.Files", Field, 0},
+ {"Package.Imports", Field, 0},
+ {"Package.Name", Field, 0},
+ {"Package.Scope", Field, 0},
+ {"PackageExports", Func, 0},
+ {"ParenExpr", Type, 0},
+ {"ParenExpr.Lparen", Field, 0},
+ {"ParenExpr.Rparen", Field, 0},
+ {"ParenExpr.X", Field, 0},
+ {"Pkg", Const, 0},
+ {"Preorder", Func, 23},
+ {"Print", Func, 0},
+ {"RECV", Const, 0},
+ {"RangeStmt", Type, 0},
+ {"RangeStmt.Body", Field, 0},
+ {"RangeStmt.For", Field, 0},
+ {"RangeStmt.Key", Field, 0},
+ {"RangeStmt.Range", Field, 20},
+ {"RangeStmt.Tok", Field, 0},
+ {"RangeStmt.TokPos", Field, 0},
+ {"RangeStmt.Value", Field, 0},
+ {"RangeStmt.X", Field, 0},
+ {"ReturnStmt", Type, 0},
+ {"ReturnStmt.Results", Field, 0},
+ {"ReturnStmt.Return", Field, 0},
+ {"SEND", Const, 0},
+ {"Scope", Type, 0},
+ {"Scope.Objects", Field, 0},
+ {"Scope.Outer", Field, 0},
+ {"SelectStmt", Type, 0},
+ {"SelectStmt.Body", Field, 0},
+ {"SelectStmt.Select", Field, 0},
+ {"SelectorExpr", Type, 0},
+ {"SelectorExpr.Sel", Field, 0},
+ {"SelectorExpr.X", Field, 0},
+ {"SendStmt", Type, 0},
+ {"SendStmt.Arrow", Field, 0},
+ {"SendStmt.Chan", Field, 0},
+ {"SendStmt.Value", Field, 0},
+ {"SliceExpr", Type, 0},
+ {"SliceExpr.High", Field, 0},
+ {"SliceExpr.Lbrack", Field, 0},
+ {"SliceExpr.Low", Field, 0},
+ {"SliceExpr.Max", Field, 2},
+ {"SliceExpr.Rbrack", Field, 0},
+ {"SliceExpr.Slice3", Field, 2},
+ {"SliceExpr.X", Field, 0},
+ {"SortImports", Func, 0},
+ {"Spec", Type, 0},
+ {"StarExpr", Type, 0},
+ {"StarExpr.Star", Field, 0},
+ {"StarExpr.X", Field, 0},
+ {"Stmt", Type, 0},
+ {"StructType", Type, 0},
+ {"StructType.Fields", Field, 0},
+ {"StructType.Incomplete", Field, 0},
+ {"StructType.Struct", Field, 0},
+ {"SwitchStmt", Type, 0},
+ {"SwitchStmt.Body", Field, 0},
+ {"SwitchStmt.Init", Field, 0},
+ {"SwitchStmt.Switch", Field, 0},
+ {"SwitchStmt.Tag", Field, 0},
+ {"Typ", Const, 0},
+ {"TypeAssertExpr", Type, 0},
+ {"TypeAssertExpr.Lparen", Field, 2},
+ {"TypeAssertExpr.Rparen", Field, 2},
+ {"TypeAssertExpr.Type", Field, 0},
+ {"TypeAssertExpr.X", Field, 0},
+ {"TypeSpec", Type, 0},
+ {"TypeSpec.Assign", Field, 9},
+ {"TypeSpec.Comment", Field, 0},
+ {"TypeSpec.Doc", Field, 0},
+ {"TypeSpec.Name", Field, 0},
+ {"TypeSpec.Type", Field, 0},
+ {"TypeSpec.TypeParams", Field, 18},
+ {"TypeSwitchStmt", Type, 0},
+ {"TypeSwitchStmt.Assign", Field, 0},
+ {"TypeSwitchStmt.Body", Field, 0},
+ {"TypeSwitchStmt.Init", Field, 0},
+ {"TypeSwitchStmt.Switch", Field, 0},
+ {"UnaryExpr", Type, 0},
+ {"UnaryExpr.Op", Field, 0},
+ {"UnaryExpr.OpPos", Field, 0},
+ {"UnaryExpr.X", Field, 0},
+ {"Unparen", Func, 22},
+ {"ValueSpec", Type, 0},
+ {"ValueSpec.Comment", Field, 0},
+ {"ValueSpec.Doc", Field, 0},
+ {"ValueSpec.Names", Field, 0},
+ {"ValueSpec.Type", Field, 0},
+ {"ValueSpec.Values", Field, 0},
+ {"Var", Const, 0},
+ {"Visitor", Type, 0},
+ {"Walk", Func, 0},
+ },
+ "go/build": {
+ {"(*Context).Import", Method, 0},
+ {"(*Context).ImportDir", Method, 0},
+ {"(*Context).MatchFile", Method, 2},
+ {"(*Context).SrcDirs", Method, 0},
+ {"(*MultiplePackageError).Error", Method, 4},
+ {"(*NoGoError).Error", Method, 0},
+ {"(*Package).IsCommand", Method, 0},
+ {"AllowBinary", Const, 0},
+ {"ArchChar", Func, 0},
+ {"Context", Type, 0},
+ {"Context.BuildTags", Field, 0},
+ {"Context.CgoEnabled", Field, 0},
+ {"Context.Compiler", Field, 0},
+ {"Context.Dir", Field, 14},
+ {"Context.GOARCH", Field, 0},
+ {"Context.GOOS", Field, 0},
+ {"Context.GOPATH", Field, 0},
+ {"Context.GOROOT", Field, 0},
+ {"Context.HasSubdir", Field, 0},
+ {"Context.InstallSuffix", Field, 1},
+ {"Context.IsAbsPath", Field, 0},
+ {"Context.IsDir", Field, 0},
+ {"Context.JoinPath", Field, 0},
+ {"Context.OpenFile", Field, 0},
+ {"Context.ReadDir", Field, 0},
+ {"Context.ReleaseTags", Field, 1},
+ {"Context.SplitPathList", Field, 0},
+ {"Context.ToolTags", Field, 17},
+ {"Context.UseAllFiles", Field, 0},
+ {"Default", Var, 0},
+ {"Directive", Type, 21},
+ {"Directive.Pos", Field, 21},
+ {"Directive.Text", Field, 21},
+ {"FindOnly", Const, 0},
+ {"IgnoreVendor", Const, 6},
+ {"Import", Func, 0},
+ {"ImportComment", Const, 4},
+ {"ImportDir", Func, 0},
+ {"ImportMode", Type, 0},
+ {"IsLocalImport", Func, 0},
+ {"MultiplePackageError", Type, 4},
+ {"MultiplePackageError.Dir", Field, 4},
+ {"MultiplePackageError.Files", Field, 4},
+ {"MultiplePackageError.Packages", Field, 4},
+ {"NoGoError", Type, 0},
+ {"NoGoError.Dir", Field, 0},
+ {"Package", Type, 0},
+ {"Package.AllTags", Field, 2},
+ {"Package.BinDir", Field, 0},
+ {"Package.BinaryOnly", Field, 7},
+ {"Package.CFiles", Field, 0},
+ {"Package.CXXFiles", Field, 2},
+ {"Package.CgoCFLAGS", Field, 0},
+ {"Package.CgoCPPFLAGS", Field, 2},
+ {"Package.CgoCXXFLAGS", Field, 2},
+ {"Package.CgoFFLAGS", Field, 7},
+ {"Package.CgoFiles", Field, 0},
+ {"Package.CgoLDFLAGS", Field, 0},
+ {"Package.CgoPkgConfig", Field, 0},
+ {"Package.ConflictDir", Field, 2},
+ {"Package.Dir", Field, 0},
+ {"Package.Directives", Field, 21},
+ {"Package.Doc", Field, 0},
+ {"Package.EmbedPatternPos", Field, 16},
+ {"Package.EmbedPatterns", Field, 16},
+ {"Package.FFiles", Field, 7},
+ {"Package.GoFiles", Field, 0},
+ {"Package.Goroot", Field, 0},
+ {"Package.HFiles", Field, 0},
+ {"Package.IgnoredGoFiles", Field, 1},
+ {"Package.IgnoredOtherFiles", Field, 16},
+ {"Package.ImportComment", Field, 4},
+ {"Package.ImportPath", Field, 0},
+ {"Package.ImportPos", Field, 0},
+ {"Package.Imports", Field, 0},
+ {"Package.InvalidGoFiles", Field, 6},
+ {"Package.MFiles", Field, 3},
+ {"Package.Name", Field, 0},
+ {"Package.PkgObj", Field, 0},
+ {"Package.PkgRoot", Field, 0},
+ {"Package.PkgTargetRoot", Field, 5},
+ {"Package.Root", Field, 0},
+ {"Package.SFiles", Field, 0},
+ {"Package.SrcRoot", Field, 0},
+ {"Package.SwigCXXFiles", Field, 1},
+ {"Package.SwigFiles", Field, 1},
+ {"Package.SysoFiles", Field, 0},
+ {"Package.TestDirectives", Field, 21},
+ {"Package.TestEmbedPatternPos", Field, 16},
+ {"Package.TestEmbedPatterns", Field, 16},
+ {"Package.TestGoFiles", Field, 0},
+ {"Package.TestImportPos", Field, 0},
+ {"Package.TestImports", Field, 0},
+ {"Package.XTestDirectives", Field, 21},
+ {"Package.XTestEmbedPatternPos", Field, 16},
+ {"Package.XTestEmbedPatterns", Field, 16},
+ {"Package.XTestGoFiles", Field, 0},
+ {"Package.XTestImportPos", Field, 0},
+ {"Package.XTestImports", Field, 0},
+ {"ToolDir", Var, 0},
+ },
+ "go/build/constraint": {
+ {"(*AndExpr).Eval", Method, 16},
+ {"(*AndExpr).String", Method, 16},
+ {"(*NotExpr).Eval", Method, 16},
+ {"(*NotExpr).String", Method, 16},
+ {"(*OrExpr).Eval", Method, 16},
+ {"(*OrExpr).String", Method, 16},
+ {"(*SyntaxError).Error", Method, 16},
+ {"(*TagExpr).Eval", Method, 16},
+ {"(*TagExpr).String", Method, 16},
+ {"AndExpr", Type, 16},
+ {"AndExpr.X", Field, 16},
+ {"AndExpr.Y", Field, 16},
+ {"Expr", Type, 16},
+ {"GoVersion", Func, 21},
+ {"IsGoBuild", Func, 16},
+ {"IsPlusBuild", Func, 16},
+ {"NotExpr", Type, 16},
+ {"NotExpr.X", Field, 16},
+ {"OrExpr", Type, 16},
+ {"OrExpr.X", Field, 16},
+ {"OrExpr.Y", Field, 16},
+ {"Parse", Func, 16},
+ {"PlusBuildLines", Func, 16},
+ {"SyntaxError", Type, 16},
+ {"SyntaxError.Err", Field, 16},
+ {"SyntaxError.Offset", Field, 16},
+ {"TagExpr", Type, 16},
+ {"TagExpr.Tag", Field, 16},
+ },
+ "go/constant": {
+ {"(Kind).String", Method, 18},
+ {"BinaryOp", Func, 5},
+ {"BitLen", Func, 5},
+ {"Bool", Const, 5},
+ {"BoolVal", Func, 5},
+ {"Bytes", Func, 5},
+ {"Compare", Func, 5},
+ {"Complex", Const, 5},
+ {"Denom", Func, 5},
+ {"Float", Const, 5},
+ {"Float32Val", Func, 5},
+ {"Float64Val", Func, 5},
+ {"Imag", Func, 5},
+ {"Int", Const, 5},
+ {"Int64Val", Func, 5},
+ {"Kind", Type, 5},
+ {"Make", Func, 13},
+ {"MakeBool", Func, 5},
+ {"MakeFloat64", Func, 5},
+ {"MakeFromBytes", Func, 5},
+ {"MakeFromLiteral", Func, 5},
+ {"MakeImag", Func, 5},
+ {"MakeInt64", Func, 5},
+ {"MakeString", Func, 5},
+ {"MakeUint64", Func, 5},
+ {"MakeUnknown", Func, 5},
+ {"Num", Func, 5},
+ {"Real", Func, 5},
+ {"Shift", Func, 5},
+ {"Sign", Func, 5},
+ {"String", Const, 5},
+ {"StringVal", Func, 5},
+ {"ToComplex", Func, 6},
+ {"ToFloat", Func, 6},
+ {"ToInt", Func, 6},
+ {"Uint64Val", Func, 5},
+ {"UnaryOp", Func, 5},
+ {"Unknown", Const, 5},
+ {"Val", Func, 13},
+ {"Value", Type, 5},
+ },
+ "go/doc": {
+ {"(*Package).Filter", Method, 0},
+ {"(*Package).HTML", Method, 19},
+ {"(*Package).Markdown", Method, 19},
+ {"(*Package).Parser", Method, 19},
+ {"(*Package).Printer", Method, 19},
+ {"(*Package).Synopsis", Method, 19},
+ {"(*Package).Text", Method, 19},
+ {"AllDecls", Const, 0},
+ {"AllMethods", Const, 0},
+ {"Example", Type, 0},
+ {"Example.Code", Field, 0},
+ {"Example.Comments", Field, 0},
+ {"Example.Doc", Field, 0},
+ {"Example.EmptyOutput", Field, 1},
+ {"Example.Name", Field, 0},
+ {"Example.Order", Field, 1},
+ {"Example.Output", Field, 0},
+ {"Example.Play", Field, 1},
+ {"Example.Suffix", Field, 14},
+ {"Example.Unordered", Field, 7},
+ {"Examples", Func, 0},
+ {"Filter", Type, 0},
+ {"Func", Type, 0},
+ {"Func.Decl", Field, 0},
+ {"Func.Doc", Field, 0},
+ {"Func.Examples", Field, 14},
+ {"Func.Level", Field, 0},
+ {"Func.Name", Field, 0},
+ {"Func.Orig", Field, 0},
+ {"Func.Recv", Field, 0},
+ {"IllegalPrefixes", Var, 1},
+ {"IsPredeclared", Func, 8},
+ {"Mode", Type, 0},
+ {"New", Func, 0},
+ {"NewFromFiles", Func, 14},
+ {"Note", Type, 1},
+ {"Note.Body", Field, 1},
+ {"Note.End", Field, 1},
+ {"Note.Pos", Field, 1},
+ {"Note.UID", Field, 1},
+ {"Package", Type, 0},
+ {"Package.Bugs", Field, 0},
+ {"Package.Consts", Field, 0},
+ {"Package.Doc", Field, 0},
+ {"Package.Examples", Field, 14},
+ {"Package.Filenames", Field, 0},
+ {"Package.Funcs", Field, 0},
+ {"Package.ImportPath", Field, 0},
+ {"Package.Imports", Field, 0},
+ {"Package.Name", Field, 0},
+ {"Package.Notes", Field, 1},
+ {"Package.Types", Field, 0},
+ {"Package.Vars", Field, 0},
+ {"PreserveAST", Const, 12},
+ {"Synopsis", Func, 0},
+ {"ToHTML", Func, 0},
+ {"ToText", Func, 0},
+ {"Type", Type, 0},
+ {"Type.Consts", Field, 0},
+ {"Type.Decl", Field, 0},
+ {"Type.Doc", Field, 0},
+ {"Type.Examples", Field, 14},
+ {"Type.Funcs", Field, 0},
+ {"Type.Methods", Field, 0},
+ {"Type.Name", Field, 0},
+ {"Type.Vars", Field, 0},
+ {"Value", Type, 0},
+ {"Value.Decl", Field, 0},
+ {"Value.Doc", Field, 0},
+ {"Value.Names", Field, 0},
+ },
+ "go/doc/comment": {
+ {"(*DocLink).DefaultURL", Method, 19},
+ {"(*Heading).DefaultID", Method, 19},
+ {"(*List).BlankBefore", Method, 19},
+ {"(*List).BlankBetween", Method, 19},
+ {"(*Parser).Parse", Method, 19},
+ {"(*Printer).Comment", Method, 19},
+ {"(*Printer).HTML", Method, 19},
+ {"(*Printer).Markdown", Method, 19},
+ {"(*Printer).Text", Method, 19},
+ {"Block", Type, 19},
+ {"Code", Type, 19},
+ {"Code.Text", Field, 19},
+ {"DefaultLookupPackage", Func, 19},
+ {"Doc", Type, 19},
+ {"Doc.Content", Field, 19},
+ {"Doc.Links", Field, 19},
+ {"DocLink", Type, 19},
+ {"DocLink.ImportPath", Field, 19},
+ {"DocLink.Name", Field, 19},
+ {"DocLink.Recv", Field, 19},
+ {"DocLink.Text", Field, 19},
+ {"Heading", Type, 19},
+ {"Heading.Text", Field, 19},
+ {"Italic", Type, 19},
+ {"Link", Type, 19},
+ {"Link.Auto", Field, 19},
+ {"Link.Text", Field, 19},
+ {"Link.URL", Field, 19},
+ {"LinkDef", Type, 19},
+ {"LinkDef.Text", Field, 19},
+ {"LinkDef.URL", Field, 19},
+ {"LinkDef.Used", Field, 19},
+ {"List", Type, 19},
+ {"List.ForceBlankBefore", Field, 19},
+ {"List.ForceBlankBetween", Field, 19},
+ {"List.Items", Field, 19},
+ {"ListItem", Type, 19},
+ {"ListItem.Content", Field, 19},
+ {"ListItem.Number", Field, 19},
+ {"Paragraph", Type, 19},
+ {"Paragraph.Text", Field, 19},
+ {"Parser", Type, 19},
+ {"Parser.LookupPackage", Field, 19},
+ {"Parser.LookupSym", Field, 19},
+ {"Parser.Words", Field, 19},
+ {"Plain", Type, 19},
+ {"Printer", Type, 19},
+ {"Printer.DocLinkBaseURL", Field, 19},
+ {"Printer.DocLinkURL", Field, 19},
+ {"Printer.HeadingID", Field, 19},
+ {"Printer.HeadingLevel", Field, 19},
+ {"Printer.TextCodePrefix", Field, 19},
+ {"Printer.TextPrefix", Field, 19},
+ {"Printer.TextWidth", Field, 19},
+ {"Text", Type, 19},
+ },
+ "go/format": {
+ {"Node", Func, 1},
+ {"Source", Func, 1},
+ },
+ "go/importer": {
+ {"Default", Func, 5},
+ {"For", Func, 5},
+ {"ForCompiler", Func, 12},
+ {"Lookup", Type, 5},
+ },
+ "go/parser": {
+ {"AllErrors", Const, 1},
+ {"DeclarationErrors", Const, 0},
+ {"ImportsOnly", Const, 0},
+ {"Mode", Type, 0},
+ {"PackageClauseOnly", Const, 0},
+ {"ParseComments", Const, 0},
+ {"ParseDir", Func, 0},
+ {"ParseExpr", Func, 0},
+ {"ParseExprFrom", Func, 5},
+ {"ParseFile", Func, 0},
+ {"SkipObjectResolution", Const, 17},
+ {"SpuriousErrors", Const, 0},
+ {"Trace", Const, 0},
+ },
+ "go/printer": {
+ {"(*Config).Fprint", Method, 0},
+ {"CommentedNode", Type, 0},
+ {"CommentedNode.Comments", Field, 0},
+ {"CommentedNode.Node", Field, 0},
+ {"Config", Type, 0},
+ {"Config.Indent", Field, 1},
+ {"Config.Mode", Field, 0},
+ {"Config.Tabwidth", Field, 0},
+ {"Fprint", Func, 0},
+ {"Mode", Type, 0},
+ {"RawFormat", Const, 0},
+ {"SourcePos", Const, 0},
+ {"TabIndent", Const, 0},
+ {"UseSpaces", Const, 0},
+ },
+ "go/scanner": {
+ {"(*ErrorList).Add", Method, 0},
+ {"(*ErrorList).RemoveMultiples", Method, 0},
+ {"(*ErrorList).Reset", Method, 0},
+ {"(*Scanner).Init", Method, 0},
+ {"(*Scanner).Scan", Method, 0},
+ {"(Error).Error", Method, 0},
+ {"(ErrorList).Err", Method, 0},
+ {"(ErrorList).Error", Method, 0},
+ {"(ErrorList).Len", Method, 0},
+ {"(ErrorList).Less", Method, 0},
+ {"(ErrorList).Sort", Method, 0},
+ {"(ErrorList).Swap", Method, 0},
+ {"Error", Type, 0},
+ {"Error.Msg", Field, 0},
+ {"Error.Pos", Field, 0},
+ {"ErrorHandler", Type, 0},
+ {"ErrorList", Type, 0},
+ {"Mode", Type, 0},
+ {"PrintError", Func, 0},
+ {"ScanComments", Const, 0},
+ {"Scanner", Type, 0},
+ {"Scanner.ErrorCount", Field, 0},
+ },
+ "go/token": {
+ {"(*File).AddLine", Method, 0},
+ {"(*File).AddLineColumnInfo", Method, 11},
+ {"(*File).AddLineInfo", Method, 0},
+ {"(*File).Base", Method, 0},
+ {"(*File).Line", Method, 0},
+ {"(*File).LineCount", Method, 0},
+ {"(*File).LineStart", Method, 12},
+ {"(*File).Lines", Method, 21},
+ {"(*File).MergeLine", Method, 2},
+ {"(*File).Name", Method, 0},
+ {"(*File).Offset", Method, 0},
+ {"(*File).Pos", Method, 0},
+ {"(*File).Position", Method, 0},
+ {"(*File).PositionFor", Method, 4},
+ {"(*File).SetLines", Method, 0},
+ {"(*File).SetLinesForContent", Method, 0},
+ {"(*File).Size", Method, 0},
+ {"(*FileSet).AddFile", Method, 0},
+ {"(*FileSet).Base", Method, 0},
+ {"(*FileSet).File", Method, 0},
+ {"(*FileSet).Iterate", Method, 0},
+ {"(*FileSet).Position", Method, 0},
+ {"(*FileSet).PositionFor", Method, 4},
+ {"(*FileSet).Read", Method, 0},
+ {"(*FileSet).RemoveFile", Method, 20},
+ {"(*FileSet).Write", Method, 0},
+ {"(*Position).IsValid", Method, 0},
+ {"(Pos).IsValid", Method, 0},
+ {"(Position).String", Method, 0},
+ {"(Token).IsKeyword", Method, 0},
+ {"(Token).IsLiteral", Method, 0},
+ {"(Token).IsOperator", Method, 0},
+ {"(Token).Precedence", Method, 0},
+ {"(Token).String", Method, 0},
+ {"ADD", Const, 0},
+ {"ADD_ASSIGN", Const, 0},
+ {"AND", Const, 0},
+ {"AND_ASSIGN", Const, 0},
+ {"AND_NOT", Const, 0},
+ {"AND_NOT_ASSIGN", Const, 0},
+ {"ARROW", Const, 0},
+ {"ASSIGN", Const, 0},
+ {"BREAK", Const, 0},
+ {"CASE", Const, 0},
+ {"CHAN", Const, 0},
+ {"CHAR", Const, 0},
+ {"COLON", Const, 0},
+ {"COMMA", Const, 0},
+ {"COMMENT", Const, 0},
+ {"CONST", Const, 0},
+ {"CONTINUE", Const, 0},
+ {"DEC", Const, 0},
+ {"DEFAULT", Const, 0},
+ {"DEFER", Const, 0},
+ {"DEFINE", Const, 0},
+ {"ELLIPSIS", Const, 0},
+ {"ELSE", Const, 0},
+ {"EOF", Const, 0},
+ {"EQL", Const, 0},
+ {"FALLTHROUGH", Const, 0},
+ {"FLOAT", Const, 0},
+ {"FOR", Const, 0},
+ {"FUNC", Const, 0},
+ {"File", Type, 0},
+ {"FileSet", Type, 0},
+ {"GEQ", Const, 0},
+ {"GO", Const, 0},
+ {"GOTO", Const, 0},
+ {"GTR", Const, 0},
+ {"HighestPrec", Const, 0},
+ {"IDENT", Const, 0},
+ {"IF", Const, 0},
+ {"ILLEGAL", Const, 0},
+ {"IMAG", Const, 0},
+ {"IMPORT", Const, 0},
+ {"INC", Const, 0},
+ {"INT", Const, 0},
+ {"INTERFACE", Const, 0},
+ {"IsExported", Func, 13},
+ {"IsIdentifier", Func, 13},
+ {"IsKeyword", Func, 13},
+ {"LAND", Const, 0},
+ {"LBRACE", Const, 0},
+ {"LBRACK", Const, 0},
+ {"LEQ", Const, 0},
+ {"LOR", Const, 0},
+ {"LPAREN", Const, 0},
+ {"LSS", Const, 0},
+ {"Lookup", Func, 0},
+ {"LowestPrec", Const, 0},
+ {"MAP", Const, 0},
+ {"MUL", Const, 0},
+ {"MUL_ASSIGN", Const, 0},
+ {"NEQ", Const, 0},
+ {"NOT", Const, 0},
+ {"NewFileSet", Func, 0},
+ {"NoPos", Const, 0},
+ {"OR", Const, 0},
+ {"OR_ASSIGN", Const, 0},
+ {"PACKAGE", Const, 0},
+ {"PERIOD", Const, 0},
+ {"Pos", Type, 0},
+ {"Position", Type, 0},
+ {"Position.Column", Field, 0},
+ {"Position.Filename", Field, 0},
+ {"Position.Line", Field, 0},
+ {"Position.Offset", Field, 0},
+ {"QUO", Const, 0},
+ {"QUO_ASSIGN", Const, 0},
+ {"RANGE", Const, 0},
+ {"RBRACE", Const, 0},
+ {"RBRACK", Const, 0},
+ {"REM", Const, 0},
+ {"REM_ASSIGN", Const, 0},
+ {"RETURN", Const, 0},
+ {"RPAREN", Const, 0},
+ {"SELECT", Const, 0},
+ {"SEMICOLON", Const, 0},
+ {"SHL", Const, 0},
+ {"SHL_ASSIGN", Const, 0},
+ {"SHR", Const, 0},
+ {"SHR_ASSIGN", Const, 0},
+ {"STRING", Const, 0},
+ {"STRUCT", Const, 0},
+ {"SUB", Const, 0},
+ {"SUB_ASSIGN", Const, 0},
+ {"SWITCH", Const, 0},
+ {"TILDE", Const, 18},
+ {"TYPE", Const, 0},
+ {"Token", Type, 0},
+ {"UnaryPrec", Const, 0},
+ {"VAR", Const, 0},
+ {"XOR", Const, 0},
+ {"XOR_ASSIGN", Const, 0},
+ },
+ "go/types": {
+ {"(*Alias).Obj", Method, 22},
+ {"(*Alias).Origin", Method, 23},
+ {"(*Alias).Rhs", Method, 23},
+ {"(*Alias).SetTypeParams", Method, 23},
+ {"(*Alias).String", Method, 22},
+ {"(*Alias).TypeArgs", Method, 23},
+ {"(*Alias).TypeParams", Method, 23},
+ {"(*Alias).Underlying", Method, 22},
+ {"(*ArgumentError).Error", Method, 18},
+ {"(*ArgumentError).Unwrap", Method, 18},
+ {"(*Array).Elem", Method, 5},
+ {"(*Array).Len", Method, 5},
+ {"(*Array).String", Method, 5},
+ {"(*Array).Underlying", Method, 5},
+ {"(*Basic).Info", Method, 5},
+ {"(*Basic).Kind", Method, 5},
+ {"(*Basic).Name", Method, 5},
+ {"(*Basic).String", Method, 5},
+ {"(*Basic).Underlying", Method, 5},
+ {"(*Builtin).Exported", Method, 5},
+ {"(*Builtin).Id", Method, 5},
+ {"(*Builtin).Name", Method, 5},
+ {"(*Builtin).Parent", Method, 5},
+ {"(*Builtin).Pkg", Method, 5},
+ {"(*Builtin).Pos", Method, 5},
+ {"(*Builtin).String", Method, 5},
+ {"(*Builtin).Type", Method, 5},
+ {"(*Chan).Dir", Method, 5},
+ {"(*Chan).Elem", Method, 5},
+ {"(*Chan).String", Method, 5},
+ {"(*Chan).Underlying", Method, 5},
+ {"(*Checker).Files", Method, 5},
+ {"(*Config).Check", Method, 5},
+ {"(*Const).Exported", Method, 5},
+ {"(*Const).Id", Method, 5},
+ {"(*Const).Name", Method, 5},
+ {"(*Const).Parent", Method, 5},
+ {"(*Const).Pkg", Method, 5},
+ {"(*Const).Pos", Method, 5},
+ {"(*Const).String", Method, 5},
+ {"(*Const).Type", Method, 5},
+ {"(*Const).Val", Method, 5},
+ {"(*Func).Exported", Method, 5},
+ {"(*Func).FullName", Method, 5},
+ {"(*Func).Id", Method, 5},
+ {"(*Func).Name", Method, 5},
+ {"(*Func).Origin", Method, 19},
+ {"(*Func).Parent", Method, 5},
+ {"(*Func).Pkg", Method, 5},
+ {"(*Func).Pos", Method, 5},
+ {"(*Func).Scope", Method, 5},
+ {"(*Func).Signature", Method, 23},
+ {"(*Func).String", Method, 5},
+ {"(*Func).Type", Method, 5},
+ {"(*Info).ObjectOf", Method, 5},
+ {"(*Info).PkgNameOf", Method, 22},
+ {"(*Info).TypeOf", Method, 5},
+ {"(*Initializer).String", Method, 5},
+ {"(*Interface).Complete", Method, 5},
+ {"(*Interface).Embedded", Method, 5},
+ {"(*Interface).EmbeddedType", Method, 11},
+ {"(*Interface).Empty", Method, 5},
+ {"(*Interface).ExplicitMethod", Method, 5},
+ {"(*Interface).IsComparable", Method, 18},
+ {"(*Interface).IsImplicit", Method, 18},
+ {"(*Interface).IsMethodSet", Method, 18},
+ {"(*Interface).MarkImplicit", Method, 18},
+ {"(*Interface).Method", Method, 5},
+ {"(*Interface).NumEmbeddeds", Method, 5},
+ {"(*Interface).NumExplicitMethods", Method, 5},
+ {"(*Interface).NumMethods", Method, 5},
+ {"(*Interface).String", Method, 5},
+ {"(*Interface).Underlying", Method, 5},
+ {"(*Label).Exported", Method, 5},
+ {"(*Label).Id", Method, 5},
+ {"(*Label).Name", Method, 5},
+ {"(*Label).Parent", Method, 5},
+ {"(*Label).Pkg", Method, 5},
+ {"(*Label).Pos", Method, 5},
+ {"(*Label).String", Method, 5},
+ {"(*Label).Type", Method, 5},
+ {"(*Map).Elem", Method, 5},
+ {"(*Map).Key", Method, 5},
+ {"(*Map).String", Method, 5},
+ {"(*Map).Underlying", Method, 5},
+ {"(*MethodSet).At", Method, 5},
+ {"(*MethodSet).Len", Method, 5},
+ {"(*MethodSet).Lookup", Method, 5},
+ {"(*MethodSet).String", Method, 5},
+ {"(*Named).AddMethod", Method, 5},
+ {"(*Named).Method", Method, 5},
+ {"(*Named).NumMethods", Method, 5},
+ {"(*Named).Obj", Method, 5},
+ {"(*Named).Origin", Method, 18},
+ {"(*Named).SetTypeParams", Method, 18},
+ {"(*Named).SetUnderlying", Method, 5},
+ {"(*Named).String", Method, 5},
+ {"(*Named).TypeArgs", Method, 18},
+ {"(*Named).TypeParams", Method, 18},
+ {"(*Named).Underlying", Method, 5},
+ {"(*Nil).Exported", Method, 5},
+ {"(*Nil).Id", Method, 5},
+ {"(*Nil).Name", Method, 5},
+ {"(*Nil).Parent", Method, 5},
+ {"(*Nil).Pkg", Method, 5},
+ {"(*Nil).Pos", Method, 5},
+ {"(*Nil).String", Method, 5},
+ {"(*Nil).Type", Method, 5},
+ {"(*Package).Complete", Method, 5},
+ {"(*Package).GoVersion", Method, 21},
+ {"(*Package).Imports", Method, 5},
+ {"(*Package).MarkComplete", Method, 5},
+ {"(*Package).Name", Method, 5},
+ {"(*Package).Path", Method, 5},
+ {"(*Package).Scope", Method, 5},
+ {"(*Package).SetImports", Method, 5},
+ {"(*Package).SetName", Method, 6},
+ {"(*Package).String", Method, 5},
+ {"(*PkgName).Exported", Method, 5},
+ {"(*PkgName).Id", Method, 5},
+ {"(*PkgName).Imported", Method, 5},
+ {"(*PkgName).Name", Method, 5},
+ {"(*PkgName).Parent", Method, 5},
+ {"(*PkgName).Pkg", Method, 5},
+ {"(*PkgName).Pos", Method, 5},
+ {"(*PkgName).String", Method, 5},
+ {"(*PkgName).Type", Method, 5},
+ {"(*Pointer).Elem", Method, 5},
+ {"(*Pointer).String", Method, 5},
+ {"(*Pointer).Underlying", Method, 5},
+ {"(*Scope).Child", Method, 5},
+ {"(*Scope).Contains", Method, 5},
+ {"(*Scope).End", Method, 5},
+ {"(*Scope).Innermost", Method, 5},
+ {"(*Scope).Insert", Method, 5},
+ {"(*Scope).Len", Method, 5},
+ {"(*Scope).Lookup", Method, 5},
+ {"(*Scope).LookupParent", Method, 5},
+ {"(*Scope).Names", Method, 5},
+ {"(*Scope).NumChildren", Method, 5},
+ {"(*Scope).Parent", Method, 5},
+ {"(*Scope).Pos", Method, 5},
+ {"(*Scope).String", Method, 5},
+ {"(*Scope).WriteTo", Method, 5},
+ {"(*Selection).Index", Method, 5},
+ {"(*Selection).Indirect", Method, 5},
+ {"(*Selection).Kind", Method, 5},
+ {"(*Selection).Obj", Method, 5},
+ {"(*Selection).Recv", Method, 5},
+ {"(*Selection).String", Method, 5},
+ {"(*Selection).Type", Method, 5},
+ {"(*Signature).Params", Method, 5},
+ {"(*Signature).Recv", Method, 5},
+ {"(*Signature).RecvTypeParams", Method, 18},
+ {"(*Signature).Results", Method, 5},
+ {"(*Signature).String", Method, 5},
+ {"(*Signature).TypeParams", Method, 18},
+ {"(*Signature).Underlying", Method, 5},
+ {"(*Signature).Variadic", Method, 5},
+ {"(*Slice).Elem", Method, 5},
+ {"(*Slice).String", Method, 5},
+ {"(*Slice).Underlying", Method, 5},
+ {"(*StdSizes).Alignof", Method, 5},
+ {"(*StdSizes).Offsetsof", Method, 5},
+ {"(*StdSizes).Sizeof", Method, 5},
+ {"(*Struct).Field", Method, 5},
+ {"(*Struct).NumFields", Method, 5},
+ {"(*Struct).String", Method, 5},
+ {"(*Struct).Tag", Method, 5},
+ {"(*Struct).Underlying", Method, 5},
+ {"(*Term).String", Method, 18},
+ {"(*Term).Tilde", Method, 18},
+ {"(*Term).Type", Method, 18},
+ {"(*Tuple).At", Method, 5},
+ {"(*Tuple).Len", Method, 5},
+ {"(*Tuple).String", Method, 5},
+ {"(*Tuple).Underlying", Method, 5},
+ {"(*TypeList).At", Method, 18},
+ {"(*TypeList).Len", Method, 18},
+ {"(*TypeName).Exported", Method, 5},
+ {"(*TypeName).Id", Method, 5},
+ {"(*TypeName).IsAlias", Method, 9},
+ {"(*TypeName).Name", Method, 5},
+ {"(*TypeName).Parent", Method, 5},
+ {"(*TypeName).Pkg", Method, 5},
+ {"(*TypeName).Pos", Method, 5},
+ {"(*TypeName).String", Method, 5},
+ {"(*TypeName).Type", Method, 5},
+ {"(*TypeParam).Constraint", Method, 18},
+ {"(*TypeParam).Index", Method, 18},
+ {"(*TypeParam).Obj", Method, 18},
+ {"(*TypeParam).SetConstraint", Method, 18},
+ {"(*TypeParam).String", Method, 18},
+ {"(*TypeParam).Underlying", Method, 18},
+ {"(*TypeParamList).At", Method, 18},
+ {"(*TypeParamList).Len", Method, 18},
+ {"(*Union).Len", Method, 18},
+ {"(*Union).String", Method, 18},
+ {"(*Union).Term", Method, 18},
+ {"(*Union).Underlying", Method, 18},
+ {"(*Var).Anonymous", Method, 5},
+ {"(*Var).Embedded", Method, 11},
+ {"(*Var).Exported", Method, 5},
+ {"(*Var).Id", Method, 5},
+ {"(*Var).IsField", Method, 5},
+ {"(*Var).Name", Method, 5},
+ {"(*Var).Origin", Method, 19},
+ {"(*Var).Parent", Method, 5},
+ {"(*Var).Pkg", Method, 5},
+ {"(*Var).Pos", Method, 5},
+ {"(*Var).String", Method, 5},
+ {"(*Var).Type", Method, 5},
+ {"(Checker).ObjectOf", Method, 5},
+ {"(Checker).PkgNameOf", Method, 22},
+ {"(Checker).TypeOf", Method, 5},
+ {"(Error).Error", Method, 5},
+ {"(TypeAndValue).Addressable", Method, 5},
+ {"(TypeAndValue).Assignable", Method, 5},
+ {"(TypeAndValue).HasOk", Method, 5},
+ {"(TypeAndValue).IsBuiltin", Method, 5},
+ {"(TypeAndValue).IsNil", Method, 5},
+ {"(TypeAndValue).IsType", Method, 5},
+ {"(TypeAndValue).IsValue", Method, 5},
+ {"(TypeAndValue).IsVoid", Method, 5},
+ {"Alias", Type, 22},
+ {"ArgumentError", Type, 18},
+ {"ArgumentError.Err", Field, 18},
+ {"ArgumentError.Index", Field, 18},
+ {"Array", Type, 5},
+ {"AssertableTo", Func, 5},
+ {"AssignableTo", Func, 5},
+ {"Basic", Type, 5},
+ {"BasicInfo", Type, 5},
+ {"BasicKind", Type, 5},
+ {"Bool", Const, 5},
+ {"Builtin", Type, 5},
+ {"Byte", Const, 5},
+ {"Chan", Type, 5},
+ {"ChanDir", Type, 5},
+ {"CheckExpr", Func, 13},
+ {"Checker", Type, 5},
+ {"Checker.Info", Field, 5},
+ {"Comparable", Func, 5},
+ {"Complex128", Const, 5},
+ {"Complex64", Const, 5},
+ {"Config", Type, 5},
+ {"Config.Context", Field, 18},
+ {"Config.DisableUnusedImportCheck", Field, 5},
+ {"Config.Error", Field, 5},
+ {"Config.FakeImportC", Field, 5},
+ {"Config.GoVersion", Field, 18},
+ {"Config.IgnoreFuncBodies", Field, 5},
+ {"Config.Importer", Field, 5},
+ {"Config.Sizes", Field, 5},
+ {"Const", Type, 5},
+ {"Context", Type, 18},
+ {"ConvertibleTo", Func, 5},
+ {"DefPredeclaredTestFuncs", Func, 5},
+ {"Default", Func, 8},
+ {"Error", Type, 5},
+ {"Error.Fset", Field, 5},
+ {"Error.Msg", Field, 5},
+ {"Error.Pos", Field, 5},
+ {"Error.Soft", Field, 5},
+ {"Eval", Func, 5},
+ {"ExprString", Func, 5},
+ {"FieldVal", Const, 5},
+ {"Float32", Const, 5},
+ {"Float64", Const, 5},
+ {"Func", Type, 5},
+ {"Id", Func, 5},
+ {"Identical", Func, 5},
+ {"IdenticalIgnoreTags", Func, 8},
+ {"Implements", Func, 5},
+ {"ImportMode", Type, 6},
+ {"Importer", Type, 5},
+ {"ImporterFrom", Type, 6},
+ {"Info", Type, 5},
+ {"Info.Defs", Field, 5},
+ {"Info.FileVersions", Field, 22},
+ {"Info.Implicits", Field, 5},
+ {"Info.InitOrder", Field, 5},
+ {"Info.Instances", Field, 18},
+ {"Info.Scopes", Field, 5},
+ {"Info.Selections", Field, 5},
+ {"Info.Types", Field, 5},
+ {"Info.Uses", Field, 5},
+ {"Initializer", Type, 5},
+ {"Initializer.Lhs", Field, 5},
+ {"Initializer.Rhs", Field, 5},
+ {"Instance", Type, 18},
+ {"Instance.Type", Field, 18},
+ {"Instance.TypeArgs", Field, 18},
+ {"Instantiate", Func, 18},
+ {"Int", Const, 5},
+ {"Int16", Const, 5},
+ {"Int32", Const, 5},
+ {"Int64", Const, 5},
+ {"Int8", Const, 5},
+ {"Interface", Type, 5},
+ {"Invalid", Const, 5},
+ {"IsBoolean", Const, 5},
+ {"IsComplex", Const, 5},
+ {"IsConstType", Const, 5},
+ {"IsFloat", Const, 5},
+ {"IsInteger", Const, 5},
+ {"IsInterface", Func, 5},
+ {"IsNumeric", Const, 5},
+ {"IsOrdered", Const, 5},
+ {"IsString", Const, 5},
+ {"IsUnsigned", Const, 5},
+ {"IsUntyped", Const, 5},
+ {"Label", Type, 5},
+ {"LookupFieldOrMethod", Func, 5},
+ {"Map", Type, 5},
+ {"MethodExpr", Const, 5},
+ {"MethodSet", Type, 5},
+ {"MethodVal", Const, 5},
+ {"MissingMethod", Func, 5},
+ {"Named", Type, 5},
+ {"NewAlias", Func, 22},
+ {"NewArray", Func, 5},
+ {"NewChan", Func, 5},
+ {"NewChecker", Func, 5},
+ {"NewConst", Func, 5},
+ {"NewContext", Func, 18},
+ {"NewField", Func, 5},
+ {"NewFunc", Func, 5},
+ {"NewInterface", Func, 5},
+ {"NewInterfaceType", Func, 11},
+ {"NewLabel", Func, 5},
+ {"NewMap", Func, 5},
+ {"NewMethodSet", Func, 5},
+ {"NewNamed", Func, 5},
+ {"NewPackage", Func, 5},
+ {"NewParam", Func, 5},
+ {"NewPkgName", Func, 5},
+ {"NewPointer", Func, 5},
+ {"NewScope", Func, 5},
+ {"NewSignature", Func, 5},
+ {"NewSignatureType", Func, 18},
+ {"NewSlice", Func, 5},
+ {"NewStruct", Func, 5},
+ {"NewTerm", Func, 18},
+ {"NewTuple", Func, 5},
+ {"NewTypeName", Func, 5},
+ {"NewTypeParam", Func, 18},
+ {"NewUnion", Func, 18},
+ {"NewVar", Func, 5},
+ {"Nil", Type, 5},
+ {"Object", Type, 5},
+ {"ObjectString", Func, 5},
+ {"Package", Type, 5},
+ {"PkgName", Type, 5},
+ {"Pointer", Type, 5},
+ {"Qualifier", Type, 5},
+ {"RecvOnly", Const, 5},
+ {"RelativeTo", Func, 5},
+ {"Rune", Const, 5},
+ {"Satisfies", Func, 20},
+ {"Scope", Type, 5},
+ {"Selection", Type, 5},
+ {"SelectionKind", Type, 5},
+ {"SelectionString", Func, 5},
+ {"SendOnly", Const, 5},
+ {"SendRecv", Const, 5},
+ {"Signature", Type, 5},
+ {"Sizes", Type, 5},
+ {"SizesFor", Func, 9},
+ {"Slice", Type, 5},
+ {"StdSizes", Type, 5},
+ {"StdSizes.MaxAlign", Field, 5},
+ {"StdSizes.WordSize", Field, 5},
+ {"String", Const, 5},
+ {"Struct", Type, 5},
+ {"Term", Type, 18},
+ {"Tuple", Type, 5},
+ {"Typ", Var, 5},
+ {"Type", Type, 5},
+ {"TypeAndValue", Type, 5},
+ {"TypeAndValue.Type", Field, 5},
+ {"TypeAndValue.Value", Field, 5},
+ {"TypeList", Type, 18},
+ {"TypeName", Type, 5},
+ {"TypeParam", Type, 18},
+ {"TypeParamList", Type, 18},
+ {"TypeString", Func, 5},
+ {"Uint", Const, 5},
+ {"Uint16", Const, 5},
+ {"Uint32", Const, 5},
+ {"Uint64", Const, 5},
+ {"Uint8", Const, 5},
+ {"Uintptr", Const, 5},
+ {"Unalias", Func, 22},
+ {"Union", Type, 18},
+ {"Universe", Var, 5},
+ {"Unsafe", Var, 5},
+ {"UnsafePointer", Const, 5},
+ {"UntypedBool", Const, 5},
+ {"UntypedComplex", Const, 5},
+ {"UntypedFloat", Const, 5},
+ {"UntypedInt", Const, 5},
+ {"UntypedNil", Const, 5},
+ {"UntypedRune", Const, 5},
+ {"UntypedString", Const, 5},
+ {"Var", Type, 5},
+ {"WriteExpr", Func, 5},
+ {"WriteSignature", Func, 5},
+ {"WriteType", Func, 5},
+ },
+ "go/version": {
+ {"Compare", Func, 22},
+ {"IsValid", Func, 22},
+ {"Lang", Func, 22},
+ },
+ "hash": {
+ {"Hash", Type, 0},
+ {"Hash32", Type, 0},
+ {"Hash64", Type, 0},
+ },
+ "hash/adler32": {
+ {"Checksum", Func, 0},
+ {"New", Func, 0},
+ {"Size", Const, 0},
+ },
+ "hash/crc32": {
+ {"Castagnoli", Const, 0},
+ {"Checksum", Func, 0},
+ {"ChecksumIEEE", Func, 0},
+ {"IEEE", Const, 0},
+ {"IEEETable", Var, 0},
+ {"Koopman", Const, 0},
+ {"MakeTable", Func, 0},
+ {"New", Func, 0},
+ {"NewIEEE", Func, 0},
+ {"Size", Const, 0},
+ {"Table", Type, 0},
+ {"Update", Func, 0},
+ },
+ "hash/crc64": {
+ {"Checksum", Func, 0},
+ {"ECMA", Const, 0},
+ {"ISO", Const, 0},
+ {"MakeTable", Func, 0},
+ {"New", Func, 0},
+ {"Size", Const, 0},
+ {"Table", Type, 0},
+ {"Update", Func, 0},
+ },
+ "hash/fnv": {
+ {"New128", Func, 9},
+ {"New128a", Func, 9},
+ {"New32", Func, 0},
+ {"New32a", Func, 0},
+ {"New64", Func, 0},
+ {"New64a", Func, 0},
+ },
+ "hash/maphash": {
+ {"(*Hash).BlockSize", Method, 14},
+ {"(*Hash).Reset", Method, 14},
+ {"(*Hash).Seed", Method, 14},
+ {"(*Hash).SetSeed", Method, 14},
+ {"(*Hash).Size", Method, 14},
+ {"(*Hash).Sum", Method, 14},
+ {"(*Hash).Sum64", Method, 14},
+ {"(*Hash).Write", Method, 14},
+ {"(*Hash).WriteByte", Method, 14},
+ {"(*Hash).WriteString", Method, 14},
+ {"Bytes", Func, 19},
+ {"Hash", Type, 14},
+ {"MakeSeed", Func, 14},
+ {"Seed", Type, 14},
+ {"String", Func, 19},
+ },
+ "html": {
+ {"EscapeString", Func, 0},
+ {"UnescapeString", Func, 0},
+ },
+ "html/template": {
+ {"(*Error).Error", Method, 0},
+ {"(*Template).AddParseTree", Method, 0},
+ {"(*Template).Clone", Method, 0},
+ {"(*Template).DefinedTemplates", Method, 6},
+ {"(*Template).Delims", Method, 0},
+ {"(*Template).Execute", Method, 0},
+ {"(*Template).ExecuteTemplate", Method, 0},
+ {"(*Template).Funcs", Method, 0},
+ {"(*Template).Lookup", Method, 0},
+ {"(*Template).Name", Method, 0},
+ {"(*Template).New", Method, 0},
+ {"(*Template).Option", Method, 5},
+ {"(*Template).Parse", Method, 0},
+ {"(*Template).ParseFS", Method, 16},
+ {"(*Template).ParseFiles", Method, 0},
+ {"(*Template).ParseGlob", Method, 0},
+ {"(*Template).Templates", Method, 0},
+ {"CSS", Type, 0},
+ {"ErrAmbigContext", Const, 0},
+ {"ErrBadHTML", Const, 0},
+ {"ErrBranchEnd", Const, 0},
+ {"ErrEndContext", Const, 0},
+ {"ErrJSTemplate", Const, 21},
+ {"ErrNoSuchTemplate", Const, 0},
+ {"ErrOutputContext", Const, 0},
+ {"ErrPartialCharset", Const, 0},
+ {"ErrPartialEscape", Const, 0},
+ {"ErrPredefinedEscaper", Const, 9},
+ {"ErrRangeLoopReentry", Const, 0},
+ {"ErrSlashAmbig", Const, 0},
+ {"Error", Type, 0},
+ {"Error.Description", Field, 0},
+ {"Error.ErrorCode", Field, 0},
+ {"Error.Line", Field, 0},
+ {"Error.Name", Field, 0},
+ {"Error.Node", Field, 4},
+ {"ErrorCode", Type, 0},
+ {"FuncMap", Type, 0},
+ {"HTML", Type, 0},
+ {"HTMLAttr", Type, 0},
+ {"HTMLEscape", Func, 0},
+ {"HTMLEscapeString", Func, 0},
+ {"HTMLEscaper", Func, 0},
+ {"IsTrue", Func, 6},
+ {"JS", Type, 0},
+ {"JSEscape", Func, 0},
+ {"JSEscapeString", Func, 0},
+ {"JSEscaper", Func, 0},
+ {"JSStr", Type, 0},
+ {"Must", Func, 0},
+ {"New", Func, 0},
+ {"OK", Const, 0},
+ {"ParseFS", Func, 16},
+ {"ParseFiles", Func, 0},
+ {"ParseGlob", Func, 0},
+ {"Srcset", Type, 10},
+ {"Template", Type, 0},
+ {"Template.Tree", Field, 2},
+ {"URL", Type, 0},
+ {"URLQueryEscaper", Func, 0},
+ },
+ "image": {
+ {"(*Alpha).AlphaAt", Method, 4},
+ {"(*Alpha).At", Method, 0},
+ {"(*Alpha).Bounds", Method, 0},
+ {"(*Alpha).ColorModel", Method, 0},
+ {"(*Alpha).Opaque", Method, 0},
+ {"(*Alpha).PixOffset", Method, 0},
+ {"(*Alpha).RGBA64At", Method, 17},
+ {"(*Alpha).Set", Method, 0},
+ {"(*Alpha).SetAlpha", Method, 0},
+ {"(*Alpha).SetRGBA64", Method, 17},
+ {"(*Alpha).SubImage", Method, 0},
+ {"(*Alpha16).Alpha16At", Method, 4},
+ {"(*Alpha16).At", Method, 0},
+ {"(*Alpha16).Bounds", Method, 0},
+ {"(*Alpha16).ColorModel", Method, 0},
+ {"(*Alpha16).Opaque", Method, 0},
+ {"(*Alpha16).PixOffset", Method, 0},
+ {"(*Alpha16).RGBA64At", Method, 17},
+ {"(*Alpha16).Set", Method, 0},
+ {"(*Alpha16).SetAlpha16", Method, 0},
+ {"(*Alpha16).SetRGBA64", Method, 17},
+ {"(*Alpha16).SubImage", Method, 0},
+ {"(*CMYK).At", Method, 5},
+ {"(*CMYK).Bounds", Method, 5},
+ {"(*CMYK).CMYKAt", Method, 5},
+ {"(*CMYK).ColorModel", Method, 5},
+ {"(*CMYK).Opaque", Method, 5},
+ {"(*CMYK).PixOffset", Method, 5},
+ {"(*CMYK).RGBA64At", Method, 17},
+ {"(*CMYK).Set", Method, 5},
+ {"(*CMYK).SetCMYK", Method, 5},
+ {"(*CMYK).SetRGBA64", Method, 17},
+ {"(*CMYK).SubImage", Method, 5},
+ {"(*Gray).At", Method, 0},
+ {"(*Gray).Bounds", Method, 0},
+ {"(*Gray).ColorModel", Method, 0},
+ {"(*Gray).GrayAt", Method, 4},
+ {"(*Gray).Opaque", Method, 0},
+ {"(*Gray).PixOffset", Method, 0},
+ {"(*Gray).RGBA64At", Method, 17},
+ {"(*Gray).Set", Method, 0},
+ {"(*Gray).SetGray", Method, 0},
+ {"(*Gray).SetRGBA64", Method, 17},
+ {"(*Gray).SubImage", Method, 0},
+ {"(*Gray16).At", Method, 0},
+ {"(*Gray16).Bounds", Method, 0},
+ {"(*Gray16).ColorModel", Method, 0},
+ {"(*Gray16).Gray16At", Method, 4},
+ {"(*Gray16).Opaque", Method, 0},
+ {"(*Gray16).PixOffset", Method, 0},
+ {"(*Gray16).RGBA64At", Method, 17},
+ {"(*Gray16).Set", Method, 0},
+ {"(*Gray16).SetGray16", Method, 0},
+ {"(*Gray16).SetRGBA64", Method, 17},
+ {"(*Gray16).SubImage", Method, 0},
+ {"(*NRGBA).At", Method, 0},
+ {"(*NRGBA).Bounds", Method, 0},
+ {"(*NRGBA).ColorModel", Method, 0},
+ {"(*NRGBA).NRGBAAt", Method, 4},
+ {"(*NRGBA).Opaque", Method, 0},
+ {"(*NRGBA).PixOffset", Method, 0},
+ {"(*NRGBA).RGBA64At", Method, 17},
+ {"(*NRGBA).Set", Method, 0},
+ {"(*NRGBA).SetNRGBA", Method, 0},
+ {"(*NRGBA).SetRGBA64", Method, 17},
+ {"(*NRGBA).SubImage", Method, 0},
+ {"(*NRGBA64).At", Method, 0},
+ {"(*NRGBA64).Bounds", Method, 0},
+ {"(*NRGBA64).ColorModel", Method, 0},
+ {"(*NRGBA64).NRGBA64At", Method, 4},
+ {"(*NRGBA64).Opaque", Method, 0},
+ {"(*NRGBA64).PixOffset", Method, 0},
+ {"(*NRGBA64).RGBA64At", Method, 17},
+ {"(*NRGBA64).Set", Method, 0},
+ {"(*NRGBA64).SetNRGBA64", Method, 0},
+ {"(*NRGBA64).SetRGBA64", Method, 17},
+ {"(*NRGBA64).SubImage", Method, 0},
+ {"(*NYCbCrA).AOffset", Method, 6},
+ {"(*NYCbCrA).At", Method, 6},
+ {"(*NYCbCrA).Bounds", Method, 6},
+ {"(*NYCbCrA).COffset", Method, 6},
+ {"(*NYCbCrA).ColorModel", Method, 6},
+ {"(*NYCbCrA).NYCbCrAAt", Method, 6},
+ {"(*NYCbCrA).Opaque", Method, 6},
+ {"(*NYCbCrA).RGBA64At", Method, 17},
+ {"(*NYCbCrA).SubImage", Method, 6},
+ {"(*NYCbCrA).YCbCrAt", Method, 6},
+ {"(*NYCbCrA).YOffset", Method, 6},
+ {"(*Paletted).At", Method, 0},
+ {"(*Paletted).Bounds", Method, 0},
+ {"(*Paletted).ColorIndexAt", Method, 0},
+ {"(*Paletted).ColorModel", Method, 0},
+ {"(*Paletted).Opaque", Method, 0},
+ {"(*Paletted).PixOffset", Method, 0},
+ {"(*Paletted).RGBA64At", Method, 17},
+ {"(*Paletted).Set", Method, 0},
+ {"(*Paletted).SetColorIndex", Method, 0},
+ {"(*Paletted).SetRGBA64", Method, 17},
+ {"(*Paletted).SubImage", Method, 0},
+ {"(*RGBA).At", Method, 0},
+ {"(*RGBA).Bounds", Method, 0},
+ {"(*RGBA).ColorModel", Method, 0},
+ {"(*RGBA).Opaque", Method, 0},
+ {"(*RGBA).PixOffset", Method, 0},
+ {"(*RGBA).RGBA64At", Method, 17},
+ {"(*RGBA).RGBAAt", Method, 4},
+ {"(*RGBA).Set", Method, 0},
+ {"(*RGBA).SetRGBA", Method, 0},
+ {"(*RGBA).SetRGBA64", Method, 17},
+ {"(*RGBA).SubImage", Method, 0},
+ {"(*RGBA64).At", Method, 0},
+ {"(*RGBA64).Bounds", Method, 0},
+ {"(*RGBA64).ColorModel", Method, 0},
+ {"(*RGBA64).Opaque", Method, 0},
+ {"(*RGBA64).PixOffset", Method, 0},
+ {"(*RGBA64).RGBA64At", Method, 4},
+ {"(*RGBA64).Set", Method, 0},
+ {"(*RGBA64).SetRGBA64", Method, 0},
+ {"(*RGBA64).SubImage", Method, 0},
+ {"(*Uniform).At", Method, 0},
+ {"(*Uniform).Bounds", Method, 0},
+ {"(*Uniform).ColorModel", Method, 0},
+ {"(*Uniform).Convert", Method, 0},
+ {"(*Uniform).Opaque", Method, 0},
+ {"(*Uniform).RGBA", Method, 0},
+ {"(*Uniform).RGBA64At", Method, 17},
+ {"(*YCbCr).At", Method, 0},
+ {"(*YCbCr).Bounds", Method, 0},
+ {"(*YCbCr).COffset", Method, 0},
+ {"(*YCbCr).ColorModel", Method, 0},
+ {"(*YCbCr).Opaque", Method, 0},
+ {"(*YCbCr).RGBA64At", Method, 17},
+ {"(*YCbCr).SubImage", Method, 0},
+ {"(*YCbCr).YCbCrAt", Method, 4},
+ {"(*YCbCr).YOffset", Method, 0},
+ {"(Point).Add", Method, 0},
+ {"(Point).Div", Method, 0},
+ {"(Point).Eq", Method, 0},
+ {"(Point).In", Method, 0},
+ {"(Point).Mod", Method, 0},
+ {"(Point).Mul", Method, 0},
+ {"(Point).String", Method, 0},
+ {"(Point).Sub", Method, 0},
+ {"(Rectangle).Add", Method, 0},
+ {"(Rectangle).At", Method, 5},
+ {"(Rectangle).Bounds", Method, 5},
+ {"(Rectangle).Canon", Method, 0},
+ {"(Rectangle).ColorModel", Method, 5},
+ {"(Rectangle).Dx", Method, 0},
+ {"(Rectangle).Dy", Method, 0},
+ {"(Rectangle).Empty", Method, 0},
+ {"(Rectangle).Eq", Method, 0},
+ {"(Rectangle).In", Method, 0},
+ {"(Rectangle).Inset", Method, 0},
+ {"(Rectangle).Intersect", Method, 0},
+ {"(Rectangle).Overlaps", Method, 0},
+ {"(Rectangle).RGBA64At", Method, 17},
+ {"(Rectangle).Size", Method, 0},
+ {"(Rectangle).String", Method, 0},
+ {"(Rectangle).Sub", Method, 0},
+ {"(Rectangle).Union", Method, 0},
+ {"(YCbCrSubsampleRatio).String", Method, 0},
+ {"Alpha", Type, 0},
+ {"Alpha.Pix", Field, 0},
+ {"Alpha.Rect", Field, 0},
+ {"Alpha.Stride", Field, 0},
+ {"Alpha16", Type, 0},
+ {"Alpha16.Pix", Field, 0},
+ {"Alpha16.Rect", Field, 0},
+ {"Alpha16.Stride", Field, 0},
+ {"Black", Var, 0},
+ {"CMYK", Type, 5},
+ {"CMYK.Pix", Field, 5},
+ {"CMYK.Rect", Field, 5},
+ {"CMYK.Stride", Field, 5},
+ {"Config", Type, 0},
+ {"Config.ColorModel", Field, 0},
+ {"Config.Height", Field, 0},
+ {"Config.Width", Field, 0},
+ {"Decode", Func, 0},
+ {"DecodeConfig", Func, 0},
+ {"ErrFormat", Var, 0},
+ {"Gray", Type, 0},
+ {"Gray.Pix", Field, 0},
+ {"Gray.Rect", Field, 0},
+ {"Gray.Stride", Field, 0},
+ {"Gray16", Type, 0},
+ {"Gray16.Pix", Field, 0},
+ {"Gray16.Rect", Field, 0},
+ {"Gray16.Stride", Field, 0},
+ {"Image", Type, 0},
+ {"NRGBA", Type, 0},
+ {"NRGBA.Pix", Field, 0},
+ {"NRGBA.Rect", Field, 0},
+ {"NRGBA.Stride", Field, 0},
+ {"NRGBA64", Type, 0},
+ {"NRGBA64.Pix", Field, 0},
+ {"NRGBA64.Rect", Field, 0},
+ {"NRGBA64.Stride", Field, 0},
+ {"NYCbCrA", Type, 6},
+ {"NYCbCrA.A", Field, 6},
+ {"NYCbCrA.AStride", Field, 6},
+ {"NYCbCrA.YCbCr", Field, 6},
+ {"NewAlpha", Func, 0},
+ {"NewAlpha16", Func, 0},
+ {"NewCMYK", Func, 5},
+ {"NewGray", Func, 0},
+ {"NewGray16", Func, 0},
+ {"NewNRGBA", Func, 0},
+ {"NewNRGBA64", Func, 0},
+ {"NewNYCbCrA", Func, 6},
+ {"NewPaletted", Func, 0},
+ {"NewRGBA", Func, 0},
+ {"NewRGBA64", Func, 0},
+ {"NewUniform", Func, 0},
+ {"NewYCbCr", Func, 0},
+ {"Opaque", Var, 0},
+ {"Paletted", Type, 0},
+ {"Paletted.Palette", Field, 0},
+ {"Paletted.Pix", Field, 0},
+ {"Paletted.Rect", Field, 0},
+ {"Paletted.Stride", Field, 0},
+ {"PalettedImage", Type, 0},
+ {"Point", Type, 0},
+ {"Point.X", Field, 0},
+ {"Point.Y", Field, 0},
+ {"Pt", Func, 0},
+ {"RGBA", Type, 0},
+ {"RGBA.Pix", Field, 0},
+ {"RGBA.Rect", Field, 0},
+ {"RGBA.Stride", Field, 0},
+ {"RGBA64", Type, 0},
+ {"RGBA64.Pix", Field, 0},
+ {"RGBA64.Rect", Field, 0},
+ {"RGBA64.Stride", Field, 0},
+ {"RGBA64Image", Type, 17},
+ {"Rect", Func, 0},
+ {"Rectangle", Type, 0},
+ {"Rectangle.Max", Field, 0},
+ {"Rectangle.Min", Field, 0},
+ {"RegisterFormat", Func, 0},
+ {"Transparent", Var, 0},
+ {"Uniform", Type, 0},
+ {"Uniform.C", Field, 0},
+ {"White", Var, 0},
+ {"YCbCr", Type, 0},
+ {"YCbCr.CStride", Field, 0},
+ {"YCbCr.Cb", Field, 0},
+ {"YCbCr.Cr", Field, 0},
+ {"YCbCr.Rect", Field, 0},
+ {"YCbCr.SubsampleRatio", Field, 0},
+ {"YCbCr.Y", Field, 0},
+ {"YCbCr.YStride", Field, 0},
+ {"YCbCrSubsampleRatio", Type, 0},
+ {"YCbCrSubsampleRatio410", Const, 5},
+ {"YCbCrSubsampleRatio411", Const, 5},
+ {"YCbCrSubsampleRatio420", Const, 0},
+ {"YCbCrSubsampleRatio422", Const, 0},
+ {"YCbCrSubsampleRatio440", Const, 1},
+ {"YCbCrSubsampleRatio444", Const, 0},
+ {"ZP", Var, 0},
+ {"ZR", Var, 0},
+ },
+ "image/color": {
+ {"(Alpha).RGBA", Method, 0},
+ {"(Alpha16).RGBA", Method, 0},
+ {"(CMYK).RGBA", Method, 5},
+ {"(Gray).RGBA", Method, 0},
+ {"(Gray16).RGBA", Method, 0},
+ {"(NRGBA).RGBA", Method, 0},
+ {"(NRGBA64).RGBA", Method, 0},
+ {"(NYCbCrA).RGBA", Method, 6},
+ {"(Palette).Convert", Method, 0},
+ {"(Palette).Index", Method, 0},
+ {"(RGBA).RGBA", Method, 0},
+ {"(RGBA64).RGBA", Method, 0},
+ {"(YCbCr).RGBA", Method, 0},
+ {"Alpha", Type, 0},
+ {"Alpha.A", Field, 0},
+ {"Alpha16", Type, 0},
+ {"Alpha16.A", Field, 0},
+ {"Alpha16Model", Var, 0},
+ {"AlphaModel", Var, 0},
+ {"Black", Var, 0},
+ {"CMYK", Type, 5},
+ {"CMYK.C", Field, 5},
+ {"CMYK.K", Field, 5},
+ {"CMYK.M", Field, 5},
+ {"CMYK.Y", Field, 5},
+ {"CMYKModel", Var, 5},
+ {"CMYKToRGB", Func, 5},
+ {"Color", Type, 0},
+ {"Gray", Type, 0},
+ {"Gray.Y", Field, 0},
+ {"Gray16", Type, 0},
+ {"Gray16.Y", Field, 0},
+ {"Gray16Model", Var, 0},
+ {"GrayModel", Var, 0},
+ {"Model", Type, 0},
+ {"ModelFunc", Func, 0},
+ {"NRGBA", Type, 0},
+ {"NRGBA.A", Field, 0},
+ {"NRGBA.B", Field, 0},
+ {"NRGBA.G", Field, 0},
+ {"NRGBA.R", Field, 0},
+ {"NRGBA64", Type, 0},
+ {"NRGBA64.A", Field, 0},
+ {"NRGBA64.B", Field, 0},
+ {"NRGBA64.G", Field, 0},
+ {"NRGBA64.R", Field, 0},
+ {"NRGBA64Model", Var, 0},
+ {"NRGBAModel", Var, 0},
+ {"NYCbCrA", Type, 6},
+ {"NYCbCrA.A", Field, 6},
+ {"NYCbCrA.YCbCr", Field, 6},
+ {"NYCbCrAModel", Var, 6},
+ {"Opaque", Var, 0},
+ {"Palette", Type, 0},
+ {"RGBA", Type, 0},
+ {"RGBA.A", Field, 0},
+ {"RGBA.B", Field, 0},
+ {"RGBA.G", Field, 0},
+ {"RGBA.R", Field, 0},
+ {"RGBA64", Type, 0},
+ {"RGBA64.A", Field, 0},
+ {"RGBA64.B", Field, 0},
+ {"RGBA64.G", Field, 0},
+ {"RGBA64.R", Field, 0},
+ {"RGBA64Model", Var, 0},
+ {"RGBAModel", Var, 0},
+ {"RGBToCMYK", Func, 5},
+ {"RGBToYCbCr", Func, 0},
+ {"Transparent", Var, 0},
+ {"White", Var, 0},
+ {"YCbCr", Type, 0},
+ {"YCbCr.Cb", Field, 0},
+ {"YCbCr.Cr", Field, 0},
+ {"YCbCr.Y", Field, 0},
+ {"YCbCrModel", Var, 0},
+ {"YCbCrToRGB", Func, 0},
+ },
+ "image/color/palette": {
+ {"Plan9", Var, 2},
+ {"WebSafe", Var, 2},
+ },
+ "image/draw": {
+ {"(Op).Draw", Method, 2},
+ {"Draw", Func, 0},
+ {"DrawMask", Func, 0},
+ {"Drawer", Type, 2},
+ {"FloydSteinberg", Var, 2},
+ {"Image", Type, 0},
+ {"Op", Type, 0},
+ {"Over", Const, 0},
+ {"Quantizer", Type, 2},
+ {"RGBA64Image", Type, 17},
+ {"Src", Const, 0},
+ },
+ "image/gif": {
+ {"Decode", Func, 0},
+ {"DecodeAll", Func, 0},
+ {"DecodeConfig", Func, 0},
+ {"DisposalBackground", Const, 5},
+ {"DisposalNone", Const, 5},
+ {"DisposalPrevious", Const, 5},
+ {"Encode", Func, 2},
+ {"EncodeAll", Func, 2},
+ {"GIF", Type, 0},
+ {"GIF.BackgroundIndex", Field, 5},
+ {"GIF.Config", Field, 5},
+ {"GIF.Delay", Field, 0},
+ {"GIF.Disposal", Field, 5},
+ {"GIF.Image", Field, 0},
+ {"GIF.LoopCount", Field, 0},
+ {"Options", Type, 2},
+ {"Options.Drawer", Field, 2},
+ {"Options.NumColors", Field, 2},
+ {"Options.Quantizer", Field, 2},
+ },
+ "image/jpeg": {
+ {"(FormatError).Error", Method, 0},
+ {"(UnsupportedError).Error", Method, 0},
+ {"Decode", Func, 0},
+ {"DecodeConfig", Func, 0},
+ {"DefaultQuality", Const, 0},
+ {"Encode", Func, 0},
+ {"FormatError", Type, 0},
+ {"Options", Type, 0},
+ {"Options.Quality", Field, 0},
+ {"Reader", Type, 0},
+ {"UnsupportedError", Type, 0},
+ },
+ "image/png": {
+ {"(*Encoder).Encode", Method, 4},
+ {"(FormatError).Error", Method, 0},
+ {"(UnsupportedError).Error", Method, 0},
+ {"BestCompression", Const, 4},
+ {"BestSpeed", Const, 4},
+ {"CompressionLevel", Type, 4},
+ {"Decode", Func, 0},
+ {"DecodeConfig", Func, 0},
+ {"DefaultCompression", Const, 4},
+ {"Encode", Func, 0},
+ {"Encoder", Type, 4},
+ {"Encoder.BufferPool", Field, 9},
+ {"Encoder.CompressionLevel", Field, 4},
+ {"EncoderBuffer", Type, 9},
+ {"EncoderBufferPool", Type, 9},
+ {"FormatError", Type, 0},
+ {"NoCompression", Const, 4},
+ {"UnsupportedError", Type, 0},
+ },
+ "index/suffixarray": {
+ {"(*Index).Bytes", Method, 0},
+ {"(*Index).FindAllIndex", Method, 0},
+ {"(*Index).Lookup", Method, 0},
+ {"(*Index).Read", Method, 0},
+ {"(*Index).Write", Method, 0},
+ {"Index", Type, 0},
+ {"New", Func, 0},
+ },
+ "io": {
+ {"(*LimitedReader).Read", Method, 0},
+ {"(*OffsetWriter).Seek", Method, 20},
+ {"(*OffsetWriter).Write", Method, 20},
+ {"(*OffsetWriter).WriteAt", Method, 20},
+ {"(*PipeReader).Close", Method, 0},
+ {"(*PipeReader).CloseWithError", Method, 0},
+ {"(*PipeReader).Read", Method, 0},
+ {"(*PipeWriter).Close", Method, 0},
+ {"(*PipeWriter).CloseWithError", Method, 0},
+ {"(*PipeWriter).Write", Method, 0},
+ {"(*SectionReader).Outer", Method, 22},
+ {"(*SectionReader).Read", Method, 0},
+ {"(*SectionReader).ReadAt", Method, 0},
+ {"(*SectionReader).Seek", Method, 0},
+ {"(*SectionReader).Size", Method, 0},
+ {"ByteReader", Type, 0},
+ {"ByteScanner", Type, 0},
+ {"ByteWriter", Type, 1},
+ {"Closer", Type, 0},
+ {"Copy", Func, 0},
+ {"CopyBuffer", Func, 5},
+ {"CopyN", Func, 0},
+ {"Discard", Var, 16},
+ {"EOF", Var, 0},
+ {"ErrClosedPipe", Var, 0},
+ {"ErrNoProgress", Var, 1},
+ {"ErrShortBuffer", Var, 0},
+ {"ErrShortWrite", Var, 0},
+ {"ErrUnexpectedEOF", Var, 0},
+ {"LimitReader", Func, 0},
+ {"LimitedReader", Type, 0},
+ {"LimitedReader.N", Field, 0},
+ {"LimitedReader.R", Field, 0},
+ {"MultiReader", Func, 0},
+ {"MultiWriter", Func, 0},
+ {"NewOffsetWriter", Func, 20},
+ {"NewSectionReader", Func, 0},
+ {"NopCloser", Func, 16},
+ {"OffsetWriter", Type, 20},
+ {"Pipe", Func, 0},
+ {"PipeReader", Type, 0},
+ {"PipeWriter", Type, 0},
+ {"ReadAll", Func, 16},
+ {"ReadAtLeast", Func, 0},
+ {"ReadCloser", Type, 0},
+ {"ReadFull", Func, 0},
+ {"ReadSeekCloser", Type, 16},
+ {"ReadSeeker", Type, 0},
+ {"ReadWriteCloser", Type, 0},
+ {"ReadWriteSeeker", Type, 0},
+ {"ReadWriter", Type, 0},
+ {"Reader", Type, 0},
+ {"ReaderAt", Type, 0},
+ {"ReaderFrom", Type, 0},
+ {"RuneReader", Type, 0},
+ {"RuneScanner", Type, 0},
+ {"SectionReader", Type, 0},
+ {"SeekCurrent", Const, 7},
+ {"SeekEnd", Const, 7},
+ {"SeekStart", Const, 7},
+ {"Seeker", Type, 0},
+ {"StringWriter", Type, 12},
+ {"TeeReader", Func, 0},
+ {"WriteCloser", Type, 0},
+ {"WriteSeeker", Type, 0},
+ {"WriteString", Func, 0},
+ {"Writer", Type, 0},
+ {"WriterAt", Type, 0},
+ {"WriterTo", Type, 0},
+ },
+ "io/fs": {
+ {"(*PathError).Error", Method, 16},
+ {"(*PathError).Timeout", Method, 16},
+ {"(*PathError).Unwrap", Method, 16},
+ {"(FileMode).IsDir", Method, 16},
+ {"(FileMode).IsRegular", Method, 16},
+ {"(FileMode).Perm", Method, 16},
+ {"(FileMode).String", Method, 16},
+ {"(FileMode).Type", Method, 16},
+ {"DirEntry", Type, 16},
+ {"ErrClosed", Var, 16},
+ {"ErrExist", Var, 16},
+ {"ErrInvalid", Var, 16},
+ {"ErrNotExist", Var, 16},
+ {"ErrPermission", Var, 16},
+ {"FS", Type, 16},
+ {"File", Type, 16},
+ {"FileInfo", Type, 16},
+ {"FileInfoToDirEntry", Func, 17},
+ {"FileMode", Type, 16},
+ {"FormatDirEntry", Func, 21},
+ {"FormatFileInfo", Func, 21},
+ {"Glob", Func, 16},
+ {"GlobFS", Type, 16},
+ {"ModeAppend", Const, 16},
+ {"ModeCharDevice", Const, 16},
+ {"ModeDevice", Const, 16},
+ {"ModeDir", Const, 16},
+ {"ModeExclusive", Const, 16},
+ {"ModeIrregular", Const, 16},
+ {"ModeNamedPipe", Const, 16},
+ {"ModePerm", Const, 16},
+ {"ModeSetgid", Const, 16},
+ {"ModeSetuid", Const, 16},
+ {"ModeSocket", Const, 16},
+ {"ModeSticky", Const, 16},
+ {"ModeSymlink", Const, 16},
+ {"ModeTemporary", Const, 16},
+ {"ModeType", Const, 16},
+ {"PathError", Type, 16},
+ {"PathError.Err", Field, 16},
+ {"PathError.Op", Field, 16},
+ {"PathError.Path", Field, 16},
+ {"ReadDir", Func, 16},
+ {"ReadDirFS", Type, 16},
+ {"ReadDirFile", Type, 16},
+ {"ReadFile", Func, 16},
+ {"ReadFileFS", Type, 16},
+ {"SkipAll", Var, 20},
+ {"SkipDir", Var, 16},
+ {"Stat", Func, 16},
+ {"StatFS", Type, 16},
+ {"Sub", Func, 16},
+ {"SubFS", Type, 16},
+ {"ValidPath", Func, 16},
+ {"WalkDir", Func, 16},
+ {"WalkDirFunc", Type, 16},
+ },
+ "io/ioutil": {
+ {"Discard", Var, 0},
+ {"NopCloser", Func, 0},
+ {"ReadAll", Func, 0},
+ {"ReadDir", Func, 0},
+ {"ReadFile", Func, 0},
+ {"TempDir", Func, 0},
+ {"TempFile", Func, 0},
+ {"WriteFile", Func, 0},
+ },
+ "iter": {
+ {"Pull", Func, 23},
+ {"Pull2", Func, 23},
+ {"Seq", Type, 23},
+ {"Seq2", Type, 23},
+ },
+ "log": {
+ {"(*Logger).Fatal", Method, 0},
+ {"(*Logger).Fatalf", Method, 0},
+ {"(*Logger).Fatalln", Method, 0},
+ {"(*Logger).Flags", Method, 0},
+ {"(*Logger).Output", Method, 0},
+ {"(*Logger).Panic", Method, 0},
+ {"(*Logger).Panicf", Method, 0},
+ {"(*Logger).Panicln", Method, 0},
+ {"(*Logger).Prefix", Method, 0},
+ {"(*Logger).Print", Method, 0},
+ {"(*Logger).Printf", Method, 0},
+ {"(*Logger).Println", Method, 0},
+ {"(*Logger).SetFlags", Method, 0},
+ {"(*Logger).SetOutput", Method, 5},
+ {"(*Logger).SetPrefix", Method, 0},
+ {"(*Logger).Writer", Method, 12},
+ {"Default", Func, 16},
+ {"Fatal", Func, 0},
+ {"Fatalf", Func, 0},
+ {"Fatalln", Func, 0},
+ {"Flags", Func, 0},
+ {"LUTC", Const, 5},
+ {"Ldate", Const, 0},
+ {"Llongfile", Const, 0},
+ {"Lmicroseconds", Const, 0},
+ {"Lmsgprefix", Const, 14},
+ {"Logger", Type, 0},
+ {"Lshortfile", Const, 0},
+ {"LstdFlags", Const, 0},
+ {"Ltime", Const, 0},
+ {"New", Func, 0},
+ {"Output", Func, 5},
+ {"Panic", Func, 0},
+ {"Panicf", Func, 0},
+ {"Panicln", Func, 0},
+ {"Prefix", Func, 0},
+ {"Print", Func, 0},
+ {"Printf", Func, 0},
+ {"Println", Func, 0},
+ {"SetFlags", Func, 0},
+ {"SetOutput", Func, 0},
+ {"SetPrefix", Func, 0},
+ {"Writer", Func, 13},
+ },
+ "log/slog": {
+ {"(*JSONHandler).Enabled", Method, 21},
+ {"(*JSONHandler).Handle", Method, 21},
+ {"(*JSONHandler).WithAttrs", Method, 21},
+ {"(*JSONHandler).WithGroup", Method, 21},
+ {"(*Level).UnmarshalJSON", Method, 21},
+ {"(*Level).UnmarshalText", Method, 21},
+ {"(*LevelVar).Level", Method, 21},
+ {"(*LevelVar).MarshalText", Method, 21},
+ {"(*LevelVar).Set", Method, 21},
+ {"(*LevelVar).String", Method, 21},
+ {"(*LevelVar).UnmarshalText", Method, 21},
+ {"(*Logger).Debug", Method, 21},
+ {"(*Logger).DebugContext", Method, 21},
+ {"(*Logger).Enabled", Method, 21},
+ {"(*Logger).Error", Method, 21},
+ {"(*Logger).ErrorContext", Method, 21},
+ {"(*Logger).Handler", Method, 21},
+ {"(*Logger).Info", Method, 21},
+ {"(*Logger).InfoContext", Method, 21},
+ {"(*Logger).Log", Method, 21},
+ {"(*Logger).LogAttrs", Method, 21},
+ {"(*Logger).Warn", Method, 21},
+ {"(*Logger).WarnContext", Method, 21},
+ {"(*Logger).With", Method, 21},
+ {"(*Logger).WithGroup", Method, 21},
+ {"(*Record).Add", Method, 21},
+ {"(*Record).AddAttrs", Method, 21},
+ {"(*TextHandler).Enabled", Method, 21},
+ {"(*TextHandler).Handle", Method, 21},
+ {"(*TextHandler).WithAttrs", Method, 21},
+ {"(*TextHandler).WithGroup", Method, 21},
+ {"(Attr).Equal", Method, 21},
+ {"(Attr).String", Method, 21},
+ {"(Kind).String", Method, 21},
+ {"(Level).Level", Method, 21},
+ {"(Level).MarshalJSON", Method, 21},
+ {"(Level).MarshalText", Method, 21},
+ {"(Level).String", Method, 21},
+ {"(Record).Attrs", Method, 21},
+ {"(Record).Clone", Method, 21},
+ {"(Record).NumAttrs", Method, 21},
+ {"(Value).Any", Method, 21},
+ {"(Value).Bool", Method, 21},
+ {"(Value).Duration", Method, 21},
+ {"(Value).Equal", Method, 21},
+ {"(Value).Float64", Method, 21},
+ {"(Value).Group", Method, 21},
+ {"(Value).Int64", Method, 21},
+ {"(Value).Kind", Method, 21},
+ {"(Value).LogValuer", Method, 21},
+ {"(Value).Resolve", Method, 21},
+ {"(Value).String", Method, 21},
+ {"(Value).Time", Method, 21},
+ {"(Value).Uint64", Method, 21},
+ {"Any", Func, 21},
+ {"AnyValue", Func, 21},
+ {"Attr", Type, 21},
+ {"Attr.Key", Field, 21},
+ {"Attr.Value", Field, 21},
+ {"Bool", Func, 21},
+ {"BoolValue", Func, 21},
+ {"Debug", Func, 21},
+ {"DebugContext", Func, 21},
+ {"Default", Func, 21},
+ {"Duration", Func, 21},
+ {"DurationValue", Func, 21},
+ {"Error", Func, 21},
+ {"ErrorContext", Func, 21},
+ {"Float64", Func, 21},
+ {"Float64Value", Func, 21},
+ {"Group", Func, 21},
+ {"GroupValue", Func, 21},
+ {"Handler", Type, 21},
+ {"HandlerOptions", Type, 21},
+ {"HandlerOptions.AddSource", Field, 21},
+ {"HandlerOptions.Level", Field, 21},
+ {"HandlerOptions.ReplaceAttr", Field, 21},
+ {"Info", Func, 21},
+ {"InfoContext", Func, 21},
+ {"Int", Func, 21},
+ {"Int64", Func, 21},
+ {"Int64Value", Func, 21},
+ {"IntValue", Func, 21},
+ {"JSONHandler", Type, 21},
+ {"Kind", Type, 21},
+ {"KindAny", Const, 21},
+ {"KindBool", Const, 21},
+ {"KindDuration", Const, 21},
+ {"KindFloat64", Const, 21},
+ {"KindGroup", Const, 21},
+ {"KindInt64", Const, 21},
+ {"KindLogValuer", Const, 21},
+ {"KindString", Const, 21},
+ {"KindTime", Const, 21},
+ {"KindUint64", Const, 21},
+ {"Level", Type, 21},
+ {"LevelDebug", Const, 21},
+ {"LevelError", Const, 21},
+ {"LevelInfo", Const, 21},
+ {"LevelKey", Const, 21},
+ {"LevelVar", Type, 21},
+ {"LevelWarn", Const, 21},
+ {"Leveler", Type, 21},
+ {"Log", Func, 21},
+ {"LogAttrs", Func, 21},
+ {"LogValuer", Type, 21},
+ {"Logger", Type, 21},
+ {"MessageKey", Const, 21},
+ {"New", Func, 21},
+ {"NewJSONHandler", Func, 21},
+ {"NewLogLogger", Func, 21},
+ {"NewRecord", Func, 21},
+ {"NewTextHandler", Func, 21},
+ {"Record", Type, 21},
+ {"Record.Level", Field, 21},
+ {"Record.Message", Field, 21},
+ {"Record.PC", Field, 21},
+ {"Record.Time", Field, 21},
+ {"SetDefault", Func, 21},
+ {"SetLogLoggerLevel", Func, 22},
+ {"Source", Type, 21},
+ {"Source.File", Field, 21},
+ {"Source.Function", Field, 21},
+ {"Source.Line", Field, 21},
+ {"SourceKey", Const, 21},
+ {"String", Func, 21},
+ {"StringValue", Func, 21},
+ {"TextHandler", Type, 21},
+ {"Time", Func, 21},
+ {"TimeKey", Const, 21},
+ {"TimeValue", Func, 21},
+ {"Uint64", Func, 21},
+ {"Uint64Value", Func, 21},
+ {"Value", Type, 21},
+ {"Warn", Func, 21},
+ {"WarnContext", Func, 21},
+ {"With", Func, 21},
+ },
+ "log/syslog": {
+ {"(*Writer).Alert", Method, 0},
+ {"(*Writer).Close", Method, 0},
+ {"(*Writer).Crit", Method, 0},
+ {"(*Writer).Debug", Method, 0},
+ {"(*Writer).Emerg", Method, 0},
+ {"(*Writer).Err", Method, 0},
+ {"(*Writer).Info", Method, 0},
+ {"(*Writer).Notice", Method, 0},
+ {"(*Writer).Warning", Method, 0},
+ {"(*Writer).Write", Method, 0},
+ {"Dial", Func, 0},
+ {"LOG_ALERT", Const, 0},
+ {"LOG_AUTH", Const, 1},
+ {"LOG_AUTHPRIV", Const, 1},
+ {"LOG_CRIT", Const, 0},
+ {"LOG_CRON", Const, 1},
+ {"LOG_DAEMON", Const, 1},
+ {"LOG_DEBUG", Const, 0},
+ {"LOG_EMERG", Const, 0},
+ {"LOG_ERR", Const, 0},
+ {"LOG_FTP", Const, 1},
+ {"LOG_INFO", Const, 0},
+ {"LOG_KERN", Const, 1},
+ {"LOG_LOCAL0", Const, 1},
+ {"LOG_LOCAL1", Const, 1},
+ {"LOG_LOCAL2", Const, 1},
+ {"LOG_LOCAL3", Const, 1},
+ {"LOG_LOCAL4", Const, 1},
+ {"LOG_LOCAL5", Const, 1},
+ {"LOG_LOCAL6", Const, 1},
+ {"LOG_LOCAL7", Const, 1},
+ {"LOG_LPR", Const, 1},
+ {"LOG_MAIL", Const, 1},
+ {"LOG_NEWS", Const, 1},
+ {"LOG_NOTICE", Const, 0},
+ {"LOG_SYSLOG", Const, 1},
+ {"LOG_USER", Const, 1},
+ {"LOG_UUCP", Const, 1},
+ {"LOG_WARNING", Const, 0},
+ {"New", Func, 0},
+ {"NewLogger", Func, 0},
+ {"Priority", Type, 0},
+ {"Writer", Type, 0},
+ },
+ "maps": {
+ {"All", Func, 23},
+ {"Clone", Func, 21},
+ {"Collect", Func, 23},
+ {"Copy", Func, 21},
+ {"DeleteFunc", Func, 21},
+ {"Equal", Func, 21},
+ {"EqualFunc", Func, 21},
+ {"Insert", Func, 23},
+ {"Keys", Func, 23},
+ {"Values", Func, 23},
+ },
+ "math": {
+ {"Abs", Func, 0},
+ {"Acos", Func, 0},
+ {"Acosh", Func, 0},
+ {"Asin", Func, 0},
+ {"Asinh", Func, 0},
+ {"Atan", Func, 0},
+ {"Atan2", Func, 0},
+ {"Atanh", Func, 0},
+ {"Cbrt", Func, 0},
+ {"Ceil", Func, 0},
+ {"Copysign", Func, 0},
+ {"Cos", Func, 0},
+ {"Cosh", Func, 0},
+ {"Dim", Func, 0},
+ {"E", Const, 0},
+ {"Erf", Func, 0},
+ {"Erfc", Func, 0},
+ {"Erfcinv", Func, 10},
+ {"Erfinv", Func, 10},
+ {"Exp", Func, 0},
+ {"Exp2", Func, 0},
+ {"Expm1", Func, 0},
+ {"FMA", Func, 14},
+ {"Float32bits", Func, 0},
+ {"Float32frombits", Func, 0},
+ {"Float64bits", Func, 0},
+ {"Float64frombits", Func, 0},
+ {"Floor", Func, 0},
+ {"Frexp", Func, 0},
+ {"Gamma", Func, 0},
+ {"Hypot", Func, 0},
+ {"Ilogb", Func, 0},
+ {"Inf", Func, 0},
+ {"IsInf", Func, 0},
+ {"IsNaN", Func, 0},
+ {"J0", Func, 0},
+ {"J1", Func, 0},
+ {"Jn", Func, 0},
+ {"Ldexp", Func, 0},
+ {"Lgamma", Func, 0},
+ {"Ln10", Const, 0},
+ {"Ln2", Const, 0},
+ {"Log", Func, 0},
+ {"Log10", Func, 0},
+ {"Log10E", Const, 0},
+ {"Log1p", Func, 0},
+ {"Log2", Func, 0},
+ {"Log2E", Const, 0},
+ {"Logb", Func, 0},
+ {"Max", Func, 0},
+ {"MaxFloat32", Const, 0},
+ {"MaxFloat64", Const, 0},
+ {"MaxInt", Const, 17},
+ {"MaxInt16", Const, 0},
+ {"MaxInt32", Const, 0},
+ {"MaxInt64", Const, 0},
+ {"MaxInt8", Const, 0},
+ {"MaxUint", Const, 17},
+ {"MaxUint16", Const, 0},
+ {"MaxUint32", Const, 0},
+ {"MaxUint64", Const, 0},
+ {"MaxUint8", Const, 0},
+ {"Min", Func, 0},
+ {"MinInt", Const, 17},
+ {"MinInt16", Const, 0},
+ {"MinInt32", Const, 0},
+ {"MinInt64", Const, 0},
+ {"MinInt8", Const, 0},
+ {"Mod", Func, 0},
+ {"Modf", Func, 0},
+ {"NaN", Func, 0},
+ {"Nextafter", Func, 0},
+ {"Nextafter32", Func, 4},
+ {"Phi", Const, 0},
+ {"Pi", Const, 0},
+ {"Pow", Func, 0},
+ {"Pow10", Func, 0},
+ {"Remainder", Func, 0},
+ {"Round", Func, 10},
+ {"RoundToEven", Func, 10},
+ {"Signbit", Func, 0},
+ {"Sin", Func, 0},
+ {"Sincos", Func, 0},
+ {"Sinh", Func, 0},
+ {"SmallestNonzeroFloat32", Const, 0},
+ {"SmallestNonzeroFloat64", Const, 0},
+ {"Sqrt", Func, 0},
+ {"Sqrt2", Const, 0},
+ {"SqrtE", Const, 0},
+ {"SqrtPhi", Const, 0},
+ {"SqrtPi", Const, 0},
+ {"Tan", Func, 0},
+ {"Tanh", Func, 0},
+ {"Trunc", Func, 0},
+ {"Y0", Func, 0},
+ {"Y1", Func, 0},
+ {"Yn", Func, 0},
+ },
+ "math/big": {
+ {"(*Float).Abs", Method, 5},
+ {"(*Float).Acc", Method, 5},
+ {"(*Float).Add", Method, 5},
+ {"(*Float).Append", Method, 5},
+ {"(*Float).Cmp", Method, 5},
+ {"(*Float).Copy", Method, 5},
+ {"(*Float).Float32", Method, 5},
+ {"(*Float).Float64", Method, 5},
+ {"(*Float).Format", Method, 5},
+ {"(*Float).GobDecode", Method, 7},
+ {"(*Float).GobEncode", Method, 7},
+ {"(*Float).Int", Method, 5},
+ {"(*Float).Int64", Method, 5},
+ {"(*Float).IsInf", Method, 5},
+ {"(*Float).IsInt", Method, 5},
+ {"(*Float).MantExp", Method, 5},
+ {"(*Float).MarshalText", Method, 6},
+ {"(*Float).MinPrec", Method, 5},
+ {"(*Float).Mode", Method, 5},
+ {"(*Float).Mul", Method, 5},
+ {"(*Float).Neg", Method, 5},
+ {"(*Float).Parse", Method, 5},
+ {"(*Float).Prec", Method, 5},
+ {"(*Float).Quo", Method, 5},
+ {"(*Float).Rat", Method, 5},
+ {"(*Float).Scan", Method, 8},
+ {"(*Float).Set", Method, 5},
+ {"(*Float).SetFloat64", Method, 5},
+ {"(*Float).SetInf", Method, 5},
+ {"(*Float).SetInt", Method, 5},
+ {"(*Float).SetInt64", Method, 5},
+ {"(*Float).SetMantExp", Method, 5},
+ {"(*Float).SetMode", Method, 5},
+ {"(*Float).SetPrec", Method, 5},
+ {"(*Float).SetRat", Method, 5},
+ {"(*Float).SetString", Method, 5},
+ {"(*Float).SetUint64", Method, 5},
+ {"(*Float).Sign", Method, 5},
+ {"(*Float).Signbit", Method, 5},
+ {"(*Float).Sqrt", Method, 10},
+ {"(*Float).String", Method, 5},
+ {"(*Float).Sub", Method, 5},
+ {"(*Float).Text", Method, 5},
+ {"(*Float).Uint64", Method, 5},
+ {"(*Float).UnmarshalText", Method, 6},
+ {"(*Int).Abs", Method, 0},
+ {"(*Int).Add", Method, 0},
+ {"(*Int).And", Method, 0},
+ {"(*Int).AndNot", Method, 0},
+ {"(*Int).Append", Method, 6},
+ {"(*Int).Binomial", Method, 0},
+ {"(*Int).Bit", Method, 0},
+ {"(*Int).BitLen", Method, 0},
+ {"(*Int).Bits", Method, 0},
+ {"(*Int).Bytes", Method, 0},
+ {"(*Int).Cmp", Method, 0},
+ {"(*Int).CmpAbs", Method, 10},
+ {"(*Int).Div", Method, 0},
+ {"(*Int).DivMod", Method, 0},
+ {"(*Int).Exp", Method, 0},
+ {"(*Int).FillBytes", Method, 15},
+ {"(*Int).Float64", Method, 21},
+ {"(*Int).Format", Method, 0},
+ {"(*Int).GCD", Method, 0},
+ {"(*Int).GobDecode", Method, 0},
+ {"(*Int).GobEncode", Method, 0},
+ {"(*Int).Int64", Method, 0},
+ {"(*Int).IsInt64", Method, 9},
+ {"(*Int).IsUint64", Method, 9},
+ {"(*Int).Lsh", Method, 0},
+ {"(*Int).MarshalJSON", Method, 1},
+ {"(*Int).MarshalText", Method, 3},
+ {"(*Int).Mod", Method, 0},
+ {"(*Int).ModInverse", Method, 0},
+ {"(*Int).ModSqrt", Method, 5},
+ {"(*Int).Mul", Method, 0},
+ {"(*Int).MulRange", Method, 0},
+ {"(*Int).Neg", Method, 0},
+ {"(*Int).Not", Method, 0},
+ {"(*Int).Or", Method, 0},
+ {"(*Int).ProbablyPrime", Method, 0},
+ {"(*Int).Quo", Method, 0},
+ {"(*Int).QuoRem", Method, 0},
+ {"(*Int).Rand", Method, 0},
+ {"(*Int).Rem", Method, 0},
+ {"(*Int).Rsh", Method, 0},
+ {"(*Int).Scan", Method, 0},
+ {"(*Int).Set", Method, 0},
+ {"(*Int).SetBit", Method, 0},
+ {"(*Int).SetBits", Method, 0},
+ {"(*Int).SetBytes", Method, 0},
+ {"(*Int).SetInt64", Method, 0},
+ {"(*Int).SetString", Method, 0},
+ {"(*Int).SetUint64", Method, 1},
+ {"(*Int).Sign", Method, 0},
+ {"(*Int).Sqrt", Method, 8},
+ {"(*Int).String", Method, 0},
+ {"(*Int).Sub", Method, 0},
+ {"(*Int).Text", Method, 6},
+ {"(*Int).TrailingZeroBits", Method, 13},
+ {"(*Int).Uint64", Method, 1},
+ {"(*Int).UnmarshalJSON", Method, 1},
+ {"(*Int).UnmarshalText", Method, 3},
+ {"(*Int).Xor", Method, 0},
+ {"(*Rat).Abs", Method, 0},
+ {"(*Rat).Add", Method, 0},
+ {"(*Rat).Cmp", Method, 0},
+ {"(*Rat).Denom", Method, 0},
+ {"(*Rat).Float32", Method, 4},
+ {"(*Rat).Float64", Method, 1},
+ {"(*Rat).FloatPrec", Method, 22},
+ {"(*Rat).FloatString", Method, 0},
+ {"(*Rat).GobDecode", Method, 0},
+ {"(*Rat).GobEncode", Method, 0},
+ {"(*Rat).Inv", Method, 0},
+ {"(*Rat).IsInt", Method, 0},
+ {"(*Rat).MarshalText", Method, 3},
+ {"(*Rat).Mul", Method, 0},
+ {"(*Rat).Neg", Method, 0},
+ {"(*Rat).Num", Method, 0},
+ {"(*Rat).Quo", Method, 0},
+ {"(*Rat).RatString", Method, 0},
+ {"(*Rat).Scan", Method, 0},
+ {"(*Rat).Set", Method, 0},
+ {"(*Rat).SetFloat64", Method, 1},
+ {"(*Rat).SetFrac", Method, 0},
+ {"(*Rat).SetFrac64", Method, 0},
+ {"(*Rat).SetInt", Method, 0},
+ {"(*Rat).SetInt64", Method, 0},
+ {"(*Rat).SetString", Method, 0},
+ {"(*Rat).SetUint64", Method, 13},
+ {"(*Rat).Sign", Method, 0},
+ {"(*Rat).String", Method, 0},
+ {"(*Rat).Sub", Method, 0},
+ {"(*Rat).UnmarshalText", Method, 3},
+ {"(Accuracy).String", Method, 5},
+ {"(ErrNaN).Error", Method, 5},
+ {"(RoundingMode).String", Method, 5},
+ {"Above", Const, 5},
+ {"Accuracy", Type, 5},
+ {"AwayFromZero", Const, 5},
+ {"Below", Const, 5},
+ {"ErrNaN", Type, 5},
+ {"Exact", Const, 5},
+ {"Float", Type, 5},
+ {"Int", Type, 0},
+ {"Jacobi", Func, 5},
+ {"MaxBase", Const, 0},
+ {"MaxExp", Const, 5},
+ {"MaxPrec", Const, 5},
+ {"MinExp", Const, 5},
+ {"NewFloat", Func, 5},
+ {"NewInt", Func, 0},
+ {"NewRat", Func, 0},
+ {"ParseFloat", Func, 5},
+ {"Rat", Type, 0},
+ {"RoundingMode", Type, 5},
+ {"ToNearestAway", Const, 5},
+ {"ToNearestEven", Const, 5},
+ {"ToNegativeInf", Const, 5},
+ {"ToPositiveInf", Const, 5},
+ {"ToZero", Const, 5},
+ {"Word", Type, 0},
+ },
+ "math/bits": {
+ {"Add", Func, 12},
+ {"Add32", Func, 12},
+ {"Add64", Func, 12},
+ {"Div", Func, 12},
+ {"Div32", Func, 12},
+ {"Div64", Func, 12},
+ {"LeadingZeros", Func, 9},
+ {"LeadingZeros16", Func, 9},
+ {"LeadingZeros32", Func, 9},
+ {"LeadingZeros64", Func, 9},
+ {"LeadingZeros8", Func, 9},
+ {"Len", Func, 9},
+ {"Len16", Func, 9},
+ {"Len32", Func, 9},
+ {"Len64", Func, 9},
+ {"Len8", Func, 9},
+ {"Mul", Func, 12},
+ {"Mul32", Func, 12},
+ {"Mul64", Func, 12},
+ {"OnesCount", Func, 9},
+ {"OnesCount16", Func, 9},
+ {"OnesCount32", Func, 9},
+ {"OnesCount64", Func, 9},
+ {"OnesCount8", Func, 9},
+ {"Rem", Func, 14},
+ {"Rem32", Func, 14},
+ {"Rem64", Func, 14},
+ {"Reverse", Func, 9},
+ {"Reverse16", Func, 9},
+ {"Reverse32", Func, 9},
+ {"Reverse64", Func, 9},
+ {"Reverse8", Func, 9},
+ {"ReverseBytes", Func, 9},
+ {"ReverseBytes16", Func, 9},
+ {"ReverseBytes32", Func, 9},
+ {"ReverseBytes64", Func, 9},
+ {"RotateLeft", Func, 9},
+ {"RotateLeft16", Func, 9},
+ {"RotateLeft32", Func, 9},
+ {"RotateLeft64", Func, 9},
+ {"RotateLeft8", Func, 9},
+ {"Sub", Func, 12},
+ {"Sub32", Func, 12},
+ {"Sub64", Func, 12},
+ {"TrailingZeros", Func, 9},
+ {"TrailingZeros16", Func, 9},
+ {"TrailingZeros32", Func, 9},
+ {"TrailingZeros64", Func, 9},
+ {"TrailingZeros8", Func, 9},
+ {"UintSize", Const, 9},
+ },
+ "math/cmplx": {
+ {"Abs", Func, 0},
+ {"Acos", Func, 0},
+ {"Acosh", Func, 0},
+ {"Asin", Func, 0},
+ {"Asinh", Func, 0},
+ {"Atan", Func, 0},
+ {"Atanh", Func, 0},
+ {"Conj", Func, 0},
+ {"Cos", Func, 0},
+ {"Cosh", Func, 0},
+ {"Cot", Func, 0},
+ {"Exp", Func, 0},
+ {"Inf", Func, 0},
+ {"IsInf", Func, 0},
+ {"IsNaN", Func, 0},
+ {"Log", Func, 0},
+ {"Log10", Func, 0},
+ {"NaN", Func, 0},
+ {"Phase", Func, 0},
+ {"Polar", Func, 0},
+ {"Pow", Func, 0},
+ {"Rect", Func, 0},
+ {"Sin", Func, 0},
+ {"Sinh", Func, 0},
+ {"Sqrt", Func, 0},
+ {"Tan", Func, 0},
+ {"Tanh", Func, 0},
+ },
+ "math/rand": {
+ {"(*Rand).ExpFloat64", Method, 0},
+ {"(*Rand).Float32", Method, 0},
+ {"(*Rand).Float64", Method, 0},
+ {"(*Rand).Int", Method, 0},
+ {"(*Rand).Int31", Method, 0},
+ {"(*Rand).Int31n", Method, 0},
+ {"(*Rand).Int63", Method, 0},
+ {"(*Rand).Int63n", Method, 0},
+ {"(*Rand).Intn", Method, 0},
+ {"(*Rand).NormFloat64", Method, 0},
+ {"(*Rand).Perm", Method, 0},
+ {"(*Rand).Read", Method, 6},
+ {"(*Rand).Seed", Method, 0},
+ {"(*Rand).Shuffle", Method, 10},
+ {"(*Rand).Uint32", Method, 0},
+ {"(*Rand).Uint64", Method, 8},
+ {"(*Zipf).Uint64", Method, 0},
+ {"ExpFloat64", Func, 0},
+ {"Float32", Func, 0},
+ {"Float64", Func, 0},
+ {"Int", Func, 0},
+ {"Int31", Func, 0},
+ {"Int31n", Func, 0},
+ {"Int63", Func, 0},
+ {"Int63n", Func, 0},
+ {"Intn", Func, 0},
+ {"New", Func, 0},
+ {"NewSource", Func, 0},
+ {"NewZipf", Func, 0},
+ {"NormFloat64", Func, 0},
+ {"Perm", Func, 0},
+ {"Rand", Type, 0},
+ {"Read", Func, 6},
+ {"Seed", Func, 0},
+ {"Shuffle", Func, 10},
+ {"Source", Type, 0},
+ {"Source64", Type, 8},
+ {"Uint32", Func, 0},
+ {"Uint64", Func, 8},
+ {"Zipf", Type, 0},
+ },
+ "math/rand/v2": {
+ {"(*ChaCha8).MarshalBinary", Method, 22},
+ {"(*ChaCha8).Read", Method, 23},
+ {"(*ChaCha8).Seed", Method, 22},
+ {"(*ChaCha8).Uint64", Method, 22},
+ {"(*ChaCha8).UnmarshalBinary", Method, 22},
+ {"(*PCG).MarshalBinary", Method, 22},
+ {"(*PCG).Seed", Method, 22},
+ {"(*PCG).Uint64", Method, 22},
+ {"(*PCG).UnmarshalBinary", Method, 22},
+ {"(*Rand).ExpFloat64", Method, 22},
+ {"(*Rand).Float32", Method, 22},
+ {"(*Rand).Float64", Method, 22},
+ {"(*Rand).Int", Method, 22},
+ {"(*Rand).Int32", Method, 22},
+ {"(*Rand).Int32N", Method, 22},
+ {"(*Rand).Int64", Method, 22},
+ {"(*Rand).Int64N", Method, 22},
+ {"(*Rand).IntN", Method, 22},
+ {"(*Rand).NormFloat64", Method, 22},
+ {"(*Rand).Perm", Method, 22},
+ {"(*Rand).Shuffle", Method, 22},
+ {"(*Rand).Uint", Method, 23},
+ {"(*Rand).Uint32", Method, 22},
+ {"(*Rand).Uint32N", Method, 22},
+ {"(*Rand).Uint64", Method, 22},
+ {"(*Rand).Uint64N", Method, 22},
+ {"(*Rand).UintN", Method, 22},
+ {"(*Zipf).Uint64", Method, 22},
+ {"ChaCha8", Type, 22},
+ {"ExpFloat64", Func, 22},
+ {"Float32", Func, 22},
+ {"Float64", Func, 22},
+ {"Int", Func, 22},
+ {"Int32", Func, 22},
+ {"Int32N", Func, 22},
+ {"Int64", Func, 22},
+ {"Int64N", Func, 22},
+ {"IntN", Func, 22},
+ {"N", Func, 22},
+ {"New", Func, 22},
+ {"NewChaCha8", Func, 22},
+ {"NewPCG", Func, 22},
+ {"NewZipf", Func, 22},
+ {"NormFloat64", Func, 22},
+ {"PCG", Type, 22},
+ {"Perm", Func, 22},
+ {"Rand", Type, 22},
+ {"Shuffle", Func, 22},
+ {"Source", Type, 22},
+ {"Uint", Func, 23},
+ {"Uint32", Func, 22},
+ {"Uint32N", Func, 22},
+ {"Uint64", Func, 22},
+ {"Uint64N", Func, 22},
+ {"UintN", Func, 22},
+ {"Zipf", Type, 22},
+ },
+ "mime": {
+ {"(*WordDecoder).Decode", Method, 5},
+ {"(*WordDecoder).DecodeHeader", Method, 5},
+ {"(WordEncoder).Encode", Method, 5},
+ {"AddExtensionType", Func, 0},
+ {"BEncoding", Const, 5},
+ {"ErrInvalidMediaParameter", Var, 9},
+ {"ExtensionsByType", Func, 5},
+ {"FormatMediaType", Func, 0},
+ {"ParseMediaType", Func, 0},
+ {"QEncoding", Const, 5},
+ {"TypeByExtension", Func, 0},
+ {"WordDecoder", Type, 5},
+ {"WordDecoder.CharsetReader", Field, 5},
+ {"WordEncoder", Type, 5},
+ },
+ "mime/multipart": {
+ {"(*FileHeader).Open", Method, 0},
+ {"(*Form).RemoveAll", Method, 0},
+ {"(*Part).Close", Method, 0},
+ {"(*Part).FileName", Method, 0},
+ {"(*Part).FormName", Method, 0},
+ {"(*Part).Read", Method, 0},
+ {"(*Reader).NextPart", Method, 0},
+ {"(*Reader).NextRawPart", Method, 14},
+ {"(*Reader).ReadForm", Method, 0},
+ {"(*Writer).Boundary", Method, 0},
+ {"(*Writer).Close", Method, 0},
+ {"(*Writer).CreateFormField", Method, 0},
+ {"(*Writer).CreateFormFile", Method, 0},
+ {"(*Writer).CreatePart", Method, 0},
+ {"(*Writer).FormDataContentType", Method, 0},
+ {"(*Writer).SetBoundary", Method, 1},
+ {"(*Writer).WriteField", Method, 0},
+ {"ErrMessageTooLarge", Var, 9},
+ {"File", Type, 0},
+ {"FileHeader", Type, 0},
+ {"FileHeader.Filename", Field, 0},
+ {"FileHeader.Header", Field, 0},
+ {"FileHeader.Size", Field, 9},
+ {"Form", Type, 0},
+ {"Form.File", Field, 0},
+ {"Form.Value", Field, 0},
+ {"NewReader", Func, 0},
+ {"NewWriter", Func, 0},
+ {"Part", Type, 0},
+ {"Part.Header", Field, 0},
+ {"Reader", Type, 0},
+ {"Writer", Type, 0},
+ },
+ "mime/quotedprintable": {
+ {"(*Reader).Read", Method, 5},
+ {"(*Writer).Close", Method, 5},
+ {"(*Writer).Write", Method, 5},
+ {"NewReader", Func, 5},
+ {"NewWriter", Func, 5},
+ {"Reader", Type, 5},
+ {"Writer", Type, 5},
+ {"Writer.Binary", Field, 5},
+ },
+ "net": {
+ {"(*AddrError).Error", Method, 0},
+ {"(*AddrError).Temporary", Method, 0},
+ {"(*AddrError).Timeout", Method, 0},
+ {"(*Buffers).Read", Method, 8},
+ {"(*Buffers).WriteTo", Method, 8},
+ {"(*DNSConfigError).Error", Method, 0},
+ {"(*DNSConfigError).Temporary", Method, 0},
+ {"(*DNSConfigError).Timeout", Method, 0},
+ {"(*DNSConfigError).Unwrap", Method, 13},
+ {"(*DNSError).Error", Method, 0},
+ {"(*DNSError).Temporary", Method, 0},
+ {"(*DNSError).Timeout", Method, 0},
+ {"(*DNSError).Unwrap", Method, 23},
+ {"(*Dialer).Dial", Method, 1},
+ {"(*Dialer).DialContext", Method, 7},
+ {"(*Dialer).MultipathTCP", Method, 21},
+ {"(*Dialer).SetMultipathTCP", Method, 21},
+ {"(*IP).UnmarshalText", Method, 2},
+ {"(*IPAddr).Network", Method, 0},
+ {"(*IPAddr).String", Method, 0},
+ {"(*IPConn).Close", Method, 0},
+ {"(*IPConn).File", Method, 0},
+ {"(*IPConn).LocalAddr", Method, 0},
+ {"(*IPConn).Read", Method, 0},
+ {"(*IPConn).ReadFrom", Method, 0},
+ {"(*IPConn).ReadFromIP", Method, 0},
+ {"(*IPConn).ReadMsgIP", Method, 1},
+ {"(*IPConn).RemoteAddr", Method, 0},
+ {"(*IPConn).SetDeadline", Method, 0},
+ {"(*IPConn).SetReadBuffer", Method, 0},
+ {"(*IPConn).SetReadDeadline", Method, 0},
+ {"(*IPConn).SetWriteBuffer", Method, 0},
+ {"(*IPConn).SetWriteDeadline", Method, 0},
+ {"(*IPConn).SyscallConn", Method, 9},
+ {"(*IPConn).Write", Method, 0},
+ {"(*IPConn).WriteMsgIP", Method, 1},
+ {"(*IPConn).WriteTo", Method, 0},
+ {"(*IPConn).WriteToIP", Method, 0},
+ {"(*IPNet).Contains", Method, 0},
+ {"(*IPNet).Network", Method, 0},
+ {"(*IPNet).String", Method, 0},
+ {"(*Interface).Addrs", Method, 0},
+ {"(*Interface).MulticastAddrs", Method, 0},
+ {"(*ListenConfig).Listen", Method, 11},
+ {"(*ListenConfig).ListenPacket", Method, 11},
+ {"(*ListenConfig).MultipathTCP", Method, 21},
+ {"(*ListenConfig).SetMultipathTCP", Method, 21},
+ {"(*OpError).Error", Method, 0},
+ {"(*OpError).Temporary", Method, 0},
+ {"(*OpError).Timeout", Method, 0},
+ {"(*OpError).Unwrap", Method, 13},
+ {"(*ParseError).Error", Method, 0},
+ {"(*ParseError).Temporary", Method, 17},
+ {"(*ParseError).Timeout", Method, 17},
+ {"(*Resolver).LookupAddr", Method, 8},
+ {"(*Resolver).LookupCNAME", Method, 8},
+ {"(*Resolver).LookupHost", Method, 8},
+ {"(*Resolver).LookupIP", Method, 15},
+ {"(*Resolver).LookupIPAddr", Method, 8},
+ {"(*Resolver).LookupMX", Method, 8},
+ {"(*Resolver).LookupNS", Method, 8},
+ {"(*Resolver).LookupNetIP", Method, 18},
+ {"(*Resolver).LookupPort", Method, 8},
+ {"(*Resolver).LookupSRV", Method, 8},
+ {"(*Resolver).LookupTXT", Method, 8},
+ {"(*TCPAddr).AddrPort", Method, 18},
+ {"(*TCPAddr).Network", Method, 0},
+ {"(*TCPAddr).String", Method, 0},
+ {"(*TCPConn).Close", Method, 0},
+ {"(*TCPConn).CloseRead", Method, 0},
+ {"(*TCPConn).CloseWrite", Method, 0},
+ {"(*TCPConn).File", Method, 0},
+ {"(*TCPConn).LocalAddr", Method, 0},
+ {"(*TCPConn).MultipathTCP", Method, 21},
+ {"(*TCPConn).Read", Method, 0},
+ {"(*TCPConn).ReadFrom", Method, 0},
+ {"(*TCPConn).RemoteAddr", Method, 0},
+ {"(*TCPConn).SetDeadline", Method, 0},
+ {"(*TCPConn).SetKeepAlive", Method, 0},
+ {"(*TCPConn).SetKeepAliveConfig", Method, 23},
+ {"(*TCPConn).SetKeepAlivePeriod", Method, 2},
+ {"(*TCPConn).SetLinger", Method, 0},
+ {"(*TCPConn).SetNoDelay", Method, 0},
+ {"(*TCPConn).SetReadBuffer", Method, 0},
+ {"(*TCPConn).SetReadDeadline", Method, 0},
+ {"(*TCPConn).SetWriteBuffer", Method, 0},
+ {"(*TCPConn).SetWriteDeadline", Method, 0},
+ {"(*TCPConn).SyscallConn", Method, 9},
+ {"(*TCPConn).Write", Method, 0},
+ {"(*TCPConn).WriteTo", Method, 22},
+ {"(*TCPListener).Accept", Method, 0},
+ {"(*TCPListener).AcceptTCP", Method, 0},
+ {"(*TCPListener).Addr", Method, 0},
+ {"(*TCPListener).Close", Method, 0},
+ {"(*TCPListener).File", Method, 0},
+ {"(*TCPListener).SetDeadline", Method, 0},
+ {"(*TCPListener).SyscallConn", Method, 10},
+ {"(*UDPAddr).AddrPort", Method, 18},
+ {"(*UDPAddr).Network", Method, 0},
+ {"(*UDPAddr).String", Method, 0},
+ {"(*UDPConn).Close", Method, 0},
+ {"(*UDPConn).File", Method, 0},
+ {"(*UDPConn).LocalAddr", Method, 0},
+ {"(*UDPConn).Read", Method, 0},
+ {"(*UDPConn).ReadFrom", Method, 0},
+ {"(*UDPConn).ReadFromUDP", Method, 0},
+ {"(*UDPConn).ReadFromUDPAddrPort", Method, 18},
+ {"(*UDPConn).ReadMsgUDP", Method, 1},
+ {"(*UDPConn).ReadMsgUDPAddrPort", Method, 18},
+ {"(*UDPConn).RemoteAddr", Method, 0},
+ {"(*UDPConn).SetDeadline", Method, 0},
+ {"(*UDPConn).SetReadBuffer", Method, 0},
+ {"(*UDPConn).SetReadDeadline", Method, 0},
+ {"(*UDPConn).SetWriteBuffer", Method, 0},
+ {"(*UDPConn).SetWriteDeadline", Method, 0},
+ {"(*UDPConn).SyscallConn", Method, 9},
+ {"(*UDPConn).Write", Method, 0},
+ {"(*UDPConn).WriteMsgUDP", Method, 1},
+ {"(*UDPConn).WriteMsgUDPAddrPort", Method, 18},
+ {"(*UDPConn).WriteTo", Method, 0},
+ {"(*UDPConn).WriteToUDP", Method, 0},
+ {"(*UDPConn).WriteToUDPAddrPort", Method, 18},
+ {"(*UnixAddr).Network", Method, 0},
+ {"(*UnixAddr).String", Method, 0},
+ {"(*UnixConn).Close", Method, 0},
+ {"(*UnixConn).CloseRead", Method, 1},
+ {"(*UnixConn).CloseWrite", Method, 1},
+ {"(*UnixConn).File", Method, 0},
+ {"(*UnixConn).LocalAddr", Method, 0},
+ {"(*UnixConn).Read", Method, 0},
+ {"(*UnixConn).ReadFrom", Method, 0},
+ {"(*UnixConn).ReadFromUnix", Method, 0},
+ {"(*UnixConn).ReadMsgUnix", Method, 0},
+ {"(*UnixConn).RemoteAddr", Method, 0},
+ {"(*UnixConn).SetDeadline", Method, 0},
+ {"(*UnixConn).SetReadBuffer", Method, 0},
+ {"(*UnixConn).SetReadDeadline", Method, 0},
+ {"(*UnixConn).SetWriteBuffer", Method, 0},
+ {"(*UnixConn).SetWriteDeadline", Method, 0},
+ {"(*UnixConn).SyscallConn", Method, 9},
+ {"(*UnixConn).Write", Method, 0},
+ {"(*UnixConn).WriteMsgUnix", Method, 0},
+ {"(*UnixConn).WriteTo", Method, 0},
+ {"(*UnixConn).WriteToUnix", Method, 0},
+ {"(*UnixListener).Accept", Method, 0},
+ {"(*UnixListener).AcceptUnix", Method, 0},
+ {"(*UnixListener).Addr", Method, 0},
+ {"(*UnixListener).Close", Method, 0},
+ {"(*UnixListener).File", Method, 0},
+ {"(*UnixListener).SetDeadline", Method, 0},
+ {"(*UnixListener).SetUnlinkOnClose", Method, 8},
+ {"(*UnixListener).SyscallConn", Method, 10},
+ {"(Flags).String", Method, 0},
+ {"(HardwareAddr).String", Method, 0},
+ {"(IP).DefaultMask", Method, 0},
+ {"(IP).Equal", Method, 0},
+ {"(IP).IsGlobalUnicast", Method, 0},
+ {"(IP).IsInterfaceLocalMulticast", Method, 0},
+ {"(IP).IsLinkLocalMulticast", Method, 0},
+ {"(IP).IsLinkLocalUnicast", Method, 0},
+ {"(IP).IsLoopback", Method, 0},
+ {"(IP).IsMulticast", Method, 0},
+ {"(IP).IsPrivate", Method, 17},
+ {"(IP).IsUnspecified", Method, 0},
+ {"(IP).MarshalText", Method, 2},
+ {"(IP).Mask", Method, 0},
+ {"(IP).String", Method, 0},
+ {"(IP).To16", Method, 0},
+ {"(IP).To4", Method, 0},
+ {"(IPMask).Size", Method, 0},
+ {"(IPMask).String", Method, 0},
+ {"(InvalidAddrError).Error", Method, 0},
+ {"(InvalidAddrError).Temporary", Method, 0},
+ {"(InvalidAddrError).Timeout", Method, 0},
+ {"(UnknownNetworkError).Error", Method, 0},
+ {"(UnknownNetworkError).Temporary", Method, 0},
+ {"(UnknownNetworkError).Timeout", Method, 0},
+ {"Addr", Type, 0},
+ {"AddrError", Type, 0},
+ {"AddrError.Addr", Field, 0},
+ {"AddrError.Err", Field, 0},
+ {"Buffers", Type, 8},
+ {"CIDRMask", Func, 0},
+ {"Conn", Type, 0},
+ {"DNSConfigError", Type, 0},
+ {"DNSConfigError.Err", Field, 0},
+ {"DNSError", Type, 0},
+ {"DNSError.Err", Field, 0},
+ {"DNSError.IsNotFound", Field, 13},
+ {"DNSError.IsTemporary", Field, 6},
+ {"DNSError.IsTimeout", Field, 0},
+ {"DNSError.Name", Field, 0},
+ {"DNSError.Server", Field, 0},
+ {"DNSError.UnwrapErr", Field, 23},
+ {"DefaultResolver", Var, 8},
+ {"Dial", Func, 0},
+ {"DialIP", Func, 0},
+ {"DialTCP", Func, 0},
+ {"DialTimeout", Func, 0},
+ {"DialUDP", Func, 0},
+ {"DialUnix", Func, 0},
+ {"Dialer", Type, 1},
+ {"Dialer.Cancel", Field, 6},
+ {"Dialer.Control", Field, 11},
+ {"Dialer.ControlContext", Field, 20},
+ {"Dialer.Deadline", Field, 1},
+ {"Dialer.DualStack", Field, 2},
+ {"Dialer.FallbackDelay", Field, 5},
+ {"Dialer.KeepAlive", Field, 3},
+ {"Dialer.KeepAliveConfig", Field, 23},
+ {"Dialer.LocalAddr", Field, 1},
+ {"Dialer.Resolver", Field, 8},
+ {"Dialer.Timeout", Field, 1},
+ {"ErrClosed", Var, 16},
+ {"ErrWriteToConnected", Var, 0},
+ {"Error", Type, 0},
+ {"FileConn", Func, 0},
+ {"FileListener", Func, 0},
+ {"FilePacketConn", Func, 0},
+ {"FlagBroadcast", Const, 0},
+ {"FlagLoopback", Const, 0},
+ {"FlagMulticast", Const, 0},
+ {"FlagPointToPoint", Const, 0},
+ {"FlagRunning", Const, 20},
+ {"FlagUp", Const, 0},
+ {"Flags", Type, 0},
+ {"HardwareAddr", Type, 0},
+ {"IP", Type, 0},
+ {"IPAddr", Type, 0},
+ {"IPAddr.IP", Field, 0},
+ {"IPAddr.Zone", Field, 1},
+ {"IPConn", Type, 0},
+ {"IPMask", Type, 0},
+ {"IPNet", Type, 0},
+ {"IPNet.IP", Field, 0},
+ {"IPNet.Mask", Field, 0},
+ {"IPv4", Func, 0},
+ {"IPv4Mask", Func, 0},
+ {"IPv4allrouter", Var, 0},
+ {"IPv4allsys", Var, 0},
+ {"IPv4bcast", Var, 0},
+ {"IPv4len", Const, 0},
+ {"IPv4zero", Var, 0},
+ {"IPv6interfacelocalallnodes", Var, 0},
+ {"IPv6len", Const, 0},
+ {"IPv6linklocalallnodes", Var, 0},
+ {"IPv6linklocalallrouters", Var, 0},
+ {"IPv6loopback", Var, 0},
+ {"IPv6unspecified", Var, 0},
+ {"IPv6zero", Var, 0},
+ {"Interface", Type, 0},
+ {"Interface.Flags", Field, 0},
+ {"Interface.HardwareAddr", Field, 0},
+ {"Interface.Index", Field, 0},
+ {"Interface.MTU", Field, 0},
+ {"Interface.Name", Field, 0},
+ {"InterfaceAddrs", Func, 0},
+ {"InterfaceByIndex", Func, 0},
+ {"InterfaceByName", Func, 0},
+ {"Interfaces", Func, 0},
+ {"InvalidAddrError", Type, 0},
+ {"JoinHostPort", Func, 0},
+ {"KeepAliveConfig", Type, 23},
+ {"KeepAliveConfig.Count", Field, 23},
+ {"KeepAliveConfig.Enable", Field, 23},
+ {"KeepAliveConfig.Idle", Field, 23},
+ {"KeepAliveConfig.Interval", Field, 23},
+ {"Listen", Func, 0},
+ {"ListenConfig", Type, 11},
+ {"ListenConfig.Control", Field, 11},
+ {"ListenConfig.KeepAlive", Field, 13},
+ {"ListenConfig.KeepAliveConfig", Field, 23},
+ {"ListenIP", Func, 0},
+ {"ListenMulticastUDP", Func, 0},
+ {"ListenPacket", Func, 0},
+ {"ListenTCP", Func, 0},
+ {"ListenUDP", Func, 0},
+ {"ListenUnix", Func, 0},
+ {"ListenUnixgram", Func, 0},
+ {"Listener", Type, 0},
+ {"LookupAddr", Func, 0},
+ {"LookupCNAME", Func, 0},
+ {"LookupHost", Func, 0},
+ {"LookupIP", Func, 0},
+ {"LookupMX", Func, 0},
+ {"LookupNS", Func, 1},
+ {"LookupPort", Func, 0},
+ {"LookupSRV", Func, 0},
+ {"LookupTXT", Func, 0},
+ {"MX", Type, 0},
+ {"MX.Host", Field, 0},
+ {"MX.Pref", Field, 0},
+ {"NS", Type, 1},
+ {"NS.Host", Field, 1},
+ {"OpError", Type, 0},
+ {"OpError.Addr", Field, 0},
+ {"OpError.Err", Field, 0},
+ {"OpError.Net", Field, 0},
+ {"OpError.Op", Field, 0},
+ {"OpError.Source", Field, 5},
+ {"PacketConn", Type, 0},
+ {"ParseCIDR", Func, 0},
+ {"ParseError", Type, 0},
+ {"ParseError.Text", Field, 0},
+ {"ParseError.Type", Field, 0},
+ {"ParseIP", Func, 0},
+ {"ParseMAC", Func, 0},
+ {"Pipe", Func, 0},
+ {"ResolveIPAddr", Func, 0},
+ {"ResolveTCPAddr", Func, 0},
+ {"ResolveUDPAddr", Func, 0},
+ {"ResolveUnixAddr", Func, 0},
+ {"Resolver", Type, 8},
+ {"Resolver.Dial", Field, 9},
+ {"Resolver.PreferGo", Field, 8},
+ {"Resolver.StrictErrors", Field, 9},
+ {"SRV", Type, 0},
+ {"SRV.Port", Field, 0},
+ {"SRV.Priority", Field, 0},
+ {"SRV.Target", Field, 0},
+ {"SRV.Weight", Field, 0},
+ {"SplitHostPort", Func, 0},
+ {"TCPAddr", Type, 0},
+ {"TCPAddr.IP", Field, 0},
+ {"TCPAddr.Port", Field, 0},
+ {"TCPAddr.Zone", Field, 1},
+ {"TCPAddrFromAddrPort", Func, 18},
+ {"TCPConn", Type, 0},
+ {"TCPListener", Type, 0},
+ {"UDPAddr", Type, 0},
+ {"UDPAddr.IP", Field, 0},
+ {"UDPAddr.Port", Field, 0},
+ {"UDPAddr.Zone", Field, 1},
+ {"UDPAddrFromAddrPort", Func, 18},
+ {"UDPConn", Type, 0},
+ {"UnixAddr", Type, 0},
+ {"UnixAddr.Name", Field, 0},
+ {"UnixAddr.Net", Field, 0},
+ {"UnixConn", Type, 0},
+ {"UnixListener", Type, 0},
+ {"UnknownNetworkError", Type, 0},
+ },
+ "net/http": {
+ {"(*Client).CloseIdleConnections", Method, 12},
+ {"(*Client).Do", Method, 0},
+ {"(*Client).Get", Method, 0},
+ {"(*Client).Head", Method, 0},
+ {"(*Client).Post", Method, 0},
+ {"(*Client).PostForm", Method, 0},
+ {"(*Cookie).String", Method, 0},
+ {"(*Cookie).Valid", Method, 18},
+ {"(*MaxBytesError).Error", Method, 19},
+ {"(*ProtocolError).Error", Method, 0},
+ {"(*ProtocolError).Is", Method, 21},
+ {"(*Request).AddCookie", Method, 0},
+ {"(*Request).BasicAuth", Method, 4},
+ {"(*Request).Clone", Method, 13},
+ {"(*Request).Context", Method, 7},
+ {"(*Request).Cookie", Method, 0},
+ {"(*Request).Cookies", Method, 0},
+ {"(*Request).CookiesNamed", Method, 23},
+ {"(*Request).FormFile", Method, 0},
+ {"(*Request).FormValue", Method, 0},
+ {"(*Request).MultipartReader", Method, 0},
+ {"(*Request).ParseForm", Method, 0},
+ {"(*Request).ParseMultipartForm", Method, 0},
+ {"(*Request).PathValue", Method, 22},
+ {"(*Request).PostFormValue", Method, 1},
+ {"(*Request).ProtoAtLeast", Method, 0},
+ {"(*Request).Referer", Method, 0},
+ {"(*Request).SetBasicAuth", Method, 0},
+ {"(*Request).SetPathValue", Method, 22},
+ {"(*Request).UserAgent", Method, 0},
+ {"(*Request).WithContext", Method, 7},
+ {"(*Request).Write", Method, 0},
+ {"(*Request).WriteProxy", Method, 0},
+ {"(*Response).Cookies", Method, 0},
+ {"(*Response).Location", Method, 0},
+ {"(*Response).ProtoAtLeast", Method, 0},
+ {"(*Response).Write", Method, 0},
+ {"(*ResponseController).EnableFullDuplex", Method, 21},
+ {"(*ResponseController).Flush", Method, 20},
+ {"(*ResponseController).Hijack", Method, 20},
+ {"(*ResponseController).SetReadDeadline", Method, 20},
+ {"(*ResponseController).SetWriteDeadline", Method, 20},
+ {"(*ServeMux).Handle", Method, 0},
+ {"(*ServeMux).HandleFunc", Method, 0},
+ {"(*ServeMux).Handler", Method, 1},
+ {"(*ServeMux).ServeHTTP", Method, 0},
+ {"(*Server).Close", Method, 8},
+ {"(*Server).ListenAndServe", Method, 0},
+ {"(*Server).ListenAndServeTLS", Method, 0},
+ {"(*Server).RegisterOnShutdown", Method, 9},
+ {"(*Server).Serve", Method, 0},
+ {"(*Server).ServeTLS", Method, 9},
+ {"(*Server).SetKeepAlivesEnabled", Method, 3},
+ {"(*Server).Shutdown", Method, 8},
+ {"(*Transport).CancelRequest", Method, 1},
+ {"(*Transport).Clone", Method, 13},
+ {"(*Transport).CloseIdleConnections", Method, 0},
+ {"(*Transport).RegisterProtocol", Method, 0},
+ {"(*Transport).RoundTrip", Method, 0},
+ {"(ConnState).String", Method, 3},
+ {"(Dir).Open", Method, 0},
+ {"(HandlerFunc).ServeHTTP", Method, 0},
+ {"(Header).Add", Method, 0},
+ {"(Header).Clone", Method, 13},
+ {"(Header).Del", Method, 0},
+ {"(Header).Get", Method, 0},
+ {"(Header).Set", Method, 0},
+ {"(Header).Values", Method, 14},
+ {"(Header).Write", Method, 0},
+ {"(Header).WriteSubset", Method, 0},
+ {"AllowQuerySemicolons", Func, 17},
+ {"CanonicalHeaderKey", Func, 0},
+ {"Client", Type, 0},
+ {"Client.CheckRedirect", Field, 0},
+ {"Client.Jar", Field, 0},
+ {"Client.Timeout", Field, 3},
+ {"Client.Transport", Field, 0},
+ {"CloseNotifier", Type, 1},
+ {"ConnState", Type, 3},
+ {"Cookie", Type, 0},
+ {"Cookie.Domain", Field, 0},
+ {"Cookie.Expires", Field, 0},
+ {"Cookie.HttpOnly", Field, 0},
+ {"Cookie.MaxAge", Field, 0},
+ {"Cookie.Name", Field, 0},
+ {"Cookie.Partitioned", Field, 23},
+ {"Cookie.Path", Field, 0},
+ {"Cookie.Quoted", Field, 23},
+ {"Cookie.Raw", Field, 0},
+ {"Cookie.RawExpires", Field, 0},
+ {"Cookie.SameSite", Field, 11},
+ {"Cookie.Secure", Field, 0},
+ {"Cookie.Unparsed", Field, 0},
+ {"Cookie.Value", Field, 0},
+ {"CookieJar", Type, 0},
+ {"DefaultClient", Var, 0},
+ {"DefaultMaxHeaderBytes", Const, 0},
+ {"DefaultMaxIdleConnsPerHost", Const, 0},
+ {"DefaultServeMux", Var, 0},
+ {"DefaultTransport", Var, 0},
+ {"DetectContentType", Func, 0},
+ {"Dir", Type, 0},
+ {"ErrAbortHandler", Var, 8},
+ {"ErrBodyNotAllowed", Var, 0},
+ {"ErrBodyReadAfterClose", Var, 0},
+ {"ErrContentLength", Var, 0},
+ {"ErrHandlerTimeout", Var, 0},
+ {"ErrHeaderTooLong", Var, 0},
+ {"ErrHijacked", Var, 0},
+ {"ErrLineTooLong", Var, 0},
+ {"ErrMissingBoundary", Var, 0},
+ {"ErrMissingContentLength", Var, 0},
+ {"ErrMissingFile", Var, 0},
+ {"ErrNoCookie", Var, 0},
+ {"ErrNoLocation", Var, 0},
+ {"ErrNotMultipart", Var, 0},
+ {"ErrNotSupported", Var, 0},
+ {"ErrSchemeMismatch", Var, 21},
+ {"ErrServerClosed", Var, 8},
+ {"ErrShortBody", Var, 0},
+ {"ErrSkipAltProtocol", Var, 6},
+ {"ErrUnexpectedTrailer", Var, 0},
+ {"ErrUseLastResponse", Var, 7},
+ {"ErrWriteAfterFlush", Var, 0},
+ {"Error", Func, 0},
+ {"FS", Func, 16},
+ {"File", Type, 0},
+ {"FileServer", Func, 0},
+ {"FileServerFS", Func, 22},
+ {"FileSystem", Type, 0},
+ {"Flusher", Type, 0},
+ {"Get", Func, 0},
+ {"Handle", Func, 0},
+ {"HandleFunc", Func, 0},
+ {"Handler", Type, 0},
+ {"HandlerFunc", Type, 0},
+ {"Head", Func, 0},
+ {"Header", Type, 0},
+ {"Hijacker", Type, 0},
+ {"ListenAndServe", Func, 0},
+ {"ListenAndServeTLS", Func, 0},
+ {"LocalAddrContextKey", Var, 7},
+ {"MaxBytesError", Type, 19},
+ {"MaxBytesError.Limit", Field, 19},
+ {"MaxBytesHandler", Func, 18},
+ {"MaxBytesReader", Func, 0},
+ {"MethodConnect", Const, 6},
+ {"MethodDelete", Const, 6},
+ {"MethodGet", Const, 6},
+ {"MethodHead", Const, 6},
+ {"MethodOptions", Const, 6},
+ {"MethodPatch", Const, 6},
+ {"MethodPost", Const, 6},
+ {"MethodPut", Const, 6},
+ {"MethodTrace", Const, 6},
+ {"NewFileTransport", Func, 0},
+ {"NewFileTransportFS", Func, 22},
+ {"NewRequest", Func, 0},
+ {"NewRequestWithContext", Func, 13},
+ {"NewResponseController", Func, 20},
+ {"NewServeMux", Func, 0},
+ {"NoBody", Var, 8},
+ {"NotFound", Func, 0},
+ {"NotFoundHandler", Func, 0},
+ {"ParseCookie", Func, 23},
+ {"ParseHTTPVersion", Func, 0},
+ {"ParseSetCookie", Func, 23},
+ {"ParseTime", Func, 1},
+ {"Post", Func, 0},
+ {"PostForm", Func, 0},
+ {"ProtocolError", Type, 0},
+ {"ProtocolError.ErrorString", Field, 0},
+ {"ProxyFromEnvironment", Func, 0},
+ {"ProxyURL", Func, 0},
+ {"PushOptions", Type, 8},
+ {"PushOptions.Header", Field, 8},
+ {"PushOptions.Method", Field, 8},
+ {"Pusher", Type, 8},
+ {"ReadRequest", Func, 0},
+ {"ReadResponse", Func, 0},
+ {"Redirect", Func, 0},
+ {"RedirectHandler", Func, 0},
+ {"Request", Type, 0},
+ {"Request.Body", Field, 0},
+ {"Request.Cancel", Field, 5},
+ {"Request.Close", Field, 0},
+ {"Request.ContentLength", Field, 0},
+ {"Request.Form", Field, 0},
+ {"Request.GetBody", Field, 8},
+ {"Request.Header", Field, 0},
+ {"Request.Host", Field, 0},
+ {"Request.Method", Field, 0},
+ {"Request.MultipartForm", Field, 0},
+ {"Request.Pattern", Field, 23},
+ {"Request.PostForm", Field, 1},
+ {"Request.Proto", Field, 0},
+ {"Request.ProtoMajor", Field, 0},
+ {"Request.ProtoMinor", Field, 0},
+ {"Request.RemoteAddr", Field, 0},
+ {"Request.RequestURI", Field, 0},
+ {"Request.Response", Field, 7},
+ {"Request.TLS", Field, 0},
+ {"Request.Trailer", Field, 0},
+ {"Request.TransferEncoding", Field, 0},
+ {"Request.URL", Field, 0},
+ {"Response", Type, 0},
+ {"Response.Body", Field, 0},
+ {"Response.Close", Field, 0},
+ {"Response.ContentLength", Field, 0},
+ {"Response.Header", Field, 0},
+ {"Response.Proto", Field, 0},
+ {"Response.ProtoMajor", Field, 0},
+ {"Response.ProtoMinor", Field, 0},
+ {"Response.Request", Field, 0},
+ {"Response.Status", Field, 0},
+ {"Response.StatusCode", Field, 0},
+ {"Response.TLS", Field, 3},
+ {"Response.Trailer", Field, 0},
+ {"Response.TransferEncoding", Field, 0},
+ {"Response.Uncompressed", Field, 7},
+ {"ResponseController", Type, 20},
+ {"ResponseWriter", Type, 0},
+ {"RoundTripper", Type, 0},
+ {"SameSite", Type, 11},
+ {"SameSiteDefaultMode", Const, 11},
+ {"SameSiteLaxMode", Const, 11},
+ {"SameSiteNoneMode", Const, 13},
+ {"SameSiteStrictMode", Const, 11},
+ {"Serve", Func, 0},
+ {"ServeContent", Func, 0},
+ {"ServeFile", Func, 0},
+ {"ServeFileFS", Func, 22},
+ {"ServeMux", Type, 0},
+ {"ServeTLS", Func, 9},
+ {"Server", Type, 0},
+ {"Server.Addr", Field, 0},
+ {"Server.BaseContext", Field, 13},
+ {"Server.ConnContext", Field, 13},
+ {"Server.ConnState", Field, 3},
+ {"Server.DisableGeneralOptionsHandler", Field, 20},
+ {"Server.ErrorLog", Field, 3},
+ {"Server.Handler", Field, 0},
+ {"Server.IdleTimeout", Field, 8},
+ {"Server.MaxHeaderBytes", Field, 0},
+ {"Server.ReadHeaderTimeout", Field, 8},
+ {"Server.ReadTimeout", Field, 0},
+ {"Server.TLSConfig", Field, 0},
+ {"Server.TLSNextProto", Field, 1},
+ {"Server.WriteTimeout", Field, 0},
+ {"ServerContextKey", Var, 7},
+ {"SetCookie", Func, 0},
+ {"StateActive", Const, 3},
+ {"StateClosed", Const, 3},
+ {"StateHijacked", Const, 3},
+ {"StateIdle", Const, 3},
+ {"StateNew", Const, 3},
+ {"StatusAccepted", Const, 0},
+ {"StatusAlreadyReported", Const, 7},
+ {"StatusBadGateway", Const, 0},
+ {"StatusBadRequest", Const, 0},
+ {"StatusConflict", Const, 0},
+ {"StatusContinue", Const, 0},
+ {"StatusCreated", Const, 0},
+ {"StatusEarlyHints", Const, 13},
+ {"StatusExpectationFailed", Const, 0},
+ {"StatusFailedDependency", Const, 7},
+ {"StatusForbidden", Const, 0},
+ {"StatusFound", Const, 0},
+ {"StatusGatewayTimeout", Const, 0},
+ {"StatusGone", Const, 0},
+ {"StatusHTTPVersionNotSupported", Const, 0},
+ {"StatusIMUsed", Const, 7},
+ {"StatusInsufficientStorage", Const, 7},
+ {"StatusInternalServerError", Const, 0},
+ {"StatusLengthRequired", Const, 0},
+ {"StatusLocked", Const, 7},
+ {"StatusLoopDetected", Const, 7},
+ {"StatusMethodNotAllowed", Const, 0},
+ {"StatusMisdirectedRequest", Const, 11},
+ {"StatusMovedPermanently", Const, 0},
+ {"StatusMultiStatus", Const, 7},
+ {"StatusMultipleChoices", Const, 0},
+ {"StatusNetworkAuthenticationRequired", Const, 6},
+ {"StatusNoContent", Const, 0},
+ {"StatusNonAuthoritativeInfo", Const, 0},
+ {"StatusNotAcceptable", Const, 0},
+ {"StatusNotExtended", Const, 7},
+ {"StatusNotFound", Const, 0},
+ {"StatusNotImplemented", Const, 0},
+ {"StatusNotModified", Const, 0},
+ {"StatusOK", Const, 0},
+ {"StatusPartialContent", Const, 0},
+ {"StatusPaymentRequired", Const, 0},
+ {"StatusPermanentRedirect", Const, 7},
+ {"StatusPreconditionFailed", Const, 0},
+ {"StatusPreconditionRequired", Const, 6},
+ {"StatusProcessing", Const, 7},
+ {"StatusProxyAuthRequired", Const, 0},
+ {"StatusRequestEntityTooLarge", Const, 0},
+ {"StatusRequestHeaderFieldsTooLarge", Const, 6},
+ {"StatusRequestTimeout", Const, 0},
+ {"StatusRequestURITooLong", Const, 0},
+ {"StatusRequestedRangeNotSatisfiable", Const, 0},
+ {"StatusResetContent", Const, 0},
+ {"StatusSeeOther", Const, 0},
+ {"StatusServiceUnavailable", Const, 0},
+ {"StatusSwitchingProtocols", Const, 0},
+ {"StatusTeapot", Const, 0},
+ {"StatusTemporaryRedirect", Const, 0},
+ {"StatusText", Func, 0},
+ {"StatusTooEarly", Const, 12},
+ {"StatusTooManyRequests", Const, 6},
+ {"StatusUnauthorized", Const, 0},
+ {"StatusUnavailableForLegalReasons", Const, 6},
+ {"StatusUnprocessableEntity", Const, 7},
+ {"StatusUnsupportedMediaType", Const, 0},
+ {"StatusUpgradeRequired", Const, 7},
+ {"StatusUseProxy", Const, 0},
+ {"StatusVariantAlsoNegotiates", Const, 7},
+ {"StripPrefix", Func, 0},
+ {"TimeFormat", Const, 0},
+ {"TimeoutHandler", Func, 0},
+ {"TrailerPrefix", Const, 8},
+ {"Transport", Type, 0},
+ {"Transport.Dial", Field, 0},
+ {"Transport.DialContext", Field, 7},
+ {"Transport.DialTLS", Field, 4},
+ {"Transport.DialTLSContext", Field, 14},
+ {"Transport.DisableCompression", Field, 0},
+ {"Transport.DisableKeepAlives", Field, 0},
+ {"Transport.ExpectContinueTimeout", Field, 6},
+ {"Transport.ForceAttemptHTTP2", Field, 13},
+ {"Transport.GetProxyConnectHeader", Field, 16},
+ {"Transport.IdleConnTimeout", Field, 7},
+ {"Transport.MaxConnsPerHost", Field, 11},
+ {"Transport.MaxIdleConns", Field, 7},
+ {"Transport.MaxIdleConnsPerHost", Field, 0},
+ {"Transport.MaxResponseHeaderBytes", Field, 7},
+ {"Transport.OnProxyConnectResponse", Field, 20},
+ {"Transport.Proxy", Field, 0},
+ {"Transport.ProxyConnectHeader", Field, 8},
+ {"Transport.ReadBufferSize", Field, 13},
+ {"Transport.ResponseHeaderTimeout", Field, 1},
+ {"Transport.TLSClientConfig", Field, 0},
+ {"Transport.TLSHandshakeTimeout", Field, 3},
+ {"Transport.TLSNextProto", Field, 6},
+ {"Transport.WriteBufferSize", Field, 13},
+ },
+ "net/http/cgi": {
+ {"(*Handler).ServeHTTP", Method, 0},
+ {"Handler", Type, 0},
+ {"Handler.Args", Field, 0},
+ {"Handler.Dir", Field, 0},
+ {"Handler.Env", Field, 0},
+ {"Handler.InheritEnv", Field, 0},
+ {"Handler.Logger", Field, 0},
+ {"Handler.Path", Field, 0},
+ {"Handler.PathLocationHandler", Field, 0},
+ {"Handler.Root", Field, 0},
+ {"Handler.Stderr", Field, 7},
+ {"Request", Func, 0},
+ {"RequestFromMap", Func, 0},
+ {"Serve", Func, 0},
+ },
+ "net/http/cookiejar": {
+ {"(*Jar).Cookies", Method, 1},
+ {"(*Jar).SetCookies", Method, 1},
+ {"Jar", Type, 1},
+ {"New", Func, 1},
+ {"Options", Type, 1},
+ {"Options.PublicSuffixList", Field, 1},
+ {"PublicSuffixList", Type, 1},
+ },
+ "net/http/fcgi": {
+ {"ErrConnClosed", Var, 5},
+ {"ErrRequestAborted", Var, 5},
+ {"ProcessEnv", Func, 9},
+ {"Serve", Func, 0},
+ },
+ "net/http/httptest": {
+ {"(*ResponseRecorder).Flush", Method, 0},
+ {"(*ResponseRecorder).Header", Method, 0},
+ {"(*ResponseRecorder).Result", Method, 7},
+ {"(*ResponseRecorder).Write", Method, 0},
+ {"(*ResponseRecorder).WriteHeader", Method, 0},
+ {"(*ResponseRecorder).WriteString", Method, 6},
+ {"(*Server).Certificate", Method, 9},
+ {"(*Server).Client", Method, 9},
+ {"(*Server).Close", Method, 0},
+ {"(*Server).CloseClientConnections", Method, 0},
+ {"(*Server).Start", Method, 0},
+ {"(*Server).StartTLS", Method, 0},
+ {"DefaultRemoteAddr", Const, 0},
+ {"NewRecorder", Func, 0},
+ {"NewRequest", Func, 7},
+ {"NewRequestWithContext", Func, 23},
+ {"NewServer", Func, 0},
+ {"NewTLSServer", Func, 0},
+ {"NewUnstartedServer", Func, 0},
+ {"ResponseRecorder", Type, 0},
+ {"ResponseRecorder.Body", Field, 0},
+ {"ResponseRecorder.Code", Field, 0},
+ {"ResponseRecorder.Flushed", Field, 0},
+ {"ResponseRecorder.HeaderMap", Field, 0},
+ {"Server", Type, 0},
+ {"Server.Config", Field, 0},
+ {"Server.EnableHTTP2", Field, 14},
+ {"Server.Listener", Field, 0},
+ {"Server.TLS", Field, 0},
+ {"Server.URL", Field, 0},
+ },
+ "net/http/httptrace": {
+ {"ClientTrace", Type, 7},
+ {"ClientTrace.ConnectDone", Field, 7},
+ {"ClientTrace.ConnectStart", Field, 7},
+ {"ClientTrace.DNSDone", Field, 7},
+ {"ClientTrace.DNSStart", Field, 7},
+ {"ClientTrace.GetConn", Field, 7},
+ {"ClientTrace.Got100Continue", Field, 7},
+ {"ClientTrace.Got1xxResponse", Field, 11},
+ {"ClientTrace.GotConn", Field, 7},
+ {"ClientTrace.GotFirstResponseByte", Field, 7},
+ {"ClientTrace.PutIdleConn", Field, 7},
+ {"ClientTrace.TLSHandshakeDone", Field, 8},
+ {"ClientTrace.TLSHandshakeStart", Field, 8},
+ {"ClientTrace.Wait100Continue", Field, 7},
+ {"ClientTrace.WroteHeaderField", Field, 11},
+ {"ClientTrace.WroteHeaders", Field, 7},
+ {"ClientTrace.WroteRequest", Field, 7},
+ {"ContextClientTrace", Func, 7},
+ {"DNSDoneInfo", Type, 7},
+ {"DNSDoneInfo.Addrs", Field, 7},
+ {"DNSDoneInfo.Coalesced", Field, 7},
+ {"DNSDoneInfo.Err", Field, 7},
+ {"DNSStartInfo", Type, 7},
+ {"DNSStartInfo.Host", Field, 7},
+ {"GotConnInfo", Type, 7},
+ {"GotConnInfo.Conn", Field, 7},
+ {"GotConnInfo.IdleTime", Field, 7},
+ {"GotConnInfo.Reused", Field, 7},
+ {"GotConnInfo.WasIdle", Field, 7},
+ {"WithClientTrace", Func, 7},
+ {"WroteRequestInfo", Type, 7},
+ {"WroteRequestInfo.Err", Field, 7},
+ },
+ "net/http/httputil": {
+ {"(*ClientConn).Close", Method, 0},
+ {"(*ClientConn).Do", Method, 0},
+ {"(*ClientConn).Hijack", Method, 0},
+ {"(*ClientConn).Pending", Method, 0},
+ {"(*ClientConn).Read", Method, 0},
+ {"(*ClientConn).Write", Method, 0},
+ {"(*ProxyRequest).SetURL", Method, 20},
+ {"(*ProxyRequest).SetXForwarded", Method, 20},
+ {"(*ReverseProxy).ServeHTTP", Method, 0},
+ {"(*ServerConn).Close", Method, 0},
+ {"(*ServerConn).Hijack", Method, 0},
+ {"(*ServerConn).Pending", Method, 0},
+ {"(*ServerConn).Read", Method, 0},
+ {"(*ServerConn).Write", Method, 0},
+ {"BufferPool", Type, 6},
+ {"ClientConn", Type, 0},
+ {"DumpRequest", Func, 0},
+ {"DumpRequestOut", Func, 0},
+ {"DumpResponse", Func, 0},
+ {"ErrClosed", Var, 0},
+ {"ErrLineTooLong", Var, 0},
+ {"ErrPersistEOF", Var, 0},
+ {"ErrPipeline", Var, 0},
+ {"NewChunkedReader", Func, 0},
+ {"NewChunkedWriter", Func, 0},
+ {"NewClientConn", Func, 0},
+ {"NewProxyClientConn", Func, 0},
+ {"NewServerConn", Func, 0},
+ {"NewSingleHostReverseProxy", Func, 0},
+ {"ProxyRequest", Type, 20},
+ {"ProxyRequest.In", Field, 20},
+ {"ProxyRequest.Out", Field, 20},
+ {"ReverseProxy", Type, 0},
+ {"ReverseProxy.BufferPool", Field, 6},
+ {"ReverseProxy.Director", Field, 0},
+ {"ReverseProxy.ErrorHandler", Field, 11},
+ {"ReverseProxy.ErrorLog", Field, 4},
+ {"ReverseProxy.FlushInterval", Field, 0},
+ {"ReverseProxy.ModifyResponse", Field, 8},
+ {"ReverseProxy.Rewrite", Field, 20},
+ {"ReverseProxy.Transport", Field, 0},
+ {"ServerConn", Type, 0},
+ },
+ "net/http/pprof": {
+ {"Cmdline", Func, 0},
+ {"Handler", Func, 0},
+ {"Index", Func, 0},
+ {"Profile", Func, 0},
+ {"Symbol", Func, 0},
+ {"Trace", Func, 5},
+ },
+ "net/mail": {
+ {"(*Address).String", Method, 0},
+ {"(*AddressParser).Parse", Method, 5},
+ {"(*AddressParser).ParseList", Method, 5},
+ {"(Header).AddressList", Method, 0},
+ {"(Header).Date", Method, 0},
+ {"(Header).Get", Method, 0},
+ {"Address", Type, 0},
+ {"Address.Address", Field, 0},
+ {"Address.Name", Field, 0},
+ {"AddressParser", Type, 5},
+ {"AddressParser.WordDecoder", Field, 5},
+ {"ErrHeaderNotPresent", Var, 0},
+ {"Header", Type, 0},
+ {"Message", Type, 0},
+ {"Message.Body", Field, 0},
+ {"Message.Header", Field, 0},
+ {"ParseAddress", Func, 1},
+ {"ParseAddressList", Func, 1},
+ {"ParseDate", Func, 8},
+ {"ReadMessage", Func, 0},
+ },
+ "net/netip": {
+ {"(*Addr).UnmarshalBinary", Method, 18},
+ {"(*Addr).UnmarshalText", Method, 18},
+ {"(*AddrPort).UnmarshalBinary", Method, 18},
+ {"(*AddrPort).UnmarshalText", Method, 18},
+ {"(*Prefix).UnmarshalBinary", Method, 18},
+ {"(*Prefix).UnmarshalText", Method, 18},
+ {"(Addr).AppendTo", Method, 18},
+ {"(Addr).As16", Method, 18},
+ {"(Addr).As4", Method, 18},
+ {"(Addr).AsSlice", Method, 18},
+ {"(Addr).BitLen", Method, 18},
+ {"(Addr).Compare", Method, 18},
+ {"(Addr).Is4", Method, 18},
+ {"(Addr).Is4In6", Method, 18},
+ {"(Addr).Is6", Method, 18},
+ {"(Addr).IsGlobalUnicast", Method, 18},
+ {"(Addr).IsInterfaceLocalMulticast", Method, 18},
+ {"(Addr).IsLinkLocalMulticast", Method, 18},
+ {"(Addr).IsLinkLocalUnicast", Method, 18},
+ {"(Addr).IsLoopback", Method, 18},
+ {"(Addr).IsMulticast", Method, 18},
+ {"(Addr).IsPrivate", Method, 18},
+ {"(Addr).IsUnspecified", Method, 18},
+ {"(Addr).IsValid", Method, 18},
+ {"(Addr).Less", Method, 18},
+ {"(Addr).MarshalBinary", Method, 18},
+ {"(Addr).MarshalText", Method, 18},
+ {"(Addr).Next", Method, 18},
+ {"(Addr).Prefix", Method, 18},
+ {"(Addr).Prev", Method, 18},
+ {"(Addr).String", Method, 18},
+ {"(Addr).StringExpanded", Method, 18},
+ {"(Addr).Unmap", Method, 18},
+ {"(Addr).WithZone", Method, 18},
+ {"(Addr).Zone", Method, 18},
+ {"(AddrPort).Addr", Method, 18},
+ {"(AddrPort).AppendTo", Method, 18},
+ {"(AddrPort).Compare", Method, 22},
+ {"(AddrPort).IsValid", Method, 18},
+ {"(AddrPort).MarshalBinary", Method, 18},
+ {"(AddrPort).MarshalText", Method, 18},
+ {"(AddrPort).Port", Method, 18},
+ {"(AddrPort).String", Method, 18},
+ {"(Prefix).Addr", Method, 18},
+ {"(Prefix).AppendTo", Method, 18},
+ {"(Prefix).Bits", Method, 18},
+ {"(Prefix).Contains", Method, 18},
+ {"(Prefix).IsSingleIP", Method, 18},
+ {"(Prefix).IsValid", Method, 18},
+ {"(Prefix).MarshalBinary", Method, 18},
+ {"(Prefix).MarshalText", Method, 18},
+ {"(Prefix).Masked", Method, 18},
+ {"(Prefix).Overlaps", Method, 18},
+ {"(Prefix).String", Method, 18},
+ {"Addr", Type, 18},
+ {"AddrFrom16", Func, 18},
+ {"AddrFrom4", Func, 18},
+ {"AddrFromSlice", Func, 18},
+ {"AddrPort", Type, 18},
+ {"AddrPortFrom", Func, 18},
+ {"IPv4Unspecified", Func, 18},
+ {"IPv6LinkLocalAllNodes", Func, 18},
+ {"IPv6LinkLocalAllRouters", Func, 20},
+ {"IPv6Loopback", Func, 20},
+ {"IPv6Unspecified", Func, 18},
+ {"MustParseAddr", Func, 18},
+ {"MustParseAddrPort", Func, 18},
+ {"MustParsePrefix", Func, 18},
+ {"ParseAddr", Func, 18},
+ {"ParseAddrPort", Func, 18},
+ {"ParsePrefix", Func, 18},
+ {"Prefix", Type, 18},
+ {"PrefixFrom", Func, 18},
+ },
+ "net/rpc": {
+ {"(*Client).Call", Method, 0},
+ {"(*Client).Close", Method, 0},
+ {"(*Client).Go", Method, 0},
+ {"(*Server).Accept", Method, 0},
+ {"(*Server).HandleHTTP", Method, 0},
+ {"(*Server).Register", Method, 0},
+ {"(*Server).RegisterName", Method, 0},
+ {"(*Server).ServeCodec", Method, 0},
+ {"(*Server).ServeConn", Method, 0},
+ {"(*Server).ServeHTTP", Method, 0},
+ {"(*Server).ServeRequest", Method, 0},
+ {"(ServerError).Error", Method, 0},
+ {"Accept", Func, 0},
+ {"Call", Type, 0},
+ {"Call.Args", Field, 0},
+ {"Call.Done", Field, 0},
+ {"Call.Error", Field, 0},
+ {"Call.Reply", Field, 0},
+ {"Call.ServiceMethod", Field, 0},
+ {"Client", Type, 0},
+ {"ClientCodec", Type, 0},
+ {"DefaultDebugPath", Const, 0},
+ {"DefaultRPCPath", Const, 0},
+ {"DefaultServer", Var, 0},
+ {"Dial", Func, 0},
+ {"DialHTTP", Func, 0},
+ {"DialHTTPPath", Func, 0},
+ {"ErrShutdown", Var, 0},
+ {"HandleHTTP", Func, 0},
+ {"NewClient", Func, 0},
+ {"NewClientWithCodec", Func, 0},
+ {"NewServer", Func, 0},
+ {"Register", Func, 0},
+ {"RegisterName", Func, 0},
+ {"Request", Type, 0},
+ {"Request.Seq", Field, 0},
+ {"Request.ServiceMethod", Field, 0},
+ {"Response", Type, 0},
+ {"Response.Error", Field, 0},
+ {"Response.Seq", Field, 0},
+ {"Response.ServiceMethod", Field, 0},
+ {"ServeCodec", Func, 0},
+ {"ServeConn", Func, 0},
+ {"ServeRequest", Func, 0},
+ {"Server", Type, 0},
+ {"ServerCodec", Type, 0},
+ {"ServerError", Type, 0},
+ },
+ "net/rpc/jsonrpc": {
+ {"Dial", Func, 0},
+ {"NewClient", Func, 0},
+ {"NewClientCodec", Func, 0},
+ {"NewServerCodec", Func, 0},
+ {"ServeConn", Func, 0},
+ },
+ "net/smtp": {
+ {"(*Client).Auth", Method, 0},
+ {"(*Client).Close", Method, 2},
+ {"(*Client).Data", Method, 0},
+ {"(*Client).Extension", Method, 0},
+ {"(*Client).Hello", Method, 1},
+ {"(*Client).Mail", Method, 0},
+ {"(*Client).Noop", Method, 10},
+ {"(*Client).Quit", Method, 0},
+ {"(*Client).Rcpt", Method, 0},
+ {"(*Client).Reset", Method, 0},
+ {"(*Client).StartTLS", Method, 0},
+ {"(*Client).TLSConnectionState", Method, 5},
+ {"(*Client).Verify", Method, 0},
+ {"Auth", Type, 0},
+ {"CRAMMD5Auth", Func, 0},
+ {"Client", Type, 0},
+ {"Client.Text", Field, 0},
+ {"Dial", Func, 0},
+ {"NewClient", Func, 0},
+ {"PlainAuth", Func, 0},
+ {"SendMail", Func, 0},
+ {"ServerInfo", Type, 0},
+ {"ServerInfo.Auth", Field, 0},
+ {"ServerInfo.Name", Field, 0},
+ {"ServerInfo.TLS", Field, 0},
+ },
+ "net/textproto": {
+ {"(*Conn).Close", Method, 0},
+ {"(*Conn).Cmd", Method, 0},
+ {"(*Conn).DotReader", Method, 0},
+ {"(*Conn).DotWriter", Method, 0},
+ {"(*Conn).EndRequest", Method, 0},
+ {"(*Conn).EndResponse", Method, 0},
+ {"(*Conn).Next", Method, 0},
+ {"(*Conn).PrintfLine", Method, 0},
+ {"(*Conn).ReadCodeLine", Method, 0},
+ {"(*Conn).ReadContinuedLine", Method, 0},
+ {"(*Conn).ReadContinuedLineBytes", Method, 0},
+ {"(*Conn).ReadDotBytes", Method, 0},
+ {"(*Conn).ReadDotLines", Method, 0},
+ {"(*Conn).ReadLine", Method, 0},
+ {"(*Conn).ReadLineBytes", Method, 0},
+ {"(*Conn).ReadMIMEHeader", Method, 0},
+ {"(*Conn).ReadResponse", Method, 0},
+ {"(*Conn).StartRequest", Method, 0},
+ {"(*Conn).StartResponse", Method, 0},
+ {"(*Error).Error", Method, 0},
+ {"(*Pipeline).EndRequest", Method, 0},
+ {"(*Pipeline).EndResponse", Method, 0},
+ {"(*Pipeline).Next", Method, 0},
+ {"(*Pipeline).StartRequest", Method, 0},
+ {"(*Pipeline).StartResponse", Method, 0},
+ {"(*Reader).DotReader", Method, 0},
+ {"(*Reader).ReadCodeLine", Method, 0},
+ {"(*Reader).ReadContinuedLine", Method, 0},
+ {"(*Reader).ReadContinuedLineBytes", Method, 0},
+ {"(*Reader).ReadDotBytes", Method, 0},
+ {"(*Reader).ReadDotLines", Method, 0},
+ {"(*Reader).ReadLine", Method, 0},
+ {"(*Reader).ReadLineBytes", Method, 0},
+ {"(*Reader).ReadMIMEHeader", Method, 0},
+ {"(*Reader).ReadResponse", Method, 0},
+ {"(*Writer).DotWriter", Method, 0},
+ {"(*Writer).PrintfLine", Method, 0},
+ {"(MIMEHeader).Add", Method, 0},
+ {"(MIMEHeader).Del", Method, 0},
+ {"(MIMEHeader).Get", Method, 0},
+ {"(MIMEHeader).Set", Method, 0},
+ {"(MIMEHeader).Values", Method, 14},
+ {"(ProtocolError).Error", Method, 0},
+ {"CanonicalMIMEHeaderKey", Func, 0},
+ {"Conn", Type, 0},
+ {"Conn.Pipeline", Field, 0},
+ {"Conn.Reader", Field, 0},
+ {"Conn.Writer", Field, 0},
+ {"Dial", Func, 0},
+ {"Error", Type, 0},
+ {"Error.Code", Field, 0},
+ {"Error.Msg", Field, 0},
+ {"MIMEHeader", Type, 0},
+ {"NewConn", Func, 0},
+ {"NewReader", Func, 0},
+ {"NewWriter", Func, 0},
+ {"Pipeline", Type, 0},
+ {"ProtocolError", Type, 0},
+ {"Reader", Type, 0},
+ {"Reader.R", Field, 0},
+ {"TrimBytes", Func, 1},
+ {"TrimString", Func, 1},
+ {"Writer", Type, 0},
+ {"Writer.W", Field, 0},
+ },
+ "net/url": {
+ {"(*Error).Error", Method, 0},
+ {"(*Error).Temporary", Method, 6},
+ {"(*Error).Timeout", Method, 6},
+ {"(*Error).Unwrap", Method, 13},
+ {"(*URL).EscapedFragment", Method, 15},
+ {"(*URL).EscapedPath", Method, 5},
+ {"(*URL).Hostname", Method, 8},
+ {"(*URL).IsAbs", Method, 0},
+ {"(*URL).JoinPath", Method, 19},
+ {"(*URL).MarshalBinary", Method, 8},
+ {"(*URL).Parse", Method, 0},
+ {"(*URL).Port", Method, 8},
+ {"(*URL).Query", Method, 0},
+ {"(*URL).Redacted", Method, 15},
+ {"(*URL).RequestURI", Method, 0},
+ {"(*URL).ResolveReference", Method, 0},
+ {"(*URL).String", Method, 0},
+ {"(*URL).UnmarshalBinary", Method, 8},
+ {"(*Userinfo).Password", Method, 0},
+ {"(*Userinfo).String", Method, 0},
+ {"(*Userinfo).Username", Method, 0},
+ {"(EscapeError).Error", Method, 0},
+ {"(InvalidHostError).Error", Method, 6},
+ {"(Values).Add", Method, 0},
+ {"(Values).Del", Method, 0},
+ {"(Values).Encode", Method, 0},
+ {"(Values).Get", Method, 0},
+ {"(Values).Has", Method, 17},
+ {"(Values).Set", Method, 0},
+ {"Error", Type, 0},
+ {"Error.Err", Field, 0},
+ {"Error.Op", Field, 0},
+ {"Error.URL", Field, 0},
+ {"EscapeError", Type, 0},
+ {"InvalidHostError", Type, 6},
+ {"JoinPath", Func, 19},
+ {"Parse", Func, 0},
+ {"ParseQuery", Func, 0},
+ {"ParseRequestURI", Func, 0},
+ {"PathEscape", Func, 8},
+ {"PathUnescape", Func, 8},
+ {"QueryEscape", Func, 0},
+ {"QueryUnescape", Func, 0},
+ {"URL", Type, 0},
+ {"URL.ForceQuery", Field, 7},
+ {"URL.Fragment", Field, 0},
+ {"URL.Host", Field, 0},
+ {"URL.OmitHost", Field, 19},
+ {"URL.Opaque", Field, 0},
+ {"URL.Path", Field, 0},
+ {"URL.RawFragment", Field, 15},
+ {"URL.RawPath", Field, 5},
+ {"URL.RawQuery", Field, 0},
+ {"URL.Scheme", Field, 0},
+ {"URL.User", Field, 0},
+ {"User", Func, 0},
+ {"UserPassword", Func, 0},
+ {"Userinfo", Type, 0},
+ {"Values", Type, 0},
+ },
+ "os": {
+ {"(*File).Chdir", Method, 0},
+ {"(*File).Chmod", Method, 0},
+ {"(*File).Chown", Method, 0},
+ {"(*File).Close", Method, 0},
+ {"(*File).Fd", Method, 0},
+ {"(*File).Name", Method, 0},
+ {"(*File).Read", Method, 0},
+ {"(*File).ReadAt", Method, 0},
+ {"(*File).ReadDir", Method, 16},
+ {"(*File).ReadFrom", Method, 15},
+ {"(*File).Readdir", Method, 0},
+ {"(*File).Readdirnames", Method, 0},
+ {"(*File).Seek", Method, 0},
+ {"(*File).SetDeadline", Method, 10},
+ {"(*File).SetReadDeadline", Method, 10},
+ {"(*File).SetWriteDeadline", Method, 10},
+ {"(*File).Stat", Method, 0},
+ {"(*File).Sync", Method, 0},
+ {"(*File).SyscallConn", Method, 12},
+ {"(*File).Truncate", Method, 0},
+ {"(*File).Write", Method, 0},
+ {"(*File).WriteAt", Method, 0},
+ {"(*File).WriteString", Method, 0},
+ {"(*File).WriteTo", Method, 22},
+ {"(*LinkError).Error", Method, 0},
+ {"(*LinkError).Unwrap", Method, 13},
+ {"(*PathError).Error", Method, 0},
+ {"(*PathError).Timeout", Method, 10},
+ {"(*PathError).Unwrap", Method, 13},
+ {"(*Process).Kill", Method, 0},
+ {"(*Process).Release", Method, 0},
+ {"(*Process).Signal", Method, 0},
+ {"(*Process).Wait", Method, 0},
+ {"(*ProcessState).ExitCode", Method, 12},
+ {"(*ProcessState).Exited", Method, 0},
+ {"(*ProcessState).Pid", Method, 0},
+ {"(*ProcessState).String", Method, 0},
+ {"(*ProcessState).Success", Method, 0},
+ {"(*ProcessState).Sys", Method, 0},
+ {"(*ProcessState).SysUsage", Method, 0},
+ {"(*ProcessState).SystemTime", Method, 0},
+ {"(*ProcessState).UserTime", Method, 0},
+ {"(*SyscallError).Error", Method, 0},
+ {"(*SyscallError).Timeout", Method, 10},
+ {"(*SyscallError).Unwrap", Method, 13},
+ {"(FileMode).IsDir", Method, 0},
+ {"(FileMode).IsRegular", Method, 1},
+ {"(FileMode).Perm", Method, 0},
+ {"(FileMode).String", Method, 0},
+ {"Args", Var, 0},
+ {"Chdir", Func, 0},
+ {"Chmod", Func, 0},
+ {"Chown", Func, 0},
+ {"Chtimes", Func, 0},
+ {"Clearenv", Func, 0},
+ {"CopyFS", Func, 23},
+ {"Create", Func, 0},
+ {"CreateTemp", Func, 16},
+ {"DevNull", Const, 0},
+ {"DirEntry", Type, 16},
+ {"DirFS", Func, 16},
+ {"Environ", Func, 0},
+ {"ErrClosed", Var, 8},
+ {"ErrDeadlineExceeded", Var, 15},
+ {"ErrExist", Var, 0},
+ {"ErrInvalid", Var, 0},
+ {"ErrNoDeadline", Var, 10},
+ {"ErrNotExist", Var, 0},
+ {"ErrPermission", Var, 0},
+ {"ErrProcessDone", Var, 16},
+ {"Executable", Func, 8},
+ {"Exit", Func, 0},
+ {"Expand", Func, 0},
+ {"ExpandEnv", Func, 0},
+ {"File", Type, 0},
+ {"FileInfo", Type, 0},
+ {"FileMode", Type, 0},
+ {"FindProcess", Func, 0},
+ {"Getegid", Func, 0},
+ {"Getenv", Func, 0},
+ {"Geteuid", Func, 0},
+ {"Getgid", Func, 0},
+ {"Getgroups", Func, 0},
+ {"Getpagesize", Func, 0},
+ {"Getpid", Func, 0},
+ {"Getppid", Func, 0},
+ {"Getuid", Func, 0},
+ {"Getwd", Func, 0},
+ {"Hostname", Func, 0},
+ {"Interrupt", Var, 0},
+ {"IsExist", Func, 0},
+ {"IsNotExist", Func, 0},
+ {"IsPathSeparator", Func, 0},
+ {"IsPermission", Func, 0},
+ {"IsTimeout", Func, 10},
+ {"Kill", Var, 0},
+ {"Lchown", Func, 0},
+ {"Link", Func, 0},
+ {"LinkError", Type, 0},
+ {"LinkError.Err", Field, 0},
+ {"LinkError.New", Field, 0},
+ {"LinkError.Old", Field, 0},
+ {"LinkError.Op", Field, 0},
+ {"LookupEnv", Func, 5},
+ {"Lstat", Func, 0},
+ {"Mkdir", Func, 0},
+ {"MkdirAll", Func, 0},
+ {"MkdirTemp", Func, 16},
+ {"ModeAppend", Const, 0},
+ {"ModeCharDevice", Const, 0},
+ {"ModeDevice", Const, 0},
+ {"ModeDir", Const, 0},
+ {"ModeExclusive", Const, 0},
+ {"ModeIrregular", Const, 11},
+ {"ModeNamedPipe", Const, 0},
+ {"ModePerm", Const, 0},
+ {"ModeSetgid", Const, 0},
+ {"ModeSetuid", Const, 0},
+ {"ModeSocket", Const, 0},
+ {"ModeSticky", Const, 0},
+ {"ModeSymlink", Const, 0},
+ {"ModeTemporary", Const, 0},
+ {"ModeType", Const, 0},
+ {"NewFile", Func, 0},
+ {"NewSyscallError", Func, 0},
+ {"O_APPEND", Const, 0},
+ {"O_CREATE", Const, 0},
+ {"O_EXCL", Const, 0},
+ {"O_RDONLY", Const, 0},
+ {"O_RDWR", Const, 0},
+ {"O_SYNC", Const, 0},
+ {"O_TRUNC", Const, 0},
+ {"O_WRONLY", Const, 0},
+ {"Open", Func, 0},
+ {"OpenFile", Func, 0},
+ {"PathError", Type, 0},
+ {"PathError.Err", Field, 0},
+ {"PathError.Op", Field, 0},
+ {"PathError.Path", Field, 0},
+ {"PathListSeparator", Const, 0},
+ {"PathSeparator", Const, 0},
+ {"Pipe", Func, 0},
+ {"ProcAttr", Type, 0},
+ {"ProcAttr.Dir", Field, 0},
+ {"ProcAttr.Env", Field, 0},
+ {"ProcAttr.Files", Field, 0},
+ {"ProcAttr.Sys", Field, 0},
+ {"Process", Type, 0},
+ {"Process.Pid", Field, 0},
+ {"ProcessState", Type, 0},
+ {"ReadDir", Func, 16},
+ {"ReadFile", Func, 16},
+ {"Readlink", Func, 0},
+ {"Remove", Func, 0},
+ {"RemoveAll", Func, 0},
+ {"Rename", Func, 0},
+ {"SEEK_CUR", Const, 0},
+ {"SEEK_END", Const, 0},
+ {"SEEK_SET", Const, 0},
+ {"SameFile", Func, 0},
+ {"Setenv", Func, 0},
+ {"Signal", Type, 0},
+ {"StartProcess", Func, 0},
+ {"Stat", Func, 0},
+ {"Stderr", Var, 0},
+ {"Stdin", Var, 0},
+ {"Stdout", Var, 0},
+ {"Symlink", Func, 0},
+ {"SyscallError", Type, 0},
+ {"SyscallError.Err", Field, 0},
+ {"SyscallError.Syscall", Field, 0},
+ {"TempDir", Func, 0},
+ {"Truncate", Func, 0},
+ {"Unsetenv", Func, 4},
+ {"UserCacheDir", Func, 11},
+ {"UserConfigDir", Func, 13},
+ {"UserHomeDir", Func, 12},
+ {"WriteFile", Func, 16},
+ },
+ "os/exec": {
+ {"(*Cmd).CombinedOutput", Method, 0},
+ {"(*Cmd).Environ", Method, 19},
+ {"(*Cmd).Output", Method, 0},
+ {"(*Cmd).Run", Method, 0},
+ {"(*Cmd).Start", Method, 0},
+ {"(*Cmd).StderrPipe", Method, 0},
+ {"(*Cmd).StdinPipe", Method, 0},
+ {"(*Cmd).StdoutPipe", Method, 0},
+ {"(*Cmd).String", Method, 13},
+ {"(*Cmd).Wait", Method, 0},
+ {"(*Error).Error", Method, 0},
+ {"(*Error).Unwrap", Method, 13},
+ {"(*ExitError).Error", Method, 0},
+ {"(ExitError).ExitCode", Method, 12},
+ {"(ExitError).Exited", Method, 0},
+ {"(ExitError).Pid", Method, 0},
+ {"(ExitError).String", Method, 0},
+ {"(ExitError).Success", Method, 0},
+ {"(ExitError).Sys", Method, 0},
+ {"(ExitError).SysUsage", Method, 0},
+ {"(ExitError).SystemTime", Method, 0},
+ {"(ExitError).UserTime", Method, 0},
+ {"Cmd", Type, 0},
+ {"Cmd.Args", Field, 0},
+ {"Cmd.Cancel", Field, 20},
+ {"Cmd.Dir", Field, 0},
+ {"Cmd.Env", Field, 0},
+ {"Cmd.Err", Field, 19},
+ {"Cmd.ExtraFiles", Field, 0},
+ {"Cmd.Path", Field, 0},
+ {"Cmd.Process", Field, 0},
+ {"Cmd.ProcessState", Field, 0},
+ {"Cmd.Stderr", Field, 0},
+ {"Cmd.Stdin", Field, 0},
+ {"Cmd.Stdout", Field, 0},
+ {"Cmd.SysProcAttr", Field, 0},
+ {"Cmd.WaitDelay", Field, 20},
+ {"Command", Func, 0},
+ {"CommandContext", Func, 7},
+ {"ErrDot", Var, 19},
+ {"ErrNotFound", Var, 0},
+ {"ErrWaitDelay", Var, 20},
+ {"Error", Type, 0},
+ {"Error.Err", Field, 0},
+ {"Error.Name", Field, 0},
+ {"ExitError", Type, 0},
+ {"ExitError.ProcessState", Field, 0},
+ {"ExitError.Stderr", Field, 6},
+ {"LookPath", Func, 0},
+ },
+ "os/signal": {
+ {"Ignore", Func, 5},
+ {"Ignored", Func, 11},
+ {"Notify", Func, 0},
+ {"NotifyContext", Func, 16},
+ {"Reset", Func, 5},
+ {"Stop", Func, 1},
+ },
+ "os/user": {
+ {"(*User).GroupIds", Method, 7},
+ {"(UnknownGroupError).Error", Method, 7},
+ {"(UnknownGroupIdError).Error", Method, 7},
+ {"(UnknownUserError).Error", Method, 0},
+ {"(UnknownUserIdError).Error", Method, 0},
+ {"Current", Func, 0},
+ {"Group", Type, 7},
+ {"Group.Gid", Field, 7},
+ {"Group.Name", Field, 7},
+ {"Lookup", Func, 0},
+ {"LookupGroup", Func, 7},
+ {"LookupGroupId", Func, 7},
+ {"LookupId", Func, 0},
+ {"UnknownGroupError", Type, 7},
+ {"UnknownGroupIdError", Type, 7},
+ {"UnknownUserError", Type, 0},
+ {"UnknownUserIdError", Type, 0},
+ {"User", Type, 0},
+ {"User.Gid", Field, 0},
+ {"User.HomeDir", Field, 0},
+ {"User.Name", Field, 0},
+ {"User.Uid", Field, 0},
+ {"User.Username", Field, 0},
+ },
+ "path": {
+ {"Base", Func, 0},
+ {"Clean", Func, 0},
+ {"Dir", Func, 0},
+ {"ErrBadPattern", Var, 0},
+ {"Ext", Func, 0},
+ {"IsAbs", Func, 0},
+ {"Join", Func, 0},
+ {"Match", Func, 0},
+ {"Split", Func, 0},
+ },
+ "path/filepath": {
+ {"Abs", Func, 0},
+ {"Base", Func, 0},
+ {"Clean", Func, 0},
+ {"Dir", Func, 0},
+ {"ErrBadPattern", Var, 0},
+ {"EvalSymlinks", Func, 0},
+ {"Ext", Func, 0},
+ {"FromSlash", Func, 0},
+ {"Glob", Func, 0},
+ {"HasPrefix", Func, 0},
+ {"IsAbs", Func, 0},
+ {"IsLocal", Func, 20},
+ {"Join", Func, 0},
+ {"ListSeparator", Const, 0},
+ {"Localize", Func, 23},
+ {"Match", Func, 0},
+ {"Rel", Func, 0},
+ {"Separator", Const, 0},
+ {"SkipAll", Var, 20},
+ {"SkipDir", Var, 0},
+ {"Split", Func, 0},
+ {"SplitList", Func, 0},
+ {"ToSlash", Func, 0},
+ {"VolumeName", Func, 0},
+ {"Walk", Func, 0},
+ {"WalkDir", Func, 16},
+ {"WalkFunc", Type, 0},
+ },
+ "plugin": {
+ {"(*Plugin).Lookup", Method, 8},
+ {"Open", Func, 8},
+ {"Plugin", Type, 8},
+ {"Symbol", Type, 8},
+ },
+ "reflect": {
+ {"(*MapIter).Key", Method, 12},
+ {"(*MapIter).Next", Method, 12},
+ {"(*MapIter).Reset", Method, 18},
+ {"(*MapIter).Value", Method, 12},
+ {"(*ValueError).Error", Method, 0},
+ {"(ChanDir).String", Method, 0},
+ {"(Kind).String", Method, 0},
+ {"(Method).IsExported", Method, 17},
+ {"(StructField).IsExported", Method, 17},
+ {"(StructTag).Get", Method, 0},
+ {"(StructTag).Lookup", Method, 7},
+ {"(Value).Addr", Method, 0},
+ {"(Value).Bool", Method, 0},
+ {"(Value).Bytes", Method, 0},
+ {"(Value).Call", Method, 0},
+ {"(Value).CallSlice", Method, 0},
+ {"(Value).CanAddr", Method, 0},
+ {"(Value).CanComplex", Method, 18},
+ {"(Value).CanConvert", Method, 17},
+ {"(Value).CanFloat", Method, 18},
+ {"(Value).CanInt", Method, 18},
+ {"(Value).CanInterface", Method, 0},
+ {"(Value).CanSet", Method, 0},
+ {"(Value).CanUint", Method, 18},
+ {"(Value).Cap", Method, 0},
+ {"(Value).Clear", Method, 21},
+ {"(Value).Close", Method, 0},
+ {"(Value).Comparable", Method, 20},
+ {"(Value).Complex", Method, 0},
+ {"(Value).Convert", Method, 1},
+ {"(Value).Elem", Method, 0},
+ {"(Value).Equal", Method, 20},
+ {"(Value).Field", Method, 0},
+ {"(Value).FieldByIndex", Method, 0},
+ {"(Value).FieldByIndexErr", Method, 18},
+ {"(Value).FieldByName", Method, 0},
+ {"(Value).FieldByNameFunc", Method, 0},
+ {"(Value).Float", Method, 0},
+ {"(Value).Grow", Method, 20},
+ {"(Value).Index", Method, 0},
+ {"(Value).Int", Method, 0},
+ {"(Value).Interface", Method, 0},
+ {"(Value).InterfaceData", Method, 0},
+ {"(Value).IsNil", Method, 0},
+ {"(Value).IsValid", Method, 0},
+ {"(Value).IsZero", Method, 13},
+ {"(Value).Kind", Method, 0},
+ {"(Value).Len", Method, 0},
+ {"(Value).MapIndex", Method, 0},
+ {"(Value).MapKeys", Method, 0},
+ {"(Value).MapRange", Method, 12},
+ {"(Value).Method", Method, 0},
+ {"(Value).MethodByName", Method, 0},
+ {"(Value).NumField", Method, 0},
+ {"(Value).NumMethod", Method, 0},
+ {"(Value).OverflowComplex", Method, 0},
+ {"(Value).OverflowFloat", Method, 0},
+ {"(Value).OverflowInt", Method, 0},
+ {"(Value).OverflowUint", Method, 0},
+ {"(Value).Pointer", Method, 0},
+ {"(Value).Recv", Method, 0},
+ {"(Value).Send", Method, 0},
+ {"(Value).Seq", Method, 23},
+ {"(Value).Seq2", Method, 23},
+ {"(Value).Set", Method, 0},
+ {"(Value).SetBool", Method, 0},
+ {"(Value).SetBytes", Method, 0},
+ {"(Value).SetCap", Method, 2},
+ {"(Value).SetComplex", Method, 0},
+ {"(Value).SetFloat", Method, 0},
+ {"(Value).SetInt", Method, 0},
+ {"(Value).SetIterKey", Method, 18},
+ {"(Value).SetIterValue", Method, 18},
+ {"(Value).SetLen", Method, 0},
+ {"(Value).SetMapIndex", Method, 0},
+ {"(Value).SetPointer", Method, 0},
+ {"(Value).SetString", Method, 0},
+ {"(Value).SetUint", Method, 0},
+ {"(Value).SetZero", Method, 20},
+ {"(Value).Slice", Method, 0},
+ {"(Value).Slice3", Method, 2},
+ {"(Value).String", Method, 0},
+ {"(Value).TryRecv", Method, 0},
+ {"(Value).TrySend", Method, 0},
+ {"(Value).Type", Method, 0},
+ {"(Value).Uint", Method, 0},
+ {"(Value).UnsafeAddr", Method, 0},
+ {"(Value).UnsafePointer", Method, 18},
+ {"Append", Func, 0},
+ {"AppendSlice", Func, 0},
+ {"Array", Const, 0},
+ {"ArrayOf", Func, 5},
+ {"Bool", Const, 0},
+ {"BothDir", Const, 0},
+ {"Chan", Const, 0},
+ {"ChanDir", Type, 0},
+ {"ChanOf", Func, 1},
+ {"Complex128", Const, 0},
+ {"Complex64", Const, 0},
+ {"Copy", Func, 0},
+ {"DeepEqual", Func, 0},
+ {"Float32", Const, 0},
+ {"Float64", Const, 0},
+ {"Func", Const, 0},
+ {"FuncOf", Func, 5},
+ {"Indirect", Func, 0},
+ {"Int", Const, 0},
+ {"Int16", Const, 0},
+ {"Int32", Const, 0},
+ {"Int64", Const, 0},
+ {"Int8", Const, 0},
+ {"Interface", Const, 0},
+ {"Invalid", Const, 0},
+ {"Kind", Type, 0},
+ {"MakeChan", Func, 0},
+ {"MakeFunc", Func, 1},
+ {"MakeMap", Func, 0},
+ {"MakeMapWithSize", Func, 9},
+ {"MakeSlice", Func, 0},
+ {"Map", Const, 0},
+ {"MapIter", Type, 12},
+ {"MapOf", Func, 1},
+ {"Method", Type, 0},
+ {"Method.Func", Field, 0},
+ {"Method.Index", Field, 0},
+ {"Method.Name", Field, 0},
+ {"Method.PkgPath", Field, 0},
+ {"Method.Type", Field, 0},
+ {"New", Func, 0},
+ {"NewAt", Func, 0},
+ {"Pointer", Const, 18},
+ {"PointerTo", Func, 18},
+ {"Ptr", Const, 0},
+ {"PtrTo", Func, 0},
+ {"RecvDir", Const, 0},
+ {"Select", Func, 1},
+ {"SelectCase", Type, 1},
+ {"SelectCase.Chan", Field, 1},
+ {"SelectCase.Dir", Field, 1},
+ {"SelectCase.Send", Field, 1},
+ {"SelectDefault", Const, 1},
+ {"SelectDir", Type, 1},
+ {"SelectRecv", Const, 1},
+ {"SelectSend", Const, 1},
+ {"SendDir", Const, 0},
+ {"Slice", Const, 0},
+ {"SliceAt", Func, 23},
+ {"SliceHeader", Type, 0},
+ {"SliceHeader.Cap", Field, 0},
+ {"SliceHeader.Data", Field, 0},
+ {"SliceHeader.Len", Field, 0},
+ {"SliceOf", Func, 1},
+ {"String", Const, 0},
+ {"StringHeader", Type, 0},
+ {"StringHeader.Data", Field, 0},
+ {"StringHeader.Len", Field, 0},
+ {"Struct", Const, 0},
+ {"StructField", Type, 0},
+ {"StructField.Anonymous", Field, 0},
+ {"StructField.Index", Field, 0},
+ {"StructField.Name", Field, 0},
+ {"StructField.Offset", Field, 0},
+ {"StructField.PkgPath", Field, 0},
+ {"StructField.Tag", Field, 0},
+ {"StructField.Type", Field, 0},
+ {"StructOf", Func, 7},
+ {"StructTag", Type, 0},
+ {"Swapper", Func, 8},
+ {"Type", Type, 0},
+ {"TypeFor", Func, 22},
+ {"TypeOf", Func, 0},
+ {"Uint", Const, 0},
+ {"Uint16", Const, 0},
+ {"Uint32", Const, 0},
+ {"Uint64", Const, 0},
+ {"Uint8", Const, 0},
+ {"Uintptr", Const, 0},
+ {"UnsafePointer", Const, 0},
+ {"Value", Type, 0},
+ {"ValueError", Type, 0},
+ {"ValueError.Kind", Field, 0},
+ {"ValueError.Method", Field, 0},
+ {"ValueOf", Func, 0},
+ {"VisibleFields", Func, 17},
+ {"Zero", Func, 0},
+ },
+ "regexp": {
+ {"(*Regexp).Copy", Method, 6},
+ {"(*Regexp).Expand", Method, 0},
+ {"(*Regexp).ExpandString", Method, 0},
+ {"(*Regexp).Find", Method, 0},
+ {"(*Regexp).FindAll", Method, 0},
+ {"(*Regexp).FindAllIndex", Method, 0},
+ {"(*Regexp).FindAllString", Method, 0},
+ {"(*Regexp).FindAllStringIndex", Method, 0},
+ {"(*Regexp).FindAllStringSubmatch", Method, 0},
+ {"(*Regexp).FindAllStringSubmatchIndex", Method, 0},
+ {"(*Regexp).FindAllSubmatch", Method, 0},
+ {"(*Regexp).FindAllSubmatchIndex", Method, 0},
+ {"(*Regexp).FindIndex", Method, 0},
+ {"(*Regexp).FindReaderIndex", Method, 0},
+ {"(*Regexp).FindReaderSubmatchIndex", Method, 0},
+ {"(*Regexp).FindString", Method, 0},
+ {"(*Regexp).FindStringIndex", Method, 0},
+ {"(*Regexp).FindStringSubmatch", Method, 0},
+ {"(*Regexp).FindStringSubmatchIndex", Method, 0},
+ {"(*Regexp).FindSubmatch", Method, 0},
+ {"(*Regexp).FindSubmatchIndex", Method, 0},
+ {"(*Regexp).LiteralPrefix", Method, 0},
+ {"(*Regexp).Longest", Method, 1},
+ {"(*Regexp).MarshalText", Method, 21},
+ {"(*Regexp).Match", Method, 0},
+ {"(*Regexp).MatchReader", Method, 0},
+ {"(*Regexp).MatchString", Method, 0},
+ {"(*Regexp).NumSubexp", Method, 0},
+ {"(*Regexp).ReplaceAll", Method, 0},
+ {"(*Regexp).ReplaceAllFunc", Method, 0},
+ {"(*Regexp).ReplaceAllLiteral", Method, 0},
+ {"(*Regexp).ReplaceAllLiteralString", Method, 0},
+ {"(*Regexp).ReplaceAllString", Method, 0},
+ {"(*Regexp).ReplaceAllStringFunc", Method, 0},
+ {"(*Regexp).Split", Method, 1},
+ {"(*Regexp).String", Method, 0},
+ {"(*Regexp).SubexpIndex", Method, 15},
+ {"(*Regexp).SubexpNames", Method, 0},
+ {"(*Regexp).UnmarshalText", Method, 21},
+ {"Compile", Func, 0},
+ {"CompilePOSIX", Func, 0},
+ {"Match", Func, 0},
+ {"MatchReader", Func, 0},
+ {"MatchString", Func, 0},
+ {"MustCompile", Func, 0},
+ {"MustCompilePOSIX", Func, 0},
+ {"QuoteMeta", Func, 0},
+ {"Regexp", Type, 0},
+ },
+ "regexp/syntax": {
+ {"(*Error).Error", Method, 0},
+ {"(*Inst).MatchEmptyWidth", Method, 0},
+ {"(*Inst).MatchRune", Method, 0},
+ {"(*Inst).MatchRunePos", Method, 3},
+ {"(*Inst).String", Method, 0},
+ {"(*Prog).Prefix", Method, 0},
+ {"(*Prog).StartCond", Method, 0},
+ {"(*Prog).String", Method, 0},
+ {"(*Regexp).CapNames", Method, 0},
+ {"(*Regexp).Equal", Method, 0},
+ {"(*Regexp).MaxCap", Method, 0},
+ {"(*Regexp).Simplify", Method, 0},
+ {"(*Regexp).String", Method, 0},
+ {"(ErrorCode).String", Method, 0},
+ {"(InstOp).String", Method, 3},
+ {"(Op).String", Method, 11},
+ {"ClassNL", Const, 0},
+ {"Compile", Func, 0},
+ {"DotNL", Const, 0},
+ {"EmptyBeginLine", Const, 0},
+ {"EmptyBeginText", Const, 0},
+ {"EmptyEndLine", Const, 0},
+ {"EmptyEndText", Const, 0},
+ {"EmptyNoWordBoundary", Const, 0},
+ {"EmptyOp", Type, 0},
+ {"EmptyOpContext", Func, 0},
+ {"EmptyWordBoundary", Const, 0},
+ {"ErrInternalError", Const, 0},
+ {"ErrInvalidCharClass", Const, 0},
+ {"ErrInvalidCharRange", Const, 0},
+ {"ErrInvalidEscape", Const, 0},
+ {"ErrInvalidNamedCapture", Const, 0},
+ {"ErrInvalidPerlOp", Const, 0},
+ {"ErrInvalidRepeatOp", Const, 0},
+ {"ErrInvalidRepeatSize", Const, 0},
+ {"ErrInvalidUTF8", Const, 0},
+ {"ErrLarge", Const, 20},
+ {"ErrMissingBracket", Const, 0},
+ {"ErrMissingParen", Const, 0},
+ {"ErrMissingRepeatArgument", Const, 0},
+ {"ErrNestingDepth", Const, 19},
+ {"ErrTrailingBackslash", Const, 0},
+ {"ErrUnexpectedParen", Const, 1},
+ {"Error", Type, 0},
+ {"Error.Code", Field, 0},
+ {"Error.Expr", Field, 0},
+ {"ErrorCode", Type, 0},
+ {"Flags", Type, 0},
+ {"FoldCase", Const, 0},
+ {"Inst", Type, 0},
+ {"Inst.Arg", Field, 0},
+ {"Inst.Op", Field, 0},
+ {"Inst.Out", Field, 0},
+ {"Inst.Rune", Field, 0},
+ {"InstAlt", Const, 0},
+ {"InstAltMatch", Const, 0},
+ {"InstCapture", Const, 0},
+ {"InstEmptyWidth", Const, 0},
+ {"InstFail", Const, 0},
+ {"InstMatch", Const, 0},
+ {"InstNop", Const, 0},
+ {"InstOp", Type, 0},
+ {"InstRune", Const, 0},
+ {"InstRune1", Const, 0},
+ {"InstRuneAny", Const, 0},
+ {"InstRuneAnyNotNL", Const, 0},
+ {"IsWordChar", Func, 0},
+ {"Literal", Const, 0},
+ {"MatchNL", Const, 0},
+ {"NonGreedy", Const, 0},
+ {"OneLine", Const, 0},
+ {"Op", Type, 0},
+ {"OpAlternate", Const, 0},
+ {"OpAnyChar", Const, 0},
+ {"OpAnyCharNotNL", Const, 0},
+ {"OpBeginLine", Const, 0},
+ {"OpBeginText", Const, 0},
+ {"OpCapture", Const, 0},
+ {"OpCharClass", Const, 0},
+ {"OpConcat", Const, 0},
+ {"OpEmptyMatch", Const, 0},
+ {"OpEndLine", Const, 0},
+ {"OpEndText", Const, 0},
+ {"OpLiteral", Const, 0},
+ {"OpNoMatch", Const, 0},
+ {"OpNoWordBoundary", Const, 0},
+ {"OpPlus", Const, 0},
+ {"OpQuest", Const, 0},
+ {"OpRepeat", Const, 0},
+ {"OpStar", Const, 0},
+ {"OpWordBoundary", Const, 0},
+ {"POSIX", Const, 0},
+ {"Parse", Func, 0},
+ {"Perl", Const, 0},
+ {"PerlX", Const, 0},
+ {"Prog", Type, 0},
+ {"Prog.Inst", Field, 0},
+ {"Prog.NumCap", Field, 0},
+ {"Prog.Start", Field, 0},
+ {"Regexp", Type, 0},
+ {"Regexp.Cap", Field, 0},
+ {"Regexp.Flags", Field, 0},
+ {"Regexp.Max", Field, 0},
+ {"Regexp.Min", Field, 0},
+ {"Regexp.Name", Field, 0},
+ {"Regexp.Op", Field, 0},
+ {"Regexp.Rune", Field, 0},
+ {"Regexp.Rune0", Field, 0},
+ {"Regexp.Sub", Field, 0},
+ {"Regexp.Sub0", Field, 0},
+ {"Simple", Const, 0},
+ {"UnicodeGroups", Const, 0},
+ {"WasDollar", Const, 0},
+ },
+ "runtime": {
+ {"(*BlockProfileRecord).Stack", Method, 1},
+ {"(*Frames).Next", Method, 7},
+ {"(*Func).Entry", Method, 0},
+ {"(*Func).FileLine", Method, 0},
+ {"(*Func).Name", Method, 0},
+ {"(*MemProfileRecord).InUseBytes", Method, 0},
+ {"(*MemProfileRecord).InUseObjects", Method, 0},
+ {"(*MemProfileRecord).Stack", Method, 0},
+ {"(*PanicNilError).Error", Method, 21},
+ {"(*PanicNilError).RuntimeError", Method, 21},
+ {"(*Pinner).Pin", Method, 21},
+ {"(*Pinner).Unpin", Method, 21},
+ {"(*StackRecord).Stack", Method, 0},
+ {"(*TypeAssertionError).Error", Method, 0},
+ {"(*TypeAssertionError).RuntimeError", Method, 0},
+ {"BlockProfile", Func, 1},
+ {"BlockProfileRecord", Type, 1},
+ {"BlockProfileRecord.Count", Field, 1},
+ {"BlockProfileRecord.Cycles", Field, 1},
+ {"BlockProfileRecord.StackRecord", Field, 1},
+ {"Breakpoint", Func, 0},
+ {"CPUProfile", Func, 0},
+ {"Caller", Func, 0},
+ {"Callers", Func, 0},
+ {"CallersFrames", Func, 7},
+ {"Compiler", Const, 0},
+ {"Error", Type, 0},
+ {"Frame", Type, 7},
+ {"Frame.Entry", Field, 7},
+ {"Frame.File", Field, 7},
+ {"Frame.Func", Field, 7},
+ {"Frame.Function", Field, 7},
+ {"Frame.Line", Field, 7},
+ {"Frame.PC", Field, 7},
+ {"Frames", Type, 7},
+ {"Func", Type, 0},
+ {"FuncForPC", Func, 0},
+ {"GC", Func, 0},
+ {"GOARCH", Const, 0},
+ {"GOMAXPROCS", Func, 0},
+ {"GOOS", Const, 0},
+ {"GOROOT", Func, 0},
+ {"Goexit", Func, 0},
+ {"GoroutineProfile", Func, 0},
+ {"Gosched", Func, 0},
+ {"KeepAlive", Func, 7},
+ {"LockOSThread", Func, 0},
+ {"MemProfile", Func, 0},
+ {"MemProfileRate", Var, 0},
+ {"MemProfileRecord", Type, 0},
+ {"MemProfileRecord.AllocBytes", Field, 0},
+ {"MemProfileRecord.AllocObjects", Field, 0},
+ {"MemProfileRecord.FreeBytes", Field, 0},
+ {"MemProfileRecord.FreeObjects", Field, 0},
+ {"MemProfileRecord.Stack0", Field, 0},
+ {"MemStats", Type, 0},
+ {"MemStats.Alloc", Field, 0},
+ {"MemStats.BuckHashSys", Field, 0},
+ {"MemStats.BySize", Field, 0},
+ {"MemStats.DebugGC", Field, 0},
+ {"MemStats.EnableGC", Field, 0},
+ {"MemStats.Frees", Field, 0},
+ {"MemStats.GCCPUFraction", Field, 5},
+ {"MemStats.GCSys", Field, 2},
+ {"MemStats.HeapAlloc", Field, 0},
+ {"MemStats.HeapIdle", Field, 0},
+ {"MemStats.HeapInuse", Field, 0},
+ {"MemStats.HeapObjects", Field, 0},
+ {"MemStats.HeapReleased", Field, 0},
+ {"MemStats.HeapSys", Field, 0},
+ {"MemStats.LastGC", Field, 0},
+ {"MemStats.Lookups", Field, 0},
+ {"MemStats.MCacheInuse", Field, 0},
+ {"MemStats.MCacheSys", Field, 0},
+ {"MemStats.MSpanInuse", Field, 0},
+ {"MemStats.MSpanSys", Field, 0},
+ {"MemStats.Mallocs", Field, 0},
+ {"MemStats.NextGC", Field, 0},
+ {"MemStats.NumForcedGC", Field, 8},
+ {"MemStats.NumGC", Field, 0},
+ {"MemStats.OtherSys", Field, 2},
+ {"MemStats.PauseEnd", Field, 4},
+ {"MemStats.PauseNs", Field, 0},
+ {"MemStats.PauseTotalNs", Field, 0},
+ {"MemStats.StackInuse", Field, 0},
+ {"MemStats.StackSys", Field, 0},
+ {"MemStats.Sys", Field, 0},
+ {"MemStats.TotalAlloc", Field, 0},
+ {"MutexProfile", Func, 8},
+ {"NumCPU", Func, 0},
+ {"NumCgoCall", Func, 0},
+ {"NumGoroutine", Func, 0},
+ {"PanicNilError", Type, 21},
+ {"Pinner", Type, 21},
+ {"ReadMemStats", Func, 0},
+ {"ReadTrace", Func, 5},
+ {"SetBlockProfileRate", Func, 1},
+ {"SetCPUProfileRate", Func, 0},
+ {"SetCgoTraceback", Func, 7},
+ {"SetFinalizer", Func, 0},
+ {"SetMutexProfileFraction", Func, 8},
+ {"Stack", Func, 0},
+ {"StackRecord", Type, 0},
+ {"StackRecord.Stack0", Field, 0},
+ {"StartTrace", Func, 5},
+ {"StopTrace", Func, 5},
+ {"ThreadCreateProfile", Func, 0},
+ {"TypeAssertionError", Type, 0},
+ {"UnlockOSThread", Func, 0},
+ {"Version", Func, 0},
+ },
+ "runtime/cgo": {
+ {"(Handle).Delete", Method, 17},
+ {"(Handle).Value", Method, 17},
+ {"Handle", Type, 17},
+ {"Incomplete", Type, 20},
+ {"NewHandle", Func, 17},
+ },
+ "runtime/coverage": {
+ {"ClearCounters", Func, 20},
+ {"WriteCounters", Func, 20},
+ {"WriteCountersDir", Func, 20},
+ {"WriteMeta", Func, 20},
+ {"WriteMetaDir", Func, 20},
+ },
+ "runtime/debug": {
+ {"(*BuildInfo).String", Method, 18},
+ {"BuildInfo", Type, 12},
+ {"BuildInfo.Deps", Field, 12},
+ {"BuildInfo.GoVersion", Field, 18},
+ {"BuildInfo.Main", Field, 12},
+ {"BuildInfo.Path", Field, 12},
+ {"BuildInfo.Settings", Field, 18},
+ {"BuildSetting", Type, 18},
+ {"BuildSetting.Key", Field, 18},
+ {"BuildSetting.Value", Field, 18},
+ {"CrashOptions", Type, 23},
+ {"FreeOSMemory", Func, 1},
+ {"GCStats", Type, 1},
+ {"GCStats.LastGC", Field, 1},
+ {"GCStats.NumGC", Field, 1},
+ {"GCStats.Pause", Field, 1},
+ {"GCStats.PauseEnd", Field, 4},
+ {"GCStats.PauseQuantiles", Field, 1},
+ {"GCStats.PauseTotal", Field, 1},
+ {"Module", Type, 12},
+ {"Module.Path", Field, 12},
+ {"Module.Replace", Field, 12},
+ {"Module.Sum", Field, 12},
+ {"Module.Version", Field, 12},
+ {"ParseBuildInfo", Func, 18},
+ {"PrintStack", Func, 0},
+ {"ReadBuildInfo", Func, 12},
+ {"ReadGCStats", Func, 1},
+ {"SetCrashOutput", Func, 23},
+ {"SetGCPercent", Func, 1},
+ {"SetMaxStack", Func, 2},
+ {"SetMaxThreads", Func, 2},
+ {"SetMemoryLimit", Func, 19},
+ {"SetPanicOnFault", Func, 3},
+ {"SetTraceback", Func, 6},
+ {"Stack", Func, 0},
+ {"WriteHeapDump", Func, 3},
+ },
+ "runtime/metrics": {
+ {"(Value).Float64", Method, 16},
+ {"(Value).Float64Histogram", Method, 16},
+ {"(Value).Kind", Method, 16},
+ {"(Value).Uint64", Method, 16},
+ {"All", Func, 16},
+ {"Description", Type, 16},
+ {"Description.Cumulative", Field, 16},
+ {"Description.Description", Field, 16},
+ {"Description.Kind", Field, 16},
+ {"Description.Name", Field, 16},
+ {"Float64Histogram", Type, 16},
+ {"Float64Histogram.Buckets", Field, 16},
+ {"Float64Histogram.Counts", Field, 16},
+ {"KindBad", Const, 16},
+ {"KindFloat64", Const, 16},
+ {"KindFloat64Histogram", Const, 16},
+ {"KindUint64", Const, 16},
+ {"Read", Func, 16},
+ {"Sample", Type, 16},
+ {"Sample.Name", Field, 16},
+ {"Sample.Value", Field, 16},
+ {"Value", Type, 16},
+ {"ValueKind", Type, 16},
+ },
+ "runtime/pprof": {
+ {"(*Profile).Add", Method, 0},
+ {"(*Profile).Count", Method, 0},
+ {"(*Profile).Name", Method, 0},
+ {"(*Profile).Remove", Method, 0},
+ {"(*Profile).WriteTo", Method, 0},
+ {"Do", Func, 9},
+ {"ForLabels", Func, 9},
+ {"Label", Func, 9},
+ {"LabelSet", Type, 9},
+ {"Labels", Func, 9},
+ {"Lookup", Func, 0},
+ {"NewProfile", Func, 0},
+ {"Profile", Type, 0},
+ {"Profiles", Func, 0},
+ {"SetGoroutineLabels", Func, 9},
+ {"StartCPUProfile", Func, 0},
+ {"StopCPUProfile", Func, 0},
+ {"WithLabels", Func, 9},
+ {"WriteHeapProfile", Func, 0},
+ },
+ "runtime/trace": {
+ {"(*Region).End", Method, 11},
+ {"(*Task).End", Method, 11},
+ {"IsEnabled", Func, 11},
+ {"Log", Func, 11},
+ {"Logf", Func, 11},
+ {"NewTask", Func, 11},
+ {"Region", Type, 11},
+ {"Start", Func, 5},
+ {"StartRegion", Func, 11},
+ {"Stop", Func, 5},
+ {"Task", Type, 11},
+ {"WithRegion", Func, 11},
+ },
+ "slices": {
+ {"All", Func, 23},
+ {"AppendSeq", Func, 23},
+ {"Backward", Func, 23},
+ {"BinarySearch", Func, 21},
+ {"BinarySearchFunc", Func, 21},
+ {"Chunk", Func, 23},
+ {"Clip", Func, 21},
+ {"Clone", Func, 21},
+ {"Collect", Func, 23},
+ {"Compact", Func, 21},
+ {"CompactFunc", Func, 21},
+ {"Compare", Func, 21},
+ {"CompareFunc", Func, 21},
+ {"Concat", Func, 22},
+ {"Contains", Func, 21},
+ {"ContainsFunc", Func, 21},
+ {"Delete", Func, 21},
+ {"DeleteFunc", Func, 21},
+ {"Equal", Func, 21},
+ {"EqualFunc", Func, 21},
+ {"Grow", Func, 21},
+ {"Index", Func, 21},
+ {"IndexFunc", Func, 21},
+ {"Insert", Func, 21},
+ {"IsSorted", Func, 21},
+ {"IsSortedFunc", Func, 21},
+ {"Max", Func, 21},
+ {"MaxFunc", Func, 21},
+ {"Min", Func, 21},
+ {"MinFunc", Func, 21},
+ {"Repeat", Func, 23},
+ {"Replace", Func, 21},
+ {"Reverse", Func, 21},
+ {"Sort", Func, 21},
+ {"SortFunc", Func, 21},
+ {"SortStableFunc", Func, 21},
+ {"Sorted", Func, 23},
+ {"SortedFunc", Func, 23},
+ {"SortedStableFunc", Func, 23},
+ {"Values", Func, 23},
+ },
+ "sort": {
+ {"(Float64Slice).Len", Method, 0},
+ {"(Float64Slice).Less", Method, 0},
+ {"(Float64Slice).Search", Method, 0},
+ {"(Float64Slice).Sort", Method, 0},
+ {"(Float64Slice).Swap", Method, 0},
+ {"(IntSlice).Len", Method, 0},
+ {"(IntSlice).Less", Method, 0},
+ {"(IntSlice).Search", Method, 0},
+ {"(IntSlice).Sort", Method, 0},
+ {"(IntSlice).Swap", Method, 0},
+ {"(StringSlice).Len", Method, 0},
+ {"(StringSlice).Less", Method, 0},
+ {"(StringSlice).Search", Method, 0},
+ {"(StringSlice).Sort", Method, 0},
+ {"(StringSlice).Swap", Method, 0},
+ {"Find", Func, 19},
+ {"Float64Slice", Type, 0},
+ {"Float64s", Func, 0},
+ {"Float64sAreSorted", Func, 0},
+ {"IntSlice", Type, 0},
+ {"Interface", Type, 0},
+ {"Ints", Func, 0},
+ {"IntsAreSorted", Func, 0},
+ {"IsSorted", Func, 0},
+ {"Reverse", Func, 1},
+ {"Search", Func, 0},
+ {"SearchFloat64s", Func, 0},
+ {"SearchInts", Func, 0},
+ {"SearchStrings", Func, 0},
+ {"Slice", Func, 8},
+ {"SliceIsSorted", Func, 8},
+ {"SliceStable", Func, 8},
+ {"Sort", Func, 0},
+ {"Stable", Func, 2},
+ {"StringSlice", Type, 0},
+ {"Strings", Func, 0},
+ {"StringsAreSorted", Func, 0},
+ },
+ "strconv": {
+ {"(*NumError).Error", Method, 0},
+ {"(*NumError).Unwrap", Method, 14},
+ {"AppendBool", Func, 0},
+ {"AppendFloat", Func, 0},
+ {"AppendInt", Func, 0},
+ {"AppendQuote", Func, 0},
+ {"AppendQuoteRune", Func, 0},
+ {"AppendQuoteRuneToASCII", Func, 0},
+ {"AppendQuoteRuneToGraphic", Func, 6},
+ {"AppendQuoteToASCII", Func, 0},
+ {"AppendQuoteToGraphic", Func, 6},
+ {"AppendUint", Func, 0},
+ {"Atoi", Func, 0},
+ {"CanBackquote", Func, 0},
+ {"ErrRange", Var, 0},
+ {"ErrSyntax", Var, 0},
+ {"FormatBool", Func, 0},
+ {"FormatComplex", Func, 15},
+ {"FormatFloat", Func, 0},
+ {"FormatInt", Func, 0},
+ {"FormatUint", Func, 0},
+ {"IntSize", Const, 0},
+ {"IsGraphic", Func, 6},
+ {"IsPrint", Func, 0},
+ {"Itoa", Func, 0},
+ {"NumError", Type, 0},
+ {"NumError.Err", Field, 0},
+ {"NumError.Func", Field, 0},
+ {"NumError.Num", Field, 0},
+ {"ParseBool", Func, 0},
+ {"ParseComplex", Func, 15},
+ {"ParseFloat", Func, 0},
+ {"ParseInt", Func, 0},
+ {"ParseUint", Func, 0},
+ {"Quote", Func, 0},
+ {"QuoteRune", Func, 0},
+ {"QuoteRuneToASCII", Func, 0},
+ {"QuoteRuneToGraphic", Func, 6},
+ {"QuoteToASCII", Func, 0},
+ {"QuoteToGraphic", Func, 6},
+ {"QuotedPrefix", Func, 17},
+ {"Unquote", Func, 0},
+ {"UnquoteChar", Func, 0},
+ },
+ "strings": {
+ {"(*Builder).Cap", Method, 12},
+ {"(*Builder).Grow", Method, 10},
+ {"(*Builder).Len", Method, 10},
+ {"(*Builder).Reset", Method, 10},
+ {"(*Builder).String", Method, 10},
+ {"(*Builder).Write", Method, 10},
+ {"(*Builder).WriteByte", Method, 10},
+ {"(*Builder).WriteRune", Method, 10},
+ {"(*Builder).WriteString", Method, 10},
+ {"(*Reader).Len", Method, 0},
+ {"(*Reader).Read", Method, 0},
+ {"(*Reader).ReadAt", Method, 0},
+ {"(*Reader).ReadByte", Method, 0},
+ {"(*Reader).ReadRune", Method, 0},
+ {"(*Reader).Reset", Method, 7},
+ {"(*Reader).Seek", Method, 0},
+ {"(*Reader).Size", Method, 5},
+ {"(*Reader).UnreadByte", Method, 0},
+ {"(*Reader).UnreadRune", Method, 0},
+ {"(*Reader).WriteTo", Method, 1},
+ {"(*Replacer).Replace", Method, 0},
+ {"(*Replacer).WriteString", Method, 0},
+ {"Builder", Type, 10},
+ {"Clone", Func, 18},
+ {"Compare", Func, 5},
+ {"Contains", Func, 0},
+ {"ContainsAny", Func, 0},
+ {"ContainsFunc", Func, 21},
+ {"ContainsRune", Func, 0},
+ {"Count", Func, 0},
+ {"Cut", Func, 18},
+ {"CutPrefix", Func, 20},
+ {"CutSuffix", Func, 20},
+ {"EqualFold", Func, 0},
+ {"Fields", Func, 0},
+ {"FieldsFunc", Func, 0},
+ {"HasPrefix", Func, 0},
+ {"HasSuffix", Func, 0},
+ {"Index", Func, 0},
+ {"IndexAny", Func, 0},
+ {"IndexByte", Func, 2},
+ {"IndexFunc", Func, 0},
+ {"IndexRune", Func, 0},
+ {"Join", Func, 0},
+ {"LastIndex", Func, 0},
+ {"LastIndexAny", Func, 0},
+ {"LastIndexByte", Func, 5},
+ {"LastIndexFunc", Func, 0},
+ {"Map", Func, 0},
+ {"NewReader", Func, 0},
+ {"NewReplacer", Func, 0},
+ {"Reader", Type, 0},
+ {"Repeat", Func, 0},
+ {"Replace", Func, 0},
+ {"ReplaceAll", Func, 12},
+ {"Replacer", Type, 0},
+ {"Split", Func, 0},
+ {"SplitAfter", Func, 0},
+ {"SplitAfterN", Func, 0},
+ {"SplitN", Func, 0},
+ {"Title", Func, 0},
+ {"ToLower", Func, 0},
+ {"ToLowerSpecial", Func, 0},
+ {"ToTitle", Func, 0},
+ {"ToTitleSpecial", Func, 0},
+ {"ToUpper", Func, 0},
+ {"ToUpperSpecial", Func, 0},
+ {"ToValidUTF8", Func, 13},
+ {"Trim", Func, 0},
+ {"TrimFunc", Func, 0},
+ {"TrimLeft", Func, 0},
+ {"TrimLeftFunc", Func, 0},
+ {"TrimPrefix", Func, 1},
+ {"TrimRight", Func, 0},
+ {"TrimRightFunc", Func, 0},
+ {"TrimSpace", Func, 0},
+ {"TrimSuffix", Func, 1},
+ },
+ "structs": {
+ {"HostLayout", Type, 23},
+ },
+ "sync": {
+ {"(*Cond).Broadcast", Method, 0},
+ {"(*Cond).Signal", Method, 0},
+ {"(*Cond).Wait", Method, 0},
+ {"(*Map).Clear", Method, 23},
+ {"(*Map).CompareAndDelete", Method, 20},
+ {"(*Map).CompareAndSwap", Method, 20},
+ {"(*Map).Delete", Method, 9},
+ {"(*Map).Load", Method, 9},
+ {"(*Map).LoadAndDelete", Method, 15},
+ {"(*Map).LoadOrStore", Method, 9},
+ {"(*Map).Range", Method, 9},
+ {"(*Map).Store", Method, 9},
+ {"(*Map).Swap", Method, 20},
+ {"(*Mutex).Lock", Method, 0},
+ {"(*Mutex).TryLock", Method, 18},
+ {"(*Mutex).Unlock", Method, 0},
+ {"(*Once).Do", Method, 0},
+ {"(*Pool).Get", Method, 3},
+ {"(*Pool).Put", Method, 3},
+ {"(*RWMutex).Lock", Method, 0},
+ {"(*RWMutex).RLock", Method, 0},
+ {"(*RWMutex).RLocker", Method, 0},
+ {"(*RWMutex).RUnlock", Method, 0},
+ {"(*RWMutex).TryLock", Method, 18},
+ {"(*RWMutex).TryRLock", Method, 18},
+ {"(*RWMutex).Unlock", Method, 0},
+ {"(*WaitGroup).Add", Method, 0},
+ {"(*WaitGroup).Done", Method, 0},
+ {"(*WaitGroup).Wait", Method, 0},
+ {"Cond", Type, 0},
+ {"Cond.L", Field, 0},
+ {"Locker", Type, 0},
+ {"Map", Type, 9},
+ {"Mutex", Type, 0},
+ {"NewCond", Func, 0},
+ {"Once", Type, 0},
+ {"OnceFunc", Func, 21},
+ {"OnceValue", Func, 21},
+ {"OnceValues", Func, 21},
+ {"Pool", Type, 3},
+ {"Pool.New", Field, 3},
+ {"RWMutex", Type, 0},
+ {"WaitGroup", Type, 0},
+ },
+ "sync/atomic": {
+ {"(*Bool).CompareAndSwap", Method, 19},
+ {"(*Bool).Load", Method, 19},
+ {"(*Bool).Store", Method, 19},
+ {"(*Bool).Swap", Method, 19},
+ {"(*Int32).Add", Method, 19},
+ {"(*Int32).And", Method, 23},
+ {"(*Int32).CompareAndSwap", Method, 19},
+ {"(*Int32).Load", Method, 19},
+ {"(*Int32).Or", Method, 23},
+ {"(*Int32).Store", Method, 19},
+ {"(*Int32).Swap", Method, 19},
+ {"(*Int64).Add", Method, 19},
+ {"(*Int64).And", Method, 23},
+ {"(*Int64).CompareAndSwap", Method, 19},
+ {"(*Int64).Load", Method, 19},
+ {"(*Int64).Or", Method, 23},
+ {"(*Int64).Store", Method, 19},
+ {"(*Int64).Swap", Method, 19},
+ {"(*Pointer).CompareAndSwap", Method, 19},
+ {"(*Pointer).Load", Method, 19},
+ {"(*Pointer).Store", Method, 19},
+ {"(*Pointer).Swap", Method, 19},
+ {"(*Uint32).Add", Method, 19},
+ {"(*Uint32).And", Method, 23},
+ {"(*Uint32).CompareAndSwap", Method, 19},
+ {"(*Uint32).Load", Method, 19},
+ {"(*Uint32).Or", Method, 23},
+ {"(*Uint32).Store", Method, 19},
+ {"(*Uint32).Swap", Method, 19},
+ {"(*Uint64).Add", Method, 19},
+ {"(*Uint64).And", Method, 23},
+ {"(*Uint64).CompareAndSwap", Method, 19},
+ {"(*Uint64).Load", Method, 19},
+ {"(*Uint64).Or", Method, 23},
+ {"(*Uint64).Store", Method, 19},
+ {"(*Uint64).Swap", Method, 19},
+ {"(*Uintptr).Add", Method, 19},
+ {"(*Uintptr).And", Method, 23},
+ {"(*Uintptr).CompareAndSwap", Method, 19},
+ {"(*Uintptr).Load", Method, 19},
+ {"(*Uintptr).Or", Method, 23},
+ {"(*Uintptr).Store", Method, 19},
+ {"(*Uintptr).Swap", Method, 19},
+ {"(*Value).CompareAndSwap", Method, 17},
+ {"(*Value).Load", Method, 4},
+ {"(*Value).Store", Method, 4},
+ {"(*Value).Swap", Method, 17},
+ {"AddInt32", Func, 0},
+ {"AddInt64", Func, 0},
+ {"AddUint32", Func, 0},
+ {"AddUint64", Func, 0},
+ {"AddUintptr", Func, 0},
+ {"AndInt32", Func, 23},
+ {"AndInt64", Func, 23},
+ {"AndUint32", Func, 23},
+ {"AndUint64", Func, 23},
+ {"AndUintptr", Func, 23},
+ {"Bool", Type, 19},
+ {"CompareAndSwapInt32", Func, 0},
+ {"CompareAndSwapInt64", Func, 0},
+ {"CompareAndSwapPointer", Func, 0},
+ {"CompareAndSwapUint32", Func, 0},
+ {"CompareAndSwapUint64", Func, 0},
+ {"CompareAndSwapUintptr", Func, 0},
+ {"Int32", Type, 19},
+ {"Int64", Type, 19},
+ {"LoadInt32", Func, 0},
+ {"LoadInt64", Func, 0},
+ {"LoadPointer", Func, 0},
+ {"LoadUint32", Func, 0},
+ {"LoadUint64", Func, 0},
+ {"LoadUintptr", Func, 0},
+ {"OrInt32", Func, 23},
+ {"OrInt64", Func, 23},
+ {"OrUint32", Func, 23},
+ {"OrUint64", Func, 23},
+ {"OrUintptr", Func, 23},
+ {"Pointer", Type, 19},
+ {"StoreInt32", Func, 0},
+ {"StoreInt64", Func, 0},
+ {"StorePointer", Func, 0},
+ {"StoreUint32", Func, 0},
+ {"StoreUint64", Func, 0},
+ {"StoreUintptr", Func, 0},
+ {"SwapInt32", Func, 2},
+ {"SwapInt64", Func, 2},
+ {"SwapPointer", Func, 2},
+ {"SwapUint32", Func, 2},
+ {"SwapUint64", Func, 2},
+ {"SwapUintptr", Func, 2},
+ {"Uint32", Type, 19},
+ {"Uint64", Type, 19},
+ {"Uintptr", Type, 19},
+ {"Value", Type, 4},
+ },
+ "syscall": {
+ {"(*Cmsghdr).SetLen", Method, 0},
+ {"(*DLL).FindProc", Method, 0},
+ {"(*DLL).MustFindProc", Method, 0},
+ {"(*DLL).Release", Method, 0},
+ {"(*DLLError).Error", Method, 0},
+ {"(*DLLError).Unwrap", Method, 16},
+ {"(*Filetime).Nanoseconds", Method, 0},
+ {"(*Iovec).SetLen", Method, 0},
+ {"(*LazyDLL).Handle", Method, 0},
+ {"(*LazyDLL).Load", Method, 0},
+ {"(*LazyDLL).NewProc", Method, 0},
+ {"(*LazyProc).Addr", Method, 0},
+ {"(*LazyProc).Call", Method, 0},
+ {"(*LazyProc).Find", Method, 0},
+ {"(*Msghdr).SetControllen", Method, 0},
+ {"(*Proc).Addr", Method, 0},
+ {"(*Proc).Call", Method, 0},
+ {"(*PtraceRegs).PC", Method, 0},
+ {"(*PtraceRegs).SetPC", Method, 0},
+ {"(*RawSockaddrAny).Sockaddr", Method, 0},
+ {"(*SID).Copy", Method, 0},
+ {"(*SID).Len", Method, 0},
+ {"(*SID).LookupAccount", Method, 0},
+ {"(*SID).String", Method, 0},
+ {"(*Timespec).Nano", Method, 0},
+ {"(*Timespec).Unix", Method, 0},
+ {"(*Timeval).Nano", Method, 0},
+ {"(*Timeval).Nanoseconds", Method, 0},
+ {"(*Timeval).Unix", Method, 0},
+ {"(Errno).Error", Method, 0},
+ {"(Errno).Is", Method, 13},
+ {"(Errno).Temporary", Method, 0},
+ {"(Errno).Timeout", Method, 0},
+ {"(Signal).Signal", Method, 0},
+ {"(Signal).String", Method, 0},
+ {"(Token).Close", Method, 0},
+ {"(Token).GetTokenPrimaryGroup", Method, 0},
+ {"(Token).GetTokenUser", Method, 0},
+ {"(Token).GetUserProfileDirectory", Method, 0},
+ {"(WaitStatus).Continued", Method, 0},
+ {"(WaitStatus).CoreDump", Method, 0},
+ {"(WaitStatus).ExitStatus", Method, 0},
+ {"(WaitStatus).Exited", Method, 0},
+ {"(WaitStatus).Signal", Method, 0},
+ {"(WaitStatus).Signaled", Method, 0},
+ {"(WaitStatus).StopSignal", Method, 0},
+ {"(WaitStatus).Stopped", Method, 0},
+ {"(WaitStatus).TrapCause", Method, 0},
+ {"AF_ALG", Const, 0},
+ {"AF_APPLETALK", Const, 0},
+ {"AF_ARP", Const, 0},
+ {"AF_ASH", Const, 0},
+ {"AF_ATM", Const, 0},
+ {"AF_ATMPVC", Const, 0},
+ {"AF_ATMSVC", Const, 0},
+ {"AF_AX25", Const, 0},
+ {"AF_BLUETOOTH", Const, 0},
+ {"AF_BRIDGE", Const, 0},
+ {"AF_CAIF", Const, 0},
+ {"AF_CAN", Const, 0},
+ {"AF_CCITT", Const, 0},
+ {"AF_CHAOS", Const, 0},
+ {"AF_CNT", Const, 0},
+ {"AF_COIP", Const, 0},
+ {"AF_DATAKIT", Const, 0},
+ {"AF_DECnet", Const, 0},
+ {"AF_DLI", Const, 0},
+ {"AF_E164", Const, 0},
+ {"AF_ECMA", Const, 0},
+ {"AF_ECONET", Const, 0},
+ {"AF_ENCAP", Const, 1},
+ {"AF_FILE", Const, 0},
+ {"AF_HYLINK", Const, 0},
+ {"AF_IEEE80211", Const, 0},
+ {"AF_IEEE802154", Const, 0},
+ {"AF_IMPLINK", Const, 0},
+ {"AF_INET", Const, 0},
+ {"AF_INET6", Const, 0},
+ {"AF_INET6_SDP", Const, 3},
+ {"AF_INET_SDP", Const, 3},
+ {"AF_IPX", Const, 0},
+ {"AF_IRDA", Const, 0},
+ {"AF_ISDN", Const, 0},
+ {"AF_ISO", Const, 0},
+ {"AF_IUCV", Const, 0},
+ {"AF_KEY", Const, 0},
+ {"AF_LAT", Const, 0},
+ {"AF_LINK", Const, 0},
+ {"AF_LLC", Const, 0},
+ {"AF_LOCAL", Const, 0},
+ {"AF_MAX", Const, 0},
+ {"AF_MPLS", Const, 1},
+ {"AF_NATM", Const, 0},
+ {"AF_NDRV", Const, 0},
+ {"AF_NETBEUI", Const, 0},
+ {"AF_NETBIOS", Const, 0},
+ {"AF_NETGRAPH", Const, 0},
+ {"AF_NETLINK", Const, 0},
+ {"AF_NETROM", Const, 0},
+ {"AF_NS", Const, 0},
+ {"AF_OROUTE", Const, 1},
+ {"AF_OSI", Const, 0},
+ {"AF_PACKET", Const, 0},
+ {"AF_PHONET", Const, 0},
+ {"AF_PPP", Const, 0},
+ {"AF_PPPOX", Const, 0},
+ {"AF_PUP", Const, 0},
+ {"AF_RDS", Const, 0},
+ {"AF_RESERVED_36", Const, 0},
+ {"AF_ROSE", Const, 0},
+ {"AF_ROUTE", Const, 0},
+ {"AF_RXRPC", Const, 0},
+ {"AF_SCLUSTER", Const, 0},
+ {"AF_SECURITY", Const, 0},
+ {"AF_SIP", Const, 0},
+ {"AF_SLOW", Const, 0},
+ {"AF_SNA", Const, 0},
+ {"AF_SYSTEM", Const, 0},
+ {"AF_TIPC", Const, 0},
+ {"AF_UNIX", Const, 0},
+ {"AF_UNSPEC", Const, 0},
+ {"AF_UTUN", Const, 16},
+ {"AF_VENDOR00", Const, 0},
+ {"AF_VENDOR01", Const, 0},
+ {"AF_VENDOR02", Const, 0},
+ {"AF_VENDOR03", Const, 0},
+ {"AF_VENDOR04", Const, 0},
+ {"AF_VENDOR05", Const, 0},
+ {"AF_VENDOR06", Const, 0},
+ {"AF_VENDOR07", Const, 0},
+ {"AF_VENDOR08", Const, 0},
+ {"AF_VENDOR09", Const, 0},
+ {"AF_VENDOR10", Const, 0},
+ {"AF_VENDOR11", Const, 0},
+ {"AF_VENDOR12", Const, 0},
+ {"AF_VENDOR13", Const, 0},
+ {"AF_VENDOR14", Const, 0},
+ {"AF_VENDOR15", Const, 0},
+ {"AF_VENDOR16", Const, 0},
+ {"AF_VENDOR17", Const, 0},
+ {"AF_VENDOR18", Const, 0},
+ {"AF_VENDOR19", Const, 0},
+ {"AF_VENDOR20", Const, 0},
+ {"AF_VENDOR21", Const, 0},
+ {"AF_VENDOR22", Const, 0},
+ {"AF_VENDOR23", Const, 0},
+ {"AF_VENDOR24", Const, 0},
+ {"AF_VENDOR25", Const, 0},
+ {"AF_VENDOR26", Const, 0},
+ {"AF_VENDOR27", Const, 0},
+ {"AF_VENDOR28", Const, 0},
+ {"AF_VENDOR29", Const, 0},
+ {"AF_VENDOR30", Const, 0},
+ {"AF_VENDOR31", Const, 0},
+ {"AF_VENDOR32", Const, 0},
+ {"AF_VENDOR33", Const, 0},
+ {"AF_VENDOR34", Const, 0},
+ {"AF_VENDOR35", Const, 0},
+ {"AF_VENDOR36", Const, 0},
+ {"AF_VENDOR37", Const, 0},
+ {"AF_VENDOR38", Const, 0},
+ {"AF_VENDOR39", Const, 0},
+ {"AF_VENDOR40", Const, 0},
+ {"AF_VENDOR41", Const, 0},
+ {"AF_VENDOR42", Const, 0},
+ {"AF_VENDOR43", Const, 0},
+ {"AF_VENDOR44", Const, 0},
+ {"AF_VENDOR45", Const, 0},
+ {"AF_VENDOR46", Const, 0},
+ {"AF_VENDOR47", Const, 0},
+ {"AF_WANPIPE", Const, 0},
+ {"AF_X25", Const, 0},
+ {"AI_CANONNAME", Const, 1},
+ {"AI_NUMERICHOST", Const, 1},
+ {"AI_PASSIVE", Const, 1},
+ {"APPLICATION_ERROR", Const, 0},
+ {"ARPHRD_ADAPT", Const, 0},
+ {"ARPHRD_APPLETLK", Const, 0},
+ {"ARPHRD_ARCNET", Const, 0},
+ {"ARPHRD_ASH", Const, 0},
+ {"ARPHRD_ATM", Const, 0},
+ {"ARPHRD_AX25", Const, 0},
+ {"ARPHRD_BIF", Const, 0},
+ {"ARPHRD_CHAOS", Const, 0},
+ {"ARPHRD_CISCO", Const, 0},
+ {"ARPHRD_CSLIP", Const, 0},
+ {"ARPHRD_CSLIP6", Const, 0},
+ {"ARPHRD_DDCMP", Const, 0},
+ {"ARPHRD_DLCI", Const, 0},
+ {"ARPHRD_ECONET", Const, 0},
+ {"ARPHRD_EETHER", Const, 0},
+ {"ARPHRD_ETHER", Const, 0},
+ {"ARPHRD_EUI64", Const, 0},
+ {"ARPHRD_FCAL", Const, 0},
+ {"ARPHRD_FCFABRIC", Const, 0},
+ {"ARPHRD_FCPL", Const, 0},
+ {"ARPHRD_FCPP", Const, 0},
+ {"ARPHRD_FDDI", Const, 0},
+ {"ARPHRD_FRAD", Const, 0},
+ {"ARPHRD_FRELAY", Const, 1},
+ {"ARPHRD_HDLC", Const, 0},
+ {"ARPHRD_HIPPI", Const, 0},
+ {"ARPHRD_HWX25", Const, 0},
+ {"ARPHRD_IEEE1394", Const, 0},
+ {"ARPHRD_IEEE802", Const, 0},
+ {"ARPHRD_IEEE80211", Const, 0},
+ {"ARPHRD_IEEE80211_PRISM", Const, 0},
+ {"ARPHRD_IEEE80211_RADIOTAP", Const, 0},
+ {"ARPHRD_IEEE802154", Const, 0},
+ {"ARPHRD_IEEE802154_PHY", Const, 0},
+ {"ARPHRD_IEEE802_TR", Const, 0},
+ {"ARPHRD_INFINIBAND", Const, 0},
+ {"ARPHRD_IPDDP", Const, 0},
+ {"ARPHRD_IPGRE", Const, 0},
+ {"ARPHRD_IRDA", Const, 0},
+ {"ARPHRD_LAPB", Const, 0},
+ {"ARPHRD_LOCALTLK", Const, 0},
+ {"ARPHRD_LOOPBACK", Const, 0},
+ {"ARPHRD_METRICOM", Const, 0},
+ {"ARPHRD_NETROM", Const, 0},
+ {"ARPHRD_NONE", Const, 0},
+ {"ARPHRD_PIMREG", Const, 0},
+ {"ARPHRD_PPP", Const, 0},
+ {"ARPHRD_PRONET", Const, 0},
+ {"ARPHRD_RAWHDLC", Const, 0},
+ {"ARPHRD_ROSE", Const, 0},
+ {"ARPHRD_RSRVD", Const, 0},
+ {"ARPHRD_SIT", Const, 0},
+ {"ARPHRD_SKIP", Const, 0},
+ {"ARPHRD_SLIP", Const, 0},
+ {"ARPHRD_SLIP6", Const, 0},
+ {"ARPHRD_STRIP", Const, 1},
+ {"ARPHRD_TUNNEL", Const, 0},
+ {"ARPHRD_TUNNEL6", Const, 0},
+ {"ARPHRD_VOID", Const, 0},
+ {"ARPHRD_X25", Const, 0},
+ {"AUTHTYPE_CLIENT", Const, 0},
+ {"AUTHTYPE_SERVER", Const, 0},
+ {"Accept", Func, 0},
+ {"Accept4", Func, 1},
+ {"AcceptEx", Func, 0},
+ {"Access", Func, 0},
+ {"Acct", Func, 0},
+ {"AddrinfoW", Type, 1},
+ {"AddrinfoW.Addr", Field, 1},
+ {"AddrinfoW.Addrlen", Field, 1},
+ {"AddrinfoW.Canonname", Field, 1},
+ {"AddrinfoW.Family", Field, 1},
+ {"AddrinfoW.Flags", Field, 1},
+ {"AddrinfoW.Next", Field, 1},
+ {"AddrinfoW.Protocol", Field, 1},
+ {"AddrinfoW.Socktype", Field, 1},
+ {"Adjtime", Func, 0},
+ {"Adjtimex", Func, 0},
+ {"AllThreadsSyscall", Func, 16},
+ {"AllThreadsSyscall6", Func, 16},
+ {"AttachLsf", Func, 0},
+ {"B0", Const, 0},
+ {"B1000000", Const, 0},
+ {"B110", Const, 0},
+ {"B115200", Const, 0},
+ {"B1152000", Const, 0},
+ {"B1200", Const, 0},
+ {"B134", Const, 0},
+ {"B14400", Const, 1},
+ {"B150", Const, 0},
+ {"B1500000", Const, 0},
+ {"B1800", Const, 0},
+ {"B19200", Const, 0},
+ {"B200", Const, 0},
+ {"B2000000", Const, 0},
+ {"B230400", Const, 0},
+ {"B2400", Const, 0},
+ {"B2500000", Const, 0},
+ {"B28800", Const, 1},
+ {"B300", Const, 0},
+ {"B3000000", Const, 0},
+ {"B3500000", Const, 0},
+ {"B38400", Const, 0},
+ {"B4000000", Const, 0},
+ {"B460800", Const, 0},
+ {"B4800", Const, 0},
+ {"B50", Const, 0},
+ {"B500000", Const, 0},
+ {"B57600", Const, 0},
+ {"B576000", Const, 0},
+ {"B600", Const, 0},
+ {"B7200", Const, 1},
+ {"B75", Const, 0},
+ {"B76800", Const, 1},
+ {"B921600", Const, 0},
+ {"B9600", Const, 0},
+ {"BASE_PROTOCOL", Const, 2},
+ {"BIOCFEEDBACK", Const, 0},
+ {"BIOCFLUSH", Const, 0},
+ {"BIOCGBLEN", Const, 0},
+ {"BIOCGDIRECTION", Const, 0},
+ {"BIOCGDIRFILT", Const, 1},
+ {"BIOCGDLT", Const, 0},
+ {"BIOCGDLTLIST", Const, 0},
+ {"BIOCGETBUFMODE", Const, 0},
+ {"BIOCGETIF", Const, 0},
+ {"BIOCGETZMAX", Const, 0},
+ {"BIOCGFEEDBACK", Const, 1},
+ {"BIOCGFILDROP", Const, 1},
+ {"BIOCGHDRCMPLT", Const, 0},
+ {"BIOCGRSIG", Const, 0},
+ {"BIOCGRTIMEOUT", Const, 0},
+ {"BIOCGSEESENT", Const, 0},
+ {"BIOCGSTATS", Const, 0},
+ {"BIOCGSTATSOLD", Const, 1},
+ {"BIOCGTSTAMP", Const, 1},
+ {"BIOCIMMEDIATE", Const, 0},
+ {"BIOCLOCK", Const, 0},
+ {"BIOCPROMISC", Const, 0},
+ {"BIOCROTZBUF", Const, 0},
+ {"BIOCSBLEN", Const, 0},
+ {"BIOCSDIRECTION", Const, 0},
+ {"BIOCSDIRFILT", Const, 1},
+ {"BIOCSDLT", Const, 0},
+ {"BIOCSETBUFMODE", Const, 0},
+ {"BIOCSETF", Const, 0},
+ {"BIOCSETFNR", Const, 0},
+ {"BIOCSETIF", Const, 0},
+ {"BIOCSETWF", Const, 0},
+ {"BIOCSETZBUF", Const, 0},
+ {"BIOCSFEEDBACK", Const, 1},
+ {"BIOCSFILDROP", Const, 1},
+ {"BIOCSHDRCMPLT", Const, 0},
+ {"BIOCSRSIG", Const, 0},
+ {"BIOCSRTIMEOUT", Const, 0},
+ {"BIOCSSEESENT", Const, 0},
+ {"BIOCSTCPF", Const, 1},
+ {"BIOCSTSTAMP", Const, 1},
+ {"BIOCSUDPF", Const, 1},
+ {"BIOCVERSION", Const, 0},
+ {"BPF_A", Const, 0},
+ {"BPF_ABS", Const, 0},
+ {"BPF_ADD", Const, 0},
+ {"BPF_ALIGNMENT", Const, 0},
+ {"BPF_ALIGNMENT32", Const, 1},
+ {"BPF_ALU", Const, 0},
+ {"BPF_AND", Const, 0},
+ {"BPF_B", Const, 0},
+ {"BPF_BUFMODE_BUFFER", Const, 0},
+ {"BPF_BUFMODE_ZBUF", Const, 0},
+ {"BPF_DFLTBUFSIZE", Const, 1},
+ {"BPF_DIRECTION_IN", Const, 1},
+ {"BPF_DIRECTION_OUT", Const, 1},
+ {"BPF_DIV", Const, 0},
+ {"BPF_H", Const, 0},
+ {"BPF_IMM", Const, 0},
+ {"BPF_IND", Const, 0},
+ {"BPF_JA", Const, 0},
+ {"BPF_JEQ", Const, 0},
+ {"BPF_JGE", Const, 0},
+ {"BPF_JGT", Const, 0},
+ {"BPF_JMP", Const, 0},
+ {"BPF_JSET", Const, 0},
+ {"BPF_K", Const, 0},
+ {"BPF_LD", Const, 0},
+ {"BPF_LDX", Const, 0},
+ {"BPF_LEN", Const, 0},
+ {"BPF_LSH", Const, 0},
+ {"BPF_MAJOR_VERSION", Const, 0},
+ {"BPF_MAXBUFSIZE", Const, 0},
+ {"BPF_MAXINSNS", Const, 0},
+ {"BPF_MEM", Const, 0},
+ {"BPF_MEMWORDS", Const, 0},
+ {"BPF_MINBUFSIZE", Const, 0},
+ {"BPF_MINOR_VERSION", Const, 0},
+ {"BPF_MISC", Const, 0},
+ {"BPF_MSH", Const, 0},
+ {"BPF_MUL", Const, 0},
+ {"BPF_NEG", Const, 0},
+ {"BPF_OR", Const, 0},
+ {"BPF_RELEASE", Const, 0},
+ {"BPF_RET", Const, 0},
+ {"BPF_RSH", Const, 0},
+ {"BPF_ST", Const, 0},
+ {"BPF_STX", Const, 0},
+ {"BPF_SUB", Const, 0},
+ {"BPF_TAX", Const, 0},
+ {"BPF_TXA", Const, 0},
+ {"BPF_T_BINTIME", Const, 1},
+ {"BPF_T_BINTIME_FAST", Const, 1},
+ {"BPF_T_BINTIME_MONOTONIC", Const, 1},
+ {"BPF_T_BINTIME_MONOTONIC_FAST", Const, 1},
+ {"BPF_T_FAST", Const, 1},
+ {"BPF_T_FLAG_MASK", Const, 1},
+ {"BPF_T_FORMAT_MASK", Const, 1},
+ {"BPF_T_MICROTIME", Const, 1},
+ {"BPF_T_MICROTIME_FAST", Const, 1},
+ {"BPF_T_MICROTIME_MONOTONIC", Const, 1},
+ {"BPF_T_MICROTIME_MONOTONIC_FAST", Const, 1},
+ {"BPF_T_MONOTONIC", Const, 1},
+ {"BPF_T_MONOTONIC_FAST", Const, 1},
+ {"BPF_T_NANOTIME", Const, 1},
+ {"BPF_T_NANOTIME_FAST", Const, 1},
+ {"BPF_T_NANOTIME_MONOTONIC", Const, 1},
+ {"BPF_T_NANOTIME_MONOTONIC_FAST", Const, 1},
+ {"BPF_T_NONE", Const, 1},
+ {"BPF_T_NORMAL", Const, 1},
+ {"BPF_W", Const, 0},
+ {"BPF_X", Const, 0},
+ {"BRKINT", Const, 0},
+ {"Bind", Func, 0},
+ {"BindToDevice", Func, 0},
+ {"BpfBuflen", Func, 0},
+ {"BpfDatalink", Func, 0},
+ {"BpfHdr", Type, 0},
+ {"BpfHdr.Caplen", Field, 0},
+ {"BpfHdr.Datalen", Field, 0},
+ {"BpfHdr.Hdrlen", Field, 0},
+ {"BpfHdr.Pad_cgo_0", Field, 0},
+ {"BpfHdr.Tstamp", Field, 0},
+ {"BpfHeadercmpl", Func, 0},
+ {"BpfInsn", Type, 0},
+ {"BpfInsn.Code", Field, 0},
+ {"BpfInsn.Jf", Field, 0},
+ {"BpfInsn.Jt", Field, 0},
+ {"BpfInsn.K", Field, 0},
+ {"BpfInterface", Func, 0},
+ {"BpfJump", Func, 0},
+ {"BpfProgram", Type, 0},
+ {"BpfProgram.Insns", Field, 0},
+ {"BpfProgram.Len", Field, 0},
+ {"BpfProgram.Pad_cgo_0", Field, 0},
+ {"BpfStat", Type, 0},
+ {"BpfStat.Capt", Field, 2},
+ {"BpfStat.Drop", Field, 0},
+ {"BpfStat.Padding", Field, 2},
+ {"BpfStat.Recv", Field, 0},
+ {"BpfStats", Func, 0},
+ {"BpfStmt", Func, 0},
+ {"BpfTimeout", Func, 0},
+ {"BpfTimeval", Type, 2},
+ {"BpfTimeval.Sec", Field, 2},
+ {"BpfTimeval.Usec", Field, 2},
+ {"BpfVersion", Type, 0},
+ {"BpfVersion.Major", Field, 0},
+ {"BpfVersion.Minor", Field, 0},
+ {"BpfZbuf", Type, 0},
+ {"BpfZbuf.Bufa", Field, 0},
+ {"BpfZbuf.Bufb", Field, 0},
+ {"BpfZbuf.Buflen", Field, 0},
+ {"BpfZbufHeader", Type, 0},
+ {"BpfZbufHeader.Kernel_gen", Field, 0},
+ {"BpfZbufHeader.Kernel_len", Field, 0},
+ {"BpfZbufHeader.User_gen", Field, 0},
+ {"BpfZbufHeader.X_bzh_pad", Field, 0},
+ {"ByHandleFileInformation", Type, 0},
+ {"ByHandleFileInformation.CreationTime", Field, 0},
+ {"ByHandleFileInformation.FileAttributes", Field, 0},
+ {"ByHandleFileInformation.FileIndexHigh", Field, 0},
+ {"ByHandleFileInformation.FileIndexLow", Field, 0},
+ {"ByHandleFileInformation.FileSizeHigh", Field, 0},
+ {"ByHandleFileInformation.FileSizeLow", Field, 0},
+ {"ByHandleFileInformation.LastAccessTime", Field, 0},
+ {"ByHandleFileInformation.LastWriteTime", Field, 0},
+ {"ByHandleFileInformation.NumberOfLinks", Field, 0},
+ {"ByHandleFileInformation.VolumeSerialNumber", Field, 0},
+ {"BytePtrFromString", Func, 1},
+ {"ByteSliceFromString", Func, 1},
+ {"CCR0_FLUSH", Const, 1},
+ {"CERT_CHAIN_POLICY_AUTHENTICODE", Const, 0},
+ {"CERT_CHAIN_POLICY_AUTHENTICODE_TS", Const, 0},
+ {"CERT_CHAIN_POLICY_BASE", Const, 0},
+ {"CERT_CHAIN_POLICY_BASIC_CONSTRAINTS", Const, 0},
+ {"CERT_CHAIN_POLICY_EV", Const, 0},
+ {"CERT_CHAIN_POLICY_MICROSOFT_ROOT", Const, 0},
+ {"CERT_CHAIN_POLICY_NT_AUTH", Const, 0},
+ {"CERT_CHAIN_POLICY_SSL", Const, 0},
+ {"CERT_E_CN_NO_MATCH", Const, 0},
+ {"CERT_E_EXPIRED", Const, 0},
+ {"CERT_E_PURPOSE", Const, 0},
+ {"CERT_E_ROLE", Const, 0},
+ {"CERT_E_UNTRUSTEDROOT", Const, 0},
+ {"CERT_STORE_ADD_ALWAYS", Const, 0},
+ {"CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG", Const, 0},
+ {"CERT_STORE_PROV_MEMORY", Const, 0},
+ {"CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT", Const, 0},
+ {"CERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINT", Const, 0},
+ {"CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT", Const, 0},
+ {"CERT_TRUST_HAS_NOT_SUPPORTED_CRITICAL_EXT", Const, 0},
+ {"CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT", Const, 0},
+ {"CERT_TRUST_INVALID_BASIC_CONSTRAINTS", Const, 0},
+ {"CERT_TRUST_INVALID_EXTENSION", Const, 0},
+ {"CERT_TRUST_INVALID_NAME_CONSTRAINTS", Const, 0},
+ {"CERT_TRUST_INVALID_POLICY_CONSTRAINTS", Const, 0},
+ {"CERT_TRUST_IS_CYCLIC", Const, 0},
+ {"CERT_TRUST_IS_EXPLICIT_DISTRUST", Const, 0},
+ {"CERT_TRUST_IS_NOT_SIGNATURE_VALID", Const, 0},
+ {"CERT_TRUST_IS_NOT_TIME_VALID", Const, 0},
+ {"CERT_TRUST_IS_NOT_VALID_FOR_USAGE", Const, 0},
+ {"CERT_TRUST_IS_OFFLINE_REVOCATION", Const, 0},
+ {"CERT_TRUST_IS_REVOKED", Const, 0},
+ {"CERT_TRUST_IS_UNTRUSTED_ROOT", Const, 0},
+ {"CERT_TRUST_NO_ERROR", Const, 0},
+ {"CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY", Const, 0},
+ {"CERT_TRUST_REVOCATION_STATUS_UNKNOWN", Const, 0},
+ {"CFLUSH", Const, 1},
+ {"CLOCAL", Const, 0},
+ {"CLONE_CHILD_CLEARTID", Const, 2},
+ {"CLONE_CHILD_SETTID", Const, 2},
+ {"CLONE_CLEAR_SIGHAND", Const, 20},
+ {"CLONE_CSIGNAL", Const, 3},
+ {"CLONE_DETACHED", Const, 2},
+ {"CLONE_FILES", Const, 2},
+ {"CLONE_FS", Const, 2},
+ {"CLONE_INTO_CGROUP", Const, 20},
+ {"CLONE_IO", Const, 2},
+ {"CLONE_NEWCGROUP", Const, 20},
+ {"CLONE_NEWIPC", Const, 2},
+ {"CLONE_NEWNET", Const, 2},
+ {"CLONE_NEWNS", Const, 2},
+ {"CLONE_NEWPID", Const, 2},
+ {"CLONE_NEWTIME", Const, 20},
+ {"CLONE_NEWUSER", Const, 2},
+ {"CLONE_NEWUTS", Const, 2},
+ {"CLONE_PARENT", Const, 2},
+ {"CLONE_PARENT_SETTID", Const, 2},
+ {"CLONE_PID", Const, 3},
+ {"CLONE_PIDFD", Const, 20},
+ {"CLONE_PTRACE", Const, 2},
+ {"CLONE_SETTLS", Const, 2},
+ {"CLONE_SIGHAND", Const, 2},
+ {"CLONE_SYSVSEM", Const, 2},
+ {"CLONE_THREAD", Const, 2},
+ {"CLONE_UNTRACED", Const, 2},
+ {"CLONE_VFORK", Const, 2},
+ {"CLONE_VM", Const, 2},
+ {"CPUID_CFLUSH", Const, 1},
+ {"CREAD", Const, 0},
+ {"CREATE_ALWAYS", Const, 0},
+ {"CREATE_NEW", Const, 0},
+ {"CREATE_NEW_PROCESS_GROUP", Const, 1},
+ {"CREATE_UNICODE_ENVIRONMENT", Const, 0},
+ {"CRYPT_DEFAULT_CONTAINER_OPTIONAL", Const, 0},
+ {"CRYPT_DELETEKEYSET", Const, 0},
+ {"CRYPT_MACHINE_KEYSET", Const, 0},
+ {"CRYPT_NEWKEYSET", Const, 0},
+ {"CRYPT_SILENT", Const, 0},
+ {"CRYPT_VERIFYCONTEXT", Const, 0},
+ {"CS5", Const, 0},
+ {"CS6", Const, 0},
+ {"CS7", Const, 0},
+ {"CS8", Const, 0},
+ {"CSIZE", Const, 0},
+ {"CSTART", Const, 1},
+ {"CSTATUS", Const, 1},
+ {"CSTOP", Const, 1},
+ {"CSTOPB", Const, 0},
+ {"CSUSP", Const, 1},
+ {"CTL_MAXNAME", Const, 0},
+ {"CTL_NET", Const, 0},
+ {"CTL_QUERY", Const, 1},
+ {"CTRL_BREAK_EVENT", Const, 1},
+ {"CTRL_CLOSE_EVENT", Const, 14},
+ {"CTRL_C_EVENT", Const, 1},
+ {"CTRL_LOGOFF_EVENT", Const, 14},
+ {"CTRL_SHUTDOWN_EVENT", Const, 14},
+ {"CancelIo", Func, 0},
+ {"CancelIoEx", Func, 1},
+ {"CertAddCertificateContextToStore", Func, 0},
+ {"CertChainContext", Type, 0},
+ {"CertChainContext.ChainCount", Field, 0},
+ {"CertChainContext.Chains", Field, 0},
+ {"CertChainContext.HasRevocationFreshnessTime", Field, 0},
+ {"CertChainContext.LowerQualityChainCount", Field, 0},
+ {"CertChainContext.LowerQualityChains", Field, 0},
+ {"CertChainContext.RevocationFreshnessTime", Field, 0},
+ {"CertChainContext.Size", Field, 0},
+ {"CertChainContext.TrustStatus", Field, 0},
+ {"CertChainElement", Type, 0},
+ {"CertChainElement.ApplicationUsage", Field, 0},
+ {"CertChainElement.CertContext", Field, 0},
+ {"CertChainElement.ExtendedErrorInfo", Field, 0},
+ {"CertChainElement.IssuanceUsage", Field, 0},
+ {"CertChainElement.RevocationInfo", Field, 0},
+ {"CertChainElement.Size", Field, 0},
+ {"CertChainElement.TrustStatus", Field, 0},
+ {"CertChainPara", Type, 0},
+ {"CertChainPara.CacheResync", Field, 0},
+ {"CertChainPara.CheckRevocationFreshnessTime", Field, 0},
+ {"CertChainPara.RequestedUsage", Field, 0},
+ {"CertChainPara.RequstedIssuancePolicy", Field, 0},
+ {"CertChainPara.RevocationFreshnessTime", Field, 0},
+ {"CertChainPara.Size", Field, 0},
+ {"CertChainPara.URLRetrievalTimeout", Field, 0},
+ {"CertChainPolicyPara", Type, 0},
+ {"CertChainPolicyPara.ExtraPolicyPara", Field, 0},
+ {"CertChainPolicyPara.Flags", Field, 0},
+ {"CertChainPolicyPara.Size", Field, 0},
+ {"CertChainPolicyStatus", Type, 0},
+ {"CertChainPolicyStatus.ChainIndex", Field, 0},
+ {"CertChainPolicyStatus.ElementIndex", Field, 0},
+ {"CertChainPolicyStatus.Error", Field, 0},
+ {"CertChainPolicyStatus.ExtraPolicyStatus", Field, 0},
+ {"CertChainPolicyStatus.Size", Field, 0},
+ {"CertCloseStore", Func, 0},
+ {"CertContext", Type, 0},
+ {"CertContext.CertInfo", Field, 0},
+ {"CertContext.EncodedCert", Field, 0},
+ {"CertContext.EncodingType", Field, 0},
+ {"CertContext.Length", Field, 0},
+ {"CertContext.Store", Field, 0},
+ {"CertCreateCertificateContext", Func, 0},
+ {"CertEnhKeyUsage", Type, 0},
+ {"CertEnhKeyUsage.Length", Field, 0},
+ {"CertEnhKeyUsage.UsageIdentifiers", Field, 0},
+ {"CertEnumCertificatesInStore", Func, 0},
+ {"CertFreeCertificateChain", Func, 0},
+ {"CertFreeCertificateContext", Func, 0},
+ {"CertGetCertificateChain", Func, 0},
+ {"CertInfo", Type, 11},
+ {"CertOpenStore", Func, 0},
+ {"CertOpenSystemStore", Func, 0},
+ {"CertRevocationCrlInfo", Type, 11},
+ {"CertRevocationInfo", Type, 0},
+ {"CertRevocationInfo.CrlInfo", Field, 0},
+ {"CertRevocationInfo.FreshnessTime", Field, 0},
+ {"CertRevocationInfo.HasFreshnessTime", Field, 0},
+ {"CertRevocationInfo.OidSpecificInfo", Field, 0},
+ {"CertRevocationInfo.RevocationOid", Field, 0},
+ {"CertRevocationInfo.RevocationResult", Field, 0},
+ {"CertRevocationInfo.Size", Field, 0},
+ {"CertSimpleChain", Type, 0},
+ {"CertSimpleChain.Elements", Field, 0},
+ {"CertSimpleChain.HasRevocationFreshnessTime", Field, 0},
+ {"CertSimpleChain.NumElements", Field, 0},
+ {"CertSimpleChain.RevocationFreshnessTime", Field, 0},
+ {"CertSimpleChain.Size", Field, 0},
+ {"CertSimpleChain.TrustListInfo", Field, 0},
+ {"CertSimpleChain.TrustStatus", Field, 0},
+ {"CertTrustListInfo", Type, 11},
+ {"CertTrustStatus", Type, 0},
+ {"CertTrustStatus.ErrorStatus", Field, 0},
+ {"CertTrustStatus.InfoStatus", Field, 0},
+ {"CertUsageMatch", Type, 0},
+ {"CertUsageMatch.Type", Field, 0},
+ {"CertUsageMatch.Usage", Field, 0},
+ {"CertVerifyCertificateChainPolicy", Func, 0},
+ {"Chdir", Func, 0},
+ {"CheckBpfVersion", Func, 0},
+ {"Chflags", Func, 0},
+ {"Chmod", Func, 0},
+ {"Chown", Func, 0},
+ {"Chroot", Func, 0},
+ {"Clearenv", Func, 0},
+ {"Close", Func, 0},
+ {"CloseHandle", Func, 0},
+ {"CloseOnExec", Func, 0},
+ {"Closesocket", Func, 0},
+ {"CmsgLen", Func, 0},
+ {"CmsgSpace", Func, 0},
+ {"Cmsghdr", Type, 0},
+ {"Cmsghdr.Len", Field, 0},
+ {"Cmsghdr.Level", Field, 0},
+ {"Cmsghdr.Type", Field, 0},
+ {"Cmsghdr.X__cmsg_data", Field, 0},
+ {"CommandLineToArgv", Func, 0},
+ {"ComputerName", Func, 0},
+ {"Conn", Type, 9},
+ {"Connect", Func, 0},
+ {"ConnectEx", Func, 1},
+ {"ConvertSidToStringSid", Func, 0},
+ {"ConvertStringSidToSid", Func, 0},
+ {"CopySid", Func, 0},
+ {"Creat", Func, 0},
+ {"CreateDirectory", Func, 0},
+ {"CreateFile", Func, 0},
+ {"CreateFileMapping", Func, 0},
+ {"CreateHardLink", Func, 4},
+ {"CreateIoCompletionPort", Func, 0},
+ {"CreatePipe", Func, 0},
+ {"CreateProcess", Func, 0},
+ {"CreateProcessAsUser", Func, 10},
+ {"CreateSymbolicLink", Func, 4},
+ {"CreateToolhelp32Snapshot", Func, 4},
+ {"Credential", Type, 0},
+ {"Credential.Gid", Field, 0},
+ {"Credential.Groups", Field, 0},
+ {"Credential.NoSetGroups", Field, 9},
+ {"Credential.Uid", Field, 0},
+ {"CryptAcquireContext", Func, 0},
+ {"CryptGenRandom", Func, 0},
+ {"CryptReleaseContext", Func, 0},
+ {"DIOCBSFLUSH", Const, 1},
+ {"DIOCOSFPFLUSH", Const, 1},
+ {"DLL", Type, 0},
+ {"DLL.Handle", Field, 0},
+ {"DLL.Name", Field, 0},
+ {"DLLError", Type, 0},
+ {"DLLError.Err", Field, 0},
+ {"DLLError.Msg", Field, 0},
+ {"DLLError.ObjName", Field, 0},
+ {"DLT_A429", Const, 0},
+ {"DLT_A653_ICM", Const, 0},
+ {"DLT_AIRONET_HEADER", Const, 0},
+ {"DLT_AOS", Const, 1},
+ {"DLT_APPLE_IP_OVER_IEEE1394", Const, 0},
+ {"DLT_ARCNET", Const, 0},
+ {"DLT_ARCNET_LINUX", Const, 0},
+ {"DLT_ATM_CLIP", Const, 0},
+ {"DLT_ATM_RFC1483", Const, 0},
+ {"DLT_AURORA", Const, 0},
+ {"DLT_AX25", Const, 0},
+ {"DLT_AX25_KISS", Const, 0},
+ {"DLT_BACNET_MS_TP", Const, 0},
+ {"DLT_BLUETOOTH_HCI_H4", Const, 0},
+ {"DLT_BLUETOOTH_HCI_H4_WITH_PHDR", Const, 0},
+ {"DLT_CAN20B", Const, 0},
+ {"DLT_CAN_SOCKETCAN", Const, 1},
+ {"DLT_CHAOS", Const, 0},
+ {"DLT_CHDLC", Const, 0},
+ {"DLT_CISCO_IOS", Const, 0},
+ {"DLT_C_HDLC", Const, 0},
+ {"DLT_C_HDLC_WITH_DIR", Const, 0},
+ {"DLT_DBUS", Const, 1},
+ {"DLT_DECT", Const, 1},
+ {"DLT_DOCSIS", Const, 0},
+ {"DLT_DVB_CI", Const, 1},
+ {"DLT_ECONET", Const, 0},
+ {"DLT_EN10MB", Const, 0},
+ {"DLT_EN3MB", Const, 0},
+ {"DLT_ENC", Const, 0},
+ {"DLT_ERF", Const, 0},
+ {"DLT_ERF_ETH", Const, 0},
+ {"DLT_ERF_POS", Const, 0},
+ {"DLT_FC_2", Const, 1},
+ {"DLT_FC_2_WITH_FRAME_DELIMS", Const, 1},
+ {"DLT_FDDI", Const, 0},
+ {"DLT_FLEXRAY", Const, 0},
+ {"DLT_FRELAY", Const, 0},
+ {"DLT_FRELAY_WITH_DIR", Const, 0},
+ {"DLT_GCOM_SERIAL", Const, 0},
+ {"DLT_GCOM_T1E1", Const, 0},
+ {"DLT_GPF_F", Const, 0},
+ {"DLT_GPF_T", Const, 0},
+ {"DLT_GPRS_LLC", Const, 0},
+ {"DLT_GSMTAP_ABIS", Const, 1},
+ {"DLT_GSMTAP_UM", Const, 1},
+ {"DLT_HDLC", Const, 1},
+ {"DLT_HHDLC", Const, 0},
+ {"DLT_HIPPI", Const, 1},
+ {"DLT_IBM_SN", Const, 0},
+ {"DLT_IBM_SP", Const, 0},
+ {"DLT_IEEE802", Const, 0},
+ {"DLT_IEEE802_11", Const, 0},
+ {"DLT_IEEE802_11_RADIO", Const, 0},
+ {"DLT_IEEE802_11_RADIO_AVS", Const, 0},
+ {"DLT_IEEE802_15_4", Const, 0},
+ {"DLT_IEEE802_15_4_LINUX", Const, 0},
+ {"DLT_IEEE802_15_4_NOFCS", Const, 1},
+ {"DLT_IEEE802_15_4_NONASK_PHY", Const, 0},
+ {"DLT_IEEE802_16_MAC_CPS", Const, 0},
+ {"DLT_IEEE802_16_MAC_CPS_RADIO", Const, 0},
+ {"DLT_IPFILTER", Const, 0},
+ {"DLT_IPMB", Const, 0},
+ {"DLT_IPMB_LINUX", Const, 0},
+ {"DLT_IPNET", Const, 1},
+ {"DLT_IPOIB", Const, 1},
+ {"DLT_IPV4", Const, 1},
+ {"DLT_IPV6", Const, 1},
+ {"DLT_IP_OVER_FC", Const, 0},
+ {"DLT_JUNIPER_ATM1", Const, 0},
+ {"DLT_JUNIPER_ATM2", Const, 0},
+ {"DLT_JUNIPER_ATM_CEMIC", Const, 1},
+ {"DLT_JUNIPER_CHDLC", Const, 0},
+ {"DLT_JUNIPER_ES", Const, 0},
+ {"DLT_JUNIPER_ETHER", Const, 0},
+ {"DLT_JUNIPER_FIBRECHANNEL", Const, 1},
+ {"DLT_JUNIPER_FRELAY", Const, 0},
+ {"DLT_JUNIPER_GGSN", Const, 0},
+ {"DLT_JUNIPER_ISM", Const, 0},
+ {"DLT_JUNIPER_MFR", Const, 0},
+ {"DLT_JUNIPER_MLFR", Const, 0},
+ {"DLT_JUNIPER_MLPPP", Const, 0},
+ {"DLT_JUNIPER_MONITOR", Const, 0},
+ {"DLT_JUNIPER_PIC_PEER", Const, 0},
+ {"DLT_JUNIPER_PPP", Const, 0},
+ {"DLT_JUNIPER_PPPOE", Const, 0},
+ {"DLT_JUNIPER_PPPOE_ATM", Const, 0},
+ {"DLT_JUNIPER_SERVICES", Const, 0},
+ {"DLT_JUNIPER_SRX_E2E", Const, 1},
+ {"DLT_JUNIPER_ST", Const, 0},
+ {"DLT_JUNIPER_VP", Const, 0},
+ {"DLT_JUNIPER_VS", Const, 1},
+ {"DLT_LAPB_WITH_DIR", Const, 0},
+ {"DLT_LAPD", Const, 0},
+ {"DLT_LIN", Const, 0},
+ {"DLT_LINUX_EVDEV", Const, 1},
+ {"DLT_LINUX_IRDA", Const, 0},
+ {"DLT_LINUX_LAPD", Const, 0},
+ {"DLT_LINUX_PPP_WITHDIRECTION", Const, 0},
+ {"DLT_LINUX_SLL", Const, 0},
+ {"DLT_LOOP", Const, 0},
+ {"DLT_LTALK", Const, 0},
+ {"DLT_MATCHING_MAX", Const, 1},
+ {"DLT_MATCHING_MIN", Const, 1},
+ {"DLT_MFR", Const, 0},
+ {"DLT_MOST", Const, 0},
+ {"DLT_MPEG_2_TS", Const, 1},
+ {"DLT_MPLS", Const, 1},
+ {"DLT_MTP2", Const, 0},
+ {"DLT_MTP2_WITH_PHDR", Const, 0},
+ {"DLT_MTP3", Const, 0},
+ {"DLT_MUX27010", Const, 1},
+ {"DLT_NETANALYZER", Const, 1},
+ {"DLT_NETANALYZER_TRANSPARENT", Const, 1},
+ {"DLT_NFC_LLCP", Const, 1},
+ {"DLT_NFLOG", Const, 1},
+ {"DLT_NG40", Const, 1},
+ {"DLT_NULL", Const, 0},
+ {"DLT_PCI_EXP", Const, 0},
+ {"DLT_PFLOG", Const, 0},
+ {"DLT_PFSYNC", Const, 0},
+ {"DLT_PPI", Const, 0},
+ {"DLT_PPP", Const, 0},
+ {"DLT_PPP_BSDOS", Const, 0},
+ {"DLT_PPP_ETHER", Const, 0},
+ {"DLT_PPP_PPPD", Const, 0},
+ {"DLT_PPP_SERIAL", Const, 0},
+ {"DLT_PPP_WITH_DIR", Const, 0},
+ {"DLT_PPP_WITH_DIRECTION", Const, 0},
+ {"DLT_PRISM_HEADER", Const, 0},
+ {"DLT_PRONET", Const, 0},
+ {"DLT_RAIF1", Const, 0},
+ {"DLT_RAW", Const, 0},
+ {"DLT_RAWAF_MASK", Const, 1},
+ {"DLT_RIO", Const, 0},
+ {"DLT_SCCP", Const, 0},
+ {"DLT_SITA", Const, 0},
+ {"DLT_SLIP", Const, 0},
+ {"DLT_SLIP_BSDOS", Const, 0},
+ {"DLT_STANAG_5066_D_PDU", Const, 1},
+ {"DLT_SUNATM", Const, 0},
+ {"DLT_SYMANTEC_FIREWALL", Const, 0},
+ {"DLT_TZSP", Const, 0},
+ {"DLT_USB", Const, 0},
+ {"DLT_USB_LINUX", Const, 0},
+ {"DLT_USB_LINUX_MMAPPED", Const, 1},
+ {"DLT_USER0", Const, 0},
+ {"DLT_USER1", Const, 0},
+ {"DLT_USER10", Const, 0},
+ {"DLT_USER11", Const, 0},
+ {"DLT_USER12", Const, 0},
+ {"DLT_USER13", Const, 0},
+ {"DLT_USER14", Const, 0},
+ {"DLT_USER15", Const, 0},
+ {"DLT_USER2", Const, 0},
+ {"DLT_USER3", Const, 0},
+ {"DLT_USER4", Const, 0},
+ {"DLT_USER5", Const, 0},
+ {"DLT_USER6", Const, 0},
+ {"DLT_USER7", Const, 0},
+ {"DLT_USER8", Const, 0},
+ {"DLT_USER9", Const, 0},
+ {"DLT_WIHART", Const, 1},
+ {"DLT_X2E_SERIAL", Const, 0},
+ {"DLT_X2E_XORAYA", Const, 0},
+ {"DNSMXData", Type, 0},
+ {"DNSMXData.NameExchange", Field, 0},
+ {"DNSMXData.Pad", Field, 0},
+ {"DNSMXData.Preference", Field, 0},
+ {"DNSPTRData", Type, 0},
+ {"DNSPTRData.Host", Field, 0},
+ {"DNSRecord", Type, 0},
+ {"DNSRecord.Data", Field, 0},
+ {"DNSRecord.Dw", Field, 0},
+ {"DNSRecord.Length", Field, 0},
+ {"DNSRecord.Name", Field, 0},
+ {"DNSRecord.Next", Field, 0},
+ {"DNSRecord.Reserved", Field, 0},
+ {"DNSRecord.Ttl", Field, 0},
+ {"DNSRecord.Type", Field, 0},
+ {"DNSSRVData", Type, 0},
+ {"DNSSRVData.Pad", Field, 0},
+ {"DNSSRVData.Port", Field, 0},
+ {"DNSSRVData.Priority", Field, 0},
+ {"DNSSRVData.Target", Field, 0},
+ {"DNSSRVData.Weight", Field, 0},
+ {"DNSTXTData", Type, 0},
+ {"DNSTXTData.StringArray", Field, 0},
+ {"DNSTXTData.StringCount", Field, 0},
+ {"DNS_INFO_NO_RECORDS", Const, 4},
+ {"DNS_TYPE_A", Const, 0},
+ {"DNS_TYPE_A6", Const, 0},
+ {"DNS_TYPE_AAAA", Const, 0},
+ {"DNS_TYPE_ADDRS", Const, 0},
+ {"DNS_TYPE_AFSDB", Const, 0},
+ {"DNS_TYPE_ALL", Const, 0},
+ {"DNS_TYPE_ANY", Const, 0},
+ {"DNS_TYPE_ATMA", Const, 0},
+ {"DNS_TYPE_AXFR", Const, 0},
+ {"DNS_TYPE_CERT", Const, 0},
+ {"DNS_TYPE_CNAME", Const, 0},
+ {"DNS_TYPE_DHCID", Const, 0},
+ {"DNS_TYPE_DNAME", Const, 0},
+ {"DNS_TYPE_DNSKEY", Const, 0},
+ {"DNS_TYPE_DS", Const, 0},
+ {"DNS_TYPE_EID", Const, 0},
+ {"DNS_TYPE_GID", Const, 0},
+ {"DNS_TYPE_GPOS", Const, 0},
+ {"DNS_TYPE_HINFO", Const, 0},
+ {"DNS_TYPE_ISDN", Const, 0},
+ {"DNS_TYPE_IXFR", Const, 0},
+ {"DNS_TYPE_KEY", Const, 0},
+ {"DNS_TYPE_KX", Const, 0},
+ {"DNS_TYPE_LOC", Const, 0},
+ {"DNS_TYPE_MAILA", Const, 0},
+ {"DNS_TYPE_MAILB", Const, 0},
+ {"DNS_TYPE_MB", Const, 0},
+ {"DNS_TYPE_MD", Const, 0},
+ {"DNS_TYPE_MF", Const, 0},
+ {"DNS_TYPE_MG", Const, 0},
+ {"DNS_TYPE_MINFO", Const, 0},
+ {"DNS_TYPE_MR", Const, 0},
+ {"DNS_TYPE_MX", Const, 0},
+ {"DNS_TYPE_NAPTR", Const, 0},
+ {"DNS_TYPE_NBSTAT", Const, 0},
+ {"DNS_TYPE_NIMLOC", Const, 0},
+ {"DNS_TYPE_NS", Const, 0},
+ {"DNS_TYPE_NSAP", Const, 0},
+ {"DNS_TYPE_NSAPPTR", Const, 0},
+ {"DNS_TYPE_NSEC", Const, 0},
+ {"DNS_TYPE_NULL", Const, 0},
+ {"DNS_TYPE_NXT", Const, 0},
+ {"DNS_TYPE_OPT", Const, 0},
+ {"DNS_TYPE_PTR", Const, 0},
+ {"DNS_TYPE_PX", Const, 0},
+ {"DNS_TYPE_RP", Const, 0},
+ {"DNS_TYPE_RRSIG", Const, 0},
+ {"DNS_TYPE_RT", Const, 0},
+ {"DNS_TYPE_SIG", Const, 0},
+ {"DNS_TYPE_SINK", Const, 0},
+ {"DNS_TYPE_SOA", Const, 0},
+ {"DNS_TYPE_SRV", Const, 0},
+ {"DNS_TYPE_TEXT", Const, 0},
+ {"DNS_TYPE_TKEY", Const, 0},
+ {"DNS_TYPE_TSIG", Const, 0},
+ {"DNS_TYPE_UID", Const, 0},
+ {"DNS_TYPE_UINFO", Const, 0},
+ {"DNS_TYPE_UNSPEC", Const, 0},
+ {"DNS_TYPE_WINS", Const, 0},
+ {"DNS_TYPE_WINSR", Const, 0},
+ {"DNS_TYPE_WKS", Const, 0},
+ {"DNS_TYPE_X25", Const, 0},
+ {"DT_BLK", Const, 0},
+ {"DT_CHR", Const, 0},
+ {"DT_DIR", Const, 0},
+ {"DT_FIFO", Const, 0},
+ {"DT_LNK", Const, 0},
+ {"DT_REG", Const, 0},
+ {"DT_SOCK", Const, 0},
+ {"DT_UNKNOWN", Const, 0},
+ {"DT_WHT", Const, 0},
+ {"DUPLICATE_CLOSE_SOURCE", Const, 0},
+ {"DUPLICATE_SAME_ACCESS", Const, 0},
+ {"DeleteFile", Func, 0},
+ {"DetachLsf", Func, 0},
+ {"DeviceIoControl", Func, 4},
+ {"Dirent", Type, 0},
+ {"Dirent.Fileno", Field, 0},
+ {"Dirent.Ino", Field, 0},
+ {"Dirent.Name", Field, 0},
+ {"Dirent.Namlen", Field, 0},
+ {"Dirent.Off", Field, 0},
+ {"Dirent.Pad0", Field, 12},
+ {"Dirent.Pad1", Field, 12},
+ {"Dirent.Pad_cgo_0", Field, 0},
+ {"Dirent.Reclen", Field, 0},
+ {"Dirent.Seekoff", Field, 0},
+ {"Dirent.Type", Field, 0},
+ {"Dirent.X__d_padding", Field, 3},
+ {"DnsNameCompare", Func, 4},
+ {"DnsQuery", Func, 0},
+ {"DnsRecordListFree", Func, 0},
+ {"DnsSectionAdditional", Const, 4},
+ {"DnsSectionAnswer", Const, 4},
+ {"DnsSectionAuthority", Const, 4},
+ {"DnsSectionQuestion", Const, 4},
+ {"Dup", Func, 0},
+ {"Dup2", Func, 0},
+ {"Dup3", Func, 2},
+ {"DuplicateHandle", Func, 0},
+ {"E2BIG", Const, 0},
+ {"EACCES", Const, 0},
+ {"EADDRINUSE", Const, 0},
+ {"EADDRNOTAVAIL", Const, 0},
+ {"EADV", Const, 0},
+ {"EAFNOSUPPORT", Const, 0},
+ {"EAGAIN", Const, 0},
+ {"EALREADY", Const, 0},
+ {"EAUTH", Const, 0},
+ {"EBADARCH", Const, 0},
+ {"EBADE", Const, 0},
+ {"EBADEXEC", Const, 0},
+ {"EBADF", Const, 0},
+ {"EBADFD", Const, 0},
+ {"EBADMACHO", Const, 0},
+ {"EBADMSG", Const, 0},
+ {"EBADR", Const, 0},
+ {"EBADRPC", Const, 0},
+ {"EBADRQC", Const, 0},
+ {"EBADSLT", Const, 0},
+ {"EBFONT", Const, 0},
+ {"EBUSY", Const, 0},
+ {"ECANCELED", Const, 0},
+ {"ECAPMODE", Const, 1},
+ {"ECHILD", Const, 0},
+ {"ECHO", Const, 0},
+ {"ECHOCTL", Const, 0},
+ {"ECHOE", Const, 0},
+ {"ECHOK", Const, 0},
+ {"ECHOKE", Const, 0},
+ {"ECHONL", Const, 0},
+ {"ECHOPRT", Const, 0},
+ {"ECHRNG", Const, 0},
+ {"ECOMM", Const, 0},
+ {"ECONNABORTED", Const, 0},
+ {"ECONNREFUSED", Const, 0},
+ {"ECONNRESET", Const, 0},
+ {"EDEADLK", Const, 0},
+ {"EDEADLOCK", Const, 0},
+ {"EDESTADDRREQ", Const, 0},
+ {"EDEVERR", Const, 0},
+ {"EDOM", Const, 0},
+ {"EDOOFUS", Const, 0},
+ {"EDOTDOT", Const, 0},
+ {"EDQUOT", Const, 0},
+ {"EEXIST", Const, 0},
+ {"EFAULT", Const, 0},
+ {"EFBIG", Const, 0},
+ {"EFER_LMA", Const, 1},
+ {"EFER_LME", Const, 1},
+ {"EFER_NXE", Const, 1},
+ {"EFER_SCE", Const, 1},
+ {"EFTYPE", Const, 0},
+ {"EHOSTDOWN", Const, 0},
+ {"EHOSTUNREACH", Const, 0},
+ {"EHWPOISON", Const, 0},
+ {"EIDRM", Const, 0},
+ {"EILSEQ", Const, 0},
+ {"EINPROGRESS", Const, 0},
+ {"EINTR", Const, 0},
+ {"EINVAL", Const, 0},
+ {"EIO", Const, 0},
+ {"EIPSEC", Const, 1},
+ {"EISCONN", Const, 0},
+ {"EISDIR", Const, 0},
+ {"EISNAM", Const, 0},
+ {"EKEYEXPIRED", Const, 0},
+ {"EKEYREJECTED", Const, 0},
+ {"EKEYREVOKED", Const, 0},
+ {"EL2HLT", Const, 0},
+ {"EL2NSYNC", Const, 0},
+ {"EL3HLT", Const, 0},
+ {"EL3RST", Const, 0},
+ {"ELAST", Const, 0},
+ {"ELF_NGREG", Const, 0},
+ {"ELF_PRARGSZ", Const, 0},
+ {"ELIBACC", Const, 0},
+ {"ELIBBAD", Const, 0},
+ {"ELIBEXEC", Const, 0},
+ {"ELIBMAX", Const, 0},
+ {"ELIBSCN", Const, 0},
+ {"ELNRNG", Const, 0},
+ {"ELOOP", Const, 0},
+ {"EMEDIUMTYPE", Const, 0},
+ {"EMFILE", Const, 0},
+ {"EMLINK", Const, 0},
+ {"EMSGSIZE", Const, 0},
+ {"EMT_TAGOVF", Const, 1},
+ {"EMULTIHOP", Const, 0},
+ {"EMUL_ENABLED", Const, 1},
+ {"EMUL_LINUX", Const, 1},
+ {"EMUL_LINUX32", Const, 1},
+ {"EMUL_MAXID", Const, 1},
+ {"EMUL_NATIVE", Const, 1},
+ {"ENAMETOOLONG", Const, 0},
+ {"ENAVAIL", Const, 0},
+ {"ENDRUNDISC", Const, 1},
+ {"ENEEDAUTH", Const, 0},
+ {"ENETDOWN", Const, 0},
+ {"ENETRESET", Const, 0},
+ {"ENETUNREACH", Const, 0},
+ {"ENFILE", Const, 0},
+ {"ENOANO", Const, 0},
+ {"ENOATTR", Const, 0},
+ {"ENOBUFS", Const, 0},
+ {"ENOCSI", Const, 0},
+ {"ENODATA", Const, 0},
+ {"ENODEV", Const, 0},
+ {"ENOENT", Const, 0},
+ {"ENOEXEC", Const, 0},
+ {"ENOKEY", Const, 0},
+ {"ENOLCK", Const, 0},
+ {"ENOLINK", Const, 0},
+ {"ENOMEDIUM", Const, 0},
+ {"ENOMEM", Const, 0},
+ {"ENOMSG", Const, 0},
+ {"ENONET", Const, 0},
+ {"ENOPKG", Const, 0},
+ {"ENOPOLICY", Const, 0},
+ {"ENOPROTOOPT", Const, 0},
+ {"ENOSPC", Const, 0},
+ {"ENOSR", Const, 0},
+ {"ENOSTR", Const, 0},
+ {"ENOSYS", Const, 0},
+ {"ENOTBLK", Const, 0},
+ {"ENOTCAPABLE", Const, 0},
+ {"ENOTCONN", Const, 0},
+ {"ENOTDIR", Const, 0},
+ {"ENOTEMPTY", Const, 0},
+ {"ENOTNAM", Const, 0},
+ {"ENOTRECOVERABLE", Const, 0},
+ {"ENOTSOCK", Const, 0},
+ {"ENOTSUP", Const, 0},
+ {"ENOTTY", Const, 0},
+ {"ENOTUNIQ", Const, 0},
+ {"ENXIO", Const, 0},
+ {"EN_SW_CTL_INF", Const, 1},
+ {"EN_SW_CTL_PREC", Const, 1},
+ {"EN_SW_CTL_ROUND", Const, 1},
+ {"EN_SW_DATACHAIN", Const, 1},
+ {"EN_SW_DENORM", Const, 1},
+ {"EN_SW_INVOP", Const, 1},
+ {"EN_SW_OVERFLOW", Const, 1},
+ {"EN_SW_PRECLOSS", Const, 1},
+ {"EN_SW_UNDERFLOW", Const, 1},
+ {"EN_SW_ZERODIV", Const, 1},
+ {"EOPNOTSUPP", Const, 0},
+ {"EOVERFLOW", Const, 0},
+ {"EOWNERDEAD", Const, 0},
+ {"EPERM", Const, 0},
+ {"EPFNOSUPPORT", Const, 0},
+ {"EPIPE", Const, 0},
+ {"EPOLLERR", Const, 0},
+ {"EPOLLET", Const, 0},
+ {"EPOLLHUP", Const, 0},
+ {"EPOLLIN", Const, 0},
+ {"EPOLLMSG", Const, 0},
+ {"EPOLLONESHOT", Const, 0},
+ {"EPOLLOUT", Const, 0},
+ {"EPOLLPRI", Const, 0},
+ {"EPOLLRDBAND", Const, 0},
+ {"EPOLLRDHUP", Const, 0},
+ {"EPOLLRDNORM", Const, 0},
+ {"EPOLLWRBAND", Const, 0},
+ {"EPOLLWRNORM", Const, 0},
+ {"EPOLL_CLOEXEC", Const, 0},
+ {"EPOLL_CTL_ADD", Const, 0},
+ {"EPOLL_CTL_DEL", Const, 0},
+ {"EPOLL_CTL_MOD", Const, 0},
+ {"EPOLL_NONBLOCK", Const, 0},
+ {"EPROCLIM", Const, 0},
+ {"EPROCUNAVAIL", Const, 0},
+ {"EPROGMISMATCH", Const, 0},
+ {"EPROGUNAVAIL", Const, 0},
+ {"EPROTO", Const, 0},
+ {"EPROTONOSUPPORT", Const, 0},
+ {"EPROTOTYPE", Const, 0},
+ {"EPWROFF", Const, 0},
+ {"EQFULL", Const, 16},
+ {"ERANGE", Const, 0},
+ {"EREMCHG", Const, 0},
+ {"EREMOTE", Const, 0},
+ {"EREMOTEIO", Const, 0},
+ {"ERESTART", Const, 0},
+ {"ERFKILL", Const, 0},
+ {"EROFS", Const, 0},
+ {"ERPCMISMATCH", Const, 0},
+ {"ERROR_ACCESS_DENIED", Const, 0},
+ {"ERROR_ALREADY_EXISTS", Const, 0},
+ {"ERROR_BROKEN_PIPE", Const, 0},
+ {"ERROR_BUFFER_OVERFLOW", Const, 0},
+ {"ERROR_DIR_NOT_EMPTY", Const, 8},
+ {"ERROR_ENVVAR_NOT_FOUND", Const, 0},
+ {"ERROR_FILE_EXISTS", Const, 0},
+ {"ERROR_FILE_NOT_FOUND", Const, 0},
+ {"ERROR_HANDLE_EOF", Const, 2},
+ {"ERROR_INSUFFICIENT_BUFFER", Const, 0},
+ {"ERROR_IO_PENDING", Const, 0},
+ {"ERROR_MOD_NOT_FOUND", Const, 0},
+ {"ERROR_MORE_DATA", Const, 3},
+ {"ERROR_NETNAME_DELETED", Const, 3},
+ {"ERROR_NOT_FOUND", Const, 1},
+ {"ERROR_NO_MORE_FILES", Const, 0},
+ {"ERROR_OPERATION_ABORTED", Const, 0},
+ {"ERROR_PATH_NOT_FOUND", Const, 0},
+ {"ERROR_PRIVILEGE_NOT_HELD", Const, 4},
+ {"ERROR_PROC_NOT_FOUND", Const, 0},
+ {"ESHLIBVERS", Const, 0},
+ {"ESHUTDOWN", Const, 0},
+ {"ESOCKTNOSUPPORT", Const, 0},
+ {"ESPIPE", Const, 0},
+ {"ESRCH", Const, 0},
+ {"ESRMNT", Const, 0},
+ {"ESTALE", Const, 0},
+ {"ESTRPIPE", Const, 0},
+ {"ETHERCAP_JUMBO_MTU", Const, 1},
+ {"ETHERCAP_VLAN_HWTAGGING", Const, 1},
+ {"ETHERCAP_VLAN_MTU", Const, 1},
+ {"ETHERMIN", Const, 1},
+ {"ETHERMTU", Const, 1},
+ {"ETHERMTU_JUMBO", Const, 1},
+ {"ETHERTYPE_8023", Const, 1},
+ {"ETHERTYPE_AARP", Const, 1},
+ {"ETHERTYPE_ACCTON", Const, 1},
+ {"ETHERTYPE_AEONIC", Const, 1},
+ {"ETHERTYPE_ALPHA", Const, 1},
+ {"ETHERTYPE_AMBER", Const, 1},
+ {"ETHERTYPE_AMOEBA", Const, 1},
+ {"ETHERTYPE_AOE", Const, 1},
+ {"ETHERTYPE_APOLLO", Const, 1},
+ {"ETHERTYPE_APOLLODOMAIN", Const, 1},
+ {"ETHERTYPE_APPLETALK", Const, 1},
+ {"ETHERTYPE_APPLITEK", Const, 1},
+ {"ETHERTYPE_ARGONAUT", Const, 1},
+ {"ETHERTYPE_ARP", Const, 1},
+ {"ETHERTYPE_AT", Const, 1},
+ {"ETHERTYPE_ATALK", Const, 1},
+ {"ETHERTYPE_ATOMIC", Const, 1},
+ {"ETHERTYPE_ATT", Const, 1},
+ {"ETHERTYPE_ATTSTANFORD", Const, 1},
+ {"ETHERTYPE_AUTOPHON", Const, 1},
+ {"ETHERTYPE_AXIS", Const, 1},
+ {"ETHERTYPE_BCLOOP", Const, 1},
+ {"ETHERTYPE_BOFL", Const, 1},
+ {"ETHERTYPE_CABLETRON", Const, 1},
+ {"ETHERTYPE_CHAOS", Const, 1},
+ {"ETHERTYPE_COMDESIGN", Const, 1},
+ {"ETHERTYPE_COMPUGRAPHIC", Const, 1},
+ {"ETHERTYPE_COUNTERPOINT", Const, 1},
+ {"ETHERTYPE_CRONUS", Const, 1},
+ {"ETHERTYPE_CRONUSVLN", Const, 1},
+ {"ETHERTYPE_DCA", Const, 1},
+ {"ETHERTYPE_DDE", Const, 1},
+ {"ETHERTYPE_DEBNI", Const, 1},
+ {"ETHERTYPE_DECAM", Const, 1},
+ {"ETHERTYPE_DECCUST", Const, 1},
+ {"ETHERTYPE_DECDIAG", Const, 1},
+ {"ETHERTYPE_DECDNS", Const, 1},
+ {"ETHERTYPE_DECDTS", Const, 1},
+ {"ETHERTYPE_DECEXPER", Const, 1},
+ {"ETHERTYPE_DECLAST", Const, 1},
+ {"ETHERTYPE_DECLTM", Const, 1},
+ {"ETHERTYPE_DECMUMPS", Const, 1},
+ {"ETHERTYPE_DECNETBIOS", Const, 1},
+ {"ETHERTYPE_DELTACON", Const, 1},
+ {"ETHERTYPE_DIDDLE", Const, 1},
+ {"ETHERTYPE_DLOG1", Const, 1},
+ {"ETHERTYPE_DLOG2", Const, 1},
+ {"ETHERTYPE_DN", Const, 1},
+ {"ETHERTYPE_DOGFIGHT", Const, 1},
+ {"ETHERTYPE_DSMD", Const, 1},
+ {"ETHERTYPE_ECMA", Const, 1},
+ {"ETHERTYPE_ENCRYPT", Const, 1},
+ {"ETHERTYPE_ES", Const, 1},
+ {"ETHERTYPE_EXCELAN", Const, 1},
+ {"ETHERTYPE_EXPERDATA", Const, 1},
+ {"ETHERTYPE_FLIP", Const, 1},
+ {"ETHERTYPE_FLOWCONTROL", Const, 1},
+ {"ETHERTYPE_FRARP", Const, 1},
+ {"ETHERTYPE_GENDYN", Const, 1},
+ {"ETHERTYPE_HAYES", Const, 1},
+ {"ETHERTYPE_HIPPI_FP", Const, 1},
+ {"ETHERTYPE_HITACHI", Const, 1},
+ {"ETHERTYPE_HP", Const, 1},
+ {"ETHERTYPE_IEEEPUP", Const, 1},
+ {"ETHERTYPE_IEEEPUPAT", Const, 1},
+ {"ETHERTYPE_IMLBL", Const, 1},
+ {"ETHERTYPE_IMLBLDIAG", Const, 1},
+ {"ETHERTYPE_IP", Const, 1},
+ {"ETHERTYPE_IPAS", Const, 1},
+ {"ETHERTYPE_IPV6", Const, 1},
+ {"ETHERTYPE_IPX", Const, 1},
+ {"ETHERTYPE_IPXNEW", Const, 1},
+ {"ETHERTYPE_KALPANA", Const, 1},
+ {"ETHERTYPE_LANBRIDGE", Const, 1},
+ {"ETHERTYPE_LANPROBE", Const, 1},
+ {"ETHERTYPE_LAT", Const, 1},
+ {"ETHERTYPE_LBACK", Const, 1},
+ {"ETHERTYPE_LITTLE", Const, 1},
+ {"ETHERTYPE_LLDP", Const, 1},
+ {"ETHERTYPE_LOGICRAFT", Const, 1},
+ {"ETHERTYPE_LOOPBACK", Const, 1},
+ {"ETHERTYPE_MATRA", Const, 1},
+ {"ETHERTYPE_MAX", Const, 1},
+ {"ETHERTYPE_MERIT", Const, 1},
+ {"ETHERTYPE_MICP", Const, 1},
+ {"ETHERTYPE_MOPDL", Const, 1},
+ {"ETHERTYPE_MOPRC", Const, 1},
+ {"ETHERTYPE_MOTOROLA", Const, 1},
+ {"ETHERTYPE_MPLS", Const, 1},
+ {"ETHERTYPE_MPLS_MCAST", Const, 1},
+ {"ETHERTYPE_MUMPS", Const, 1},
+ {"ETHERTYPE_NBPCC", Const, 1},
+ {"ETHERTYPE_NBPCLAIM", Const, 1},
+ {"ETHERTYPE_NBPCLREQ", Const, 1},
+ {"ETHERTYPE_NBPCLRSP", Const, 1},
+ {"ETHERTYPE_NBPCREQ", Const, 1},
+ {"ETHERTYPE_NBPCRSP", Const, 1},
+ {"ETHERTYPE_NBPDG", Const, 1},
+ {"ETHERTYPE_NBPDGB", Const, 1},
+ {"ETHERTYPE_NBPDLTE", Const, 1},
+ {"ETHERTYPE_NBPRAR", Const, 1},
+ {"ETHERTYPE_NBPRAS", Const, 1},
+ {"ETHERTYPE_NBPRST", Const, 1},
+ {"ETHERTYPE_NBPSCD", Const, 1},
+ {"ETHERTYPE_NBPVCD", Const, 1},
+ {"ETHERTYPE_NBS", Const, 1},
+ {"ETHERTYPE_NCD", Const, 1},
+ {"ETHERTYPE_NESTAR", Const, 1},
+ {"ETHERTYPE_NETBEUI", Const, 1},
+ {"ETHERTYPE_NOVELL", Const, 1},
+ {"ETHERTYPE_NS", Const, 1},
+ {"ETHERTYPE_NSAT", Const, 1},
+ {"ETHERTYPE_NSCOMPAT", Const, 1},
+ {"ETHERTYPE_NTRAILER", Const, 1},
+ {"ETHERTYPE_OS9", Const, 1},
+ {"ETHERTYPE_OS9NET", Const, 1},
+ {"ETHERTYPE_PACER", Const, 1},
+ {"ETHERTYPE_PAE", Const, 1},
+ {"ETHERTYPE_PCS", Const, 1},
+ {"ETHERTYPE_PLANNING", Const, 1},
+ {"ETHERTYPE_PPP", Const, 1},
+ {"ETHERTYPE_PPPOE", Const, 1},
+ {"ETHERTYPE_PPPOEDISC", Const, 1},
+ {"ETHERTYPE_PRIMENTS", Const, 1},
+ {"ETHERTYPE_PUP", Const, 1},
+ {"ETHERTYPE_PUPAT", Const, 1},
+ {"ETHERTYPE_QINQ", Const, 1},
+ {"ETHERTYPE_RACAL", Const, 1},
+ {"ETHERTYPE_RATIONAL", Const, 1},
+ {"ETHERTYPE_RAWFR", Const, 1},
+ {"ETHERTYPE_RCL", Const, 1},
+ {"ETHERTYPE_RDP", Const, 1},
+ {"ETHERTYPE_RETIX", Const, 1},
+ {"ETHERTYPE_REVARP", Const, 1},
+ {"ETHERTYPE_SCA", Const, 1},
+ {"ETHERTYPE_SECTRA", Const, 1},
+ {"ETHERTYPE_SECUREDATA", Const, 1},
+ {"ETHERTYPE_SGITW", Const, 1},
+ {"ETHERTYPE_SG_BOUNCE", Const, 1},
+ {"ETHERTYPE_SG_DIAG", Const, 1},
+ {"ETHERTYPE_SG_NETGAMES", Const, 1},
+ {"ETHERTYPE_SG_RESV", Const, 1},
+ {"ETHERTYPE_SIMNET", Const, 1},
+ {"ETHERTYPE_SLOW", Const, 1},
+ {"ETHERTYPE_SLOWPROTOCOLS", Const, 1},
+ {"ETHERTYPE_SNA", Const, 1},
+ {"ETHERTYPE_SNMP", Const, 1},
+ {"ETHERTYPE_SONIX", Const, 1},
+ {"ETHERTYPE_SPIDER", Const, 1},
+ {"ETHERTYPE_SPRITE", Const, 1},
+ {"ETHERTYPE_STP", Const, 1},
+ {"ETHERTYPE_TALARIS", Const, 1},
+ {"ETHERTYPE_TALARISMC", Const, 1},
+ {"ETHERTYPE_TCPCOMP", Const, 1},
+ {"ETHERTYPE_TCPSM", Const, 1},
+ {"ETHERTYPE_TEC", Const, 1},
+ {"ETHERTYPE_TIGAN", Const, 1},
+ {"ETHERTYPE_TRAIL", Const, 1},
+ {"ETHERTYPE_TRANSETHER", Const, 1},
+ {"ETHERTYPE_TYMSHARE", Const, 1},
+ {"ETHERTYPE_UBBST", Const, 1},
+ {"ETHERTYPE_UBDEBUG", Const, 1},
+ {"ETHERTYPE_UBDIAGLOOP", Const, 1},
+ {"ETHERTYPE_UBDL", Const, 1},
+ {"ETHERTYPE_UBNIU", Const, 1},
+ {"ETHERTYPE_UBNMC", Const, 1},
+ {"ETHERTYPE_VALID", Const, 1},
+ {"ETHERTYPE_VARIAN", Const, 1},
+ {"ETHERTYPE_VAXELN", Const, 1},
+ {"ETHERTYPE_VEECO", Const, 1},
+ {"ETHERTYPE_VEXP", Const, 1},
+ {"ETHERTYPE_VGLAB", Const, 1},
+ {"ETHERTYPE_VINES", Const, 1},
+ {"ETHERTYPE_VINESECHO", Const, 1},
+ {"ETHERTYPE_VINESLOOP", Const, 1},
+ {"ETHERTYPE_VITAL", Const, 1},
+ {"ETHERTYPE_VLAN", Const, 1},
+ {"ETHERTYPE_VLTLMAN", Const, 1},
+ {"ETHERTYPE_VPROD", Const, 1},
+ {"ETHERTYPE_VURESERVED", Const, 1},
+ {"ETHERTYPE_WATERLOO", Const, 1},
+ {"ETHERTYPE_WELLFLEET", Const, 1},
+ {"ETHERTYPE_X25", Const, 1},
+ {"ETHERTYPE_X75", Const, 1},
+ {"ETHERTYPE_XNSSM", Const, 1},
+ {"ETHERTYPE_XTP", Const, 1},
+ {"ETHER_ADDR_LEN", Const, 1},
+ {"ETHER_ALIGN", Const, 1},
+ {"ETHER_CRC_LEN", Const, 1},
+ {"ETHER_CRC_POLY_BE", Const, 1},
+ {"ETHER_CRC_POLY_LE", Const, 1},
+ {"ETHER_HDR_LEN", Const, 1},
+ {"ETHER_MAX_DIX_LEN", Const, 1},
+ {"ETHER_MAX_LEN", Const, 1},
+ {"ETHER_MAX_LEN_JUMBO", Const, 1},
+ {"ETHER_MIN_LEN", Const, 1},
+ {"ETHER_PPPOE_ENCAP_LEN", Const, 1},
+ {"ETHER_TYPE_LEN", Const, 1},
+ {"ETHER_VLAN_ENCAP_LEN", Const, 1},
+ {"ETH_P_1588", Const, 0},
+ {"ETH_P_8021Q", Const, 0},
+ {"ETH_P_802_2", Const, 0},
+ {"ETH_P_802_3", Const, 0},
+ {"ETH_P_AARP", Const, 0},
+ {"ETH_P_ALL", Const, 0},
+ {"ETH_P_AOE", Const, 0},
+ {"ETH_P_ARCNET", Const, 0},
+ {"ETH_P_ARP", Const, 0},
+ {"ETH_P_ATALK", Const, 0},
+ {"ETH_P_ATMFATE", Const, 0},
+ {"ETH_P_ATMMPOA", Const, 0},
+ {"ETH_P_AX25", Const, 0},
+ {"ETH_P_BPQ", Const, 0},
+ {"ETH_P_CAIF", Const, 0},
+ {"ETH_P_CAN", Const, 0},
+ {"ETH_P_CONTROL", Const, 0},
+ {"ETH_P_CUST", Const, 0},
+ {"ETH_P_DDCMP", Const, 0},
+ {"ETH_P_DEC", Const, 0},
+ {"ETH_P_DIAG", Const, 0},
+ {"ETH_P_DNA_DL", Const, 0},
+ {"ETH_P_DNA_RC", Const, 0},
+ {"ETH_P_DNA_RT", Const, 0},
+ {"ETH_P_DSA", Const, 0},
+ {"ETH_P_ECONET", Const, 0},
+ {"ETH_P_EDSA", Const, 0},
+ {"ETH_P_FCOE", Const, 0},
+ {"ETH_P_FIP", Const, 0},
+ {"ETH_P_HDLC", Const, 0},
+ {"ETH_P_IEEE802154", Const, 0},
+ {"ETH_P_IEEEPUP", Const, 0},
+ {"ETH_P_IEEEPUPAT", Const, 0},
+ {"ETH_P_IP", Const, 0},
+ {"ETH_P_IPV6", Const, 0},
+ {"ETH_P_IPX", Const, 0},
+ {"ETH_P_IRDA", Const, 0},
+ {"ETH_P_LAT", Const, 0},
+ {"ETH_P_LINK_CTL", Const, 0},
+ {"ETH_P_LOCALTALK", Const, 0},
+ {"ETH_P_LOOP", Const, 0},
+ {"ETH_P_MOBITEX", Const, 0},
+ {"ETH_P_MPLS_MC", Const, 0},
+ {"ETH_P_MPLS_UC", Const, 0},
+ {"ETH_P_PAE", Const, 0},
+ {"ETH_P_PAUSE", Const, 0},
+ {"ETH_P_PHONET", Const, 0},
+ {"ETH_P_PPPTALK", Const, 0},
+ {"ETH_P_PPP_DISC", Const, 0},
+ {"ETH_P_PPP_MP", Const, 0},
+ {"ETH_P_PPP_SES", Const, 0},
+ {"ETH_P_PUP", Const, 0},
+ {"ETH_P_PUPAT", Const, 0},
+ {"ETH_P_RARP", Const, 0},
+ {"ETH_P_SCA", Const, 0},
+ {"ETH_P_SLOW", Const, 0},
+ {"ETH_P_SNAP", Const, 0},
+ {"ETH_P_TEB", Const, 0},
+ {"ETH_P_TIPC", Const, 0},
+ {"ETH_P_TRAILER", Const, 0},
+ {"ETH_P_TR_802_2", Const, 0},
+ {"ETH_P_WAN_PPP", Const, 0},
+ {"ETH_P_WCCP", Const, 0},
+ {"ETH_P_X25", Const, 0},
+ {"ETIME", Const, 0},
+ {"ETIMEDOUT", Const, 0},
+ {"ETOOMANYREFS", Const, 0},
+ {"ETXTBSY", Const, 0},
+ {"EUCLEAN", Const, 0},
+ {"EUNATCH", Const, 0},
+ {"EUSERS", Const, 0},
+ {"EVFILT_AIO", Const, 0},
+ {"EVFILT_FS", Const, 0},
+ {"EVFILT_LIO", Const, 0},
+ {"EVFILT_MACHPORT", Const, 0},
+ {"EVFILT_PROC", Const, 0},
+ {"EVFILT_READ", Const, 0},
+ {"EVFILT_SIGNAL", Const, 0},
+ {"EVFILT_SYSCOUNT", Const, 0},
+ {"EVFILT_THREADMARKER", Const, 0},
+ {"EVFILT_TIMER", Const, 0},
+ {"EVFILT_USER", Const, 0},
+ {"EVFILT_VM", Const, 0},
+ {"EVFILT_VNODE", Const, 0},
+ {"EVFILT_WRITE", Const, 0},
+ {"EV_ADD", Const, 0},
+ {"EV_CLEAR", Const, 0},
+ {"EV_DELETE", Const, 0},
+ {"EV_DISABLE", Const, 0},
+ {"EV_DISPATCH", Const, 0},
+ {"EV_DROP", Const, 3},
+ {"EV_ENABLE", Const, 0},
+ {"EV_EOF", Const, 0},
+ {"EV_ERROR", Const, 0},
+ {"EV_FLAG0", Const, 0},
+ {"EV_FLAG1", Const, 0},
+ {"EV_ONESHOT", Const, 0},
+ {"EV_OOBAND", Const, 0},
+ {"EV_POLL", Const, 0},
+ {"EV_RECEIPT", Const, 0},
+ {"EV_SYSFLAGS", Const, 0},
+ {"EWINDOWS", Const, 0},
+ {"EWOULDBLOCK", Const, 0},
+ {"EXDEV", Const, 0},
+ {"EXFULL", Const, 0},
+ {"EXTA", Const, 0},
+ {"EXTB", Const, 0},
+ {"EXTPROC", Const, 0},
+ {"Environ", Func, 0},
+ {"EpollCreate", Func, 0},
+ {"EpollCreate1", Func, 0},
+ {"EpollCtl", Func, 0},
+ {"EpollEvent", Type, 0},
+ {"EpollEvent.Events", Field, 0},
+ {"EpollEvent.Fd", Field, 0},
+ {"EpollEvent.Pad", Field, 0},
+ {"EpollEvent.PadFd", Field, 0},
+ {"EpollWait", Func, 0},
+ {"Errno", Type, 0},
+ {"EscapeArg", Func, 0},
+ {"Exchangedata", Func, 0},
+ {"Exec", Func, 0},
+ {"Exit", Func, 0},
+ {"ExitProcess", Func, 0},
+ {"FD_CLOEXEC", Const, 0},
+ {"FD_SETSIZE", Const, 0},
+ {"FILE_ACTION_ADDED", Const, 0},
+ {"FILE_ACTION_MODIFIED", Const, 0},
+ {"FILE_ACTION_REMOVED", Const, 0},
+ {"FILE_ACTION_RENAMED_NEW_NAME", Const, 0},
+ {"FILE_ACTION_RENAMED_OLD_NAME", Const, 0},
+ {"FILE_APPEND_DATA", Const, 0},
+ {"FILE_ATTRIBUTE_ARCHIVE", Const, 0},
+ {"FILE_ATTRIBUTE_DIRECTORY", Const, 0},
+ {"FILE_ATTRIBUTE_HIDDEN", Const, 0},
+ {"FILE_ATTRIBUTE_NORMAL", Const, 0},
+ {"FILE_ATTRIBUTE_READONLY", Const, 0},
+ {"FILE_ATTRIBUTE_REPARSE_POINT", Const, 4},
+ {"FILE_ATTRIBUTE_SYSTEM", Const, 0},
+ {"FILE_BEGIN", Const, 0},
+ {"FILE_CURRENT", Const, 0},
+ {"FILE_END", Const, 0},
+ {"FILE_FLAG_BACKUP_SEMANTICS", Const, 0},
+ {"FILE_FLAG_OPEN_REPARSE_POINT", Const, 4},
+ {"FILE_FLAG_OVERLAPPED", Const, 0},
+ {"FILE_LIST_DIRECTORY", Const, 0},
+ {"FILE_MAP_COPY", Const, 0},
+ {"FILE_MAP_EXECUTE", Const, 0},
+ {"FILE_MAP_READ", Const, 0},
+ {"FILE_MAP_WRITE", Const, 0},
+ {"FILE_NOTIFY_CHANGE_ATTRIBUTES", Const, 0},
+ {"FILE_NOTIFY_CHANGE_CREATION", Const, 0},
+ {"FILE_NOTIFY_CHANGE_DIR_NAME", Const, 0},
+ {"FILE_NOTIFY_CHANGE_FILE_NAME", Const, 0},
+ {"FILE_NOTIFY_CHANGE_LAST_ACCESS", Const, 0},
+ {"FILE_NOTIFY_CHANGE_LAST_WRITE", Const, 0},
+ {"FILE_NOTIFY_CHANGE_SIZE", Const, 0},
+ {"FILE_SHARE_DELETE", Const, 0},
+ {"FILE_SHARE_READ", Const, 0},
+ {"FILE_SHARE_WRITE", Const, 0},
+ {"FILE_SKIP_COMPLETION_PORT_ON_SUCCESS", Const, 2},
+ {"FILE_SKIP_SET_EVENT_ON_HANDLE", Const, 2},
+ {"FILE_TYPE_CHAR", Const, 0},
+ {"FILE_TYPE_DISK", Const, 0},
+ {"FILE_TYPE_PIPE", Const, 0},
+ {"FILE_TYPE_REMOTE", Const, 0},
+ {"FILE_TYPE_UNKNOWN", Const, 0},
+ {"FILE_WRITE_ATTRIBUTES", Const, 0},
+ {"FLUSHO", Const, 0},
+ {"FORMAT_MESSAGE_ALLOCATE_BUFFER", Const, 0},
+ {"FORMAT_MESSAGE_ARGUMENT_ARRAY", Const, 0},
+ {"FORMAT_MESSAGE_FROM_HMODULE", Const, 0},
+ {"FORMAT_MESSAGE_FROM_STRING", Const, 0},
+ {"FORMAT_MESSAGE_FROM_SYSTEM", Const, 0},
+ {"FORMAT_MESSAGE_IGNORE_INSERTS", Const, 0},
+ {"FORMAT_MESSAGE_MAX_WIDTH_MASK", Const, 0},
+ {"FSCTL_GET_REPARSE_POINT", Const, 4},
+ {"F_ADDFILESIGS", Const, 0},
+ {"F_ADDSIGS", Const, 0},
+ {"F_ALLOCATEALL", Const, 0},
+ {"F_ALLOCATECONTIG", Const, 0},
+ {"F_CANCEL", Const, 0},
+ {"F_CHKCLEAN", Const, 0},
+ {"F_CLOSEM", Const, 1},
+ {"F_DUP2FD", Const, 0},
+ {"F_DUP2FD_CLOEXEC", Const, 1},
+ {"F_DUPFD", Const, 0},
+ {"F_DUPFD_CLOEXEC", Const, 0},
+ {"F_EXLCK", Const, 0},
+ {"F_FINDSIGS", Const, 16},
+ {"F_FLUSH_DATA", Const, 0},
+ {"F_FREEZE_FS", Const, 0},
+ {"F_FSCTL", Const, 1},
+ {"F_FSDIRMASK", Const, 1},
+ {"F_FSIN", Const, 1},
+ {"F_FSINOUT", Const, 1},
+ {"F_FSOUT", Const, 1},
+ {"F_FSPRIV", Const, 1},
+ {"F_FSVOID", Const, 1},
+ {"F_FULLFSYNC", Const, 0},
+ {"F_GETCODEDIR", Const, 16},
+ {"F_GETFD", Const, 0},
+ {"F_GETFL", Const, 0},
+ {"F_GETLEASE", Const, 0},
+ {"F_GETLK", Const, 0},
+ {"F_GETLK64", Const, 0},
+ {"F_GETLKPID", Const, 0},
+ {"F_GETNOSIGPIPE", Const, 0},
+ {"F_GETOWN", Const, 0},
+ {"F_GETOWN_EX", Const, 0},
+ {"F_GETPATH", Const, 0},
+ {"F_GETPATH_MTMINFO", Const, 0},
+ {"F_GETPIPE_SZ", Const, 0},
+ {"F_GETPROTECTIONCLASS", Const, 0},
+ {"F_GETPROTECTIONLEVEL", Const, 16},
+ {"F_GETSIG", Const, 0},
+ {"F_GLOBAL_NOCACHE", Const, 0},
+ {"F_LOCK", Const, 0},
+ {"F_LOG2PHYS", Const, 0},
+ {"F_LOG2PHYS_EXT", Const, 0},
+ {"F_MARKDEPENDENCY", Const, 0},
+ {"F_MAXFD", Const, 1},
+ {"F_NOCACHE", Const, 0},
+ {"F_NODIRECT", Const, 0},
+ {"F_NOTIFY", Const, 0},
+ {"F_OGETLK", Const, 0},
+ {"F_OK", Const, 0},
+ {"F_OSETLK", Const, 0},
+ {"F_OSETLKW", Const, 0},
+ {"F_PARAM_MASK", Const, 1},
+ {"F_PARAM_MAX", Const, 1},
+ {"F_PATHPKG_CHECK", Const, 0},
+ {"F_PEOFPOSMODE", Const, 0},
+ {"F_PREALLOCATE", Const, 0},
+ {"F_RDADVISE", Const, 0},
+ {"F_RDAHEAD", Const, 0},
+ {"F_RDLCK", Const, 0},
+ {"F_READAHEAD", Const, 0},
+ {"F_READBOOTSTRAP", Const, 0},
+ {"F_SETBACKINGSTORE", Const, 0},
+ {"F_SETFD", Const, 0},
+ {"F_SETFL", Const, 0},
+ {"F_SETLEASE", Const, 0},
+ {"F_SETLK", Const, 0},
+ {"F_SETLK64", Const, 0},
+ {"F_SETLKW", Const, 0},
+ {"F_SETLKW64", Const, 0},
+ {"F_SETLKWTIMEOUT", Const, 16},
+ {"F_SETLK_REMOTE", Const, 0},
+ {"F_SETNOSIGPIPE", Const, 0},
+ {"F_SETOWN", Const, 0},
+ {"F_SETOWN_EX", Const, 0},
+ {"F_SETPIPE_SZ", Const, 0},
+ {"F_SETPROTECTIONCLASS", Const, 0},
+ {"F_SETSIG", Const, 0},
+ {"F_SETSIZE", Const, 0},
+ {"F_SHLCK", Const, 0},
+ {"F_SINGLE_WRITER", Const, 16},
+ {"F_TEST", Const, 0},
+ {"F_THAW_FS", Const, 0},
+ {"F_TLOCK", Const, 0},
+ {"F_TRANSCODEKEY", Const, 16},
+ {"F_ULOCK", Const, 0},
+ {"F_UNLCK", Const, 0},
+ {"F_UNLCKSYS", Const, 0},
+ {"F_VOLPOSMODE", Const, 0},
+ {"F_WRITEBOOTSTRAP", Const, 0},
+ {"F_WRLCK", Const, 0},
+ {"Faccessat", Func, 0},
+ {"Fallocate", Func, 0},
+ {"Fbootstraptransfer_t", Type, 0},
+ {"Fbootstraptransfer_t.Buffer", Field, 0},
+ {"Fbootstraptransfer_t.Length", Field, 0},
+ {"Fbootstraptransfer_t.Offset", Field, 0},
+ {"Fchdir", Func, 0},
+ {"Fchflags", Func, 0},
+ {"Fchmod", Func, 0},
+ {"Fchmodat", Func, 0},
+ {"Fchown", Func, 0},
+ {"Fchownat", Func, 0},
+ {"FcntlFlock", Func, 3},
+ {"FdSet", Type, 0},
+ {"FdSet.Bits", Field, 0},
+ {"FdSet.X__fds_bits", Field, 0},
+ {"Fdatasync", Func, 0},
+ {"FileNotifyInformation", Type, 0},
+ {"FileNotifyInformation.Action", Field, 0},
+ {"FileNotifyInformation.FileName", Field, 0},
+ {"FileNotifyInformation.FileNameLength", Field, 0},
+ {"FileNotifyInformation.NextEntryOffset", Field, 0},
+ {"Filetime", Type, 0},
+ {"Filetime.HighDateTime", Field, 0},
+ {"Filetime.LowDateTime", Field, 0},
+ {"FindClose", Func, 0},
+ {"FindFirstFile", Func, 0},
+ {"FindNextFile", Func, 0},
+ {"Flock", Func, 0},
+ {"Flock_t", Type, 0},
+ {"Flock_t.Len", Field, 0},
+ {"Flock_t.Pad_cgo_0", Field, 0},
+ {"Flock_t.Pad_cgo_1", Field, 3},
+ {"Flock_t.Pid", Field, 0},
+ {"Flock_t.Start", Field, 0},
+ {"Flock_t.Sysid", Field, 0},
+ {"Flock_t.Type", Field, 0},
+ {"Flock_t.Whence", Field, 0},
+ {"FlushBpf", Func, 0},
+ {"FlushFileBuffers", Func, 0},
+ {"FlushViewOfFile", Func, 0},
+ {"ForkExec", Func, 0},
+ {"ForkLock", Var, 0},
+ {"FormatMessage", Func, 0},
+ {"Fpathconf", Func, 0},
+ {"FreeAddrInfoW", Func, 1},
+ {"FreeEnvironmentStrings", Func, 0},
+ {"FreeLibrary", Func, 0},
+ {"Fsid", Type, 0},
+ {"Fsid.Val", Field, 0},
+ {"Fsid.X__fsid_val", Field, 2},
+ {"Fsid.X__val", Field, 0},
+ {"Fstat", Func, 0},
+ {"Fstatat", Func, 12},
+ {"Fstatfs", Func, 0},
+ {"Fstore_t", Type, 0},
+ {"Fstore_t.Bytesalloc", Field, 0},
+ {"Fstore_t.Flags", Field, 0},
+ {"Fstore_t.Length", Field, 0},
+ {"Fstore_t.Offset", Field, 0},
+ {"Fstore_t.Posmode", Field, 0},
+ {"Fsync", Func, 0},
+ {"Ftruncate", Func, 0},
+ {"FullPath", Func, 4},
+ {"Futimes", Func, 0},
+ {"Futimesat", Func, 0},
+ {"GENERIC_ALL", Const, 0},
+ {"GENERIC_EXECUTE", Const, 0},
+ {"GENERIC_READ", Const, 0},
+ {"GENERIC_WRITE", Const, 0},
+ {"GUID", Type, 1},
+ {"GUID.Data1", Field, 1},
+ {"GUID.Data2", Field, 1},
+ {"GUID.Data3", Field, 1},
+ {"GUID.Data4", Field, 1},
+ {"GetAcceptExSockaddrs", Func, 0},
+ {"GetAdaptersInfo", Func, 0},
+ {"GetAddrInfoW", Func, 1},
+ {"GetCommandLine", Func, 0},
+ {"GetComputerName", Func, 0},
+ {"GetConsoleMode", Func, 1},
+ {"GetCurrentDirectory", Func, 0},
+ {"GetCurrentProcess", Func, 0},
+ {"GetEnvironmentStrings", Func, 0},
+ {"GetEnvironmentVariable", Func, 0},
+ {"GetExitCodeProcess", Func, 0},
+ {"GetFileAttributes", Func, 0},
+ {"GetFileAttributesEx", Func, 0},
+ {"GetFileExInfoStandard", Const, 0},
+ {"GetFileExMaxInfoLevel", Const, 0},
+ {"GetFileInformationByHandle", Func, 0},
+ {"GetFileType", Func, 0},
+ {"GetFullPathName", Func, 0},
+ {"GetHostByName", Func, 0},
+ {"GetIfEntry", Func, 0},
+ {"GetLastError", Func, 0},
+ {"GetLengthSid", Func, 0},
+ {"GetLongPathName", Func, 0},
+ {"GetProcAddress", Func, 0},
+ {"GetProcessTimes", Func, 0},
+ {"GetProtoByName", Func, 0},
+ {"GetQueuedCompletionStatus", Func, 0},
+ {"GetServByName", Func, 0},
+ {"GetShortPathName", Func, 0},
+ {"GetStartupInfo", Func, 0},
+ {"GetStdHandle", Func, 0},
+ {"GetSystemTimeAsFileTime", Func, 0},
+ {"GetTempPath", Func, 0},
+ {"GetTimeZoneInformation", Func, 0},
+ {"GetTokenInformation", Func, 0},
+ {"GetUserNameEx", Func, 0},
+ {"GetUserProfileDirectory", Func, 0},
+ {"GetVersion", Func, 0},
+ {"Getcwd", Func, 0},
+ {"Getdents", Func, 0},
+ {"Getdirentries", Func, 0},
+ {"Getdtablesize", Func, 0},
+ {"Getegid", Func, 0},
+ {"Getenv", Func, 0},
+ {"Geteuid", Func, 0},
+ {"Getfsstat", Func, 0},
+ {"Getgid", Func, 0},
+ {"Getgroups", Func, 0},
+ {"Getpagesize", Func, 0},
+ {"Getpeername", Func, 0},
+ {"Getpgid", Func, 0},
+ {"Getpgrp", Func, 0},
+ {"Getpid", Func, 0},
+ {"Getppid", Func, 0},
+ {"Getpriority", Func, 0},
+ {"Getrlimit", Func, 0},
+ {"Getrusage", Func, 0},
+ {"Getsid", Func, 0},
+ {"Getsockname", Func, 0},
+ {"Getsockopt", Func, 1},
+ {"GetsockoptByte", Func, 0},
+ {"GetsockoptICMPv6Filter", Func, 2},
+ {"GetsockoptIPMreq", Func, 0},
+ {"GetsockoptIPMreqn", Func, 0},
+ {"GetsockoptIPv6MTUInfo", Func, 2},
+ {"GetsockoptIPv6Mreq", Func, 0},
+ {"GetsockoptInet4Addr", Func, 0},
+ {"GetsockoptInt", Func, 0},
+ {"GetsockoptUcred", Func, 1},
+ {"Gettid", Func, 0},
+ {"Gettimeofday", Func, 0},
+ {"Getuid", Func, 0},
+ {"Getwd", Func, 0},
+ {"Getxattr", Func, 1},
+ {"HANDLE_FLAG_INHERIT", Const, 0},
+ {"HKEY_CLASSES_ROOT", Const, 0},
+ {"HKEY_CURRENT_CONFIG", Const, 0},
+ {"HKEY_CURRENT_USER", Const, 0},
+ {"HKEY_DYN_DATA", Const, 0},
+ {"HKEY_LOCAL_MACHINE", Const, 0},
+ {"HKEY_PERFORMANCE_DATA", Const, 0},
+ {"HKEY_USERS", Const, 0},
+ {"HUPCL", Const, 0},
+ {"Handle", Type, 0},
+ {"Hostent", Type, 0},
+ {"Hostent.AddrList", Field, 0},
+ {"Hostent.AddrType", Field, 0},
+ {"Hostent.Aliases", Field, 0},
+ {"Hostent.Length", Field, 0},
+ {"Hostent.Name", Field, 0},
+ {"ICANON", Const, 0},
+ {"ICMP6_FILTER", Const, 2},
+ {"ICMPV6_FILTER", Const, 2},
+ {"ICMPv6Filter", Type, 2},
+ {"ICMPv6Filter.Data", Field, 2},
+ {"ICMPv6Filter.Filt", Field, 2},
+ {"ICRNL", Const, 0},
+ {"IEXTEN", Const, 0},
+ {"IFAN_ARRIVAL", Const, 1},
+ {"IFAN_DEPARTURE", Const, 1},
+ {"IFA_ADDRESS", Const, 0},
+ {"IFA_ANYCAST", Const, 0},
+ {"IFA_BROADCAST", Const, 0},
+ {"IFA_CACHEINFO", Const, 0},
+ {"IFA_F_DADFAILED", Const, 0},
+ {"IFA_F_DEPRECATED", Const, 0},
+ {"IFA_F_HOMEADDRESS", Const, 0},
+ {"IFA_F_NODAD", Const, 0},
+ {"IFA_F_OPTIMISTIC", Const, 0},
+ {"IFA_F_PERMANENT", Const, 0},
+ {"IFA_F_SECONDARY", Const, 0},
+ {"IFA_F_TEMPORARY", Const, 0},
+ {"IFA_F_TENTATIVE", Const, 0},
+ {"IFA_LABEL", Const, 0},
+ {"IFA_LOCAL", Const, 0},
+ {"IFA_MAX", Const, 0},
+ {"IFA_MULTICAST", Const, 0},
+ {"IFA_ROUTE", Const, 1},
+ {"IFA_UNSPEC", Const, 0},
+ {"IFF_ALLMULTI", Const, 0},
+ {"IFF_ALTPHYS", Const, 0},
+ {"IFF_AUTOMEDIA", Const, 0},
+ {"IFF_BROADCAST", Const, 0},
+ {"IFF_CANTCHANGE", Const, 0},
+ {"IFF_CANTCONFIG", Const, 1},
+ {"IFF_DEBUG", Const, 0},
+ {"IFF_DRV_OACTIVE", Const, 0},
+ {"IFF_DRV_RUNNING", Const, 0},
+ {"IFF_DYING", Const, 0},
+ {"IFF_DYNAMIC", Const, 0},
+ {"IFF_LINK0", Const, 0},
+ {"IFF_LINK1", Const, 0},
+ {"IFF_LINK2", Const, 0},
+ {"IFF_LOOPBACK", Const, 0},
+ {"IFF_MASTER", Const, 0},
+ {"IFF_MONITOR", Const, 0},
+ {"IFF_MULTICAST", Const, 0},
+ {"IFF_NOARP", Const, 0},
+ {"IFF_NOTRAILERS", Const, 0},
+ {"IFF_NO_PI", Const, 0},
+ {"IFF_OACTIVE", Const, 0},
+ {"IFF_ONE_QUEUE", Const, 0},
+ {"IFF_POINTOPOINT", Const, 0},
+ {"IFF_POINTTOPOINT", Const, 0},
+ {"IFF_PORTSEL", Const, 0},
+ {"IFF_PPROMISC", Const, 0},
+ {"IFF_PROMISC", Const, 0},
+ {"IFF_RENAMING", Const, 0},
+ {"IFF_RUNNING", Const, 0},
+ {"IFF_SIMPLEX", Const, 0},
+ {"IFF_SLAVE", Const, 0},
+ {"IFF_SMART", Const, 0},
+ {"IFF_STATICARP", Const, 0},
+ {"IFF_TAP", Const, 0},
+ {"IFF_TUN", Const, 0},
+ {"IFF_TUN_EXCL", Const, 0},
+ {"IFF_UP", Const, 0},
+ {"IFF_VNET_HDR", Const, 0},
+ {"IFLA_ADDRESS", Const, 0},
+ {"IFLA_BROADCAST", Const, 0},
+ {"IFLA_COST", Const, 0},
+ {"IFLA_IFALIAS", Const, 0},
+ {"IFLA_IFNAME", Const, 0},
+ {"IFLA_LINK", Const, 0},
+ {"IFLA_LINKINFO", Const, 0},
+ {"IFLA_LINKMODE", Const, 0},
+ {"IFLA_MAP", Const, 0},
+ {"IFLA_MASTER", Const, 0},
+ {"IFLA_MAX", Const, 0},
+ {"IFLA_MTU", Const, 0},
+ {"IFLA_NET_NS_PID", Const, 0},
+ {"IFLA_OPERSTATE", Const, 0},
+ {"IFLA_PRIORITY", Const, 0},
+ {"IFLA_PROTINFO", Const, 0},
+ {"IFLA_QDISC", Const, 0},
+ {"IFLA_STATS", Const, 0},
+ {"IFLA_TXQLEN", Const, 0},
+ {"IFLA_UNSPEC", Const, 0},
+ {"IFLA_WEIGHT", Const, 0},
+ {"IFLA_WIRELESS", Const, 0},
+ {"IFNAMSIZ", Const, 0},
+ {"IFT_1822", Const, 0},
+ {"IFT_A12MPPSWITCH", Const, 0},
+ {"IFT_AAL2", Const, 0},
+ {"IFT_AAL5", Const, 0},
+ {"IFT_ADSL", Const, 0},
+ {"IFT_AFLANE8023", Const, 0},
+ {"IFT_AFLANE8025", Const, 0},
+ {"IFT_ARAP", Const, 0},
+ {"IFT_ARCNET", Const, 0},
+ {"IFT_ARCNETPLUS", Const, 0},
+ {"IFT_ASYNC", Const, 0},
+ {"IFT_ATM", Const, 0},
+ {"IFT_ATMDXI", Const, 0},
+ {"IFT_ATMFUNI", Const, 0},
+ {"IFT_ATMIMA", Const, 0},
+ {"IFT_ATMLOGICAL", Const, 0},
+ {"IFT_ATMRADIO", Const, 0},
+ {"IFT_ATMSUBINTERFACE", Const, 0},
+ {"IFT_ATMVCIENDPT", Const, 0},
+ {"IFT_ATMVIRTUAL", Const, 0},
+ {"IFT_BGPPOLICYACCOUNTING", Const, 0},
+ {"IFT_BLUETOOTH", Const, 1},
+ {"IFT_BRIDGE", Const, 0},
+ {"IFT_BSC", Const, 0},
+ {"IFT_CARP", Const, 0},
+ {"IFT_CCTEMUL", Const, 0},
+ {"IFT_CELLULAR", Const, 0},
+ {"IFT_CEPT", Const, 0},
+ {"IFT_CES", Const, 0},
+ {"IFT_CHANNEL", Const, 0},
+ {"IFT_CNR", Const, 0},
+ {"IFT_COFFEE", Const, 0},
+ {"IFT_COMPOSITELINK", Const, 0},
+ {"IFT_DCN", Const, 0},
+ {"IFT_DIGITALPOWERLINE", Const, 0},
+ {"IFT_DIGITALWRAPPEROVERHEADCHANNEL", Const, 0},
+ {"IFT_DLSW", Const, 0},
+ {"IFT_DOCSCABLEDOWNSTREAM", Const, 0},
+ {"IFT_DOCSCABLEMACLAYER", Const, 0},
+ {"IFT_DOCSCABLEUPSTREAM", Const, 0},
+ {"IFT_DOCSCABLEUPSTREAMCHANNEL", Const, 1},
+ {"IFT_DS0", Const, 0},
+ {"IFT_DS0BUNDLE", Const, 0},
+ {"IFT_DS1FDL", Const, 0},
+ {"IFT_DS3", Const, 0},
+ {"IFT_DTM", Const, 0},
+ {"IFT_DUMMY", Const, 1},
+ {"IFT_DVBASILN", Const, 0},
+ {"IFT_DVBASIOUT", Const, 0},
+ {"IFT_DVBRCCDOWNSTREAM", Const, 0},
+ {"IFT_DVBRCCMACLAYER", Const, 0},
+ {"IFT_DVBRCCUPSTREAM", Const, 0},
+ {"IFT_ECONET", Const, 1},
+ {"IFT_ENC", Const, 0},
+ {"IFT_EON", Const, 0},
+ {"IFT_EPLRS", Const, 0},
+ {"IFT_ESCON", Const, 0},
+ {"IFT_ETHER", Const, 0},
+ {"IFT_FAITH", Const, 0},
+ {"IFT_FAST", Const, 0},
+ {"IFT_FASTETHER", Const, 0},
+ {"IFT_FASTETHERFX", Const, 0},
+ {"IFT_FDDI", Const, 0},
+ {"IFT_FIBRECHANNEL", Const, 0},
+ {"IFT_FRAMERELAYINTERCONNECT", Const, 0},
+ {"IFT_FRAMERELAYMPI", Const, 0},
+ {"IFT_FRDLCIENDPT", Const, 0},
+ {"IFT_FRELAY", Const, 0},
+ {"IFT_FRELAYDCE", Const, 0},
+ {"IFT_FRF16MFRBUNDLE", Const, 0},
+ {"IFT_FRFORWARD", Const, 0},
+ {"IFT_G703AT2MB", Const, 0},
+ {"IFT_G703AT64K", Const, 0},
+ {"IFT_GIF", Const, 0},
+ {"IFT_GIGABITETHERNET", Const, 0},
+ {"IFT_GR303IDT", Const, 0},
+ {"IFT_GR303RDT", Const, 0},
+ {"IFT_H323GATEKEEPER", Const, 0},
+ {"IFT_H323PROXY", Const, 0},
+ {"IFT_HDH1822", Const, 0},
+ {"IFT_HDLC", Const, 0},
+ {"IFT_HDSL2", Const, 0},
+ {"IFT_HIPERLAN2", Const, 0},
+ {"IFT_HIPPI", Const, 0},
+ {"IFT_HIPPIINTERFACE", Const, 0},
+ {"IFT_HOSTPAD", Const, 0},
+ {"IFT_HSSI", Const, 0},
+ {"IFT_HY", Const, 0},
+ {"IFT_IBM370PARCHAN", Const, 0},
+ {"IFT_IDSL", Const, 0},
+ {"IFT_IEEE1394", Const, 0},
+ {"IFT_IEEE80211", Const, 0},
+ {"IFT_IEEE80212", Const, 0},
+ {"IFT_IEEE8023ADLAG", Const, 0},
+ {"IFT_IFGSN", Const, 0},
+ {"IFT_IMT", Const, 0},
+ {"IFT_INFINIBAND", Const, 1},
+ {"IFT_INTERLEAVE", Const, 0},
+ {"IFT_IP", Const, 0},
+ {"IFT_IPFORWARD", Const, 0},
+ {"IFT_IPOVERATM", Const, 0},
+ {"IFT_IPOVERCDLC", Const, 0},
+ {"IFT_IPOVERCLAW", Const, 0},
+ {"IFT_IPSWITCH", Const, 0},
+ {"IFT_IPXIP", Const, 0},
+ {"IFT_ISDN", Const, 0},
+ {"IFT_ISDNBASIC", Const, 0},
+ {"IFT_ISDNPRIMARY", Const, 0},
+ {"IFT_ISDNS", Const, 0},
+ {"IFT_ISDNU", Const, 0},
+ {"IFT_ISO88022LLC", Const, 0},
+ {"IFT_ISO88023", Const, 0},
+ {"IFT_ISO88024", Const, 0},
+ {"IFT_ISO88025", Const, 0},
+ {"IFT_ISO88025CRFPINT", Const, 0},
+ {"IFT_ISO88025DTR", Const, 0},
+ {"IFT_ISO88025FIBER", Const, 0},
+ {"IFT_ISO88026", Const, 0},
+ {"IFT_ISUP", Const, 0},
+ {"IFT_L2VLAN", Const, 0},
+ {"IFT_L3IPVLAN", Const, 0},
+ {"IFT_L3IPXVLAN", Const, 0},
+ {"IFT_LAPB", Const, 0},
+ {"IFT_LAPD", Const, 0},
+ {"IFT_LAPF", Const, 0},
+ {"IFT_LINEGROUP", Const, 1},
+ {"IFT_LOCALTALK", Const, 0},
+ {"IFT_LOOP", Const, 0},
+ {"IFT_MEDIAMAILOVERIP", Const, 0},
+ {"IFT_MFSIGLINK", Const, 0},
+ {"IFT_MIOX25", Const, 0},
+ {"IFT_MODEM", Const, 0},
+ {"IFT_MPC", Const, 0},
+ {"IFT_MPLS", Const, 0},
+ {"IFT_MPLSTUNNEL", Const, 0},
+ {"IFT_MSDSL", Const, 0},
+ {"IFT_MVL", Const, 0},
+ {"IFT_MYRINET", Const, 0},
+ {"IFT_NFAS", Const, 0},
+ {"IFT_NSIP", Const, 0},
+ {"IFT_OPTICALCHANNEL", Const, 0},
+ {"IFT_OPTICALTRANSPORT", Const, 0},
+ {"IFT_OTHER", Const, 0},
+ {"IFT_P10", Const, 0},
+ {"IFT_P80", Const, 0},
+ {"IFT_PARA", Const, 0},
+ {"IFT_PDP", Const, 0},
+ {"IFT_PFLOG", Const, 0},
+ {"IFT_PFLOW", Const, 1},
+ {"IFT_PFSYNC", Const, 0},
+ {"IFT_PLC", Const, 0},
+ {"IFT_PON155", Const, 1},
+ {"IFT_PON622", Const, 1},
+ {"IFT_POS", Const, 0},
+ {"IFT_PPP", Const, 0},
+ {"IFT_PPPMULTILINKBUNDLE", Const, 0},
+ {"IFT_PROPATM", Const, 1},
+ {"IFT_PROPBWAP2MP", Const, 0},
+ {"IFT_PROPCNLS", Const, 0},
+ {"IFT_PROPDOCSWIRELESSDOWNSTREAM", Const, 0},
+ {"IFT_PROPDOCSWIRELESSMACLAYER", Const, 0},
+ {"IFT_PROPDOCSWIRELESSUPSTREAM", Const, 0},
+ {"IFT_PROPMUX", Const, 0},
+ {"IFT_PROPVIRTUAL", Const, 0},
+ {"IFT_PROPWIRELESSP2P", Const, 0},
+ {"IFT_PTPSERIAL", Const, 0},
+ {"IFT_PVC", Const, 0},
+ {"IFT_Q2931", Const, 1},
+ {"IFT_QLLC", Const, 0},
+ {"IFT_RADIOMAC", Const, 0},
+ {"IFT_RADSL", Const, 0},
+ {"IFT_REACHDSL", Const, 0},
+ {"IFT_RFC1483", Const, 0},
+ {"IFT_RS232", Const, 0},
+ {"IFT_RSRB", Const, 0},
+ {"IFT_SDLC", Const, 0},
+ {"IFT_SDSL", Const, 0},
+ {"IFT_SHDSL", Const, 0},
+ {"IFT_SIP", Const, 0},
+ {"IFT_SIPSIG", Const, 1},
+ {"IFT_SIPTG", Const, 1},
+ {"IFT_SLIP", Const, 0},
+ {"IFT_SMDSDXI", Const, 0},
+ {"IFT_SMDSICIP", Const, 0},
+ {"IFT_SONET", Const, 0},
+ {"IFT_SONETOVERHEADCHANNEL", Const, 0},
+ {"IFT_SONETPATH", Const, 0},
+ {"IFT_SONETVT", Const, 0},
+ {"IFT_SRP", Const, 0},
+ {"IFT_SS7SIGLINK", Const, 0},
+ {"IFT_STACKTOSTACK", Const, 0},
+ {"IFT_STARLAN", Const, 0},
+ {"IFT_STF", Const, 0},
+ {"IFT_T1", Const, 0},
+ {"IFT_TDLC", Const, 0},
+ {"IFT_TELINK", Const, 1},
+ {"IFT_TERMPAD", Const, 0},
+ {"IFT_TR008", Const, 0},
+ {"IFT_TRANSPHDLC", Const, 0},
+ {"IFT_TUNNEL", Const, 0},
+ {"IFT_ULTRA", Const, 0},
+ {"IFT_USB", Const, 0},
+ {"IFT_V11", Const, 0},
+ {"IFT_V35", Const, 0},
+ {"IFT_V36", Const, 0},
+ {"IFT_V37", Const, 0},
+ {"IFT_VDSL", Const, 0},
+ {"IFT_VIRTUALIPADDRESS", Const, 0},
+ {"IFT_VIRTUALTG", Const, 1},
+ {"IFT_VOICEDID", Const, 1},
+ {"IFT_VOICEEM", Const, 0},
+ {"IFT_VOICEEMFGD", Const, 1},
+ {"IFT_VOICEENCAP", Const, 0},
+ {"IFT_VOICEFGDEANA", Const, 1},
+ {"IFT_VOICEFXO", Const, 0},
+ {"IFT_VOICEFXS", Const, 0},
+ {"IFT_VOICEOVERATM", Const, 0},
+ {"IFT_VOICEOVERCABLE", Const, 1},
+ {"IFT_VOICEOVERFRAMERELAY", Const, 0},
+ {"IFT_VOICEOVERIP", Const, 0},
+ {"IFT_X213", Const, 0},
+ {"IFT_X25", Const, 0},
+ {"IFT_X25DDN", Const, 0},
+ {"IFT_X25HUNTGROUP", Const, 0},
+ {"IFT_X25MLP", Const, 0},
+ {"IFT_X25PLE", Const, 0},
+ {"IFT_XETHER", Const, 0},
+ {"IGNBRK", Const, 0},
+ {"IGNCR", Const, 0},
+ {"IGNORE", Const, 0},
+ {"IGNPAR", Const, 0},
+ {"IMAXBEL", Const, 0},
+ {"INFINITE", Const, 0},
+ {"INLCR", Const, 0},
+ {"INPCK", Const, 0},
+ {"INVALID_FILE_ATTRIBUTES", Const, 0},
+ {"IN_ACCESS", Const, 0},
+ {"IN_ALL_EVENTS", Const, 0},
+ {"IN_ATTRIB", Const, 0},
+ {"IN_CLASSA_HOST", Const, 0},
+ {"IN_CLASSA_MAX", Const, 0},
+ {"IN_CLASSA_NET", Const, 0},
+ {"IN_CLASSA_NSHIFT", Const, 0},
+ {"IN_CLASSB_HOST", Const, 0},
+ {"IN_CLASSB_MAX", Const, 0},
+ {"IN_CLASSB_NET", Const, 0},
+ {"IN_CLASSB_NSHIFT", Const, 0},
+ {"IN_CLASSC_HOST", Const, 0},
+ {"IN_CLASSC_NET", Const, 0},
+ {"IN_CLASSC_NSHIFT", Const, 0},
+ {"IN_CLASSD_HOST", Const, 0},
+ {"IN_CLASSD_NET", Const, 0},
+ {"IN_CLASSD_NSHIFT", Const, 0},
+ {"IN_CLOEXEC", Const, 0},
+ {"IN_CLOSE", Const, 0},
+ {"IN_CLOSE_NOWRITE", Const, 0},
+ {"IN_CLOSE_WRITE", Const, 0},
+ {"IN_CREATE", Const, 0},
+ {"IN_DELETE", Const, 0},
+ {"IN_DELETE_SELF", Const, 0},
+ {"IN_DONT_FOLLOW", Const, 0},
+ {"IN_EXCL_UNLINK", Const, 0},
+ {"IN_IGNORED", Const, 0},
+ {"IN_ISDIR", Const, 0},
+ {"IN_LINKLOCALNETNUM", Const, 0},
+ {"IN_LOOPBACKNET", Const, 0},
+ {"IN_MASK_ADD", Const, 0},
+ {"IN_MODIFY", Const, 0},
+ {"IN_MOVE", Const, 0},
+ {"IN_MOVED_FROM", Const, 0},
+ {"IN_MOVED_TO", Const, 0},
+ {"IN_MOVE_SELF", Const, 0},
+ {"IN_NONBLOCK", Const, 0},
+ {"IN_ONESHOT", Const, 0},
+ {"IN_ONLYDIR", Const, 0},
+ {"IN_OPEN", Const, 0},
+ {"IN_Q_OVERFLOW", Const, 0},
+ {"IN_RFC3021_HOST", Const, 1},
+ {"IN_RFC3021_MASK", Const, 1},
+ {"IN_RFC3021_NET", Const, 1},
+ {"IN_RFC3021_NSHIFT", Const, 1},
+ {"IN_UNMOUNT", Const, 0},
+ {"IOC_IN", Const, 1},
+ {"IOC_INOUT", Const, 1},
+ {"IOC_OUT", Const, 1},
+ {"IOC_VENDOR", Const, 3},
+ {"IOC_WS2", Const, 1},
+ {"IO_REPARSE_TAG_SYMLINK", Const, 4},
+ {"IPMreq", Type, 0},
+ {"IPMreq.Interface", Field, 0},
+ {"IPMreq.Multiaddr", Field, 0},
+ {"IPMreqn", Type, 0},
+ {"IPMreqn.Address", Field, 0},
+ {"IPMreqn.Ifindex", Field, 0},
+ {"IPMreqn.Multiaddr", Field, 0},
+ {"IPPROTO_3PC", Const, 0},
+ {"IPPROTO_ADFS", Const, 0},
+ {"IPPROTO_AH", Const, 0},
+ {"IPPROTO_AHIP", Const, 0},
+ {"IPPROTO_APES", Const, 0},
+ {"IPPROTO_ARGUS", Const, 0},
+ {"IPPROTO_AX25", Const, 0},
+ {"IPPROTO_BHA", Const, 0},
+ {"IPPROTO_BLT", Const, 0},
+ {"IPPROTO_BRSATMON", Const, 0},
+ {"IPPROTO_CARP", Const, 0},
+ {"IPPROTO_CFTP", Const, 0},
+ {"IPPROTO_CHAOS", Const, 0},
+ {"IPPROTO_CMTP", Const, 0},
+ {"IPPROTO_COMP", Const, 0},
+ {"IPPROTO_CPHB", Const, 0},
+ {"IPPROTO_CPNX", Const, 0},
+ {"IPPROTO_DCCP", Const, 0},
+ {"IPPROTO_DDP", Const, 0},
+ {"IPPROTO_DGP", Const, 0},
+ {"IPPROTO_DIVERT", Const, 0},
+ {"IPPROTO_DIVERT_INIT", Const, 3},
+ {"IPPROTO_DIVERT_RESP", Const, 3},
+ {"IPPROTO_DONE", Const, 0},
+ {"IPPROTO_DSTOPTS", Const, 0},
+ {"IPPROTO_EGP", Const, 0},
+ {"IPPROTO_EMCON", Const, 0},
+ {"IPPROTO_ENCAP", Const, 0},
+ {"IPPROTO_EON", Const, 0},
+ {"IPPROTO_ESP", Const, 0},
+ {"IPPROTO_ETHERIP", Const, 0},
+ {"IPPROTO_FRAGMENT", Const, 0},
+ {"IPPROTO_GGP", Const, 0},
+ {"IPPROTO_GMTP", Const, 0},
+ {"IPPROTO_GRE", Const, 0},
+ {"IPPROTO_HELLO", Const, 0},
+ {"IPPROTO_HMP", Const, 0},
+ {"IPPROTO_HOPOPTS", Const, 0},
+ {"IPPROTO_ICMP", Const, 0},
+ {"IPPROTO_ICMPV6", Const, 0},
+ {"IPPROTO_IDP", Const, 0},
+ {"IPPROTO_IDPR", Const, 0},
+ {"IPPROTO_IDRP", Const, 0},
+ {"IPPROTO_IGMP", Const, 0},
+ {"IPPROTO_IGP", Const, 0},
+ {"IPPROTO_IGRP", Const, 0},
+ {"IPPROTO_IL", Const, 0},
+ {"IPPROTO_INLSP", Const, 0},
+ {"IPPROTO_INP", Const, 0},
+ {"IPPROTO_IP", Const, 0},
+ {"IPPROTO_IPCOMP", Const, 0},
+ {"IPPROTO_IPCV", Const, 0},
+ {"IPPROTO_IPEIP", Const, 0},
+ {"IPPROTO_IPIP", Const, 0},
+ {"IPPROTO_IPPC", Const, 0},
+ {"IPPROTO_IPV4", Const, 0},
+ {"IPPROTO_IPV6", Const, 0},
+ {"IPPROTO_IPV6_ICMP", Const, 1},
+ {"IPPROTO_IRTP", Const, 0},
+ {"IPPROTO_KRYPTOLAN", Const, 0},
+ {"IPPROTO_LARP", Const, 0},
+ {"IPPROTO_LEAF1", Const, 0},
+ {"IPPROTO_LEAF2", Const, 0},
+ {"IPPROTO_MAX", Const, 0},
+ {"IPPROTO_MAXID", Const, 0},
+ {"IPPROTO_MEAS", Const, 0},
+ {"IPPROTO_MH", Const, 1},
+ {"IPPROTO_MHRP", Const, 0},
+ {"IPPROTO_MICP", Const, 0},
+ {"IPPROTO_MOBILE", Const, 0},
+ {"IPPROTO_MPLS", Const, 1},
+ {"IPPROTO_MTP", Const, 0},
+ {"IPPROTO_MUX", Const, 0},
+ {"IPPROTO_ND", Const, 0},
+ {"IPPROTO_NHRP", Const, 0},
+ {"IPPROTO_NONE", Const, 0},
+ {"IPPROTO_NSP", Const, 0},
+ {"IPPROTO_NVPII", Const, 0},
+ {"IPPROTO_OLD_DIVERT", Const, 0},
+ {"IPPROTO_OSPFIGP", Const, 0},
+ {"IPPROTO_PFSYNC", Const, 0},
+ {"IPPROTO_PGM", Const, 0},
+ {"IPPROTO_PIGP", Const, 0},
+ {"IPPROTO_PIM", Const, 0},
+ {"IPPROTO_PRM", Const, 0},
+ {"IPPROTO_PUP", Const, 0},
+ {"IPPROTO_PVP", Const, 0},
+ {"IPPROTO_RAW", Const, 0},
+ {"IPPROTO_RCCMON", Const, 0},
+ {"IPPROTO_RDP", Const, 0},
+ {"IPPROTO_ROUTING", Const, 0},
+ {"IPPROTO_RSVP", Const, 0},
+ {"IPPROTO_RVD", Const, 0},
+ {"IPPROTO_SATEXPAK", Const, 0},
+ {"IPPROTO_SATMON", Const, 0},
+ {"IPPROTO_SCCSP", Const, 0},
+ {"IPPROTO_SCTP", Const, 0},
+ {"IPPROTO_SDRP", Const, 0},
+ {"IPPROTO_SEND", Const, 1},
+ {"IPPROTO_SEP", Const, 0},
+ {"IPPROTO_SKIP", Const, 0},
+ {"IPPROTO_SPACER", Const, 0},
+ {"IPPROTO_SRPC", Const, 0},
+ {"IPPROTO_ST", Const, 0},
+ {"IPPROTO_SVMTP", Const, 0},
+ {"IPPROTO_SWIPE", Const, 0},
+ {"IPPROTO_TCF", Const, 0},
+ {"IPPROTO_TCP", Const, 0},
+ {"IPPROTO_TLSP", Const, 0},
+ {"IPPROTO_TP", Const, 0},
+ {"IPPROTO_TPXX", Const, 0},
+ {"IPPROTO_TRUNK1", Const, 0},
+ {"IPPROTO_TRUNK2", Const, 0},
+ {"IPPROTO_TTP", Const, 0},
+ {"IPPROTO_UDP", Const, 0},
+ {"IPPROTO_UDPLITE", Const, 0},
+ {"IPPROTO_VINES", Const, 0},
+ {"IPPROTO_VISA", Const, 0},
+ {"IPPROTO_VMTP", Const, 0},
+ {"IPPROTO_VRRP", Const, 1},
+ {"IPPROTO_WBEXPAK", Const, 0},
+ {"IPPROTO_WBMON", Const, 0},
+ {"IPPROTO_WSN", Const, 0},
+ {"IPPROTO_XNET", Const, 0},
+ {"IPPROTO_XTP", Const, 0},
+ {"IPV6_2292DSTOPTS", Const, 0},
+ {"IPV6_2292HOPLIMIT", Const, 0},
+ {"IPV6_2292HOPOPTS", Const, 0},
+ {"IPV6_2292NEXTHOP", Const, 0},
+ {"IPV6_2292PKTINFO", Const, 0},
+ {"IPV6_2292PKTOPTIONS", Const, 0},
+ {"IPV6_2292RTHDR", Const, 0},
+ {"IPV6_ADDRFORM", Const, 0},
+ {"IPV6_ADD_MEMBERSHIP", Const, 0},
+ {"IPV6_AUTHHDR", Const, 0},
+ {"IPV6_AUTH_LEVEL", Const, 1},
+ {"IPV6_AUTOFLOWLABEL", Const, 0},
+ {"IPV6_BINDANY", Const, 0},
+ {"IPV6_BINDV6ONLY", Const, 0},
+ {"IPV6_BOUND_IF", Const, 0},
+ {"IPV6_CHECKSUM", Const, 0},
+ {"IPV6_DEFAULT_MULTICAST_HOPS", Const, 0},
+ {"IPV6_DEFAULT_MULTICAST_LOOP", Const, 0},
+ {"IPV6_DEFHLIM", Const, 0},
+ {"IPV6_DONTFRAG", Const, 0},
+ {"IPV6_DROP_MEMBERSHIP", Const, 0},
+ {"IPV6_DSTOPTS", Const, 0},
+ {"IPV6_ESP_NETWORK_LEVEL", Const, 1},
+ {"IPV6_ESP_TRANS_LEVEL", Const, 1},
+ {"IPV6_FAITH", Const, 0},
+ {"IPV6_FLOWINFO_MASK", Const, 0},
+ {"IPV6_FLOWLABEL_MASK", Const, 0},
+ {"IPV6_FRAGTTL", Const, 0},
+ {"IPV6_FW_ADD", Const, 0},
+ {"IPV6_FW_DEL", Const, 0},
+ {"IPV6_FW_FLUSH", Const, 0},
+ {"IPV6_FW_GET", Const, 0},
+ {"IPV6_FW_ZERO", Const, 0},
+ {"IPV6_HLIMDEC", Const, 0},
+ {"IPV6_HOPLIMIT", Const, 0},
+ {"IPV6_HOPOPTS", Const, 0},
+ {"IPV6_IPCOMP_LEVEL", Const, 1},
+ {"IPV6_IPSEC_POLICY", Const, 0},
+ {"IPV6_JOIN_ANYCAST", Const, 0},
+ {"IPV6_JOIN_GROUP", Const, 0},
+ {"IPV6_LEAVE_ANYCAST", Const, 0},
+ {"IPV6_LEAVE_GROUP", Const, 0},
+ {"IPV6_MAXHLIM", Const, 0},
+ {"IPV6_MAXOPTHDR", Const, 0},
+ {"IPV6_MAXPACKET", Const, 0},
+ {"IPV6_MAX_GROUP_SRC_FILTER", Const, 0},
+ {"IPV6_MAX_MEMBERSHIPS", Const, 0},
+ {"IPV6_MAX_SOCK_SRC_FILTER", Const, 0},
+ {"IPV6_MIN_MEMBERSHIPS", Const, 0},
+ {"IPV6_MMTU", Const, 0},
+ {"IPV6_MSFILTER", Const, 0},
+ {"IPV6_MTU", Const, 0},
+ {"IPV6_MTU_DISCOVER", Const, 0},
+ {"IPV6_MULTICAST_HOPS", Const, 0},
+ {"IPV6_MULTICAST_IF", Const, 0},
+ {"IPV6_MULTICAST_LOOP", Const, 0},
+ {"IPV6_NEXTHOP", Const, 0},
+ {"IPV6_OPTIONS", Const, 1},
+ {"IPV6_PATHMTU", Const, 0},
+ {"IPV6_PIPEX", Const, 1},
+ {"IPV6_PKTINFO", Const, 0},
+ {"IPV6_PMTUDISC_DO", Const, 0},
+ {"IPV6_PMTUDISC_DONT", Const, 0},
+ {"IPV6_PMTUDISC_PROBE", Const, 0},
+ {"IPV6_PMTUDISC_WANT", Const, 0},
+ {"IPV6_PORTRANGE", Const, 0},
+ {"IPV6_PORTRANGE_DEFAULT", Const, 0},
+ {"IPV6_PORTRANGE_HIGH", Const, 0},
+ {"IPV6_PORTRANGE_LOW", Const, 0},
+ {"IPV6_PREFER_TEMPADDR", Const, 0},
+ {"IPV6_RECVDSTOPTS", Const, 0},
+ {"IPV6_RECVDSTPORT", Const, 3},
+ {"IPV6_RECVERR", Const, 0},
+ {"IPV6_RECVHOPLIMIT", Const, 0},
+ {"IPV6_RECVHOPOPTS", Const, 0},
+ {"IPV6_RECVPATHMTU", Const, 0},
+ {"IPV6_RECVPKTINFO", Const, 0},
+ {"IPV6_RECVRTHDR", Const, 0},
+ {"IPV6_RECVTCLASS", Const, 0},
+ {"IPV6_ROUTER_ALERT", Const, 0},
+ {"IPV6_RTABLE", Const, 1},
+ {"IPV6_RTHDR", Const, 0},
+ {"IPV6_RTHDRDSTOPTS", Const, 0},
+ {"IPV6_RTHDR_LOOSE", Const, 0},
+ {"IPV6_RTHDR_STRICT", Const, 0},
+ {"IPV6_RTHDR_TYPE_0", Const, 0},
+ {"IPV6_RXDSTOPTS", Const, 0},
+ {"IPV6_RXHOPOPTS", Const, 0},
+ {"IPV6_SOCKOPT_RESERVED1", Const, 0},
+ {"IPV6_TCLASS", Const, 0},
+ {"IPV6_UNICAST_HOPS", Const, 0},
+ {"IPV6_USE_MIN_MTU", Const, 0},
+ {"IPV6_V6ONLY", Const, 0},
+ {"IPV6_VERSION", Const, 0},
+ {"IPV6_VERSION_MASK", Const, 0},
+ {"IPV6_XFRM_POLICY", Const, 0},
+ {"IP_ADD_MEMBERSHIP", Const, 0},
+ {"IP_ADD_SOURCE_MEMBERSHIP", Const, 0},
+ {"IP_AUTH_LEVEL", Const, 1},
+ {"IP_BINDANY", Const, 0},
+ {"IP_BLOCK_SOURCE", Const, 0},
+ {"IP_BOUND_IF", Const, 0},
+ {"IP_DEFAULT_MULTICAST_LOOP", Const, 0},
+ {"IP_DEFAULT_MULTICAST_TTL", Const, 0},
+ {"IP_DF", Const, 0},
+ {"IP_DIVERTFL", Const, 3},
+ {"IP_DONTFRAG", Const, 0},
+ {"IP_DROP_MEMBERSHIP", Const, 0},
+ {"IP_DROP_SOURCE_MEMBERSHIP", Const, 0},
+ {"IP_DUMMYNET3", Const, 0},
+ {"IP_DUMMYNET_CONFIGURE", Const, 0},
+ {"IP_DUMMYNET_DEL", Const, 0},
+ {"IP_DUMMYNET_FLUSH", Const, 0},
+ {"IP_DUMMYNET_GET", Const, 0},
+ {"IP_EF", Const, 1},
+ {"IP_ERRORMTU", Const, 1},
+ {"IP_ESP_NETWORK_LEVEL", Const, 1},
+ {"IP_ESP_TRANS_LEVEL", Const, 1},
+ {"IP_FAITH", Const, 0},
+ {"IP_FREEBIND", Const, 0},
+ {"IP_FW3", Const, 0},
+ {"IP_FW_ADD", Const, 0},
+ {"IP_FW_DEL", Const, 0},
+ {"IP_FW_FLUSH", Const, 0},
+ {"IP_FW_GET", Const, 0},
+ {"IP_FW_NAT_CFG", Const, 0},
+ {"IP_FW_NAT_DEL", Const, 0},
+ {"IP_FW_NAT_GET_CONFIG", Const, 0},
+ {"IP_FW_NAT_GET_LOG", Const, 0},
+ {"IP_FW_RESETLOG", Const, 0},
+ {"IP_FW_TABLE_ADD", Const, 0},
+ {"IP_FW_TABLE_DEL", Const, 0},
+ {"IP_FW_TABLE_FLUSH", Const, 0},
+ {"IP_FW_TABLE_GETSIZE", Const, 0},
+ {"IP_FW_TABLE_LIST", Const, 0},
+ {"IP_FW_ZERO", Const, 0},
+ {"IP_HDRINCL", Const, 0},
+ {"IP_IPCOMP_LEVEL", Const, 1},
+ {"IP_IPSECFLOWINFO", Const, 1},
+ {"IP_IPSEC_LOCAL_AUTH", Const, 1},
+ {"IP_IPSEC_LOCAL_CRED", Const, 1},
+ {"IP_IPSEC_LOCAL_ID", Const, 1},
+ {"IP_IPSEC_POLICY", Const, 0},
+ {"IP_IPSEC_REMOTE_AUTH", Const, 1},
+ {"IP_IPSEC_REMOTE_CRED", Const, 1},
+ {"IP_IPSEC_REMOTE_ID", Const, 1},
+ {"IP_MAXPACKET", Const, 0},
+ {"IP_MAX_GROUP_SRC_FILTER", Const, 0},
+ {"IP_MAX_MEMBERSHIPS", Const, 0},
+ {"IP_MAX_SOCK_MUTE_FILTER", Const, 0},
+ {"IP_MAX_SOCK_SRC_FILTER", Const, 0},
+ {"IP_MAX_SOURCE_FILTER", Const, 0},
+ {"IP_MF", Const, 0},
+ {"IP_MINFRAGSIZE", Const, 1},
+ {"IP_MINTTL", Const, 0},
+ {"IP_MIN_MEMBERSHIPS", Const, 0},
+ {"IP_MSFILTER", Const, 0},
+ {"IP_MSS", Const, 0},
+ {"IP_MTU", Const, 0},
+ {"IP_MTU_DISCOVER", Const, 0},
+ {"IP_MULTICAST_IF", Const, 0},
+ {"IP_MULTICAST_IFINDEX", Const, 0},
+ {"IP_MULTICAST_LOOP", Const, 0},
+ {"IP_MULTICAST_TTL", Const, 0},
+ {"IP_MULTICAST_VIF", Const, 0},
+ {"IP_NAT__XXX", Const, 0},
+ {"IP_OFFMASK", Const, 0},
+ {"IP_OLD_FW_ADD", Const, 0},
+ {"IP_OLD_FW_DEL", Const, 0},
+ {"IP_OLD_FW_FLUSH", Const, 0},
+ {"IP_OLD_FW_GET", Const, 0},
+ {"IP_OLD_FW_RESETLOG", Const, 0},
+ {"IP_OLD_FW_ZERO", Const, 0},
+ {"IP_ONESBCAST", Const, 0},
+ {"IP_OPTIONS", Const, 0},
+ {"IP_ORIGDSTADDR", Const, 0},
+ {"IP_PASSSEC", Const, 0},
+ {"IP_PIPEX", Const, 1},
+ {"IP_PKTINFO", Const, 0},
+ {"IP_PKTOPTIONS", Const, 0},
+ {"IP_PMTUDISC", Const, 0},
+ {"IP_PMTUDISC_DO", Const, 0},
+ {"IP_PMTUDISC_DONT", Const, 0},
+ {"IP_PMTUDISC_PROBE", Const, 0},
+ {"IP_PMTUDISC_WANT", Const, 0},
+ {"IP_PORTRANGE", Const, 0},
+ {"IP_PORTRANGE_DEFAULT", Const, 0},
+ {"IP_PORTRANGE_HIGH", Const, 0},
+ {"IP_PORTRANGE_LOW", Const, 0},
+ {"IP_RECVDSTADDR", Const, 0},
+ {"IP_RECVDSTPORT", Const, 1},
+ {"IP_RECVERR", Const, 0},
+ {"IP_RECVIF", Const, 0},
+ {"IP_RECVOPTS", Const, 0},
+ {"IP_RECVORIGDSTADDR", Const, 0},
+ {"IP_RECVPKTINFO", Const, 0},
+ {"IP_RECVRETOPTS", Const, 0},
+ {"IP_RECVRTABLE", Const, 1},
+ {"IP_RECVTOS", Const, 0},
+ {"IP_RECVTTL", Const, 0},
+ {"IP_RETOPTS", Const, 0},
+ {"IP_RF", Const, 0},
+ {"IP_ROUTER_ALERT", Const, 0},
+ {"IP_RSVP_OFF", Const, 0},
+ {"IP_RSVP_ON", Const, 0},
+ {"IP_RSVP_VIF_OFF", Const, 0},
+ {"IP_RSVP_VIF_ON", Const, 0},
+ {"IP_RTABLE", Const, 1},
+ {"IP_SENDSRCADDR", Const, 0},
+ {"IP_STRIPHDR", Const, 0},
+ {"IP_TOS", Const, 0},
+ {"IP_TRAFFIC_MGT_BACKGROUND", Const, 0},
+ {"IP_TRANSPARENT", Const, 0},
+ {"IP_TTL", Const, 0},
+ {"IP_UNBLOCK_SOURCE", Const, 0},
+ {"IP_XFRM_POLICY", Const, 0},
+ {"IPv6MTUInfo", Type, 2},
+ {"IPv6MTUInfo.Addr", Field, 2},
+ {"IPv6MTUInfo.Mtu", Field, 2},
+ {"IPv6Mreq", Type, 0},
+ {"IPv6Mreq.Interface", Field, 0},
+ {"IPv6Mreq.Multiaddr", Field, 0},
+ {"ISIG", Const, 0},
+ {"ISTRIP", Const, 0},
+ {"IUCLC", Const, 0},
+ {"IUTF8", Const, 0},
+ {"IXANY", Const, 0},
+ {"IXOFF", Const, 0},
+ {"IXON", Const, 0},
+ {"IfAddrmsg", Type, 0},
+ {"IfAddrmsg.Family", Field, 0},
+ {"IfAddrmsg.Flags", Field, 0},
+ {"IfAddrmsg.Index", Field, 0},
+ {"IfAddrmsg.Prefixlen", Field, 0},
+ {"IfAddrmsg.Scope", Field, 0},
+ {"IfAnnounceMsghdr", Type, 1},
+ {"IfAnnounceMsghdr.Hdrlen", Field, 2},
+ {"IfAnnounceMsghdr.Index", Field, 1},
+ {"IfAnnounceMsghdr.Msglen", Field, 1},
+ {"IfAnnounceMsghdr.Name", Field, 1},
+ {"IfAnnounceMsghdr.Type", Field, 1},
+ {"IfAnnounceMsghdr.Version", Field, 1},
+ {"IfAnnounceMsghdr.What", Field, 1},
+ {"IfData", Type, 0},
+ {"IfData.Addrlen", Field, 0},
+ {"IfData.Baudrate", Field, 0},
+ {"IfData.Capabilities", Field, 2},
+ {"IfData.Collisions", Field, 0},
+ {"IfData.Datalen", Field, 0},
+ {"IfData.Epoch", Field, 0},
+ {"IfData.Hdrlen", Field, 0},
+ {"IfData.Hwassist", Field, 0},
+ {"IfData.Ibytes", Field, 0},
+ {"IfData.Ierrors", Field, 0},
+ {"IfData.Imcasts", Field, 0},
+ {"IfData.Ipackets", Field, 0},
+ {"IfData.Iqdrops", Field, 0},
+ {"IfData.Lastchange", Field, 0},
+ {"IfData.Link_state", Field, 0},
+ {"IfData.Mclpool", Field, 2},
+ {"IfData.Metric", Field, 0},
+ {"IfData.Mtu", Field, 0},
+ {"IfData.Noproto", Field, 0},
+ {"IfData.Obytes", Field, 0},
+ {"IfData.Oerrors", Field, 0},
+ {"IfData.Omcasts", Field, 0},
+ {"IfData.Opackets", Field, 0},
+ {"IfData.Pad", Field, 2},
+ {"IfData.Pad_cgo_0", Field, 2},
+ {"IfData.Pad_cgo_1", Field, 2},
+ {"IfData.Physical", Field, 0},
+ {"IfData.Recvquota", Field, 0},
+ {"IfData.Recvtiming", Field, 0},
+ {"IfData.Reserved1", Field, 0},
+ {"IfData.Reserved2", Field, 0},
+ {"IfData.Spare_char1", Field, 0},
+ {"IfData.Spare_char2", Field, 0},
+ {"IfData.Type", Field, 0},
+ {"IfData.Typelen", Field, 0},
+ {"IfData.Unused1", Field, 0},
+ {"IfData.Unused2", Field, 0},
+ {"IfData.Xmitquota", Field, 0},
+ {"IfData.Xmittiming", Field, 0},
+ {"IfInfomsg", Type, 0},
+ {"IfInfomsg.Change", Field, 0},
+ {"IfInfomsg.Family", Field, 0},
+ {"IfInfomsg.Flags", Field, 0},
+ {"IfInfomsg.Index", Field, 0},
+ {"IfInfomsg.Type", Field, 0},
+ {"IfInfomsg.X__ifi_pad", Field, 0},
+ {"IfMsghdr", Type, 0},
+ {"IfMsghdr.Addrs", Field, 0},
+ {"IfMsghdr.Data", Field, 0},
+ {"IfMsghdr.Flags", Field, 0},
+ {"IfMsghdr.Hdrlen", Field, 2},
+ {"IfMsghdr.Index", Field, 0},
+ {"IfMsghdr.Msglen", Field, 0},
+ {"IfMsghdr.Pad1", Field, 2},
+ {"IfMsghdr.Pad2", Field, 2},
+ {"IfMsghdr.Pad_cgo_0", Field, 0},
+ {"IfMsghdr.Pad_cgo_1", Field, 2},
+ {"IfMsghdr.Tableid", Field, 2},
+ {"IfMsghdr.Type", Field, 0},
+ {"IfMsghdr.Version", Field, 0},
+ {"IfMsghdr.Xflags", Field, 2},
+ {"IfaMsghdr", Type, 0},
+ {"IfaMsghdr.Addrs", Field, 0},
+ {"IfaMsghdr.Flags", Field, 0},
+ {"IfaMsghdr.Hdrlen", Field, 2},
+ {"IfaMsghdr.Index", Field, 0},
+ {"IfaMsghdr.Metric", Field, 0},
+ {"IfaMsghdr.Msglen", Field, 0},
+ {"IfaMsghdr.Pad1", Field, 2},
+ {"IfaMsghdr.Pad2", Field, 2},
+ {"IfaMsghdr.Pad_cgo_0", Field, 0},
+ {"IfaMsghdr.Tableid", Field, 2},
+ {"IfaMsghdr.Type", Field, 0},
+ {"IfaMsghdr.Version", Field, 0},
+ {"IfmaMsghdr", Type, 0},
+ {"IfmaMsghdr.Addrs", Field, 0},
+ {"IfmaMsghdr.Flags", Field, 0},
+ {"IfmaMsghdr.Index", Field, 0},
+ {"IfmaMsghdr.Msglen", Field, 0},
+ {"IfmaMsghdr.Pad_cgo_0", Field, 0},
+ {"IfmaMsghdr.Type", Field, 0},
+ {"IfmaMsghdr.Version", Field, 0},
+ {"IfmaMsghdr2", Type, 0},
+ {"IfmaMsghdr2.Addrs", Field, 0},
+ {"IfmaMsghdr2.Flags", Field, 0},
+ {"IfmaMsghdr2.Index", Field, 0},
+ {"IfmaMsghdr2.Msglen", Field, 0},
+ {"IfmaMsghdr2.Pad_cgo_0", Field, 0},
+ {"IfmaMsghdr2.Refcount", Field, 0},
+ {"IfmaMsghdr2.Type", Field, 0},
+ {"IfmaMsghdr2.Version", Field, 0},
+ {"ImplementsGetwd", Const, 0},
+ {"Inet4Pktinfo", Type, 0},
+ {"Inet4Pktinfo.Addr", Field, 0},
+ {"Inet4Pktinfo.Ifindex", Field, 0},
+ {"Inet4Pktinfo.Spec_dst", Field, 0},
+ {"Inet6Pktinfo", Type, 0},
+ {"Inet6Pktinfo.Addr", Field, 0},
+ {"Inet6Pktinfo.Ifindex", Field, 0},
+ {"InotifyAddWatch", Func, 0},
+ {"InotifyEvent", Type, 0},
+ {"InotifyEvent.Cookie", Field, 0},
+ {"InotifyEvent.Len", Field, 0},
+ {"InotifyEvent.Mask", Field, 0},
+ {"InotifyEvent.Name", Field, 0},
+ {"InotifyEvent.Wd", Field, 0},
+ {"InotifyInit", Func, 0},
+ {"InotifyInit1", Func, 0},
+ {"InotifyRmWatch", Func, 0},
+ {"InterfaceAddrMessage", Type, 0},
+ {"InterfaceAddrMessage.Data", Field, 0},
+ {"InterfaceAddrMessage.Header", Field, 0},
+ {"InterfaceAnnounceMessage", Type, 1},
+ {"InterfaceAnnounceMessage.Header", Field, 1},
+ {"InterfaceInfo", Type, 0},
+ {"InterfaceInfo.Address", Field, 0},
+ {"InterfaceInfo.BroadcastAddress", Field, 0},
+ {"InterfaceInfo.Flags", Field, 0},
+ {"InterfaceInfo.Netmask", Field, 0},
+ {"InterfaceMessage", Type, 0},
+ {"InterfaceMessage.Data", Field, 0},
+ {"InterfaceMessage.Header", Field, 0},
+ {"InterfaceMulticastAddrMessage", Type, 0},
+ {"InterfaceMulticastAddrMessage.Data", Field, 0},
+ {"InterfaceMulticastAddrMessage.Header", Field, 0},
+ {"InvalidHandle", Const, 0},
+ {"Ioperm", Func, 0},
+ {"Iopl", Func, 0},
+ {"Iovec", Type, 0},
+ {"Iovec.Base", Field, 0},
+ {"Iovec.Len", Field, 0},
+ {"IpAdapterInfo", Type, 0},
+ {"IpAdapterInfo.AdapterName", Field, 0},
+ {"IpAdapterInfo.Address", Field, 0},
+ {"IpAdapterInfo.AddressLength", Field, 0},
+ {"IpAdapterInfo.ComboIndex", Field, 0},
+ {"IpAdapterInfo.CurrentIpAddress", Field, 0},
+ {"IpAdapterInfo.Description", Field, 0},
+ {"IpAdapterInfo.DhcpEnabled", Field, 0},
+ {"IpAdapterInfo.DhcpServer", Field, 0},
+ {"IpAdapterInfo.GatewayList", Field, 0},
+ {"IpAdapterInfo.HaveWins", Field, 0},
+ {"IpAdapterInfo.Index", Field, 0},
+ {"IpAdapterInfo.IpAddressList", Field, 0},
+ {"IpAdapterInfo.LeaseExpires", Field, 0},
+ {"IpAdapterInfo.LeaseObtained", Field, 0},
+ {"IpAdapterInfo.Next", Field, 0},
+ {"IpAdapterInfo.PrimaryWinsServer", Field, 0},
+ {"IpAdapterInfo.SecondaryWinsServer", Field, 0},
+ {"IpAdapterInfo.Type", Field, 0},
+ {"IpAddrString", Type, 0},
+ {"IpAddrString.Context", Field, 0},
+ {"IpAddrString.IpAddress", Field, 0},
+ {"IpAddrString.IpMask", Field, 0},
+ {"IpAddrString.Next", Field, 0},
+ {"IpAddressString", Type, 0},
+ {"IpAddressString.String", Field, 0},
+ {"IpMaskString", Type, 0},
+ {"IpMaskString.String", Field, 2},
+ {"Issetugid", Func, 0},
+ {"KEY_ALL_ACCESS", Const, 0},
+ {"KEY_CREATE_LINK", Const, 0},
+ {"KEY_CREATE_SUB_KEY", Const, 0},
+ {"KEY_ENUMERATE_SUB_KEYS", Const, 0},
+ {"KEY_EXECUTE", Const, 0},
+ {"KEY_NOTIFY", Const, 0},
+ {"KEY_QUERY_VALUE", Const, 0},
+ {"KEY_READ", Const, 0},
+ {"KEY_SET_VALUE", Const, 0},
+ {"KEY_WOW64_32KEY", Const, 0},
+ {"KEY_WOW64_64KEY", Const, 0},
+ {"KEY_WRITE", Const, 0},
+ {"Kevent", Func, 0},
+ {"Kevent_t", Type, 0},
+ {"Kevent_t.Data", Field, 0},
+ {"Kevent_t.Fflags", Field, 0},
+ {"Kevent_t.Filter", Field, 0},
+ {"Kevent_t.Flags", Field, 0},
+ {"Kevent_t.Ident", Field, 0},
+ {"Kevent_t.Pad_cgo_0", Field, 2},
+ {"Kevent_t.Udata", Field, 0},
+ {"Kill", Func, 0},
+ {"Klogctl", Func, 0},
+ {"Kqueue", Func, 0},
+ {"LANG_ENGLISH", Const, 0},
+ {"LAYERED_PROTOCOL", Const, 2},
+ {"LCNT_OVERLOAD_FLUSH", Const, 1},
+ {"LINUX_REBOOT_CMD_CAD_OFF", Const, 0},
+ {"LINUX_REBOOT_CMD_CAD_ON", Const, 0},
+ {"LINUX_REBOOT_CMD_HALT", Const, 0},
+ {"LINUX_REBOOT_CMD_KEXEC", Const, 0},
+ {"LINUX_REBOOT_CMD_POWER_OFF", Const, 0},
+ {"LINUX_REBOOT_CMD_RESTART", Const, 0},
+ {"LINUX_REBOOT_CMD_RESTART2", Const, 0},
+ {"LINUX_REBOOT_CMD_SW_SUSPEND", Const, 0},
+ {"LINUX_REBOOT_MAGIC1", Const, 0},
+ {"LINUX_REBOOT_MAGIC2", Const, 0},
+ {"LOCK_EX", Const, 0},
+ {"LOCK_NB", Const, 0},
+ {"LOCK_SH", Const, 0},
+ {"LOCK_UN", Const, 0},
+ {"LazyDLL", Type, 0},
+ {"LazyDLL.Name", Field, 0},
+ {"LazyProc", Type, 0},
+ {"LazyProc.Name", Field, 0},
+ {"Lchown", Func, 0},
+ {"Linger", Type, 0},
+ {"Linger.Linger", Field, 0},
+ {"Linger.Onoff", Field, 0},
+ {"Link", Func, 0},
+ {"Listen", Func, 0},
+ {"Listxattr", Func, 1},
+ {"LoadCancelIoEx", Func, 1},
+ {"LoadConnectEx", Func, 1},
+ {"LoadCreateSymbolicLink", Func, 4},
+ {"LoadDLL", Func, 0},
+ {"LoadGetAddrInfo", Func, 1},
+ {"LoadLibrary", Func, 0},
+ {"LoadSetFileCompletionNotificationModes", Func, 2},
+ {"LocalFree", Func, 0},
+ {"Log2phys_t", Type, 0},
+ {"Log2phys_t.Contigbytes", Field, 0},
+ {"Log2phys_t.Devoffset", Field, 0},
+ {"Log2phys_t.Flags", Field, 0},
+ {"LookupAccountName", Func, 0},
+ {"LookupAccountSid", Func, 0},
+ {"LookupSID", Func, 0},
+ {"LsfJump", Func, 0},
+ {"LsfSocket", Func, 0},
+ {"LsfStmt", Func, 0},
+ {"Lstat", Func, 0},
+ {"MADV_AUTOSYNC", Const, 1},
+ {"MADV_CAN_REUSE", Const, 0},
+ {"MADV_CORE", Const, 1},
+ {"MADV_DOFORK", Const, 0},
+ {"MADV_DONTFORK", Const, 0},
+ {"MADV_DONTNEED", Const, 0},
+ {"MADV_FREE", Const, 0},
+ {"MADV_FREE_REUSABLE", Const, 0},
+ {"MADV_FREE_REUSE", Const, 0},
+ {"MADV_HUGEPAGE", Const, 0},
+ {"MADV_HWPOISON", Const, 0},
+ {"MADV_MERGEABLE", Const, 0},
+ {"MADV_NOCORE", Const, 1},
+ {"MADV_NOHUGEPAGE", Const, 0},
+ {"MADV_NORMAL", Const, 0},
+ {"MADV_NOSYNC", Const, 1},
+ {"MADV_PROTECT", Const, 1},
+ {"MADV_RANDOM", Const, 0},
+ {"MADV_REMOVE", Const, 0},
+ {"MADV_SEQUENTIAL", Const, 0},
+ {"MADV_SPACEAVAIL", Const, 3},
+ {"MADV_UNMERGEABLE", Const, 0},
+ {"MADV_WILLNEED", Const, 0},
+ {"MADV_ZERO_WIRED_PAGES", Const, 0},
+ {"MAP_32BIT", Const, 0},
+ {"MAP_ALIGNED_SUPER", Const, 3},
+ {"MAP_ALIGNMENT_16MB", Const, 3},
+ {"MAP_ALIGNMENT_1TB", Const, 3},
+ {"MAP_ALIGNMENT_256TB", Const, 3},
+ {"MAP_ALIGNMENT_4GB", Const, 3},
+ {"MAP_ALIGNMENT_64KB", Const, 3},
+ {"MAP_ALIGNMENT_64PB", Const, 3},
+ {"MAP_ALIGNMENT_MASK", Const, 3},
+ {"MAP_ALIGNMENT_SHIFT", Const, 3},
+ {"MAP_ANON", Const, 0},
+ {"MAP_ANONYMOUS", Const, 0},
+ {"MAP_COPY", Const, 0},
+ {"MAP_DENYWRITE", Const, 0},
+ {"MAP_EXECUTABLE", Const, 0},
+ {"MAP_FILE", Const, 0},
+ {"MAP_FIXED", Const, 0},
+ {"MAP_FLAGMASK", Const, 3},
+ {"MAP_GROWSDOWN", Const, 0},
+ {"MAP_HASSEMAPHORE", Const, 0},
+ {"MAP_HUGETLB", Const, 0},
+ {"MAP_INHERIT", Const, 3},
+ {"MAP_INHERIT_COPY", Const, 3},
+ {"MAP_INHERIT_DEFAULT", Const, 3},
+ {"MAP_INHERIT_DONATE_COPY", Const, 3},
+ {"MAP_INHERIT_NONE", Const, 3},
+ {"MAP_INHERIT_SHARE", Const, 3},
+ {"MAP_JIT", Const, 0},
+ {"MAP_LOCKED", Const, 0},
+ {"MAP_NOCACHE", Const, 0},
+ {"MAP_NOCORE", Const, 1},
+ {"MAP_NOEXTEND", Const, 0},
+ {"MAP_NONBLOCK", Const, 0},
+ {"MAP_NORESERVE", Const, 0},
+ {"MAP_NOSYNC", Const, 1},
+ {"MAP_POPULATE", Const, 0},
+ {"MAP_PREFAULT_READ", Const, 1},
+ {"MAP_PRIVATE", Const, 0},
+ {"MAP_RENAME", Const, 0},
+ {"MAP_RESERVED0080", Const, 0},
+ {"MAP_RESERVED0100", Const, 1},
+ {"MAP_SHARED", Const, 0},
+ {"MAP_STACK", Const, 0},
+ {"MAP_TRYFIXED", Const, 3},
+ {"MAP_TYPE", Const, 0},
+ {"MAP_WIRED", Const, 3},
+ {"MAXIMUM_REPARSE_DATA_BUFFER_SIZE", Const, 4},
+ {"MAXLEN_IFDESCR", Const, 0},
+ {"MAXLEN_PHYSADDR", Const, 0},
+ {"MAX_ADAPTER_ADDRESS_LENGTH", Const, 0},
+ {"MAX_ADAPTER_DESCRIPTION_LENGTH", Const, 0},
+ {"MAX_ADAPTER_NAME_LENGTH", Const, 0},
+ {"MAX_COMPUTERNAME_LENGTH", Const, 0},
+ {"MAX_INTERFACE_NAME_LEN", Const, 0},
+ {"MAX_LONG_PATH", Const, 0},
+ {"MAX_PATH", Const, 0},
+ {"MAX_PROTOCOL_CHAIN", Const, 2},
+ {"MCL_CURRENT", Const, 0},
+ {"MCL_FUTURE", Const, 0},
+ {"MNT_DETACH", Const, 0},
+ {"MNT_EXPIRE", Const, 0},
+ {"MNT_FORCE", Const, 0},
+ {"MSG_BCAST", Const, 1},
+ {"MSG_CMSG_CLOEXEC", Const, 0},
+ {"MSG_COMPAT", Const, 0},
+ {"MSG_CONFIRM", Const, 0},
+ {"MSG_CONTROLMBUF", Const, 1},
+ {"MSG_CTRUNC", Const, 0},
+ {"MSG_DONTROUTE", Const, 0},
+ {"MSG_DONTWAIT", Const, 0},
+ {"MSG_EOF", Const, 0},
+ {"MSG_EOR", Const, 0},
+ {"MSG_ERRQUEUE", Const, 0},
+ {"MSG_FASTOPEN", Const, 1},
+ {"MSG_FIN", Const, 0},
+ {"MSG_FLUSH", Const, 0},
+ {"MSG_HAVEMORE", Const, 0},
+ {"MSG_HOLD", Const, 0},
+ {"MSG_IOVUSRSPACE", Const, 1},
+ {"MSG_LENUSRSPACE", Const, 1},
+ {"MSG_MCAST", Const, 1},
+ {"MSG_MORE", Const, 0},
+ {"MSG_NAMEMBUF", Const, 1},
+ {"MSG_NBIO", Const, 0},
+ {"MSG_NEEDSA", Const, 0},
+ {"MSG_NOSIGNAL", Const, 0},
+ {"MSG_NOTIFICATION", Const, 0},
+ {"MSG_OOB", Const, 0},
+ {"MSG_PEEK", Const, 0},
+ {"MSG_PROXY", Const, 0},
+ {"MSG_RCVMORE", Const, 0},
+ {"MSG_RST", Const, 0},
+ {"MSG_SEND", Const, 0},
+ {"MSG_SYN", Const, 0},
+ {"MSG_TRUNC", Const, 0},
+ {"MSG_TRYHARD", Const, 0},
+ {"MSG_USERFLAGS", Const, 1},
+ {"MSG_WAITALL", Const, 0},
+ {"MSG_WAITFORONE", Const, 0},
+ {"MSG_WAITSTREAM", Const, 0},
+ {"MS_ACTIVE", Const, 0},
+ {"MS_ASYNC", Const, 0},
+ {"MS_BIND", Const, 0},
+ {"MS_DEACTIVATE", Const, 0},
+ {"MS_DIRSYNC", Const, 0},
+ {"MS_INVALIDATE", Const, 0},
+ {"MS_I_VERSION", Const, 0},
+ {"MS_KERNMOUNT", Const, 0},
+ {"MS_KILLPAGES", Const, 0},
+ {"MS_MANDLOCK", Const, 0},
+ {"MS_MGC_MSK", Const, 0},
+ {"MS_MGC_VAL", Const, 0},
+ {"MS_MOVE", Const, 0},
+ {"MS_NOATIME", Const, 0},
+ {"MS_NODEV", Const, 0},
+ {"MS_NODIRATIME", Const, 0},
+ {"MS_NOEXEC", Const, 0},
+ {"MS_NOSUID", Const, 0},
+ {"MS_NOUSER", Const, 0},
+ {"MS_POSIXACL", Const, 0},
+ {"MS_PRIVATE", Const, 0},
+ {"MS_RDONLY", Const, 0},
+ {"MS_REC", Const, 0},
+ {"MS_RELATIME", Const, 0},
+ {"MS_REMOUNT", Const, 0},
+ {"MS_RMT_MASK", Const, 0},
+ {"MS_SHARED", Const, 0},
+ {"MS_SILENT", Const, 0},
+ {"MS_SLAVE", Const, 0},
+ {"MS_STRICTATIME", Const, 0},
+ {"MS_SYNC", Const, 0},
+ {"MS_SYNCHRONOUS", Const, 0},
+ {"MS_UNBINDABLE", Const, 0},
+ {"Madvise", Func, 0},
+ {"MapViewOfFile", Func, 0},
+ {"MaxTokenInfoClass", Const, 0},
+ {"Mclpool", Type, 2},
+ {"Mclpool.Alive", Field, 2},
+ {"Mclpool.Cwm", Field, 2},
+ {"Mclpool.Grown", Field, 2},
+ {"Mclpool.Hwm", Field, 2},
+ {"Mclpool.Lwm", Field, 2},
+ {"MibIfRow", Type, 0},
+ {"MibIfRow.AdminStatus", Field, 0},
+ {"MibIfRow.Descr", Field, 0},
+ {"MibIfRow.DescrLen", Field, 0},
+ {"MibIfRow.InDiscards", Field, 0},
+ {"MibIfRow.InErrors", Field, 0},
+ {"MibIfRow.InNUcastPkts", Field, 0},
+ {"MibIfRow.InOctets", Field, 0},
+ {"MibIfRow.InUcastPkts", Field, 0},
+ {"MibIfRow.InUnknownProtos", Field, 0},
+ {"MibIfRow.Index", Field, 0},
+ {"MibIfRow.LastChange", Field, 0},
+ {"MibIfRow.Mtu", Field, 0},
+ {"MibIfRow.Name", Field, 0},
+ {"MibIfRow.OperStatus", Field, 0},
+ {"MibIfRow.OutDiscards", Field, 0},
+ {"MibIfRow.OutErrors", Field, 0},
+ {"MibIfRow.OutNUcastPkts", Field, 0},
+ {"MibIfRow.OutOctets", Field, 0},
+ {"MibIfRow.OutQLen", Field, 0},
+ {"MibIfRow.OutUcastPkts", Field, 0},
+ {"MibIfRow.PhysAddr", Field, 0},
+ {"MibIfRow.PhysAddrLen", Field, 0},
+ {"MibIfRow.Speed", Field, 0},
+ {"MibIfRow.Type", Field, 0},
+ {"Mkdir", Func, 0},
+ {"Mkdirat", Func, 0},
+ {"Mkfifo", Func, 0},
+ {"Mknod", Func, 0},
+ {"Mknodat", Func, 0},
+ {"Mlock", Func, 0},
+ {"Mlockall", Func, 0},
+ {"Mmap", Func, 0},
+ {"Mount", Func, 0},
+ {"MoveFile", Func, 0},
+ {"Mprotect", Func, 0},
+ {"Msghdr", Type, 0},
+ {"Msghdr.Control", Field, 0},
+ {"Msghdr.Controllen", Field, 0},
+ {"Msghdr.Flags", Field, 0},
+ {"Msghdr.Iov", Field, 0},
+ {"Msghdr.Iovlen", Field, 0},
+ {"Msghdr.Name", Field, 0},
+ {"Msghdr.Namelen", Field, 0},
+ {"Msghdr.Pad_cgo_0", Field, 0},
+ {"Msghdr.Pad_cgo_1", Field, 0},
+ {"Munlock", Func, 0},
+ {"Munlockall", Func, 0},
+ {"Munmap", Func, 0},
+ {"MustLoadDLL", Func, 0},
+ {"NAME_MAX", Const, 0},
+ {"NETLINK_ADD_MEMBERSHIP", Const, 0},
+ {"NETLINK_AUDIT", Const, 0},
+ {"NETLINK_BROADCAST_ERROR", Const, 0},
+ {"NETLINK_CONNECTOR", Const, 0},
+ {"NETLINK_DNRTMSG", Const, 0},
+ {"NETLINK_DROP_MEMBERSHIP", Const, 0},
+ {"NETLINK_ECRYPTFS", Const, 0},
+ {"NETLINK_FIB_LOOKUP", Const, 0},
+ {"NETLINK_FIREWALL", Const, 0},
+ {"NETLINK_GENERIC", Const, 0},
+ {"NETLINK_INET_DIAG", Const, 0},
+ {"NETLINK_IP6_FW", Const, 0},
+ {"NETLINK_ISCSI", Const, 0},
+ {"NETLINK_KOBJECT_UEVENT", Const, 0},
+ {"NETLINK_NETFILTER", Const, 0},
+ {"NETLINK_NFLOG", Const, 0},
+ {"NETLINK_NO_ENOBUFS", Const, 0},
+ {"NETLINK_PKTINFO", Const, 0},
+ {"NETLINK_RDMA", Const, 0},
+ {"NETLINK_ROUTE", Const, 0},
+ {"NETLINK_SCSITRANSPORT", Const, 0},
+ {"NETLINK_SELINUX", Const, 0},
+ {"NETLINK_UNUSED", Const, 0},
+ {"NETLINK_USERSOCK", Const, 0},
+ {"NETLINK_XFRM", Const, 0},
+ {"NET_RT_DUMP", Const, 0},
+ {"NET_RT_DUMP2", Const, 0},
+ {"NET_RT_FLAGS", Const, 0},
+ {"NET_RT_IFLIST", Const, 0},
+ {"NET_RT_IFLIST2", Const, 0},
+ {"NET_RT_IFLISTL", Const, 1},
+ {"NET_RT_IFMALIST", Const, 0},
+ {"NET_RT_MAXID", Const, 0},
+ {"NET_RT_OIFLIST", Const, 1},
+ {"NET_RT_OOIFLIST", Const, 1},
+ {"NET_RT_STAT", Const, 0},
+ {"NET_RT_STATS", Const, 1},
+ {"NET_RT_TABLE", Const, 1},
+ {"NET_RT_TRASH", Const, 0},
+ {"NLA_ALIGNTO", Const, 0},
+ {"NLA_F_NESTED", Const, 0},
+ {"NLA_F_NET_BYTEORDER", Const, 0},
+ {"NLA_HDRLEN", Const, 0},
+ {"NLMSG_ALIGNTO", Const, 0},
+ {"NLMSG_DONE", Const, 0},
+ {"NLMSG_ERROR", Const, 0},
+ {"NLMSG_HDRLEN", Const, 0},
+ {"NLMSG_MIN_TYPE", Const, 0},
+ {"NLMSG_NOOP", Const, 0},
+ {"NLMSG_OVERRUN", Const, 0},
+ {"NLM_F_ACK", Const, 0},
+ {"NLM_F_APPEND", Const, 0},
+ {"NLM_F_ATOMIC", Const, 0},
+ {"NLM_F_CREATE", Const, 0},
+ {"NLM_F_DUMP", Const, 0},
+ {"NLM_F_ECHO", Const, 0},
+ {"NLM_F_EXCL", Const, 0},
+ {"NLM_F_MATCH", Const, 0},
+ {"NLM_F_MULTI", Const, 0},
+ {"NLM_F_REPLACE", Const, 0},
+ {"NLM_F_REQUEST", Const, 0},
+ {"NLM_F_ROOT", Const, 0},
+ {"NOFLSH", Const, 0},
+ {"NOTE_ABSOLUTE", Const, 0},
+ {"NOTE_ATTRIB", Const, 0},
+ {"NOTE_BACKGROUND", Const, 16},
+ {"NOTE_CHILD", Const, 0},
+ {"NOTE_CRITICAL", Const, 16},
+ {"NOTE_DELETE", Const, 0},
+ {"NOTE_EOF", Const, 1},
+ {"NOTE_EXEC", Const, 0},
+ {"NOTE_EXIT", Const, 0},
+ {"NOTE_EXITSTATUS", Const, 0},
+ {"NOTE_EXIT_CSERROR", Const, 16},
+ {"NOTE_EXIT_DECRYPTFAIL", Const, 16},
+ {"NOTE_EXIT_DETAIL", Const, 16},
+ {"NOTE_EXIT_DETAIL_MASK", Const, 16},
+ {"NOTE_EXIT_MEMORY", Const, 16},
+ {"NOTE_EXIT_REPARENTED", Const, 16},
+ {"NOTE_EXTEND", Const, 0},
+ {"NOTE_FFAND", Const, 0},
+ {"NOTE_FFCOPY", Const, 0},
+ {"NOTE_FFCTRLMASK", Const, 0},
+ {"NOTE_FFLAGSMASK", Const, 0},
+ {"NOTE_FFNOP", Const, 0},
+ {"NOTE_FFOR", Const, 0},
+ {"NOTE_FORK", Const, 0},
+ {"NOTE_LEEWAY", Const, 16},
+ {"NOTE_LINK", Const, 0},
+ {"NOTE_LOWAT", Const, 0},
+ {"NOTE_NONE", Const, 0},
+ {"NOTE_NSECONDS", Const, 0},
+ {"NOTE_PCTRLMASK", Const, 0},
+ {"NOTE_PDATAMASK", Const, 0},
+ {"NOTE_REAP", Const, 0},
+ {"NOTE_RENAME", Const, 0},
+ {"NOTE_RESOURCEEND", Const, 0},
+ {"NOTE_REVOKE", Const, 0},
+ {"NOTE_SECONDS", Const, 0},
+ {"NOTE_SIGNAL", Const, 0},
+ {"NOTE_TRACK", Const, 0},
+ {"NOTE_TRACKERR", Const, 0},
+ {"NOTE_TRIGGER", Const, 0},
+ {"NOTE_TRUNCATE", Const, 1},
+ {"NOTE_USECONDS", Const, 0},
+ {"NOTE_VM_ERROR", Const, 0},
+ {"NOTE_VM_PRESSURE", Const, 0},
+ {"NOTE_VM_PRESSURE_SUDDEN_TERMINATE", Const, 0},
+ {"NOTE_VM_PRESSURE_TERMINATE", Const, 0},
+ {"NOTE_WRITE", Const, 0},
+ {"NameCanonical", Const, 0},
+ {"NameCanonicalEx", Const, 0},
+ {"NameDisplay", Const, 0},
+ {"NameDnsDomain", Const, 0},
+ {"NameFullyQualifiedDN", Const, 0},
+ {"NameSamCompatible", Const, 0},
+ {"NameServicePrincipal", Const, 0},
+ {"NameUniqueId", Const, 0},
+ {"NameUnknown", Const, 0},
+ {"NameUserPrincipal", Const, 0},
+ {"Nanosleep", Func, 0},
+ {"NetApiBufferFree", Func, 0},
+ {"NetGetJoinInformation", Func, 2},
+ {"NetSetupDomainName", Const, 2},
+ {"NetSetupUnjoined", Const, 2},
+ {"NetSetupUnknownStatus", Const, 2},
+ {"NetSetupWorkgroupName", Const, 2},
+ {"NetUserGetInfo", Func, 0},
+ {"NetlinkMessage", Type, 0},
+ {"NetlinkMessage.Data", Field, 0},
+ {"NetlinkMessage.Header", Field, 0},
+ {"NetlinkRIB", Func, 0},
+ {"NetlinkRouteAttr", Type, 0},
+ {"NetlinkRouteAttr.Attr", Field, 0},
+ {"NetlinkRouteAttr.Value", Field, 0},
+ {"NetlinkRouteRequest", Type, 0},
+ {"NetlinkRouteRequest.Data", Field, 0},
+ {"NetlinkRouteRequest.Header", Field, 0},
+ {"NewCallback", Func, 0},
+ {"NewCallbackCDecl", Func, 3},
+ {"NewLazyDLL", Func, 0},
+ {"NlAttr", Type, 0},
+ {"NlAttr.Len", Field, 0},
+ {"NlAttr.Type", Field, 0},
+ {"NlMsgerr", Type, 0},
+ {"NlMsgerr.Error", Field, 0},
+ {"NlMsgerr.Msg", Field, 0},
+ {"NlMsghdr", Type, 0},
+ {"NlMsghdr.Flags", Field, 0},
+ {"NlMsghdr.Len", Field, 0},
+ {"NlMsghdr.Pid", Field, 0},
+ {"NlMsghdr.Seq", Field, 0},
+ {"NlMsghdr.Type", Field, 0},
+ {"NsecToFiletime", Func, 0},
+ {"NsecToTimespec", Func, 0},
+ {"NsecToTimeval", Func, 0},
+ {"Ntohs", Func, 0},
+ {"OCRNL", Const, 0},
+ {"OFDEL", Const, 0},
+ {"OFILL", Const, 0},
+ {"OFIOGETBMAP", Const, 1},
+ {"OID_PKIX_KP_SERVER_AUTH", Var, 0},
+ {"OID_SERVER_GATED_CRYPTO", Var, 0},
+ {"OID_SGC_NETSCAPE", Var, 0},
+ {"OLCUC", Const, 0},
+ {"ONLCR", Const, 0},
+ {"ONLRET", Const, 0},
+ {"ONOCR", Const, 0},
+ {"ONOEOT", Const, 1},
+ {"OPEN_ALWAYS", Const, 0},
+ {"OPEN_EXISTING", Const, 0},
+ {"OPOST", Const, 0},
+ {"O_ACCMODE", Const, 0},
+ {"O_ALERT", Const, 0},
+ {"O_ALT_IO", Const, 1},
+ {"O_APPEND", Const, 0},
+ {"O_ASYNC", Const, 0},
+ {"O_CLOEXEC", Const, 0},
+ {"O_CREAT", Const, 0},
+ {"O_DIRECT", Const, 0},
+ {"O_DIRECTORY", Const, 0},
+ {"O_DP_GETRAWENCRYPTED", Const, 16},
+ {"O_DSYNC", Const, 0},
+ {"O_EVTONLY", Const, 0},
+ {"O_EXCL", Const, 0},
+ {"O_EXEC", Const, 0},
+ {"O_EXLOCK", Const, 0},
+ {"O_FSYNC", Const, 0},
+ {"O_LARGEFILE", Const, 0},
+ {"O_NDELAY", Const, 0},
+ {"O_NOATIME", Const, 0},
+ {"O_NOCTTY", Const, 0},
+ {"O_NOFOLLOW", Const, 0},
+ {"O_NONBLOCK", Const, 0},
+ {"O_NOSIGPIPE", Const, 1},
+ {"O_POPUP", Const, 0},
+ {"O_RDONLY", Const, 0},
+ {"O_RDWR", Const, 0},
+ {"O_RSYNC", Const, 0},
+ {"O_SHLOCK", Const, 0},
+ {"O_SYMLINK", Const, 0},
+ {"O_SYNC", Const, 0},
+ {"O_TRUNC", Const, 0},
+ {"O_TTY_INIT", Const, 0},
+ {"O_WRONLY", Const, 0},
+ {"Open", Func, 0},
+ {"OpenCurrentProcessToken", Func, 0},
+ {"OpenProcess", Func, 0},
+ {"OpenProcessToken", Func, 0},
+ {"Openat", Func, 0},
+ {"Overlapped", Type, 0},
+ {"Overlapped.HEvent", Field, 0},
+ {"Overlapped.Internal", Field, 0},
+ {"Overlapped.InternalHigh", Field, 0},
+ {"Overlapped.Offset", Field, 0},
+ {"Overlapped.OffsetHigh", Field, 0},
+ {"PACKET_ADD_MEMBERSHIP", Const, 0},
+ {"PACKET_BROADCAST", Const, 0},
+ {"PACKET_DROP_MEMBERSHIP", Const, 0},
+ {"PACKET_FASTROUTE", Const, 0},
+ {"PACKET_HOST", Const, 0},
+ {"PACKET_LOOPBACK", Const, 0},
+ {"PACKET_MR_ALLMULTI", Const, 0},
+ {"PACKET_MR_MULTICAST", Const, 0},
+ {"PACKET_MR_PROMISC", Const, 0},
+ {"PACKET_MULTICAST", Const, 0},
+ {"PACKET_OTHERHOST", Const, 0},
+ {"PACKET_OUTGOING", Const, 0},
+ {"PACKET_RECV_OUTPUT", Const, 0},
+ {"PACKET_RX_RING", Const, 0},
+ {"PACKET_STATISTICS", Const, 0},
+ {"PAGE_EXECUTE_READ", Const, 0},
+ {"PAGE_EXECUTE_READWRITE", Const, 0},
+ {"PAGE_EXECUTE_WRITECOPY", Const, 0},
+ {"PAGE_READONLY", Const, 0},
+ {"PAGE_READWRITE", Const, 0},
+ {"PAGE_WRITECOPY", Const, 0},
+ {"PARENB", Const, 0},
+ {"PARMRK", Const, 0},
+ {"PARODD", Const, 0},
+ {"PENDIN", Const, 0},
+ {"PFL_HIDDEN", Const, 2},
+ {"PFL_MATCHES_PROTOCOL_ZERO", Const, 2},
+ {"PFL_MULTIPLE_PROTO_ENTRIES", Const, 2},
+ {"PFL_NETWORKDIRECT_PROVIDER", Const, 2},
+ {"PFL_RECOMMENDED_PROTO_ENTRY", Const, 2},
+ {"PF_FLUSH", Const, 1},
+ {"PKCS_7_ASN_ENCODING", Const, 0},
+ {"PMC5_PIPELINE_FLUSH", Const, 1},
+ {"PRIO_PGRP", Const, 2},
+ {"PRIO_PROCESS", Const, 2},
+ {"PRIO_USER", Const, 2},
+ {"PRI_IOFLUSH", Const, 1},
+ {"PROCESS_QUERY_INFORMATION", Const, 0},
+ {"PROCESS_TERMINATE", Const, 2},
+ {"PROT_EXEC", Const, 0},
+ {"PROT_GROWSDOWN", Const, 0},
+ {"PROT_GROWSUP", Const, 0},
+ {"PROT_NONE", Const, 0},
+ {"PROT_READ", Const, 0},
+ {"PROT_WRITE", Const, 0},
+ {"PROV_DH_SCHANNEL", Const, 0},
+ {"PROV_DSS", Const, 0},
+ {"PROV_DSS_DH", Const, 0},
+ {"PROV_EC_ECDSA_FULL", Const, 0},
+ {"PROV_EC_ECDSA_SIG", Const, 0},
+ {"PROV_EC_ECNRA_FULL", Const, 0},
+ {"PROV_EC_ECNRA_SIG", Const, 0},
+ {"PROV_FORTEZZA", Const, 0},
+ {"PROV_INTEL_SEC", Const, 0},
+ {"PROV_MS_EXCHANGE", Const, 0},
+ {"PROV_REPLACE_OWF", Const, 0},
+ {"PROV_RNG", Const, 0},
+ {"PROV_RSA_AES", Const, 0},
+ {"PROV_RSA_FULL", Const, 0},
+ {"PROV_RSA_SCHANNEL", Const, 0},
+ {"PROV_RSA_SIG", Const, 0},
+ {"PROV_SPYRUS_LYNKS", Const, 0},
+ {"PROV_SSL", Const, 0},
+ {"PR_CAPBSET_DROP", Const, 0},
+ {"PR_CAPBSET_READ", Const, 0},
+ {"PR_CLEAR_SECCOMP_FILTER", Const, 0},
+ {"PR_ENDIAN_BIG", Const, 0},
+ {"PR_ENDIAN_LITTLE", Const, 0},
+ {"PR_ENDIAN_PPC_LITTLE", Const, 0},
+ {"PR_FPEMU_NOPRINT", Const, 0},
+ {"PR_FPEMU_SIGFPE", Const, 0},
+ {"PR_FP_EXC_ASYNC", Const, 0},
+ {"PR_FP_EXC_DISABLED", Const, 0},
+ {"PR_FP_EXC_DIV", Const, 0},
+ {"PR_FP_EXC_INV", Const, 0},
+ {"PR_FP_EXC_NONRECOV", Const, 0},
+ {"PR_FP_EXC_OVF", Const, 0},
+ {"PR_FP_EXC_PRECISE", Const, 0},
+ {"PR_FP_EXC_RES", Const, 0},
+ {"PR_FP_EXC_SW_ENABLE", Const, 0},
+ {"PR_FP_EXC_UND", Const, 0},
+ {"PR_GET_DUMPABLE", Const, 0},
+ {"PR_GET_ENDIAN", Const, 0},
+ {"PR_GET_FPEMU", Const, 0},
+ {"PR_GET_FPEXC", Const, 0},
+ {"PR_GET_KEEPCAPS", Const, 0},
+ {"PR_GET_NAME", Const, 0},
+ {"PR_GET_PDEATHSIG", Const, 0},
+ {"PR_GET_SECCOMP", Const, 0},
+ {"PR_GET_SECCOMP_FILTER", Const, 0},
+ {"PR_GET_SECUREBITS", Const, 0},
+ {"PR_GET_TIMERSLACK", Const, 0},
+ {"PR_GET_TIMING", Const, 0},
+ {"PR_GET_TSC", Const, 0},
+ {"PR_GET_UNALIGN", Const, 0},
+ {"PR_MCE_KILL", Const, 0},
+ {"PR_MCE_KILL_CLEAR", Const, 0},
+ {"PR_MCE_KILL_DEFAULT", Const, 0},
+ {"PR_MCE_KILL_EARLY", Const, 0},
+ {"PR_MCE_KILL_GET", Const, 0},
+ {"PR_MCE_KILL_LATE", Const, 0},
+ {"PR_MCE_KILL_SET", Const, 0},
+ {"PR_SECCOMP_FILTER_EVENT", Const, 0},
+ {"PR_SECCOMP_FILTER_SYSCALL", Const, 0},
+ {"PR_SET_DUMPABLE", Const, 0},
+ {"PR_SET_ENDIAN", Const, 0},
+ {"PR_SET_FPEMU", Const, 0},
+ {"PR_SET_FPEXC", Const, 0},
+ {"PR_SET_KEEPCAPS", Const, 0},
+ {"PR_SET_NAME", Const, 0},
+ {"PR_SET_PDEATHSIG", Const, 0},
+ {"PR_SET_PTRACER", Const, 0},
+ {"PR_SET_SECCOMP", Const, 0},
+ {"PR_SET_SECCOMP_FILTER", Const, 0},
+ {"PR_SET_SECUREBITS", Const, 0},
+ {"PR_SET_TIMERSLACK", Const, 0},
+ {"PR_SET_TIMING", Const, 0},
+ {"PR_SET_TSC", Const, 0},
+ {"PR_SET_UNALIGN", Const, 0},
+ {"PR_TASK_PERF_EVENTS_DISABLE", Const, 0},
+ {"PR_TASK_PERF_EVENTS_ENABLE", Const, 0},
+ {"PR_TIMING_STATISTICAL", Const, 0},
+ {"PR_TIMING_TIMESTAMP", Const, 0},
+ {"PR_TSC_ENABLE", Const, 0},
+ {"PR_TSC_SIGSEGV", Const, 0},
+ {"PR_UNALIGN_NOPRINT", Const, 0},
+ {"PR_UNALIGN_SIGBUS", Const, 0},
+ {"PTRACE_ARCH_PRCTL", Const, 0},
+ {"PTRACE_ATTACH", Const, 0},
+ {"PTRACE_CONT", Const, 0},
+ {"PTRACE_DETACH", Const, 0},
+ {"PTRACE_EVENT_CLONE", Const, 0},
+ {"PTRACE_EVENT_EXEC", Const, 0},
+ {"PTRACE_EVENT_EXIT", Const, 0},
+ {"PTRACE_EVENT_FORK", Const, 0},
+ {"PTRACE_EVENT_VFORK", Const, 0},
+ {"PTRACE_EVENT_VFORK_DONE", Const, 0},
+ {"PTRACE_GETCRUNCHREGS", Const, 0},
+ {"PTRACE_GETEVENTMSG", Const, 0},
+ {"PTRACE_GETFPREGS", Const, 0},
+ {"PTRACE_GETFPXREGS", Const, 0},
+ {"PTRACE_GETHBPREGS", Const, 0},
+ {"PTRACE_GETREGS", Const, 0},
+ {"PTRACE_GETREGSET", Const, 0},
+ {"PTRACE_GETSIGINFO", Const, 0},
+ {"PTRACE_GETVFPREGS", Const, 0},
+ {"PTRACE_GETWMMXREGS", Const, 0},
+ {"PTRACE_GET_THREAD_AREA", Const, 0},
+ {"PTRACE_KILL", Const, 0},
+ {"PTRACE_OLDSETOPTIONS", Const, 0},
+ {"PTRACE_O_MASK", Const, 0},
+ {"PTRACE_O_TRACECLONE", Const, 0},
+ {"PTRACE_O_TRACEEXEC", Const, 0},
+ {"PTRACE_O_TRACEEXIT", Const, 0},
+ {"PTRACE_O_TRACEFORK", Const, 0},
+ {"PTRACE_O_TRACESYSGOOD", Const, 0},
+ {"PTRACE_O_TRACEVFORK", Const, 0},
+ {"PTRACE_O_TRACEVFORKDONE", Const, 0},
+ {"PTRACE_PEEKDATA", Const, 0},
+ {"PTRACE_PEEKTEXT", Const, 0},
+ {"PTRACE_PEEKUSR", Const, 0},
+ {"PTRACE_POKEDATA", Const, 0},
+ {"PTRACE_POKETEXT", Const, 0},
+ {"PTRACE_POKEUSR", Const, 0},
+ {"PTRACE_SETCRUNCHREGS", Const, 0},
+ {"PTRACE_SETFPREGS", Const, 0},
+ {"PTRACE_SETFPXREGS", Const, 0},
+ {"PTRACE_SETHBPREGS", Const, 0},
+ {"PTRACE_SETOPTIONS", Const, 0},
+ {"PTRACE_SETREGS", Const, 0},
+ {"PTRACE_SETREGSET", Const, 0},
+ {"PTRACE_SETSIGINFO", Const, 0},
+ {"PTRACE_SETVFPREGS", Const, 0},
+ {"PTRACE_SETWMMXREGS", Const, 0},
+ {"PTRACE_SET_SYSCALL", Const, 0},
+ {"PTRACE_SET_THREAD_AREA", Const, 0},
+ {"PTRACE_SINGLEBLOCK", Const, 0},
+ {"PTRACE_SINGLESTEP", Const, 0},
+ {"PTRACE_SYSCALL", Const, 0},
+ {"PTRACE_SYSEMU", Const, 0},
+ {"PTRACE_SYSEMU_SINGLESTEP", Const, 0},
+ {"PTRACE_TRACEME", Const, 0},
+ {"PT_ATTACH", Const, 0},
+ {"PT_ATTACHEXC", Const, 0},
+ {"PT_CONTINUE", Const, 0},
+ {"PT_DATA_ADDR", Const, 0},
+ {"PT_DENY_ATTACH", Const, 0},
+ {"PT_DETACH", Const, 0},
+ {"PT_FIRSTMACH", Const, 0},
+ {"PT_FORCEQUOTA", Const, 0},
+ {"PT_KILL", Const, 0},
+ {"PT_MASK", Const, 1},
+ {"PT_READ_D", Const, 0},
+ {"PT_READ_I", Const, 0},
+ {"PT_READ_U", Const, 0},
+ {"PT_SIGEXC", Const, 0},
+ {"PT_STEP", Const, 0},
+ {"PT_TEXT_ADDR", Const, 0},
+ {"PT_TEXT_END_ADDR", Const, 0},
+ {"PT_THUPDATE", Const, 0},
+ {"PT_TRACE_ME", Const, 0},
+ {"PT_WRITE_D", Const, 0},
+ {"PT_WRITE_I", Const, 0},
+ {"PT_WRITE_U", Const, 0},
+ {"ParseDirent", Func, 0},
+ {"ParseNetlinkMessage", Func, 0},
+ {"ParseNetlinkRouteAttr", Func, 0},
+ {"ParseRoutingMessage", Func, 0},
+ {"ParseRoutingSockaddr", Func, 0},
+ {"ParseSocketControlMessage", Func, 0},
+ {"ParseUnixCredentials", Func, 0},
+ {"ParseUnixRights", Func, 0},
+ {"PathMax", Const, 0},
+ {"Pathconf", Func, 0},
+ {"Pause", Func, 0},
+ {"Pipe", Func, 0},
+ {"Pipe2", Func, 1},
+ {"PivotRoot", Func, 0},
+ {"Pointer", Type, 11},
+ {"PostQueuedCompletionStatus", Func, 0},
+ {"Pread", Func, 0},
+ {"Proc", Type, 0},
+ {"Proc.Dll", Field, 0},
+ {"Proc.Name", Field, 0},
+ {"ProcAttr", Type, 0},
+ {"ProcAttr.Dir", Field, 0},
+ {"ProcAttr.Env", Field, 0},
+ {"ProcAttr.Files", Field, 0},
+ {"ProcAttr.Sys", Field, 0},
+ {"Process32First", Func, 4},
+ {"Process32Next", Func, 4},
+ {"ProcessEntry32", Type, 4},
+ {"ProcessEntry32.DefaultHeapID", Field, 4},
+ {"ProcessEntry32.ExeFile", Field, 4},
+ {"ProcessEntry32.Flags", Field, 4},
+ {"ProcessEntry32.ModuleID", Field, 4},
+ {"ProcessEntry32.ParentProcessID", Field, 4},
+ {"ProcessEntry32.PriClassBase", Field, 4},
+ {"ProcessEntry32.ProcessID", Field, 4},
+ {"ProcessEntry32.Size", Field, 4},
+ {"ProcessEntry32.Threads", Field, 4},
+ {"ProcessEntry32.Usage", Field, 4},
+ {"ProcessInformation", Type, 0},
+ {"ProcessInformation.Process", Field, 0},
+ {"ProcessInformation.ProcessId", Field, 0},
+ {"ProcessInformation.Thread", Field, 0},
+ {"ProcessInformation.ThreadId", Field, 0},
+ {"Protoent", Type, 0},
+ {"Protoent.Aliases", Field, 0},
+ {"Protoent.Name", Field, 0},
+ {"Protoent.Proto", Field, 0},
+ {"PtraceAttach", Func, 0},
+ {"PtraceCont", Func, 0},
+ {"PtraceDetach", Func, 0},
+ {"PtraceGetEventMsg", Func, 0},
+ {"PtraceGetRegs", Func, 0},
+ {"PtracePeekData", Func, 0},
+ {"PtracePeekText", Func, 0},
+ {"PtracePokeData", Func, 0},
+ {"PtracePokeText", Func, 0},
+ {"PtraceRegs", Type, 0},
+ {"PtraceRegs.Cs", Field, 0},
+ {"PtraceRegs.Ds", Field, 0},
+ {"PtraceRegs.Eax", Field, 0},
+ {"PtraceRegs.Ebp", Field, 0},
+ {"PtraceRegs.Ebx", Field, 0},
+ {"PtraceRegs.Ecx", Field, 0},
+ {"PtraceRegs.Edi", Field, 0},
+ {"PtraceRegs.Edx", Field, 0},
+ {"PtraceRegs.Eflags", Field, 0},
+ {"PtraceRegs.Eip", Field, 0},
+ {"PtraceRegs.Es", Field, 0},
+ {"PtraceRegs.Esi", Field, 0},
+ {"PtraceRegs.Esp", Field, 0},
+ {"PtraceRegs.Fs", Field, 0},
+ {"PtraceRegs.Fs_base", Field, 0},
+ {"PtraceRegs.Gs", Field, 0},
+ {"PtraceRegs.Gs_base", Field, 0},
+ {"PtraceRegs.Orig_eax", Field, 0},
+ {"PtraceRegs.Orig_rax", Field, 0},
+ {"PtraceRegs.R10", Field, 0},
+ {"PtraceRegs.R11", Field, 0},
+ {"PtraceRegs.R12", Field, 0},
+ {"PtraceRegs.R13", Field, 0},
+ {"PtraceRegs.R14", Field, 0},
+ {"PtraceRegs.R15", Field, 0},
+ {"PtraceRegs.R8", Field, 0},
+ {"PtraceRegs.R9", Field, 0},
+ {"PtraceRegs.Rax", Field, 0},
+ {"PtraceRegs.Rbp", Field, 0},
+ {"PtraceRegs.Rbx", Field, 0},
+ {"PtraceRegs.Rcx", Field, 0},
+ {"PtraceRegs.Rdi", Field, 0},
+ {"PtraceRegs.Rdx", Field, 0},
+ {"PtraceRegs.Rip", Field, 0},
+ {"PtraceRegs.Rsi", Field, 0},
+ {"PtraceRegs.Rsp", Field, 0},
+ {"PtraceRegs.Ss", Field, 0},
+ {"PtraceRegs.Uregs", Field, 0},
+ {"PtraceRegs.Xcs", Field, 0},
+ {"PtraceRegs.Xds", Field, 0},
+ {"PtraceRegs.Xes", Field, 0},
+ {"PtraceRegs.Xfs", Field, 0},
+ {"PtraceRegs.Xgs", Field, 0},
+ {"PtraceRegs.Xss", Field, 0},
+ {"PtraceSetOptions", Func, 0},
+ {"PtraceSetRegs", Func, 0},
+ {"PtraceSingleStep", Func, 0},
+ {"PtraceSyscall", Func, 1},
+ {"Pwrite", Func, 0},
+ {"REG_BINARY", Const, 0},
+ {"REG_DWORD", Const, 0},
+ {"REG_DWORD_BIG_ENDIAN", Const, 0},
+ {"REG_DWORD_LITTLE_ENDIAN", Const, 0},
+ {"REG_EXPAND_SZ", Const, 0},
+ {"REG_FULL_RESOURCE_DESCRIPTOR", Const, 0},
+ {"REG_LINK", Const, 0},
+ {"REG_MULTI_SZ", Const, 0},
+ {"REG_NONE", Const, 0},
+ {"REG_QWORD", Const, 0},
+ {"REG_QWORD_LITTLE_ENDIAN", Const, 0},
+ {"REG_RESOURCE_LIST", Const, 0},
+ {"REG_RESOURCE_REQUIREMENTS_LIST", Const, 0},
+ {"REG_SZ", Const, 0},
+ {"RLIMIT_AS", Const, 0},
+ {"RLIMIT_CORE", Const, 0},
+ {"RLIMIT_CPU", Const, 0},
+ {"RLIMIT_CPU_USAGE_MONITOR", Const, 16},
+ {"RLIMIT_DATA", Const, 0},
+ {"RLIMIT_FSIZE", Const, 0},
+ {"RLIMIT_NOFILE", Const, 0},
+ {"RLIMIT_STACK", Const, 0},
+ {"RLIM_INFINITY", Const, 0},
+ {"RTAX_ADVMSS", Const, 0},
+ {"RTAX_AUTHOR", Const, 0},
+ {"RTAX_BRD", Const, 0},
+ {"RTAX_CWND", Const, 0},
+ {"RTAX_DST", Const, 0},
+ {"RTAX_FEATURES", Const, 0},
+ {"RTAX_FEATURE_ALLFRAG", Const, 0},
+ {"RTAX_FEATURE_ECN", Const, 0},
+ {"RTAX_FEATURE_SACK", Const, 0},
+ {"RTAX_FEATURE_TIMESTAMP", Const, 0},
+ {"RTAX_GATEWAY", Const, 0},
+ {"RTAX_GENMASK", Const, 0},
+ {"RTAX_HOPLIMIT", Const, 0},
+ {"RTAX_IFA", Const, 0},
+ {"RTAX_IFP", Const, 0},
+ {"RTAX_INITCWND", Const, 0},
+ {"RTAX_INITRWND", Const, 0},
+ {"RTAX_LABEL", Const, 1},
+ {"RTAX_LOCK", Const, 0},
+ {"RTAX_MAX", Const, 0},
+ {"RTAX_MTU", Const, 0},
+ {"RTAX_NETMASK", Const, 0},
+ {"RTAX_REORDERING", Const, 0},
+ {"RTAX_RTO_MIN", Const, 0},
+ {"RTAX_RTT", Const, 0},
+ {"RTAX_RTTVAR", Const, 0},
+ {"RTAX_SRC", Const, 1},
+ {"RTAX_SRCMASK", Const, 1},
+ {"RTAX_SSTHRESH", Const, 0},
+ {"RTAX_TAG", Const, 1},
+ {"RTAX_UNSPEC", Const, 0},
+ {"RTAX_WINDOW", Const, 0},
+ {"RTA_ALIGNTO", Const, 0},
+ {"RTA_AUTHOR", Const, 0},
+ {"RTA_BRD", Const, 0},
+ {"RTA_CACHEINFO", Const, 0},
+ {"RTA_DST", Const, 0},
+ {"RTA_FLOW", Const, 0},
+ {"RTA_GATEWAY", Const, 0},
+ {"RTA_GENMASK", Const, 0},
+ {"RTA_IFA", Const, 0},
+ {"RTA_IFP", Const, 0},
+ {"RTA_IIF", Const, 0},
+ {"RTA_LABEL", Const, 1},
+ {"RTA_MAX", Const, 0},
+ {"RTA_METRICS", Const, 0},
+ {"RTA_MULTIPATH", Const, 0},
+ {"RTA_NETMASK", Const, 0},
+ {"RTA_OIF", Const, 0},
+ {"RTA_PREFSRC", Const, 0},
+ {"RTA_PRIORITY", Const, 0},
+ {"RTA_SRC", Const, 0},
+ {"RTA_SRCMASK", Const, 1},
+ {"RTA_TABLE", Const, 0},
+ {"RTA_TAG", Const, 1},
+ {"RTA_UNSPEC", Const, 0},
+ {"RTCF_DIRECTSRC", Const, 0},
+ {"RTCF_DOREDIRECT", Const, 0},
+ {"RTCF_LOG", Const, 0},
+ {"RTCF_MASQ", Const, 0},
+ {"RTCF_NAT", Const, 0},
+ {"RTCF_VALVE", Const, 0},
+ {"RTF_ADDRCLASSMASK", Const, 0},
+ {"RTF_ADDRCONF", Const, 0},
+ {"RTF_ALLONLINK", Const, 0},
+ {"RTF_ANNOUNCE", Const, 1},
+ {"RTF_BLACKHOLE", Const, 0},
+ {"RTF_BROADCAST", Const, 0},
+ {"RTF_CACHE", Const, 0},
+ {"RTF_CLONED", Const, 1},
+ {"RTF_CLONING", Const, 0},
+ {"RTF_CONDEMNED", Const, 0},
+ {"RTF_DEFAULT", Const, 0},
+ {"RTF_DELCLONE", Const, 0},
+ {"RTF_DONE", Const, 0},
+ {"RTF_DYNAMIC", Const, 0},
+ {"RTF_FLOW", Const, 0},
+ {"RTF_FMASK", Const, 0},
+ {"RTF_GATEWAY", Const, 0},
+ {"RTF_GWFLAG_COMPAT", Const, 3},
+ {"RTF_HOST", Const, 0},
+ {"RTF_IFREF", Const, 0},
+ {"RTF_IFSCOPE", Const, 0},
+ {"RTF_INTERFACE", Const, 0},
+ {"RTF_IRTT", Const, 0},
+ {"RTF_LINKRT", Const, 0},
+ {"RTF_LLDATA", Const, 0},
+ {"RTF_LLINFO", Const, 0},
+ {"RTF_LOCAL", Const, 0},
+ {"RTF_MASK", Const, 1},
+ {"RTF_MODIFIED", Const, 0},
+ {"RTF_MPATH", Const, 1},
+ {"RTF_MPLS", Const, 1},
+ {"RTF_MSS", Const, 0},
+ {"RTF_MTU", Const, 0},
+ {"RTF_MULTICAST", Const, 0},
+ {"RTF_NAT", Const, 0},
+ {"RTF_NOFORWARD", Const, 0},
+ {"RTF_NONEXTHOP", Const, 0},
+ {"RTF_NOPMTUDISC", Const, 0},
+ {"RTF_PERMANENT_ARP", Const, 1},
+ {"RTF_PINNED", Const, 0},
+ {"RTF_POLICY", Const, 0},
+ {"RTF_PRCLONING", Const, 0},
+ {"RTF_PROTO1", Const, 0},
+ {"RTF_PROTO2", Const, 0},
+ {"RTF_PROTO3", Const, 0},
+ {"RTF_PROXY", Const, 16},
+ {"RTF_REINSTATE", Const, 0},
+ {"RTF_REJECT", Const, 0},
+ {"RTF_RNH_LOCKED", Const, 0},
+ {"RTF_ROUTER", Const, 16},
+ {"RTF_SOURCE", Const, 1},
+ {"RTF_SRC", Const, 1},
+ {"RTF_STATIC", Const, 0},
+ {"RTF_STICKY", Const, 0},
+ {"RTF_THROW", Const, 0},
+ {"RTF_TUNNEL", Const, 1},
+ {"RTF_UP", Const, 0},
+ {"RTF_USETRAILERS", Const, 1},
+ {"RTF_WASCLONED", Const, 0},
+ {"RTF_WINDOW", Const, 0},
+ {"RTF_XRESOLVE", Const, 0},
+ {"RTM_ADD", Const, 0},
+ {"RTM_BASE", Const, 0},
+ {"RTM_CHANGE", Const, 0},
+ {"RTM_CHGADDR", Const, 1},
+ {"RTM_DELACTION", Const, 0},
+ {"RTM_DELADDR", Const, 0},
+ {"RTM_DELADDRLABEL", Const, 0},
+ {"RTM_DELETE", Const, 0},
+ {"RTM_DELLINK", Const, 0},
+ {"RTM_DELMADDR", Const, 0},
+ {"RTM_DELNEIGH", Const, 0},
+ {"RTM_DELQDISC", Const, 0},
+ {"RTM_DELROUTE", Const, 0},
+ {"RTM_DELRULE", Const, 0},
+ {"RTM_DELTCLASS", Const, 0},
+ {"RTM_DELTFILTER", Const, 0},
+ {"RTM_DESYNC", Const, 1},
+ {"RTM_F_CLONED", Const, 0},
+ {"RTM_F_EQUALIZE", Const, 0},
+ {"RTM_F_NOTIFY", Const, 0},
+ {"RTM_F_PREFIX", Const, 0},
+ {"RTM_GET", Const, 0},
+ {"RTM_GET2", Const, 0},
+ {"RTM_GETACTION", Const, 0},
+ {"RTM_GETADDR", Const, 0},
+ {"RTM_GETADDRLABEL", Const, 0},
+ {"RTM_GETANYCAST", Const, 0},
+ {"RTM_GETDCB", Const, 0},
+ {"RTM_GETLINK", Const, 0},
+ {"RTM_GETMULTICAST", Const, 0},
+ {"RTM_GETNEIGH", Const, 0},
+ {"RTM_GETNEIGHTBL", Const, 0},
+ {"RTM_GETQDISC", Const, 0},
+ {"RTM_GETROUTE", Const, 0},
+ {"RTM_GETRULE", Const, 0},
+ {"RTM_GETTCLASS", Const, 0},
+ {"RTM_GETTFILTER", Const, 0},
+ {"RTM_IEEE80211", Const, 0},
+ {"RTM_IFANNOUNCE", Const, 0},
+ {"RTM_IFINFO", Const, 0},
+ {"RTM_IFINFO2", Const, 0},
+ {"RTM_LLINFO_UPD", Const, 1},
+ {"RTM_LOCK", Const, 0},
+ {"RTM_LOSING", Const, 0},
+ {"RTM_MAX", Const, 0},
+ {"RTM_MAXSIZE", Const, 1},
+ {"RTM_MISS", Const, 0},
+ {"RTM_NEWACTION", Const, 0},
+ {"RTM_NEWADDR", Const, 0},
+ {"RTM_NEWADDRLABEL", Const, 0},
+ {"RTM_NEWLINK", Const, 0},
+ {"RTM_NEWMADDR", Const, 0},
+ {"RTM_NEWMADDR2", Const, 0},
+ {"RTM_NEWNDUSEROPT", Const, 0},
+ {"RTM_NEWNEIGH", Const, 0},
+ {"RTM_NEWNEIGHTBL", Const, 0},
+ {"RTM_NEWPREFIX", Const, 0},
+ {"RTM_NEWQDISC", Const, 0},
+ {"RTM_NEWROUTE", Const, 0},
+ {"RTM_NEWRULE", Const, 0},
+ {"RTM_NEWTCLASS", Const, 0},
+ {"RTM_NEWTFILTER", Const, 0},
+ {"RTM_NR_FAMILIES", Const, 0},
+ {"RTM_NR_MSGTYPES", Const, 0},
+ {"RTM_OIFINFO", Const, 1},
+ {"RTM_OLDADD", Const, 0},
+ {"RTM_OLDDEL", Const, 0},
+ {"RTM_OOIFINFO", Const, 1},
+ {"RTM_REDIRECT", Const, 0},
+ {"RTM_RESOLVE", Const, 0},
+ {"RTM_RTTUNIT", Const, 0},
+ {"RTM_SETDCB", Const, 0},
+ {"RTM_SETGATE", Const, 1},
+ {"RTM_SETLINK", Const, 0},
+ {"RTM_SETNEIGHTBL", Const, 0},
+ {"RTM_VERSION", Const, 0},
+ {"RTNH_ALIGNTO", Const, 0},
+ {"RTNH_F_DEAD", Const, 0},
+ {"RTNH_F_ONLINK", Const, 0},
+ {"RTNH_F_PERVASIVE", Const, 0},
+ {"RTNLGRP_IPV4_IFADDR", Const, 1},
+ {"RTNLGRP_IPV4_MROUTE", Const, 1},
+ {"RTNLGRP_IPV4_ROUTE", Const, 1},
+ {"RTNLGRP_IPV4_RULE", Const, 1},
+ {"RTNLGRP_IPV6_IFADDR", Const, 1},
+ {"RTNLGRP_IPV6_IFINFO", Const, 1},
+ {"RTNLGRP_IPV6_MROUTE", Const, 1},
+ {"RTNLGRP_IPV6_PREFIX", Const, 1},
+ {"RTNLGRP_IPV6_ROUTE", Const, 1},
+ {"RTNLGRP_IPV6_RULE", Const, 1},
+ {"RTNLGRP_LINK", Const, 1},
+ {"RTNLGRP_ND_USEROPT", Const, 1},
+ {"RTNLGRP_NEIGH", Const, 1},
+ {"RTNLGRP_NONE", Const, 1},
+ {"RTNLGRP_NOTIFY", Const, 1},
+ {"RTNLGRP_TC", Const, 1},
+ {"RTN_ANYCAST", Const, 0},
+ {"RTN_BLACKHOLE", Const, 0},
+ {"RTN_BROADCAST", Const, 0},
+ {"RTN_LOCAL", Const, 0},
+ {"RTN_MAX", Const, 0},
+ {"RTN_MULTICAST", Const, 0},
+ {"RTN_NAT", Const, 0},
+ {"RTN_PROHIBIT", Const, 0},
+ {"RTN_THROW", Const, 0},
+ {"RTN_UNICAST", Const, 0},
+ {"RTN_UNREACHABLE", Const, 0},
+ {"RTN_UNSPEC", Const, 0},
+ {"RTN_XRESOLVE", Const, 0},
+ {"RTPROT_BIRD", Const, 0},
+ {"RTPROT_BOOT", Const, 0},
+ {"RTPROT_DHCP", Const, 0},
+ {"RTPROT_DNROUTED", Const, 0},
+ {"RTPROT_GATED", Const, 0},
+ {"RTPROT_KERNEL", Const, 0},
+ {"RTPROT_MRT", Const, 0},
+ {"RTPROT_NTK", Const, 0},
+ {"RTPROT_RA", Const, 0},
+ {"RTPROT_REDIRECT", Const, 0},
+ {"RTPROT_STATIC", Const, 0},
+ {"RTPROT_UNSPEC", Const, 0},
+ {"RTPROT_XORP", Const, 0},
+ {"RTPROT_ZEBRA", Const, 0},
+ {"RTV_EXPIRE", Const, 0},
+ {"RTV_HOPCOUNT", Const, 0},
+ {"RTV_MTU", Const, 0},
+ {"RTV_RPIPE", Const, 0},
+ {"RTV_RTT", Const, 0},
+ {"RTV_RTTVAR", Const, 0},
+ {"RTV_SPIPE", Const, 0},
+ {"RTV_SSTHRESH", Const, 0},
+ {"RTV_WEIGHT", Const, 0},
+ {"RT_CACHING_CONTEXT", Const, 1},
+ {"RT_CLASS_DEFAULT", Const, 0},
+ {"RT_CLASS_LOCAL", Const, 0},
+ {"RT_CLASS_MAIN", Const, 0},
+ {"RT_CLASS_MAX", Const, 0},
+ {"RT_CLASS_UNSPEC", Const, 0},
+ {"RT_DEFAULT_FIB", Const, 1},
+ {"RT_NORTREF", Const, 1},
+ {"RT_SCOPE_HOST", Const, 0},
+ {"RT_SCOPE_LINK", Const, 0},
+ {"RT_SCOPE_NOWHERE", Const, 0},
+ {"RT_SCOPE_SITE", Const, 0},
+ {"RT_SCOPE_UNIVERSE", Const, 0},
+ {"RT_TABLEID_MAX", Const, 1},
+ {"RT_TABLE_COMPAT", Const, 0},
+ {"RT_TABLE_DEFAULT", Const, 0},
+ {"RT_TABLE_LOCAL", Const, 0},
+ {"RT_TABLE_MAIN", Const, 0},
+ {"RT_TABLE_MAX", Const, 0},
+ {"RT_TABLE_UNSPEC", Const, 0},
+ {"RUSAGE_CHILDREN", Const, 0},
+ {"RUSAGE_SELF", Const, 0},
+ {"RUSAGE_THREAD", Const, 0},
+ {"Radvisory_t", Type, 0},
+ {"Radvisory_t.Count", Field, 0},
+ {"Radvisory_t.Offset", Field, 0},
+ {"Radvisory_t.Pad_cgo_0", Field, 0},
+ {"RawConn", Type, 9},
+ {"RawSockaddr", Type, 0},
+ {"RawSockaddr.Data", Field, 0},
+ {"RawSockaddr.Family", Field, 0},
+ {"RawSockaddr.Len", Field, 0},
+ {"RawSockaddrAny", Type, 0},
+ {"RawSockaddrAny.Addr", Field, 0},
+ {"RawSockaddrAny.Pad", Field, 0},
+ {"RawSockaddrDatalink", Type, 0},
+ {"RawSockaddrDatalink.Alen", Field, 0},
+ {"RawSockaddrDatalink.Data", Field, 0},
+ {"RawSockaddrDatalink.Family", Field, 0},
+ {"RawSockaddrDatalink.Index", Field, 0},
+ {"RawSockaddrDatalink.Len", Field, 0},
+ {"RawSockaddrDatalink.Nlen", Field, 0},
+ {"RawSockaddrDatalink.Pad_cgo_0", Field, 2},
+ {"RawSockaddrDatalink.Slen", Field, 0},
+ {"RawSockaddrDatalink.Type", Field, 0},
+ {"RawSockaddrInet4", Type, 0},
+ {"RawSockaddrInet4.Addr", Field, 0},
+ {"RawSockaddrInet4.Family", Field, 0},
+ {"RawSockaddrInet4.Len", Field, 0},
+ {"RawSockaddrInet4.Port", Field, 0},
+ {"RawSockaddrInet4.Zero", Field, 0},
+ {"RawSockaddrInet6", Type, 0},
+ {"RawSockaddrInet6.Addr", Field, 0},
+ {"RawSockaddrInet6.Family", Field, 0},
+ {"RawSockaddrInet6.Flowinfo", Field, 0},
+ {"RawSockaddrInet6.Len", Field, 0},
+ {"RawSockaddrInet6.Port", Field, 0},
+ {"RawSockaddrInet6.Scope_id", Field, 0},
+ {"RawSockaddrLinklayer", Type, 0},
+ {"RawSockaddrLinklayer.Addr", Field, 0},
+ {"RawSockaddrLinklayer.Family", Field, 0},
+ {"RawSockaddrLinklayer.Halen", Field, 0},
+ {"RawSockaddrLinklayer.Hatype", Field, 0},
+ {"RawSockaddrLinklayer.Ifindex", Field, 0},
+ {"RawSockaddrLinklayer.Pkttype", Field, 0},
+ {"RawSockaddrLinklayer.Protocol", Field, 0},
+ {"RawSockaddrNetlink", Type, 0},
+ {"RawSockaddrNetlink.Family", Field, 0},
+ {"RawSockaddrNetlink.Groups", Field, 0},
+ {"RawSockaddrNetlink.Pad", Field, 0},
+ {"RawSockaddrNetlink.Pid", Field, 0},
+ {"RawSockaddrUnix", Type, 0},
+ {"RawSockaddrUnix.Family", Field, 0},
+ {"RawSockaddrUnix.Len", Field, 0},
+ {"RawSockaddrUnix.Pad_cgo_0", Field, 2},
+ {"RawSockaddrUnix.Path", Field, 0},
+ {"RawSyscall", Func, 0},
+ {"RawSyscall6", Func, 0},
+ {"Read", Func, 0},
+ {"ReadConsole", Func, 1},
+ {"ReadDirectoryChanges", Func, 0},
+ {"ReadDirent", Func, 0},
+ {"ReadFile", Func, 0},
+ {"Readlink", Func, 0},
+ {"Reboot", Func, 0},
+ {"Recvfrom", Func, 0},
+ {"Recvmsg", Func, 0},
+ {"RegCloseKey", Func, 0},
+ {"RegEnumKeyEx", Func, 0},
+ {"RegOpenKeyEx", Func, 0},
+ {"RegQueryInfoKey", Func, 0},
+ {"RegQueryValueEx", Func, 0},
+ {"RemoveDirectory", Func, 0},
+ {"Removexattr", Func, 1},
+ {"Rename", Func, 0},
+ {"Renameat", Func, 0},
+ {"Revoke", Func, 0},
+ {"Rlimit", Type, 0},
+ {"Rlimit.Cur", Field, 0},
+ {"Rlimit.Max", Field, 0},
+ {"Rmdir", Func, 0},
+ {"RouteMessage", Type, 0},
+ {"RouteMessage.Data", Field, 0},
+ {"RouteMessage.Header", Field, 0},
+ {"RouteRIB", Func, 0},
+ {"RoutingMessage", Type, 0},
+ {"RtAttr", Type, 0},
+ {"RtAttr.Len", Field, 0},
+ {"RtAttr.Type", Field, 0},
+ {"RtGenmsg", Type, 0},
+ {"RtGenmsg.Family", Field, 0},
+ {"RtMetrics", Type, 0},
+ {"RtMetrics.Expire", Field, 0},
+ {"RtMetrics.Filler", Field, 0},
+ {"RtMetrics.Hopcount", Field, 0},
+ {"RtMetrics.Locks", Field, 0},
+ {"RtMetrics.Mtu", Field, 0},
+ {"RtMetrics.Pad", Field, 3},
+ {"RtMetrics.Pksent", Field, 0},
+ {"RtMetrics.Recvpipe", Field, 0},
+ {"RtMetrics.Refcnt", Field, 2},
+ {"RtMetrics.Rtt", Field, 0},
+ {"RtMetrics.Rttvar", Field, 0},
+ {"RtMetrics.Sendpipe", Field, 0},
+ {"RtMetrics.Ssthresh", Field, 0},
+ {"RtMetrics.Weight", Field, 0},
+ {"RtMsg", Type, 0},
+ {"RtMsg.Dst_len", Field, 0},
+ {"RtMsg.Family", Field, 0},
+ {"RtMsg.Flags", Field, 0},
+ {"RtMsg.Protocol", Field, 0},
+ {"RtMsg.Scope", Field, 0},
+ {"RtMsg.Src_len", Field, 0},
+ {"RtMsg.Table", Field, 0},
+ {"RtMsg.Tos", Field, 0},
+ {"RtMsg.Type", Field, 0},
+ {"RtMsghdr", Type, 0},
+ {"RtMsghdr.Addrs", Field, 0},
+ {"RtMsghdr.Errno", Field, 0},
+ {"RtMsghdr.Flags", Field, 0},
+ {"RtMsghdr.Fmask", Field, 0},
+ {"RtMsghdr.Hdrlen", Field, 2},
+ {"RtMsghdr.Index", Field, 0},
+ {"RtMsghdr.Inits", Field, 0},
+ {"RtMsghdr.Mpls", Field, 2},
+ {"RtMsghdr.Msglen", Field, 0},
+ {"RtMsghdr.Pad_cgo_0", Field, 0},
+ {"RtMsghdr.Pad_cgo_1", Field, 2},
+ {"RtMsghdr.Pid", Field, 0},
+ {"RtMsghdr.Priority", Field, 2},
+ {"RtMsghdr.Rmx", Field, 0},
+ {"RtMsghdr.Seq", Field, 0},
+ {"RtMsghdr.Tableid", Field, 2},
+ {"RtMsghdr.Type", Field, 0},
+ {"RtMsghdr.Use", Field, 0},
+ {"RtMsghdr.Version", Field, 0},
+ {"RtNexthop", Type, 0},
+ {"RtNexthop.Flags", Field, 0},
+ {"RtNexthop.Hops", Field, 0},
+ {"RtNexthop.Ifindex", Field, 0},
+ {"RtNexthop.Len", Field, 0},
+ {"Rusage", Type, 0},
+ {"Rusage.CreationTime", Field, 0},
+ {"Rusage.ExitTime", Field, 0},
+ {"Rusage.Idrss", Field, 0},
+ {"Rusage.Inblock", Field, 0},
+ {"Rusage.Isrss", Field, 0},
+ {"Rusage.Ixrss", Field, 0},
+ {"Rusage.KernelTime", Field, 0},
+ {"Rusage.Majflt", Field, 0},
+ {"Rusage.Maxrss", Field, 0},
+ {"Rusage.Minflt", Field, 0},
+ {"Rusage.Msgrcv", Field, 0},
+ {"Rusage.Msgsnd", Field, 0},
+ {"Rusage.Nivcsw", Field, 0},
+ {"Rusage.Nsignals", Field, 0},
+ {"Rusage.Nswap", Field, 0},
+ {"Rusage.Nvcsw", Field, 0},
+ {"Rusage.Oublock", Field, 0},
+ {"Rusage.Stime", Field, 0},
+ {"Rusage.UserTime", Field, 0},
+ {"Rusage.Utime", Field, 0},
+ {"SCM_BINTIME", Const, 0},
+ {"SCM_CREDENTIALS", Const, 0},
+ {"SCM_CREDS", Const, 0},
+ {"SCM_RIGHTS", Const, 0},
+ {"SCM_TIMESTAMP", Const, 0},
+ {"SCM_TIMESTAMPING", Const, 0},
+ {"SCM_TIMESTAMPNS", Const, 0},
+ {"SCM_TIMESTAMP_MONOTONIC", Const, 0},
+ {"SHUT_RD", Const, 0},
+ {"SHUT_RDWR", Const, 0},
+ {"SHUT_WR", Const, 0},
+ {"SID", Type, 0},
+ {"SIDAndAttributes", Type, 0},
+ {"SIDAndAttributes.Attributes", Field, 0},
+ {"SIDAndAttributes.Sid", Field, 0},
+ {"SIGABRT", Const, 0},
+ {"SIGALRM", Const, 0},
+ {"SIGBUS", Const, 0},
+ {"SIGCHLD", Const, 0},
+ {"SIGCLD", Const, 0},
+ {"SIGCONT", Const, 0},
+ {"SIGEMT", Const, 0},
+ {"SIGFPE", Const, 0},
+ {"SIGHUP", Const, 0},
+ {"SIGILL", Const, 0},
+ {"SIGINFO", Const, 0},
+ {"SIGINT", Const, 0},
+ {"SIGIO", Const, 0},
+ {"SIGIOT", Const, 0},
+ {"SIGKILL", Const, 0},
+ {"SIGLIBRT", Const, 1},
+ {"SIGLWP", Const, 0},
+ {"SIGPIPE", Const, 0},
+ {"SIGPOLL", Const, 0},
+ {"SIGPROF", Const, 0},
+ {"SIGPWR", Const, 0},
+ {"SIGQUIT", Const, 0},
+ {"SIGSEGV", Const, 0},
+ {"SIGSTKFLT", Const, 0},
+ {"SIGSTOP", Const, 0},
+ {"SIGSYS", Const, 0},
+ {"SIGTERM", Const, 0},
+ {"SIGTHR", Const, 0},
+ {"SIGTRAP", Const, 0},
+ {"SIGTSTP", Const, 0},
+ {"SIGTTIN", Const, 0},
+ {"SIGTTOU", Const, 0},
+ {"SIGUNUSED", Const, 0},
+ {"SIGURG", Const, 0},
+ {"SIGUSR1", Const, 0},
+ {"SIGUSR2", Const, 0},
+ {"SIGVTALRM", Const, 0},
+ {"SIGWINCH", Const, 0},
+ {"SIGXCPU", Const, 0},
+ {"SIGXFSZ", Const, 0},
+ {"SIOCADDDLCI", Const, 0},
+ {"SIOCADDMULTI", Const, 0},
+ {"SIOCADDRT", Const, 0},
+ {"SIOCAIFADDR", Const, 0},
+ {"SIOCAIFGROUP", Const, 0},
+ {"SIOCALIFADDR", Const, 0},
+ {"SIOCARPIPLL", Const, 0},
+ {"SIOCATMARK", Const, 0},
+ {"SIOCAUTOADDR", Const, 0},
+ {"SIOCAUTONETMASK", Const, 0},
+ {"SIOCBRDGADD", Const, 1},
+ {"SIOCBRDGADDS", Const, 1},
+ {"SIOCBRDGARL", Const, 1},
+ {"SIOCBRDGDADDR", Const, 1},
+ {"SIOCBRDGDEL", Const, 1},
+ {"SIOCBRDGDELS", Const, 1},
+ {"SIOCBRDGFLUSH", Const, 1},
+ {"SIOCBRDGFRL", Const, 1},
+ {"SIOCBRDGGCACHE", Const, 1},
+ {"SIOCBRDGGFD", Const, 1},
+ {"SIOCBRDGGHT", Const, 1},
+ {"SIOCBRDGGIFFLGS", Const, 1},
+ {"SIOCBRDGGMA", Const, 1},
+ {"SIOCBRDGGPARAM", Const, 1},
+ {"SIOCBRDGGPRI", Const, 1},
+ {"SIOCBRDGGRL", Const, 1},
+ {"SIOCBRDGGSIFS", Const, 1},
+ {"SIOCBRDGGTO", Const, 1},
+ {"SIOCBRDGIFS", Const, 1},
+ {"SIOCBRDGRTS", Const, 1},
+ {"SIOCBRDGSADDR", Const, 1},
+ {"SIOCBRDGSCACHE", Const, 1},
+ {"SIOCBRDGSFD", Const, 1},
+ {"SIOCBRDGSHT", Const, 1},
+ {"SIOCBRDGSIFCOST", Const, 1},
+ {"SIOCBRDGSIFFLGS", Const, 1},
+ {"SIOCBRDGSIFPRIO", Const, 1},
+ {"SIOCBRDGSMA", Const, 1},
+ {"SIOCBRDGSPRI", Const, 1},
+ {"SIOCBRDGSPROTO", Const, 1},
+ {"SIOCBRDGSTO", Const, 1},
+ {"SIOCBRDGSTXHC", Const, 1},
+ {"SIOCDARP", Const, 0},
+ {"SIOCDELDLCI", Const, 0},
+ {"SIOCDELMULTI", Const, 0},
+ {"SIOCDELRT", Const, 0},
+ {"SIOCDEVPRIVATE", Const, 0},
+ {"SIOCDIFADDR", Const, 0},
+ {"SIOCDIFGROUP", Const, 0},
+ {"SIOCDIFPHYADDR", Const, 0},
+ {"SIOCDLIFADDR", Const, 0},
+ {"SIOCDRARP", Const, 0},
+ {"SIOCGARP", Const, 0},
+ {"SIOCGDRVSPEC", Const, 0},
+ {"SIOCGETKALIVE", Const, 1},
+ {"SIOCGETLABEL", Const, 1},
+ {"SIOCGETPFLOW", Const, 1},
+ {"SIOCGETPFSYNC", Const, 1},
+ {"SIOCGETSGCNT", Const, 0},
+ {"SIOCGETVIFCNT", Const, 0},
+ {"SIOCGETVLAN", Const, 0},
+ {"SIOCGHIWAT", Const, 0},
+ {"SIOCGIFADDR", Const, 0},
+ {"SIOCGIFADDRPREF", Const, 1},
+ {"SIOCGIFALIAS", Const, 1},
+ {"SIOCGIFALTMTU", Const, 0},
+ {"SIOCGIFASYNCMAP", Const, 0},
+ {"SIOCGIFBOND", Const, 0},
+ {"SIOCGIFBR", Const, 0},
+ {"SIOCGIFBRDADDR", Const, 0},
+ {"SIOCGIFCAP", Const, 0},
+ {"SIOCGIFCONF", Const, 0},
+ {"SIOCGIFCOUNT", Const, 0},
+ {"SIOCGIFDATA", Const, 1},
+ {"SIOCGIFDESCR", Const, 0},
+ {"SIOCGIFDEVMTU", Const, 0},
+ {"SIOCGIFDLT", Const, 1},
+ {"SIOCGIFDSTADDR", Const, 0},
+ {"SIOCGIFENCAP", Const, 0},
+ {"SIOCGIFFIB", Const, 1},
+ {"SIOCGIFFLAGS", Const, 0},
+ {"SIOCGIFGATTR", Const, 1},
+ {"SIOCGIFGENERIC", Const, 0},
+ {"SIOCGIFGMEMB", Const, 0},
+ {"SIOCGIFGROUP", Const, 0},
+ {"SIOCGIFHARDMTU", Const, 3},
+ {"SIOCGIFHWADDR", Const, 0},
+ {"SIOCGIFINDEX", Const, 0},
+ {"SIOCGIFKPI", Const, 0},
+ {"SIOCGIFMAC", Const, 0},
+ {"SIOCGIFMAP", Const, 0},
+ {"SIOCGIFMEDIA", Const, 0},
+ {"SIOCGIFMEM", Const, 0},
+ {"SIOCGIFMETRIC", Const, 0},
+ {"SIOCGIFMTU", Const, 0},
+ {"SIOCGIFNAME", Const, 0},
+ {"SIOCGIFNETMASK", Const, 0},
+ {"SIOCGIFPDSTADDR", Const, 0},
+ {"SIOCGIFPFLAGS", Const, 0},
+ {"SIOCGIFPHYS", Const, 0},
+ {"SIOCGIFPRIORITY", Const, 1},
+ {"SIOCGIFPSRCADDR", Const, 0},
+ {"SIOCGIFRDOMAIN", Const, 1},
+ {"SIOCGIFRTLABEL", Const, 1},
+ {"SIOCGIFSLAVE", Const, 0},
+ {"SIOCGIFSTATUS", Const, 0},
+ {"SIOCGIFTIMESLOT", Const, 1},
+ {"SIOCGIFTXQLEN", Const, 0},
+ {"SIOCGIFVLAN", Const, 0},
+ {"SIOCGIFWAKEFLAGS", Const, 0},
+ {"SIOCGIFXFLAGS", Const, 1},
+ {"SIOCGLIFADDR", Const, 0},
+ {"SIOCGLIFPHYADDR", Const, 0},
+ {"SIOCGLIFPHYRTABLE", Const, 1},
+ {"SIOCGLIFPHYTTL", Const, 3},
+ {"SIOCGLINKSTR", Const, 1},
+ {"SIOCGLOWAT", Const, 0},
+ {"SIOCGPGRP", Const, 0},
+ {"SIOCGPRIVATE_0", Const, 0},
+ {"SIOCGPRIVATE_1", Const, 0},
+ {"SIOCGRARP", Const, 0},
+ {"SIOCGSPPPPARAMS", Const, 3},
+ {"SIOCGSTAMP", Const, 0},
+ {"SIOCGSTAMPNS", Const, 0},
+ {"SIOCGVH", Const, 1},
+ {"SIOCGVNETID", Const, 3},
+ {"SIOCIFCREATE", Const, 0},
+ {"SIOCIFCREATE2", Const, 0},
+ {"SIOCIFDESTROY", Const, 0},
+ {"SIOCIFGCLONERS", Const, 0},
+ {"SIOCINITIFADDR", Const, 1},
+ {"SIOCPROTOPRIVATE", Const, 0},
+ {"SIOCRSLVMULTI", Const, 0},
+ {"SIOCRTMSG", Const, 0},
+ {"SIOCSARP", Const, 0},
+ {"SIOCSDRVSPEC", Const, 0},
+ {"SIOCSETKALIVE", Const, 1},
+ {"SIOCSETLABEL", Const, 1},
+ {"SIOCSETPFLOW", Const, 1},
+ {"SIOCSETPFSYNC", Const, 1},
+ {"SIOCSETVLAN", Const, 0},
+ {"SIOCSHIWAT", Const, 0},
+ {"SIOCSIFADDR", Const, 0},
+ {"SIOCSIFADDRPREF", Const, 1},
+ {"SIOCSIFALTMTU", Const, 0},
+ {"SIOCSIFASYNCMAP", Const, 0},
+ {"SIOCSIFBOND", Const, 0},
+ {"SIOCSIFBR", Const, 0},
+ {"SIOCSIFBRDADDR", Const, 0},
+ {"SIOCSIFCAP", Const, 0},
+ {"SIOCSIFDESCR", Const, 0},
+ {"SIOCSIFDSTADDR", Const, 0},
+ {"SIOCSIFENCAP", Const, 0},
+ {"SIOCSIFFIB", Const, 1},
+ {"SIOCSIFFLAGS", Const, 0},
+ {"SIOCSIFGATTR", Const, 1},
+ {"SIOCSIFGENERIC", Const, 0},
+ {"SIOCSIFHWADDR", Const, 0},
+ {"SIOCSIFHWBROADCAST", Const, 0},
+ {"SIOCSIFKPI", Const, 0},
+ {"SIOCSIFLINK", Const, 0},
+ {"SIOCSIFLLADDR", Const, 0},
+ {"SIOCSIFMAC", Const, 0},
+ {"SIOCSIFMAP", Const, 0},
+ {"SIOCSIFMEDIA", Const, 0},
+ {"SIOCSIFMEM", Const, 0},
+ {"SIOCSIFMETRIC", Const, 0},
+ {"SIOCSIFMTU", Const, 0},
+ {"SIOCSIFNAME", Const, 0},
+ {"SIOCSIFNETMASK", Const, 0},
+ {"SIOCSIFPFLAGS", Const, 0},
+ {"SIOCSIFPHYADDR", Const, 0},
+ {"SIOCSIFPHYS", Const, 0},
+ {"SIOCSIFPRIORITY", Const, 1},
+ {"SIOCSIFRDOMAIN", Const, 1},
+ {"SIOCSIFRTLABEL", Const, 1},
+ {"SIOCSIFRVNET", Const, 0},
+ {"SIOCSIFSLAVE", Const, 0},
+ {"SIOCSIFTIMESLOT", Const, 1},
+ {"SIOCSIFTXQLEN", Const, 0},
+ {"SIOCSIFVLAN", Const, 0},
+ {"SIOCSIFVNET", Const, 0},
+ {"SIOCSIFXFLAGS", Const, 1},
+ {"SIOCSLIFPHYADDR", Const, 0},
+ {"SIOCSLIFPHYRTABLE", Const, 1},
+ {"SIOCSLIFPHYTTL", Const, 3},
+ {"SIOCSLINKSTR", Const, 1},
+ {"SIOCSLOWAT", Const, 0},
+ {"SIOCSPGRP", Const, 0},
+ {"SIOCSRARP", Const, 0},
+ {"SIOCSSPPPPARAMS", Const, 3},
+ {"SIOCSVH", Const, 1},
+ {"SIOCSVNETID", Const, 3},
+ {"SIOCZIFDATA", Const, 1},
+ {"SIO_GET_EXTENSION_FUNCTION_POINTER", Const, 1},
+ {"SIO_GET_INTERFACE_LIST", Const, 0},
+ {"SIO_KEEPALIVE_VALS", Const, 3},
+ {"SIO_UDP_CONNRESET", Const, 4},
+ {"SOCK_CLOEXEC", Const, 0},
+ {"SOCK_DCCP", Const, 0},
+ {"SOCK_DGRAM", Const, 0},
+ {"SOCK_FLAGS_MASK", Const, 1},
+ {"SOCK_MAXADDRLEN", Const, 0},
+ {"SOCK_NONBLOCK", Const, 0},
+ {"SOCK_NOSIGPIPE", Const, 1},
+ {"SOCK_PACKET", Const, 0},
+ {"SOCK_RAW", Const, 0},
+ {"SOCK_RDM", Const, 0},
+ {"SOCK_SEQPACKET", Const, 0},
+ {"SOCK_STREAM", Const, 0},
+ {"SOL_AAL", Const, 0},
+ {"SOL_ATM", Const, 0},
+ {"SOL_DECNET", Const, 0},
+ {"SOL_ICMPV6", Const, 0},
+ {"SOL_IP", Const, 0},
+ {"SOL_IPV6", Const, 0},
+ {"SOL_IRDA", Const, 0},
+ {"SOL_PACKET", Const, 0},
+ {"SOL_RAW", Const, 0},
+ {"SOL_SOCKET", Const, 0},
+ {"SOL_TCP", Const, 0},
+ {"SOL_X25", Const, 0},
+ {"SOMAXCONN", Const, 0},
+ {"SO_ACCEPTCONN", Const, 0},
+ {"SO_ACCEPTFILTER", Const, 0},
+ {"SO_ATTACH_FILTER", Const, 0},
+ {"SO_BINDANY", Const, 1},
+ {"SO_BINDTODEVICE", Const, 0},
+ {"SO_BINTIME", Const, 0},
+ {"SO_BROADCAST", Const, 0},
+ {"SO_BSDCOMPAT", Const, 0},
+ {"SO_DEBUG", Const, 0},
+ {"SO_DETACH_FILTER", Const, 0},
+ {"SO_DOMAIN", Const, 0},
+ {"SO_DONTROUTE", Const, 0},
+ {"SO_DONTTRUNC", Const, 0},
+ {"SO_ERROR", Const, 0},
+ {"SO_KEEPALIVE", Const, 0},
+ {"SO_LABEL", Const, 0},
+ {"SO_LINGER", Const, 0},
+ {"SO_LINGER_SEC", Const, 0},
+ {"SO_LISTENINCQLEN", Const, 0},
+ {"SO_LISTENQLEN", Const, 0},
+ {"SO_LISTENQLIMIT", Const, 0},
+ {"SO_MARK", Const, 0},
+ {"SO_NETPROC", Const, 1},
+ {"SO_NKE", Const, 0},
+ {"SO_NOADDRERR", Const, 0},
+ {"SO_NOHEADER", Const, 1},
+ {"SO_NOSIGPIPE", Const, 0},
+ {"SO_NOTIFYCONFLICT", Const, 0},
+ {"SO_NO_CHECK", Const, 0},
+ {"SO_NO_DDP", Const, 0},
+ {"SO_NO_OFFLOAD", Const, 0},
+ {"SO_NP_EXTENSIONS", Const, 0},
+ {"SO_NREAD", Const, 0},
+ {"SO_NUMRCVPKT", Const, 16},
+ {"SO_NWRITE", Const, 0},
+ {"SO_OOBINLINE", Const, 0},
+ {"SO_OVERFLOWED", Const, 1},
+ {"SO_PASSCRED", Const, 0},
+ {"SO_PASSSEC", Const, 0},
+ {"SO_PEERCRED", Const, 0},
+ {"SO_PEERLABEL", Const, 0},
+ {"SO_PEERNAME", Const, 0},
+ {"SO_PEERSEC", Const, 0},
+ {"SO_PRIORITY", Const, 0},
+ {"SO_PROTOCOL", Const, 0},
+ {"SO_PROTOTYPE", Const, 1},
+ {"SO_RANDOMPORT", Const, 0},
+ {"SO_RCVBUF", Const, 0},
+ {"SO_RCVBUFFORCE", Const, 0},
+ {"SO_RCVLOWAT", Const, 0},
+ {"SO_RCVTIMEO", Const, 0},
+ {"SO_RESTRICTIONS", Const, 0},
+ {"SO_RESTRICT_DENYIN", Const, 0},
+ {"SO_RESTRICT_DENYOUT", Const, 0},
+ {"SO_RESTRICT_DENYSET", Const, 0},
+ {"SO_REUSEADDR", Const, 0},
+ {"SO_REUSEPORT", Const, 0},
+ {"SO_REUSESHAREUID", Const, 0},
+ {"SO_RTABLE", Const, 1},
+ {"SO_RXQ_OVFL", Const, 0},
+ {"SO_SECURITY_AUTHENTICATION", Const, 0},
+ {"SO_SECURITY_ENCRYPTION_NETWORK", Const, 0},
+ {"SO_SECURITY_ENCRYPTION_TRANSPORT", Const, 0},
+ {"SO_SETFIB", Const, 0},
+ {"SO_SNDBUF", Const, 0},
+ {"SO_SNDBUFFORCE", Const, 0},
+ {"SO_SNDLOWAT", Const, 0},
+ {"SO_SNDTIMEO", Const, 0},
+ {"SO_SPLICE", Const, 1},
+ {"SO_TIMESTAMP", Const, 0},
+ {"SO_TIMESTAMPING", Const, 0},
+ {"SO_TIMESTAMPNS", Const, 0},
+ {"SO_TIMESTAMP_MONOTONIC", Const, 0},
+ {"SO_TYPE", Const, 0},
+ {"SO_UPCALLCLOSEWAIT", Const, 0},
+ {"SO_UPDATE_ACCEPT_CONTEXT", Const, 0},
+ {"SO_UPDATE_CONNECT_CONTEXT", Const, 1},
+ {"SO_USELOOPBACK", Const, 0},
+ {"SO_USER_COOKIE", Const, 1},
+ {"SO_VENDOR", Const, 3},
+ {"SO_WANTMORE", Const, 0},
+ {"SO_WANTOOBFLAG", Const, 0},
+ {"SSLExtraCertChainPolicyPara", Type, 0},
+ {"SSLExtraCertChainPolicyPara.AuthType", Field, 0},
+ {"SSLExtraCertChainPolicyPara.Checks", Field, 0},
+ {"SSLExtraCertChainPolicyPara.ServerName", Field, 0},
+ {"SSLExtraCertChainPolicyPara.Size", Field, 0},
+ {"STANDARD_RIGHTS_ALL", Const, 0},
+ {"STANDARD_RIGHTS_EXECUTE", Const, 0},
+ {"STANDARD_RIGHTS_READ", Const, 0},
+ {"STANDARD_RIGHTS_REQUIRED", Const, 0},
+ {"STANDARD_RIGHTS_WRITE", Const, 0},
+ {"STARTF_USESHOWWINDOW", Const, 0},
+ {"STARTF_USESTDHANDLES", Const, 0},
+ {"STD_ERROR_HANDLE", Const, 0},
+ {"STD_INPUT_HANDLE", Const, 0},
+ {"STD_OUTPUT_HANDLE", Const, 0},
+ {"SUBLANG_ENGLISH_US", Const, 0},
+ {"SW_FORCEMINIMIZE", Const, 0},
+ {"SW_HIDE", Const, 0},
+ {"SW_MAXIMIZE", Const, 0},
+ {"SW_MINIMIZE", Const, 0},
+ {"SW_NORMAL", Const, 0},
+ {"SW_RESTORE", Const, 0},
+ {"SW_SHOW", Const, 0},
+ {"SW_SHOWDEFAULT", Const, 0},
+ {"SW_SHOWMAXIMIZED", Const, 0},
+ {"SW_SHOWMINIMIZED", Const, 0},
+ {"SW_SHOWMINNOACTIVE", Const, 0},
+ {"SW_SHOWNA", Const, 0},
+ {"SW_SHOWNOACTIVATE", Const, 0},
+ {"SW_SHOWNORMAL", Const, 0},
+ {"SYMBOLIC_LINK_FLAG_DIRECTORY", Const, 4},
+ {"SYNCHRONIZE", Const, 0},
+ {"SYSCTL_VERSION", Const, 1},
+ {"SYSCTL_VERS_0", Const, 1},
+ {"SYSCTL_VERS_1", Const, 1},
+ {"SYSCTL_VERS_MASK", Const, 1},
+ {"SYS_ABORT2", Const, 0},
+ {"SYS_ACCEPT", Const, 0},
+ {"SYS_ACCEPT4", Const, 0},
+ {"SYS_ACCEPT_NOCANCEL", Const, 0},
+ {"SYS_ACCESS", Const, 0},
+ {"SYS_ACCESS_EXTENDED", Const, 0},
+ {"SYS_ACCT", Const, 0},
+ {"SYS_ADD_KEY", Const, 0},
+ {"SYS_ADD_PROFIL", Const, 0},
+ {"SYS_ADJFREQ", Const, 1},
+ {"SYS_ADJTIME", Const, 0},
+ {"SYS_ADJTIMEX", Const, 0},
+ {"SYS_AFS_SYSCALL", Const, 0},
+ {"SYS_AIO_CANCEL", Const, 0},
+ {"SYS_AIO_ERROR", Const, 0},
+ {"SYS_AIO_FSYNC", Const, 0},
+ {"SYS_AIO_MLOCK", Const, 14},
+ {"SYS_AIO_READ", Const, 0},
+ {"SYS_AIO_RETURN", Const, 0},
+ {"SYS_AIO_SUSPEND", Const, 0},
+ {"SYS_AIO_SUSPEND_NOCANCEL", Const, 0},
+ {"SYS_AIO_WAITCOMPLETE", Const, 14},
+ {"SYS_AIO_WRITE", Const, 0},
+ {"SYS_ALARM", Const, 0},
+ {"SYS_ARCH_PRCTL", Const, 0},
+ {"SYS_ARM_FADVISE64_64", Const, 0},
+ {"SYS_ARM_SYNC_FILE_RANGE", Const, 0},
+ {"SYS_ATGETMSG", Const, 0},
+ {"SYS_ATPGETREQ", Const, 0},
+ {"SYS_ATPGETRSP", Const, 0},
+ {"SYS_ATPSNDREQ", Const, 0},
+ {"SYS_ATPSNDRSP", Const, 0},
+ {"SYS_ATPUTMSG", Const, 0},
+ {"SYS_ATSOCKET", Const, 0},
+ {"SYS_AUDIT", Const, 0},
+ {"SYS_AUDITCTL", Const, 0},
+ {"SYS_AUDITON", Const, 0},
+ {"SYS_AUDIT_SESSION_JOIN", Const, 0},
+ {"SYS_AUDIT_SESSION_PORT", Const, 0},
+ {"SYS_AUDIT_SESSION_SELF", Const, 0},
+ {"SYS_BDFLUSH", Const, 0},
+ {"SYS_BIND", Const, 0},
+ {"SYS_BINDAT", Const, 3},
+ {"SYS_BREAK", Const, 0},
+ {"SYS_BRK", Const, 0},
+ {"SYS_BSDTHREAD_CREATE", Const, 0},
+ {"SYS_BSDTHREAD_REGISTER", Const, 0},
+ {"SYS_BSDTHREAD_TERMINATE", Const, 0},
+ {"SYS_CAPGET", Const, 0},
+ {"SYS_CAPSET", Const, 0},
+ {"SYS_CAP_ENTER", Const, 0},
+ {"SYS_CAP_FCNTLS_GET", Const, 1},
+ {"SYS_CAP_FCNTLS_LIMIT", Const, 1},
+ {"SYS_CAP_GETMODE", Const, 0},
+ {"SYS_CAP_GETRIGHTS", Const, 0},
+ {"SYS_CAP_IOCTLS_GET", Const, 1},
+ {"SYS_CAP_IOCTLS_LIMIT", Const, 1},
+ {"SYS_CAP_NEW", Const, 0},
+ {"SYS_CAP_RIGHTS_GET", Const, 1},
+ {"SYS_CAP_RIGHTS_LIMIT", Const, 1},
+ {"SYS_CHDIR", Const, 0},
+ {"SYS_CHFLAGS", Const, 0},
+ {"SYS_CHFLAGSAT", Const, 3},
+ {"SYS_CHMOD", Const, 0},
+ {"SYS_CHMOD_EXTENDED", Const, 0},
+ {"SYS_CHOWN", Const, 0},
+ {"SYS_CHOWN32", Const, 0},
+ {"SYS_CHROOT", Const, 0},
+ {"SYS_CHUD", Const, 0},
+ {"SYS_CLOCK_ADJTIME", Const, 0},
+ {"SYS_CLOCK_GETCPUCLOCKID2", Const, 1},
+ {"SYS_CLOCK_GETRES", Const, 0},
+ {"SYS_CLOCK_GETTIME", Const, 0},
+ {"SYS_CLOCK_NANOSLEEP", Const, 0},
+ {"SYS_CLOCK_SETTIME", Const, 0},
+ {"SYS_CLONE", Const, 0},
+ {"SYS_CLOSE", Const, 0},
+ {"SYS_CLOSEFROM", Const, 0},
+ {"SYS_CLOSE_NOCANCEL", Const, 0},
+ {"SYS_CONNECT", Const, 0},
+ {"SYS_CONNECTAT", Const, 3},
+ {"SYS_CONNECT_NOCANCEL", Const, 0},
+ {"SYS_COPYFILE", Const, 0},
+ {"SYS_CPUSET", Const, 0},
+ {"SYS_CPUSET_GETAFFINITY", Const, 0},
+ {"SYS_CPUSET_GETID", Const, 0},
+ {"SYS_CPUSET_SETAFFINITY", Const, 0},
+ {"SYS_CPUSET_SETID", Const, 0},
+ {"SYS_CREAT", Const, 0},
+ {"SYS_CREATE_MODULE", Const, 0},
+ {"SYS_CSOPS", Const, 0},
+ {"SYS_CSOPS_AUDITTOKEN", Const, 16},
+ {"SYS_DELETE", Const, 0},
+ {"SYS_DELETE_MODULE", Const, 0},
+ {"SYS_DUP", Const, 0},
+ {"SYS_DUP2", Const, 0},
+ {"SYS_DUP3", Const, 0},
+ {"SYS_EACCESS", Const, 0},
+ {"SYS_EPOLL_CREATE", Const, 0},
+ {"SYS_EPOLL_CREATE1", Const, 0},
+ {"SYS_EPOLL_CTL", Const, 0},
+ {"SYS_EPOLL_CTL_OLD", Const, 0},
+ {"SYS_EPOLL_PWAIT", Const, 0},
+ {"SYS_EPOLL_WAIT", Const, 0},
+ {"SYS_EPOLL_WAIT_OLD", Const, 0},
+ {"SYS_EVENTFD", Const, 0},
+ {"SYS_EVENTFD2", Const, 0},
+ {"SYS_EXCHANGEDATA", Const, 0},
+ {"SYS_EXECVE", Const, 0},
+ {"SYS_EXIT", Const, 0},
+ {"SYS_EXIT_GROUP", Const, 0},
+ {"SYS_EXTATTRCTL", Const, 0},
+ {"SYS_EXTATTR_DELETE_FD", Const, 0},
+ {"SYS_EXTATTR_DELETE_FILE", Const, 0},
+ {"SYS_EXTATTR_DELETE_LINK", Const, 0},
+ {"SYS_EXTATTR_GET_FD", Const, 0},
+ {"SYS_EXTATTR_GET_FILE", Const, 0},
+ {"SYS_EXTATTR_GET_LINK", Const, 0},
+ {"SYS_EXTATTR_LIST_FD", Const, 0},
+ {"SYS_EXTATTR_LIST_FILE", Const, 0},
+ {"SYS_EXTATTR_LIST_LINK", Const, 0},
+ {"SYS_EXTATTR_SET_FD", Const, 0},
+ {"SYS_EXTATTR_SET_FILE", Const, 0},
+ {"SYS_EXTATTR_SET_LINK", Const, 0},
+ {"SYS_FACCESSAT", Const, 0},
+ {"SYS_FADVISE64", Const, 0},
+ {"SYS_FADVISE64_64", Const, 0},
+ {"SYS_FALLOCATE", Const, 0},
+ {"SYS_FANOTIFY_INIT", Const, 0},
+ {"SYS_FANOTIFY_MARK", Const, 0},
+ {"SYS_FCHDIR", Const, 0},
+ {"SYS_FCHFLAGS", Const, 0},
+ {"SYS_FCHMOD", Const, 0},
+ {"SYS_FCHMODAT", Const, 0},
+ {"SYS_FCHMOD_EXTENDED", Const, 0},
+ {"SYS_FCHOWN", Const, 0},
+ {"SYS_FCHOWN32", Const, 0},
+ {"SYS_FCHOWNAT", Const, 0},
+ {"SYS_FCHROOT", Const, 1},
+ {"SYS_FCNTL", Const, 0},
+ {"SYS_FCNTL64", Const, 0},
+ {"SYS_FCNTL_NOCANCEL", Const, 0},
+ {"SYS_FDATASYNC", Const, 0},
+ {"SYS_FEXECVE", Const, 0},
+ {"SYS_FFCLOCK_GETCOUNTER", Const, 0},
+ {"SYS_FFCLOCK_GETESTIMATE", Const, 0},
+ {"SYS_FFCLOCK_SETESTIMATE", Const, 0},
+ {"SYS_FFSCTL", Const, 0},
+ {"SYS_FGETATTRLIST", Const, 0},
+ {"SYS_FGETXATTR", Const, 0},
+ {"SYS_FHOPEN", Const, 0},
+ {"SYS_FHSTAT", Const, 0},
+ {"SYS_FHSTATFS", Const, 0},
+ {"SYS_FILEPORT_MAKEFD", Const, 0},
+ {"SYS_FILEPORT_MAKEPORT", Const, 0},
+ {"SYS_FKTRACE", Const, 1},
+ {"SYS_FLISTXATTR", Const, 0},
+ {"SYS_FLOCK", Const, 0},
+ {"SYS_FORK", Const, 0},
+ {"SYS_FPATHCONF", Const, 0},
+ {"SYS_FREEBSD6_FTRUNCATE", Const, 0},
+ {"SYS_FREEBSD6_LSEEK", Const, 0},
+ {"SYS_FREEBSD6_MMAP", Const, 0},
+ {"SYS_FREEBSD6_PREAD", Const, 0},
+ {"SYS_FREEBSD6_PWRITE", Const, 0},
+ {"SYS_FREEBSD6_TRUNCATE", Const, 0},
+ {"SYS_FREMOVEXATTR", Const, 0},
+ {"SYS_FSCTL", Const, 0},
+ {"SYS_FSETATTRLIST", Const, 0},
+ {"SYS_FSETXATTR", Const, 0},
+ {"SYS_FSGETPATH", Const, 0},
+ {"SYS_FSTAT", Const, 0},
+ {"SYS_FSTAT64", Const, 0},
+ {"SYS_FSTAT64_EXTENDED", Const, 0},
+ {"SYS_FSTATAT", Const, 0},
+ {"SYS_FSTATAT64", Const, 0},
+ {"SYS_FSTATFS", Const, 0},
+ {"SYS_FSTATFS64", Const, 0},
+ {"SYS_FSTATV", Const, 0},
+ {"SYS_FSTATVFS1", Const, 1},
+ {"SYS_FSTAT_EXTENDED", Const, 0},
+ {"SYS_FSYNC", Const, 0},
+ {"SYS_FSYNC_NOCANCEL", Const, 0},
+ {"SYS_FSYNC_RANGE", Const, 1},
+ {"SYS_FTIME", Const, 0},
+ {"SYS_FTRUNCATE", Const, 0},
+ {"SYS_FTRUNCATE64", Const, 0},
+ {"SYS_FUTEX", Const, 0},
+ {"SYS_FUTIMENS", Const, 1},
+ {"SYS_FUTIMES", Const, 0},
+ {"SYS_FUTIMESAT", Const, 0},
+ {"SYS_GETATTRLIST", Const, 0},
+ {"SYS_GETAUDIT", Const, 0},
+ {"SYS_GETAUDIT_ADDR", Const, 0},
+ {"SYS_GETAUID", Const, 0},
+ {"SYS_GETCONTEXT", Const, 0},
+ {"SYS_GETCPU", Const, 0},
+ {"SYS_GETCWD", Const, 0},
+ {"SYS_GETDENTS", Const, 0},
+ {"SYS_GETDENTS64", Const, 0},
+ {"SYS_GETDIRENTRIES", Const, 0},
+ {"SYS_GETDIRENTRIES64", Const, 0},
+ {"SYS_GETDIRENTRIESATTR", Const, 0},
+ {"SYS_GETDTABLECOUNT", Const, 1},
+ {"SYS_GETDTABLESIZE", Const, 0},
+ {"SYS_GETEGID", Const, 0},
+ {"SYS_GETEGID32", Const, 0},
+ {"SYS_GETEUID", Const, 0},
+ {"SYS_GETEUID32", Const, 0},
+ {"SYS_GETFH", Const, 0},
+ {"SYS_GETFSSTAT", Const, 0},
+ {"SYS_GETFSSTAT64", Const, 0},
+ {"SYS_GETGID", Const, 0},
+ {"SYS_GETGID32", Const, 0},
+ {"SYS_GETGROUPS", Const, 0},
+ {"SYS_GETGROUPS32", Const, 0},
+ {"SYS_GETHOSTUUID", Const, 0},
+ {"SYS_GETITIMER", Const, 0},
+ {"SYS_GETLCID", Const, 0},
+ {"SYS_GETLOGIN", Const, 0},
+ {"SYS_GETLOGINCLASS", Const, 0},
+ {"SYS_GETPEERNAME", Const, 0},
+ {"SYS_GETPGID", Const, 0},
+ {"SYS_GETPGRP", Const, 0},
+ {"SYS_GETPID", Const, 0},
+ {"SYS_GETPMSG", Const, 0},
+ {"SYS_GETPPID", Const, 0},
+ {"SYS_GETPRIORITY", Const, 0},
+ {"SYS_GETRESGID", Const, 0},
+ {"SYS_GETRESGID32", Const, 0},
+ {"SYS_GETRESUID", Const, 0},
+ {"SYS_GETRESUID32", Const, 0},
+ {"SYS_GETRLIMIT", Const, 0},
+ {"SYS_GETRTABLE", Const, 1},
+ {"SYS_GETRUSAGE", Const, 0},
+ {"SYS_GETSGROUPS", Const, 0},
+ {"SYS_GETSID", Const, 0},
+ {"SYS_GETSOCKNAME", Const, 0},
+ {"SYS_GETSOCKOPT", Const, 0},
+ {"SYS_GETTHRID", Const, 1},
+ {"SYS_GETTID", Const, 0},
+ {"SYS_GETTIMEOFDAY", Const, 0},
+ {"SYS_GETUID", Const, 0},
+ {"SYS_GETUID32", Const, 0},
+ {"SYS_GETVFSSTAT", Const, 1},
+ {"SYS_GETWGROUPS", Const, 0},
+ {"SYS_GETXATTR", Const, 0},
+ {"SYS_GET_KERNEL_SYMS", Const, 0},
+ {"SYS_GET_MEMPOLICY", Const, 0},
+ {"SYS_GET_ROBUST_LIST", Const, 0},
+ {"SYS_GET_THREAD_AREA", Const, 0},
+ {"SYS_GSSD_SYSCALL", Const, 14},
+ {"SYS_GTTY", Const, 0},
+ {"SYS_IDENTITYSVC", Const, 0},
+ {"SYS_IDLE", Const, 0},
+ {"SYS_INITGROUPS", Const, 0},
+ {"SYS_INIT_MODULE", Const, 0},
+ {"SYS_INOTIFY_ADD_WATCH", Const, 0},
+ {"SYS_INOTIFY_INIT", Const, 0},
+ {"SYS_INOTIFY_INIT1", Const, 0},
+ {"SYS_INOTIFY_RM_WATCH", Const, 0},
+ {"SYS_IOCTL", Const, 0},
+ {"SYS_IOPERM", Const, 0},
+ {"SYS_IOPL", Const, 0},
+ {"SYS_IOPOLICYSYS", Const, 0},
+ {"SYS_IOPRIO_GET", Const, 0},
+ {"SYS_IOPRIO_SET", Const, 0},
+ {"SYS_IO_CANCEL", Const, 0},
+ {"SYS_IO_DESTROY", Const, 0},
+ {"SYS_IO_GETEVENTS", Const, 0},
+ {"SYS_IO_SETUP", Const, 0},
+ {"SYS_IO_SUBMIT", Const, 0},
+ {"SYS_IPC", Const, 0},
+ {"SYS_ISSETUGID", Const, 0},
+ {"SYS_JAIL", Const, 0},
+ {"SYS_JAIL_ATTACH", Const, 0},
+ {"SYS_JAIL_GET", Const, 0},
+ {"SYS_JAIL_REMOVE", Const, 0},
+ {"SYS_JAIL_SET", Const, 0},
+ {"SYS_KAS_INFO", Const, 16},
+ {"SYS_KDEBUG_TRACE", Const, 0},
+ {"SYS_KENV", Const, 0},
+ {"SYS_KEVENT", Const, 0},
+ {"SYS_KEVENT64", Const, 0},
+ {"SYS_KEXEC_LOAD", Const, 0},
+ {"SYS_KEYCTL", Const, 0},
+ {"SYS_KILL", Const, 0},
+ {"SYS_KLDFIND", Const, 0},
+ {"SYS_KLDFIRSTMOD", Const, 0},
+ {"SYS_KLDLOAD", Const, 0},
+ {"SYS_KLDNEXT", Const, 0},
+ {"SYS_KLDSTAT", Const, 0},
+ {"SYS_KLDSYM", Const, 0},
+ {"SYS_KLDUNLOAD", Const, 0},
+ {"SYS_KLDUNLOADF", Const, 0},
+ {"SYS_KMQ_NOTIFY", Const, 14},
+ {"SYS_KMQ_OPEN", Const, 14},
+ {"SYS_KMQ_SETATTR", Const, 14},
+ {"SYS_KMQ_TIMEDRECEIVE", Const, 14},
+ {"SYS_KMQ_TIMEDSEND", Const, 14},
+ {"SYS_KMQ_UNLINK", Const, 14},
+ {"SYS_KQUEUE", Const, 0},
+ {"SYS_KQUEUE1", Const, 1},
+ {"SYS_KSEM_CLOSE", Const, 14},
+ {"SYS_KSEM_DESTROY", Const, 14},
+ {"SYS_KSEM_GETVALUE", Const, 14},
+ {"SYS_KSEM_INIT", Const, 14},
+ {"SYS_KSEM_OPEN", Const, 14},
+ {"SYS_KSEM_POST", Const, 14},
+ {"SYS_KSEM_TIMEDWAIT", Const, 14},
+ {"SYS_KSEM_TRYWAIT", Const, 14},
+ {"SYS_KSEM_UNLINK", Const, 14},
+ {"SYS_KSEM_WAIT", Const, 14},
+ {"SYS_KTIMER_CREATE", Const, 0},
+ {"SYS_KTIMER_DELETE", Const, 0},
+ {"SYS_KTIMER_GETOVERRUN", Const, 0},
+ {"SYS_KTIMER_GETTIME", Const, 0},
+ {"SYS_KTIMER_SETTIME", Const, 0},
+ {"SYS_KTRACE", Const, 0},
+ {"SYS_LCHFLAGS", Const, 0},
+ {"SYS_LCHMOD", Const, 0},
+ {"SYS_LCHOWN", Const, 0},
+ {"SYS_LCHOWN32", Const, 0},
+ {"SYS_LEDGER", Const, 16},
+ {"SYS_LGETFH", Const, 0},
+ {"SYS_LGETXATTR", Const, 0},
+ {"SYS_LINK", Const, 0},
+ {"SYS_LINKAT", Const, 0},
+ {"SYS_LIO_LISTIO", Const, 0},
+ {"SYS_LISTEN", Const, 0},
+ {"SYS_LISTXATTR", Const, 0},
+ {"SYS_LLISTXATTR", Const, 0},
+ {"SYS_LOCK", Const, 0},
+ {"SYS_LOOKUP_DCOOKIE", Const, 0},
+ {"SYS_LPATHCONF", Const, 0},
+ {"SYS_LREMOVEXATTR", Const, 0},
+ {"SYS_LSEEK", Const, 0},
+ {"SYS_LSETXATTR", Const, 0},
+ {"SYS_LSTAT", Const, 0},
+ {"SYS_LSTAT64", Const, 0},
+ {"SYS_LSTAT64_EXTENDED", Const, 0},
+ {"SYS_LSTATV", Const, 0},
+ {"SYS_LSTAT_EXTENDED", Const, 0},
+ {"SYS_LUTIMES", Const, 0},
+ {"SYS_MAC_SYSCALL", Const, 0},
+ {"SYS_MADVISE", Const, 0},
+ {"SYS_MADVISE1", Const, 0},
+ {"SYS_MAXSYSCALL", Const, 0},
+ {"SYS_MBIND", Const, 0},
+ {"SYS_MIGRATE_PAGES", Const, 0},
+ {"SYS_MINCORE", Const, 0},
+ {"SYS_MINHERIT", Const, 0},
+ {"SYS_MKCOMPLEX", Const, 0},
+ {"SYS_MKDIR", Const, 0},
+ {"SYS_MKDIRAT", Const, 0},
+ {"SYS_MKDIR_EXTENDED", Const, 0},
+ {"SYS_MKFIFO", Const, 0},
+ {"SYS_MKFIFOAT", Const, 0},
+ {"SYS_MKFIFO_EXTENDED", Const, 0},
+ {"SYS_MKNOD", Const, 0},
+ {"SYS_MKNODAT", Const, 0},
+ {"SYS_MLOCK", Const, 0},
+ {"SYS_MLOCKALL", Const, 0},
+ {"SYS_MMAP", Const, 0},
+ {"SYS_MMAP2", Const, 0},
+ {"SYS_MODCTL", Const, 1},
+ {"SYS_MODFIND", Const, 0},
+ {"SYS_MODFNEXT", Const, 0},
+ {"SYS_MODIFY_LDT", Const, 0},
+ {"SYS_MODNEXT", Const, 0},
+ {"SYS_MODSTAT", Const, 0},
+ {"SYS_MODWATCH", Const, 0},
+ {"SYS_MOUNT", Const, 0},
+ {"SYS_MOVE_PAGES", Const, 0},
+ {"SYS_MPROTECT", Const, 0},
+ {"SYS_MPX", Const, 0},
+ {"SYS_MQUERY", Const, 1},
+ {"SYS_MQ_GETSETATTR", Const, 0},
+ {"SYS_MQ_NOTIFY", Const, 0},
+ {"SYS_MQ_OPEN", Const, 0},
+ {"SYS_MQ_TIMEDRECEIVE", Const, 0},
+ {"SYS_MQ_TIMEDSEND", Const, 0},
+ {"SYS_MQ_UNLINK", Const, 0},
+ {"SYS_MREMAP", Const, 0},
+ {"SYS_MSGCTL", Const, 0},
+ {"SYS_MSGGET", Const, 0},
+ {"SYS_MSGRCV", Const, 0},
+ {"SYS_MSGRCV_NOCANCEL", Const, 0},
+ {"SYS_MSGSND", Const, 0},
+ {"SYS_MSGSND_NOCANCEL", Const, 0},
+ {"SYS_MSGSYS", Const, 0},
+ {"SYS_MSYNC", Const, 0},
+ {"SYS_MSYNC_NOCANCEL", Const, 0},
+ {"SYS_MUNLOCK", Const, 0},
+ {"SYS_MUNLOCKALL", Const, 0},
+ {"SYS_MUNMAP", Const, 0},
+ {"SYS_NAME_TO_HANDLE_AT", Const, 0},
+ {"SYS_NANOSLEEP", Const, 0},
+ {"SYS_NEWFSTATAT", Const, 0},
+ {"SYS_NFSCLNT", Const, 0},
+ {"SYS_NFSSERVCTL", Const, 0},
+ {"SYS_NFSSVC", Const, 0},
+ {"SYS_NFSTAT", Const, 0},
+ {"SYS_NICE", Const, 0},
+ {"SYS_NLM_SYSCALL", Const, 14},
+ {"SYS_NLSTAT", Const, 0},
+ {"SYS_NMOUNT", Const, 0},
+ {"SYS_NSTAT", Const, 0},
+ {"SYS_NTP_ADJTIME", Const, 0},
+ {"SYS_NTP_GETTIME", Const, 0},
+ {"SYS_NUMA_GETAFFINITY", Const, 14},
+ {"SYS_NUMA_SETAFFINITY", Const, 14},
+ {"SYS_OABI_SYSCALL_BASE", Const, 0},
+ {"SYS_OBREAK", Const, 0},
+ {"SYS_OLDFSTAT", Const, 0},
+ {"SYS_OLDLSTAT", Const, 0},
+ {"SYS_OLDOLDUNAME", Const, 0},
+ {"SYS_OLDSTAT", Const, 0},
+ {"SYS_OLDUNAME", Const, 0},
+ {"SYS_OPEN", Const, 0},
+ {"SYS_OPENAT", Const, 0},
+ {"SYS_OPENBSD_POLL", Const, 0},
+ {"SYS_OPEN_BY_HANDLE_AT", Const, 0},
+ {"SYS_OPEN_DPROTECTED_NP", Const, 16},
+ {"SYS_OPEN_EXTENDED", Const, 0},
+ {"SYS_OPEN_NOCANCEL", Const, 0},
+ {"SYS_OVADVISE", Const, 0},
+ {"SYS_PACCEPT", Const, 1},
+ {"SYS_PATHCONF", Const, 0},
+ {"SYS_PAUSE", Const, 0},
+ {"SYS_PCICONFIG_IOBASE", Const, 0},
+ {"SYS_PCICONFIG_READ", Const, 0},
+ {"SYS_PCICONFIG_WRITE", Const, 0},
+ {"SYS_PDFORK", Const, 0},
+ {"SYS_PDGETPID", Const, 0},
+ {"SYS_PDKILL", Const, 0},
+ {"SYS_PERF_EVENT_OPEN", Const, 0},
+ {"SYS_PERSONALITY", Const, 0},
+ {"SYS_PID_HIBERNATE", Const, 0},
+ {"SYS_PID_RESUME", Const, 0},
+ {"SYS_PID_SHUTDOWN_SOCKETS", Const, 0},
+ {"SYS_PID_SUSPEND", Const, 0},
+ {"SYS_PIPE", Const, 0},
+ {"SYS_PIPE2", Const, 0},
+ {"SYS_PIVOT_ROOT", Const, 0},
+ {"SYS_PMC_CONTROL", Const, 1},
+ {"SYS_PMC_GET_INFO", Const, 1},
+ {"SYS_POLL", Const, 0},
+ {"SYS_POLLTS", Const, 1},
+ {"SYS_POLL_NOCANCEL", Const, 0},
+ {"SYS_POSIX_FADVISE", Const, 0},
+ {"SYS_POSIX_FALLOCATE", Const, 0},
+ {"SYS_POSIX_OPENPT", Const, 0},
+ {"SYS_POSIX_SPAWN", Const, 0},
+ {"SYS_PPOLL", Const, 0},
+ {"SYS_PRCTL", Const, 0},
+ {"SYS_PREAD", Const, 0},
+ {"SYS_PREAD64", Const, 0},
+ {"SYS_PREADV", Const, 0},
+ {"SYS_PREAD_NOCANCEL", Const, 0},
+ {"SYS_PRLIMIT64", Const, 0},
+ {"SYS_PROCCTL", Const, 3},
+ {"SYS_PROCESS_POLICY", Const, 0},
+ {"SYS_PROCESS_VM_READV", Const, 0},
+ {"SYS_PROCESS_VM_WRITEV", Const, 0},
+ {"SYS_PROC_INFO", Const, 0},
+ {"SYS_PROF", Const, 0},
+ {"SYS_PROFIL", Const, 0},
+ {"SYS_PSELECT", Const, 0},
+ {"SYS_PSELECT6", Const, 0},
+ {"SYS_PSET_ASSIGN", Const, 1},
+ {"SYS_PSET_CREATE", Const, 1},
+ {"SYS_PSET_DESTROY", Const, 1},
+ {"SYS_PSYNCH_CVBROAD", Const, 0},
+ {"SYS_PSYNCH_CVCLRPREPOST", Const, 0},
+ {"SYS_PSYNCH_CVSIGNAL", Const, 0},
+ {"SYS_PSYNCH_CVWAIT", Const, 0},
+ {"SYS_PSYNCH_MUTEXDROP", Const, 0},
+ {"SYS_PSYNCH_MUTEXWAIT", Const, 0},
+ {"SYS_PSYNCH_RW_DOWNGRADE", Const, 0},
+ {"SYS_PSYNCH_RW_LONGRDLOCK", Const, 0},
+ {"SYS_PSYNCH_RW_RDLOCK", Const, 0},
+ {"SYS_PSYNCH_RW_UNLOCK", Const, 0},
+ {"SYS_PSYNCH_RW_UNLOCK2", Const, 0},
+ {"SYS_PSYNCH_RW_UPGRADE", Const, 0},
+ {"SYS_PSYNCH_RW_WRLOCK", Const, 0},
+ {"SYS_PSYNCH_RW_YIELDWRLOCK", Const, 0},
+ {"SYS_PTRACE", Const, 0},
+ {"SYS_PUTPMSG", Const, 0},
+ {"SYS_PWRITE", Const, 0},
+ {"SYS_PWRITE64", Const, 0},
+ {"SYS_PWRITEV", Const, 0},
+ {"SYS_PWRITE_NOCANCEL", Const, 0},
+ {"SYS_QUERY_MODULE", Const, 0},
+ {"SYS_QUOTACTL", Const, 0},
+ {"SYS_RASCTL", Const, 1},
+ {"SYS_RCTL_ADD_RULE", Const, 0},
+ {"SYS_RCTL_GET_LIMITS", Const, 0},
+ {"SYS_RCTL_GET_RACCT", Const, 0},
+ {"SYS_RCTL_GET_RULES", Const, 0},
+ {"SYS_RCTL_REMOVE_RULE", Const, 0},
+ {"SYS_READ", Const, 0},
+ {"SYS_READAHEAD", Const, 0},
+ {"SYS_READDIR", Const, 0},
+ {"SYS_READLINK", Const, 0},
+ {"SYS_READLINKAT", Const, 0},
+ {"SYS_READV", Const, 0},
+ {"SYS_READV_NOCANCEL", Const, 0},
+ {"SYS_READ_NOCANCEL", Const, 0},
+ {"SYS_REBOOT", Const, 0},
+ {"SYS_RECV", Const, 0},
+ {"SYS_RECVFROM", Const, 0},
+ {"SYS_RECVFROM_NOCANCEL", Const, 0},
+ {"SYS_RECVMMSG", Const, 0},
+ {"SYS_RECVMSG", Const, 0},
+ {"SYS_RECVMSG_NOCANCEL", Const, 0},
+ {"SYS_REMAP_FILE_PAGES", Const, 0},
+ {"SYS_REMOVEXATTR", Const, 0},
+ {"SYS_RENAME", Const, 0},
+ {"SYS_RENAMEAT", Const, 0},
+ {"SYS_REQUEST_KEY", Const, 0},
+ {"SYS_RESTART_SYSCALL", Const, 0},
+ {"SYS_REVOKE", Const, 0},
+ {"SYS_RFORK", Const, 0},
+ {"SYS_RMDIR", Const, 0},
+ {"SYS_RTPRIO", Const, 0},
+ {"SYS_RTPRIO_THREAD", Const, 0},
+ {"SYS_RT_SIGACTION", Const, 0},
+ {"SYS_RT_SIGPENDING", Const, 0},
+ {"SYS_RT_SIGPROCMASK", Const, 0},
+ {"SYS_RT_SIGQUEUEINFO", Const, 0},
+ {"SYS_RT_SIGRETURN", Const, 0},
+ {"SYS_RT_SIGSUSPEND", Const, 0},
+ {"SYS_RT_SIGTIMEDWAIT", Const, 0},
+ {"SYS_RT_TGSIGQUEUEINFO", Const, 0},
+ {"SYS_SBRK", Const, 0},
+ {"SYS_SCHED_GETAFFINITY", Const, 0},
+ {"SYS_SCHED_GETPARAM", Const, 0},
+ {"SYS_SCHED_GETSCHEDULER", Const, 0},
+ {"SYS_SCHED_GET_PRIORITY_MAX", Const, 0},
+ {"SYS_SCHED_GET_PRIORITY_MIN", Const, 0},
+ {"SYS_SCHED_RR_GET_INTERVAL", Const, 0},
+ {"SYS_SCHED_SETAFFINITY", Const, 0},
+ {"SYS_SCHED_SETPARAM", Const, 0},
+ {"SYS_SCHED_SETSCHEDULER", Const, 0},
+ {"SYS_SCHED_YIELD", Const, 0},
+ {"SYS_SCTP_GENERIC_RECVMSG", Const, 0},
+ {"SYS_SCTP_GENERIC_SENDMSG", Const, 0},
+ {"SYS_SCTP_GENERIC_SENDMSG_IOV", Const, 0},
+ {"SYS_SCTP_PEELOFF", Const, 0},
+ {"SYS_SEARCHFS", Const, 0},
+ {"SYS_SECURITY", Const, 0},
+ {"SYS_SELECT", Const, 0},
+ {"SYS_SELECT_NOCANCEL", Const, 0},
+ {"SYS_SEMCONFIG", Const, 1},
+ {"SYS_SEMCTL", Const, 0},
+ {"SYS_SEMGET", Const, 0},
+ {"SYS_SEMOP", Const, 0},
+ {"SYS_SEMSYS", Const, 0},
+ {"SYS_SEMTIMEDOP", Const, 0},
+ {"SYS_SEM_CLOSE", Const, 0},
+ {"SYS_SEM_DESTROY", Const, 0},
+ {"SYS_SEM_GETVALUE", Const, 0},
+ {"SYS_SEM_INIT", Const, 0},
+ {"SYS_SEM_OPEN", Const, 0},
+ {"SYS_SEM_POST", Const, 0},
+ {"SYS_SEM_TRYWAIT", Const, 0},
+ {"SYS_SEM_UNLINK", Const, 0},
+ {"SYS_SEM_WAIT", Const, 0},
+ {"SYS_SEM_WAIT_NOCANCEL", Const, 0},
+ {"SYS_SEND", Const, 0},
+ {"SYS_SENDFILE", Const, 0},
+ {"SYS_SENDFILE64", Const, 0},
+ {"SYS_SENDMMSG", Const, 0},
+ {"SYS_SENDMSG", Const, 0},
+ {"SYS_SENDMSG_NOCANCEL", Const, 0},
+ {"SYS_SENDTO", Const, 0},
+ {"SYS_SENDTO_NOCANCEL", Const, 0},
+ {"SYS_SETATTRLIST", Const, 0},
+ {"SYS_SETAUDIT", Const, 0},
+ {"SYS_SETAUDIT_ADDR", Const, 0},
+ {"SYS_SETAUID", Const, 0},
+ {"SYS_SETCONTEXT", Const, 0},
+ {"SYS_SETDOMAINNAME", Const, 0},
+ {"SYS_SETEGID", Const, 0},
+ {"SYS_SETEUID", Const, 0},
+ {"SYS_SETFIB", Const, 0},
+ {"SYS_SETFSGID", Const, 0},
+ {"SYS_SETFSGID32", Const, 0},
+ {"SYS_SETFSUID", Const, 0},
+ {"SYS_SETFSUID32", Const, 0},
+ {"SYS_SETGID", Const, 0},
+ {"SYS_SETGID32", Const, 0},
+ {"SYS_SETGROUPS", Const, 0},
+ {"SYS_SETGROUPS32", Const, 0},
+ {"SYS_SETHOSTNAME", Const, 0},
+ {"SYS_SETITIMER", Const, 0},
+ {"SYS_SETLCID", Const, 0},
+ {"SYS_SETLOGIN", Const, 0},
+ {"SYS_SETLOGINCLASS", Const, 0},
+ {"SYS_SETNS", Const, 0},
+ {"SYS_SETPGID", Const, 0},
+ {"SYS_SETPRIORITY", Const, 0},
+ {"SYS_SETPRIVEXEC", Const, 0},
+ {"SYS_SETREGID", Const, 0},
+ {"SYS_SETREGID32", Const, 0},
+ {"SYS_SETRESGID", Const, 0},
+ {"SYS_SETRESGID32", Const, 0},
+ {"SYS_SETRESUID", Const, 0},
+ {"SYS_SETRESUID32", Const, 0},
+ {"SYS_SETREUID", Const, 0},
+ {"SYS_SETREUID32", Const, 0},
+ {"SYS_SETRLIMIT", Const, 0},
+ {"SYS_SETRTABLE", Const, 1},
+ {"SYS_SETSGROUPS", Const, 0},
+ {"SYS_SETSID", Const, 0},
+ {"SYS_SETSOCKOPT", Const, 0},
+ {"SYS_SETTID", Const, 0},
+ {"SYS_SETTID_WITH_PID", Const, 0},
+ {"SYS_SETTIMEOFDAY", Const, 0},
+ {"SYS_SETUID", Const, 0},
+ {"SYS_SETUID32", Const, 0},
+ {"SYS_SETWGROUPS", Const, 0},
+ {"SYS_SETXATTR", Const, 0},
+ {"SYS_SET_MEMPOLICY", Const, 0},
+ {"SYS_SET_ROBUST_LIST", Const, 0},
+ {"SYS_SET_THREAD_AREA", Const, 0},
+ {"SYS_SET_TID_ADDRESS", Const, 0},
+ {"SYS_SGETMASK", Const, 0},
+ {"SYS_SHARED_REGION_CHECK_NP", Const, 0},
+ {"SYS_SHARED_REGION_MAP_AND_SLIDE_NP", Const, 0},
+ {"SYS_SHMAT", Const, 0},
+ {"SYS_SHMCTL", Const, 0},
+ {"SYS_SHMDT", Const, 0},
+ {"SYS_SHMGET", Const, 0},
+ {"SYS_SHMSYS", Const, 0},
+ {"SYS_SHM_OPEN", Const, 0},
+ {"SYS_SHM_UNLINK", Const, 0},
+ {"SYS_SHUTDOWN", Const, 0},
+ {"SYS_SIGACTION", Const, 0},
+ {"SYS_SIGALTSTACK", Const, 0},
+ {"SYS_SIGNAL", Const, 0},
+ {"SYS_SIGNALFD", Const, 0},
+ {"SYS_SIGNALFD4", Const, 0},
+ {"SYS_SIGPENDING", Const, 0},
+ {"SYS_SIGPROCMASK", Const, 0},
+ {"SYS_SIGQUEUE", Const, 0},
+ {"SYS_SIGQUEUEINFO", Const, 1},
+ {"SYS_SIGRETURN", Const, 0},
+ {"SYS_SIGSUSPEND", Const, 0},
+ {"SYS_SIGSUSPEND_NOCANCEL", Const, 0},
+ {"SYS_SIGTIMEDWAIT", Const, 0},
+ {"SYS_SIGWAIT", Const, 0},
+ {"SYS_SIGWAITINFO", Const, 0},
+ {"SYS_SOCKET", Const, 0},
+ {"SYS_SOCKETCALL", Const, 0},
+ {"SYS_SOCKETPAIR", Const, 0},
+ {"SYS_SPLICE", Const, 0},
+ {"SYS_SSETMASK", Const, 0},
+ {"SYS_SSTK", Const, 0},
+ {"SYS_STACK_SNAPSHOT", Const, 0},
+ {"SYS_STAT", Const, 0},
+ {"SYS_STAT64", Const, 0},
+ {"SYS_STAT64_EXTENDED", Const, 0},
+ {"SYS_STATFS", Const, 0},
+ {"SYS_STATFS64", Const, 0},
+ {"SYS_STATV", Const, 0},
+ {"SYS_STATVFS1", Const, 1},
+ {"SYS_STAT_EXTENDED", Const, 0},
+ {"SYS_STIME", Const, 0},
+ {"SYS_STTY", Const, 0},
+ {"SYS_SWAPCONTEXT", Const, 0},
+ {"SYS_SWAPCTL", Const, 1},
+ {"SYS_SWAPOFF", Const, 0},
+ {"SYS_SWAPON", Const, 0},
+ {"SYS_SYMLINK", Const, 0},
+ {"SYS_SYMLINKAT", Const, 0},
+ {"SYS_SYNC", Const, 0},
+ {"SYS_SYNCFS", Const, 0},
+ {"SYS_SYNC_FILE_RANGE", Const, 0},
+ {"SYS_SYSARCH", Const, 0},
+ {"SYS_SYSCALL", Const, 0},
+ {"SYS_SYSCALL_BASE", Const, 0},
+ {"SYS_SYSFS", Const, 0},
+ {"SYS_SYSINFO", Const, 0},
+ {"SYS_SYSLOG", Const, 0},
+ {"SYS_TEE", Const, 0},
+ {"SYS_TGKILL", Const, 0},
+ {"SYS_THREAD_SELFID", Const, 0},
+ {"SYS_THR_CREATE", Const, 0},
+ {"SYS_THR_EXIT", Const, 0},
+ {"SYS_THR_KILL", Const, 0},
+ {"SYS_THR_KILL2", Const, 0},
+ {"SYS_THR_NEW", Const, 0},
+ {"SYS_THR_SELF", Const, 0},
+ {"SYS_THR_SET_NAME", Const, 0},
+ {"SYS_THR_SUSPEND", Const, 0},
+ {"SYS_THR_WAKE", Const, 0},
+ {"SYS_TIME", Const, 0},
+ {"SYS_TIMERFD_CREATE", Const, 0},
+ {"SYS_TIMERFD_GETTIME", Const, 0},
+ {"SYS_TIMERFD_SETTIME", Const, 0},
+ {"SYS_TIMER_CREATE", Const, 0},
+ {"SYS_TIMER_DELETE", Const, 0},
+ {"SYS_TIMER_GETOVERRUN", Const, 0},
+ {"SYS_TIMER_GETTIME", Const, 0},
+ {"SYS_TIMER_SETTIME", Const, 0},
+ {"SYS_TIMES", Const, 0},
+ {"SYS_TKILL", Const, 0},
+ {"SYS_TRUNCATE", Const, 0},
+ {"SYS_TRUNCATE64", Const, 0},
+ {"SYS_TUXCALL", Const, 0},
+ {"SYS_UGETRLIMIT", Const, 0},
+ {"SYS_ULIMIT", Const, 0},
+ {"SYS_UMASK", Const, 0},
+ {"SYS_UMASK_EXTENDED", Const, 0},
+ {"SYS_UMOUNT", Const, 0},
+ {"SYS_UMOUNT2", Const, 0},
+ {"SYS_UNAME", Const, 0},
+ {"SYS_UNDELETE", Const, 0},
+ {"SYS_UNLINK", Const, 0},
+ {"SYS_UNLINKAT", Const, 0},
+ {"SYS_UNMOUNT", Const, 0},
+ {"SYS_UNSHARE", Const, 0},
+ {"SYS_USELIB", Const, 0},
+ {"SYS_USTAT", Const, 0},
+ {"SYS_UTIME", Const, 0},
+ {"SYS_UTIMENSAT", Const, 0},
+ {"SYS_UTIMES", Const, 0},
+ {"SYS_UTRACE", Const, 0},
+ {"SYS_UUIDGEN", Const, 0},
+ {"SYS_VADVISE", Const, 1},
+ {"SYS_VFORK", Const, 0},
+ {"SYS_VHANGUP", Const, 0},
+ {"SYS_VM86", Const, 0},
+ {"SYS_VM86OLD", Const, 0},
+ {"SYS_VMSPLICE", Const, 0},
+ {"SYS_VM_PRESSURE_MONITOR", Const, 0},
+ {"SYS_VSERVER", Const, 0},
+ {"SYS_WAIT4", Const, 0},
+ {"SYS_WAIT4_NOCANCEL", Const, 0},
+ {"SYS_WAIT6", Const, 1},
+ {"SYS_WAITEVENT", Const, 0},
+ {"SYS_WAITID", Const, 0},
+ {"SYS_WAITID_NOCANCEL", Const, 0},
+ {"SYS_WAITPID", Const, 0},
+ {"SYS_WATCHEVENT", Const, 0},
+ {"SYS_WORKQ_KERNRETURN", Const, 0},
+ {"SYS_WORKQ_OPEN", Const, 0},
+ {"SYS_WRITE", Const, 0},
+ {"SYS_WRITEV", Const, 0},
+ {"SYS_WRITEV_NOCANCEL", Const, 0},
+ {"SYS_WRITE_NOCANCEL", Const, 0},
+ {"SYS_YIELD", Const, 0},
+ {"SYS__LLSEEK", Const, 0},
+ {"SYS__LWP_CONTINUE", Const, 1},
+ {"SYS__LWP_CREATE", Const, 1},
+ {"SYS__LWP_CTL", Const, 1},
+ {"SYS__LWP_DETACH", Const, 1},
+ {"SYS__LWP_EXIT", Const, 1},
+ {"SYS__LWP_GETNAME", Const, 1},
+ {"SYS__LWP_GETPRIVATE", Const, 1},
+ {"SYS__LWP_KILL", Const, 1},
+ {"SYS__LWP_PARK", Const, 1},
+ {"SYS__LWP_SELF", Const, 1},
+ {"SYS__LWP_SETNAME", Const, 1},
+ {"SYS__LWP_SETPRIVATE", Const, 1},
+ {"SYS__LWP_SUSPEND", Const, 1},
+ {"SYS__LWP_UNPARK", Const, 1},
+ {"SYS__LWP_UNPARK_ALL", Const, 1},
+ {"SYS__LWP_WAIT", Const, 1},
+ {"SYS__LWP_WAKEUP", Const, 1},
+ {"SYS__NEWSELECT", Const, 0},
+ {"SYS__PSET_BIND", Const, 1},
+ {"SYS__SCHED_GETAFFINITY", Const, 1},
+ {"SYS__SCHED_GETPARAM", Const, 1},
+ {"SYS__SCHED_SETAFFINITY", Const, 1},
+ {"SYS__SCHED_SETPARAM", Const, 1},
+ {"SYS__SYSCTL", Const, 0},
+ {"SYS__UMTX_LOCK", Const, 0},
+ {"SYS__UMTX_OP", Const, 0},
+ {"SYS__UMTX_UNLOCK", Const, 0},
+ {"SYS___ACL_ACLCHECK_FD", Const, 0},
+ {"SYS___ACL_ACLCHECK_FILE", Const, 0},
+ {"SYS___ACL_ACLCHECK_LINK", Const, 0},
+ {"SYS___ACL_DELETE_FD", Const, 0},
+ {"SYS___ACL_DELETE_FILE", Const, 0},
+ {"SYS___ACL_DELETE_LINK", Const, 0},
+ {"SYS___ACL_GET_FD", Const, 0},
+ {"SYS___ACL_GET_FILE", Const, 0},
+ {"SYS___ACL_GET_LINK", Const, 0},
+ {"SYS___ACL_SET_FD", Const, 0},
+ {"SYS___ACL_SET_FILE", Const, 0},
+ {"SYS___ACL_SET_LINK", Const, 0},
+ {"SYS___CAP_RIGHTS_GET", Const, 14},
+ {"SYS___CLONE", Const, 1},
+ {"SYS___DISABLE_THREADSIGNAL", Const, 0},
+ {"SYS___GETCWD", Const, 0},
+ {"SYS___GETLOGIN", Const, 1},
+ {"SYS___GET_TCB", Const, 1},
+ {"SYS___MAC_EXECVE", Const, 0},
+ {"SYS___MAC_GETFSSTAT", Const, 0},
+ {"SYS___MAC_GET_FD", Const, 0},
+ {"SYS___MAC_GET_FILE", Const, 0},
+ {"SYS___MAC_GET_LCID", Const, 0},
+ {"SYS___MAC_GET_LCTX", Const, 0},
+ {"SYS___MAC_GET_LINK", Const, 0},
+ {"SYS___MAC_GET_MOUNT", Const, 0},
+ {"SYS___MAC_GET_PID", Const, 0},
+ {"SYS___MAC_GET_PROC", Const, 0},
+ {"SYS___MAC_MOUNT", Const, 0},
+ {"SYS___MAC_SET_FD", Const, 0},
+ {"SYS___MAC_SET_FILE", Const, 0},
+ {"SYS___MAC_SET_LCTX", Const, 0},
+ {"SYS___MAC_SET_LINK", Const, 0},
+ {"SYS___MAC_SET_PROC", Const, 0},
+ {"SYS___MAC_SYSCALL", Const, 0},
+ {"SYS___OLD_SEMWAIT_SIGNAL", Const, 0},
+ {"SYS___OLD_SEMWAIT_SIGNAL_NOCANCEL", Const, 0},
+ {"SYS___POSIX_CHOWN", Const, 1},
+ {"SYS___POSIX_FCHOWN", Const, 1},
+ {"SYS___POSIX_LCHOWN", Const, 1},
+ {"SYS___POSIX_RENAME", Const, 1},
+ {"SYS___PTHREAD_CANCELED", Const, 0},
+ {"SYS___PTHREAD_CHDIR", Const, 0},
+ {"SYS___PTHREAD_FCHDIR", Const, 0},
+ {"SYS___PTHREAD_KILL", Const, 0},
+ {"SYS___PTHREAD_MARKCANCEL", Const, 0},
+ {"SYS___PTHREAD_SIGMASK", Const, 0},
+ {"SYS___QUOTACTL", Const, 1},
+ {"SYS___SEMCTL", Const, 1},
+ {"SYS___SEMWAIT_SIGNAL", Const, 0},
+ {"SYS___SEMWAIT_SIGNAL_NOCANCEL", Const, 0},
+ {"SYS___SETLOGIN", Const, 1},
+ {"SYS___SETUGID", Const, 0},
+ {"SYS___SET_TCB", Const, 1},
+ {"SYS___SIGACTION_SIGTRAMP", Const, 1},
+ {"SYS___SIGTIMEDWAIT", Const, 1},
+ {"SYS___SIGWAIT", Const, 0},
+ {"SYS___SIGWAIT_NOCANCEL", Const, 0},
+ {"SYS___SYSCTL", Const, 0},
+ {"SYS___TFORK", Const, 1},
+ {"SYS___THREXIT", Const, 1},
+ {"SYS___THRSIGDIVERT", Const, 1},
+ {"SYS___THRSLEEP", Const, 1},
+ {"SYS___THRWAKEUP", Const, 1},
+ {"S_ARCH1", Const, 1},
+ {"S_ARCH2", Const, 1},
+ {"S_BLKSIZE", Const, 0},
+ {"S_IEXEC", Const, 0},
+ {"S_IFBLK", Const, 0},
+ {"S_IFCHR", Const, 0},
+ {"S_IFDIR", Const, 0},
+ {"S_IFIFO", Const, 0},
+ {"S_IFLNK", Const, 0},
+ {"S_IFMT", Const, 0},
+ {"S_IFREG", Const, 0},
+ {"S_IFSOCK", Const, 0},
+ {"S_IFWHT", Const, 0},
+ {"S_IREAD", Const, 0},
+ {"S_IRGRP", Const, 0},
+ {"S_IROTH", Const, 0},
+ {"S_IRUSR", Const, 0},
+ {"S_IRWXG", Const, 0},
+ {"S_IRWXO", Const, 0},
+ {"S_IRWXU", Const, 0},
+ {"S_ISGID", Const, 0},
+ {"S_ISTXT", Const, 0},
+ {"S_ISUID", Const, 0},
+ {"S_ISVTX", Const, 0},
+ {"S_IWGRP", Const, 0},
+ {"S_IWOTH", Const, 0},
+ {"S_IWRITE", Const, 0},
+ {"S_IWUSR", Const, 0},
+ {"S_IXGRP", Const, 0},
+ {"S_IXOTH", Const, 0},
+ {"S_IXUSR", Const, 0},
+ {"S_LOGIN_SET", Const, 1},
+ {"SecurityAttributes", Type, 0},
+ {"SecurityAttributes.InheritHandle", Field, 0},
+ {"SecurityAttributes.Length", Field, 0},
+ {"SecurityAttributes.SecurityDescriptor", Field, 0},
+ {"Seek", Func, 0},
+ {"Select", Func, 0},
+ {"Sendfile", Func, 0},
+ {"Sendmsg", Func, 0},
+ {"SendmsgN", Func, 3},
+ {"Sendto", Func, 0},
+ {"Servent", Type, 0},
+ {"Servent.Aliases", Field, 0},
+ {"Servent.Name", Field, 0},
+ {"Servent.Port", Field, 0},
+ {"Servent.Proto", Field, 0},
+ {"SetBpf", Func, 0},
+ {"SetBpfBuflen", Func, 0},
+ {"SetBpfDatalink", Func, 0},
+ {"SetBpfHeadercmpl", Func, 0},
+ {"SetBpfImmediate", Func, 0},
+ {"SetBpfInterface", Func, 0},
+ {"SetBpfPromisc", Func, 0},
+ {"SetBpfTimeout", Func, 0},
+ {"SetCurrentDirectory", Func, 0},
+ {"SetEndOfFile", Func, 0},
+ {"SetEnvironmentVariable", Func, 0},
+ {"SetFileAttributes", Func, 0},
+ {"SetFileCompletionNotificationModes", Func, 2},
+ {"SetFilePointer", Func, 0},
+ {"SetFileTime", Func, 0},
+ {"SetHandleInformation", Func, 0},
+ {"SetKevent", Func, 0},
+ {"SetLsfPromisc", Func, 0},
+ {"SetNonblock", Func, 0},
+ {"Setdomainname", Func, 0},
+ {"Setegid", Func, 0},
+ {"Setenv", Func, 0},
+ {"Seteuid", Func, 0},
+ {"Setfsgid", Func, 0},
+ {"Setfsuid", Func, 0},
+ {"Setgid", Func, 0},
+ {"Setgroups", Func, 0},
+ {"Sethostname", Func, 0},
+ {"Setlogin", Func, 0},
+ {"Setpgid", Func, 0},
+ {"Setpriority", Func, 0},
+ {"Setprivexec", Func, 0},
+ {"Setregid", Func, 0},
+ {"Setresgid", Func, 0},
+ {"Setresuid", Func, 0},
+ {"Setreuid", Func, 0},
+ {"Setrlimit", Func, 0},
+ {"Setsid", Func, 0},
+ {"Setsockopt", Func, 0},
+ {"SetsockoptByte", Func, 0},
+ {"SetsockoptICMPv6Filter", Func, 2},
+ {"SetsockoptIPMreq", Func, 0},
+ {"SetsockoptIPMreqn", Func, 0},
+ {"SetsockoptIPv6Mreq", Func, 0},
+ {"SetsockoptInet4Addr", Func, 0},
+ {"SetsockoptInt", Func, 0},
+ {"SetsockoptLinger", Func, 0},
+ {"SetsockoptString", Func, 0},
+ {"SetsockoptTimeval", Func, 0},
+ {"Settimeofday", Func, 0},
+ {"Setuid", Func, 0},
+ {"Setxattr", Func, 1},
+ {"Shutdown", Func, 0},
+ {"SidTypeAlias", Const, 0},
+ {"SidTypeComputer", Const, 0},
+ {"SidTypeDeletedAccount", Const, 0},
+ {"SidTypeDomain", Const, 0},
+ {"SidTypeGroup", Const, 0},
+ {"SidTypeInvalid", Const, 0},
+ {"SidTypeLabel", Const, 0},
+ {"SidTypeUnknown", Const, 0},
+ {"SidTypeUser", Const, 0},
+ {"SidTypeWellKnownGroup", Const, 0},
+ {"Signal", Type, 0},
+ {"SizeofBpfHdr", Const, 0},
+ {"SizeofBpfInsn", Const, 0},
+ {"SizeofBpfProgram", Const, 0},
+ {"SizeofBpfStat", Const, 0},
+ {"SizeofBpfVersion", Const, 0},
+ {"SizeofBpfZbuf", Const, 0},
+ {"SizeofBpfZbufHeader", Const, 0},
+ {"SizeofCmsghdr", Const, 0},
+ {"SizeofICMPv6Filter", Const, 2},
+ {"SizeofIPMreq", Const, 0},
+ {"SizeofIPMreqn", Const, 0},
+ {"SizeofIPv6MTUInfo", Const, 2},
+ {"SizeofIPv6Mreq", Const, 0},
+ {"SizeofIfAddrmsg", Const, 0},
+ {"SizeofIfAnnounceMsghdr", Const, 1},
+ {"SizeofIfData", Const, 0},
+ {"SizeofIfInfomsg", Const, 0},
+ {"SizeofIfMsghdr", Const, 0},
+ {"SizeofIfaMsghdr", Const, 0},
+ {"SizeofIfmaMsghdr", Const, 0},
+ {"SizeofIfmaMsghdr2", Const, 0},
+ {"SizeofInet4Pktinfo", Const, 0},
+ {"SizeofInet6Pktinfo", Const, 0},
+ {"SizeofInotifyEvent", Const, 0},
+ {"SizeofLinger", Const, 0},
+ {"SizeofMsghdr", Const, 0},
+ {"SizeofNlAttr", Const, 0},
+ {"SizeofNlMsgerr", Const, 0},
+ {"SizeofNlMsghdr", Const, 0},
+ {"SizeofRtAttr", Const, 0},
+ {"SizeofRtGenmsg", Const, 0},
+ {"SizeofRtMetrics", Const, 0},
+ {"SizeofRtMsg", Const, 0},
+ {"SizeofRtMsghdr", Const, 0},
+ {"SizeofRtNexthop", Const, 0},
+ {"SizeofSockFilter", Const, 0},
+ {"SizeofSockFprog", Const, 0},
+ {"SizeofSockaddrAny", Const, 0},
+ {"SizeofSockaddrDatalink", Const, 0},
+ {"SizeofSockaddrInet4", Const, 0},
+ {"SizeofSockaddrInet6", Const, 0},
+ {"SizeofSockaddrLinklayer", Const, 0},
+ {"SizeofSockaddrNetlink", Const, 0},
+ {"SizeofSockaddrUnix", Const, 0},
+ {"SizeofTCPInfo", Const, 1},
+ {"SizeofUcred", Const, 0},
+ {"SlicePtrFromStrings", Func, 1},
+ {"SockFilter", Type, 0},
+ {"SockFilter.Code", Field, 0},
+ {"SockFilter.Jf", Field, 0},
+ {"SockFilter.Jt", Field, 0},
+ {"SockFilter.K", Field, 0},
+ {"SockFprog", Type, 0},
+ {"SockFprog.Filter", Field, 0},
+ {"SockFprog.Len", Field, 0},
+ {"SockFprog.Pad_cgo_0", Field, 0},
+ {"Sockaddr", Type, 0},
+ {"SockaddrDatalink", Type, 0},
+ {"SockaddrDatalink.Alen", Field, 0},
+ {"SockaddrDatalink.Data", Field, 0},
+ {"SockaddrDatalink.Family", Field, 0},
+ {"SockaddrDatalink.Index", Field, 0},
+ {"SockaddrDatalink.Len", Field, 0},
+ {"SockaddrDatalink.Nlen", Field, 0},
+ {"SockaddrDatalink.Slen", Field, 0},
+ {"SockaddrDatalink.Type", Field, 0},
+ {"SockaddrGen", Type, 0},
+ {"SockaddrInet4", Type, 0},
+ {"SockaddrInet4.Addr", Field, 0},
+ {"SockaddrInet4.Port", Field, 0},
+ {"SockaddrInet6", Type, 0},
+ {"SockaddrInet6.Addr", Field, 0},
+ {"SockaddrInet6.Port", Field, 0},
+ {"SockaddrInet6.ZoneId", Field, 0},
+ {"SockaddrLinklayer", Type, 0},
+ {"SockaddrLinklayer.Addr", Field, 0},
+ {"SockaddrLinklayer.Halen", Field, 0},
+ {"SockaddrLinklayer.Hatype", Field, 0},
+ {"SockaddrLinklayer.Ifindex", Field, 0},
+ {"SockaddrLinklayer.Pkttype", Field, 0},
+ {"SockaddrLinklayer.Protocol", Field, 0},
+ {"SockaddrNetlink", Type, 0},
+ {"SockaddrNetlink.Family", Field, 0},
+ {"SockaddrNetlink.Groups", Field, 0},
+ {"SockaddrNetlink.Pad", Field, 0},
+ {"SockaddrNetlink.Pid", Field, 0},
+ {"SockaddrUnix", Type, 0},
+ {"SockaddrUnix.Name", Field, 0},
+ {"Socket", Func, 0},
+ {"SocketControlMessage", Type, 0},
+ {"SocketControlMessage.Data", Field, 0},
+ {"SocketControlMessage.Header", Field, 0},
+ {"SocketDisableIPv6", Var, 0},
+ {"Socketpair", Func, 0},
+ {"Splice", Func, 0},
+ {"StartProcess", Func, 0},
+ {"StartupInfo", Type, 0},
+ {"StartupInfo.Cb", Field, 0},
+ {"StartupInfo.Desktop", Field, 0},
+ {"StartupInfo.FillAttribute", Field, 0},
+ {"StartupInfo.Flags", Field, 0},
+ {"StartupInfo.ShowWindow", Field, 0},
+ {"StartupInfo.StdErr", Field, 0},
+ {"StartupInfo.StdInput", Field, 0},
+ {"StartupInfo.StdOutput", Field, 0},
+ {"StartupInfo.Title", Field, 0},
+ {"StartupInfo.X", Field, 0},
+ {"StartupInfo.XCountChars", Field, 0},
+ {"StartupInfo.XSize", Field, 0},
+ {"StartupInfo.Y", Field, 0},
+ {"StartupInfo.YCountChars", Field, 0},
+ {"StartupInfo.YSize", Field, 0},
+ {"Stat", Func, 0},
+ {"Stat_t", Type, 0},
+ {"Stat_t.Atim", Field, 0},
+ {"Stat_t.Atim_ext", Field, 12},
+ {"Stat_t.Atimespec", Field, 0},
+ {"Stat_t.Birthtimespec", Field, 0},
+ {"Stat_t.Blksize", Field, 0},
+ {"Stat_t.Blocks", Field, 0},
+ {"Stat_t.Btim_ext", Field, 12},
+ {"Stat_t.Ctim", Field, 0},
+ {"Stat_t.Ctim_ext", Field, 12},
+ {"Stat_t.Ctimespec", Field, 0},
+ {"Stat_t.Dev", Field, 0},
+ {"Stat_t.Flags", Field, 0},
+ {"Stat_t.Gen", Field, 0},
+ {"Stat_t.Gid", Field, 0},
+ {"Stat_t.Ino", Field, 0},
+ {"Stat_t.Lspare", Field, 0},
+ {"Stat_t.Lspare0", Field, 2},
+ {"Stat_t.Lspare1", Field, 2},
+ {"Stat_t.Mode", Field, 0},
+ {"Stat_t.Mtim", Field, 0},
+ {"Stat_t.Mtim_ext", Field, 12},
+ {"Stat_t.Mtimespec", Field, 0},
+ {"Stat_t.Nlink", Field, 0},
+ {"Stat_t.Pad_cgo_0", Field, 0},
+ {"Stat_t.Pad_cgo_1", Field, 0},
+ {"Stat_t.Pad_cgo_2", Field, 0},
+ {"Stat_t.Padding0", Field, 12},
+ {"Stat_t.Padding1", Field, 12},
+ {"Stat_t.Qspare", Field, 0},
+ {"Stat_t.Rdev", Field, 0},
+ {"Stat_t.Size", Field, 0},
+ {"Stat_t.Spare", Field, 2},
+ {"Stat_t.Uid", Field, 0},
+ {"Stat_t.X__pad0", Field, 0},
+ {"Stat_t.X__pad1", Field, 0},
+ {"Stat_t.X__pad2", Field, 0},
+ {"Stat_t.X__st_birthtim", Field, 2},
+ {"Stat_t.X__st_ino", Field, 0},
+ {"Stat_t.X__unused", Field, 0},
+ {"Statfs", Func, 0},
+ {"Statfs_t", Type, 0},
+ {"Statfs_t.Asyncreads", Field, 0},
+ {"Statfs_t.Asyncwrites", Field, 0},
+ {"Statfs_t.Bavail", Field, 0},
+ {"Statfs_t.Bfree", Field, 0},
+ {"Statfs_t.Blocks", Field, 0},
+ {"Statfs_t.Bsize", Field, 0},
+ {"Statfs_t.Charspare", Field, 0},
+ {"Statfs_t.F_asyncreads", Field, 2},
+ {"Statfs_t.F_asyncwrites", Field, 2},
+ {"Statfs_t.F_bavail", Field, 2},
+ {"Statfs_t.F_bfree", Field, 2},
+ {"Statfs_t.F_blocks", Field, 2},
+ {"Statfs_t.F_bsize", Field, 2},
+ {"Statfs_t.F_ctime", Field, 2},
+ {"Statfs_t.F_favail", Field, 2},
+ {"Statfs_t.F_ffree", Field, 2},
+ {"Statfs_t.F_files", Field, 2},
+ {"Statfs_t.F_flags", Field, 2},
+ {"Statfs_t.F_fsid", Field, 2},
+ {"Statfs_t.F_fstypename", Field, 2},
+ {"Statfs_t.F_iosize", Field, 2},
+ {"Statfs_t.F_mntfromname", Field, 2},
+ {"Statfs_t.F_mntfromspec", Field, 3},
+ {"Statfs_t.F_mntonname", Field, 2},
+ {"Statfs_t.F_namemax", Field, 2},
+ {"Statfs_t.F_owner", Field, 2},
+ {"Statfs_t.F_spare", Field, 2},
+ {"Statfs_t.F_syncreads", Field, 2},
+ {"Statfs_t.F_syncwrites", Field, 2},
+ {"Statfs_t.Ffree", Field, 0},
+ {"Statfs_t.Files", Field, 0},
+ {"Statfs_t.Flags", Field, 0},
+ {"Statfs_t.Frsize", Field, 0},
+ {"Statfs_t.Fsid", Field, 0},
+ {"Statfs_t.Fssubtype", Field, 0},
+ {"Statfs_t.Fstypename", Field, 0},
+ {"Statfs_t.Iosize", Field, 0},
+ {"Statfs_t.Mntfromname", Field, 0},
+ {"Statfs_t.Mntonname", Field, 0},
+ {"Statfs_t.Mount_info", Field, 2},
+ {"Statfs_t.Namelen", Field, 0},
+ {"Statfs_t.Namemax", Field, 0},
+ {"Statfs_t.Owner", Field, 0},
+ {"Statfs_t.Pad_cgo_0", Field, 0},
+ {"Statfs_t.Pad_cgo_1", Field, 2},
+ {"Statfs_t.Reserved", Field, 0},
+ {"Statfs_t.Spare", Field, 0},
+ {"Statfs_t.Syncreads", Field, 0},
+ {"Statfs_t.Syncwrites", Field, 0},
+ {"Statfs_t.Type", Field, 0},
+ {"Statfs_t.Version", Field, 0},
+ {"Stderr", Var, 0},
+ {"Stdin", Var, 0},
+ {"Stdout", Var, 0},
+ {"StringBytePtr", Func, 0},
+ {"StringByteSlice", Func, 0},
+ {"StringSlicePtr", Func, 0},
+ {"StringToSid", Func, 0},
+ {"StringToUTF16", Func, 0},
+ {"StringToUTF16Ptr", Func, 0},
+ {"Symlink", Func, 0},
+ {"Sync", Func, 0},
+ {"SyncFileRange", Func, 0},
+ {"SysProcAttr", Type, 0},
+ {"SysProcAttr.AdditionalInheritedHandles", Field, 17},
+ {"SysProcAttr.AmbientCaps", Field, 9},
+ {"SysProcAttr.CgroupFD", Field, 20},
+ {"SysProcAttr.Chroot", Field, 0},
+ {"SysProcAttr.Cloneflags", Field, 2},
+ {"SysProcAttr.CmdLine", Field, 0},
+ {"SysProcAttr.CreationFlags", Field, 1},
+ {"SysProcAttr.Credential", Field, 0},
+ {"SysProcAttr.Ctty", Field, 1},
+ {"SysProcAttr.Foreground", Field, 5},
+ {"SysProcAttr.GidMappings", Field, 4},
+ {"SysProcAttr.GidMappingsEnableSetgroups", Field, 5},
+ {"SysProcAttr.HideWindow", Field, 0},
+ {"SysProcAttr.Jail", Field, 21},
+ {"SysProcAttr.NoInheritHandles", Field, 16},
+ {"SysProcAttr.Noctty", Field, 0},
+ {"SysProcAttr.ParentProcess", Field, 17},
+ {"SysProcAttr.Pdeathsig", Field, 0},
+ {"SysProcAttr.Pgid", Field, 5},
+ {"SysProcAttr.PidFD", Field, 22},
+ {"SysProcAttr.ProcessAttributes", Field, 13},
+ {"SysProcAttr.Ptrace", Field, 0},
+ {"SysProcAttr.Setctty", Field, 0},
+ {"SysProcAttr.Setpgid", Field, 0},
+ {"SysProcAttr.Setsid", Field, 0},
+ {"SysProcAttr.ThreadAttributes", Field, 13},
+ {"SysProcAttr.Token", Field, 10},
+ {"SysProcAttr.UidMappings", Field, 4},
+ {"SysProcAttr.Unshareflags", Field, 7},
+ {"SysProcAttr.UseCgroupFD", Field, 20},
+ {"SysProcIDMap", Type, 4},
+ {"SysProcIDMap.ContainerID", Field, 4},
+ {"SysProcIDMap.HostID", Field, 4},
+ {"SysProcIDMap.Size", Field, 4},
+ {"Syscall", Func, 0},
+ {"Syscall12", Func, 0},
+ {"Syscall15", Func, 0},
+ {"Syscall18", Func, 12},
+ {"Syscall6", Func, 0},
+ {"Syscall9", Func, 0},
+ {"SyscallN", Func, 18},
+ {"Sysctl", Func, 0},
+ {"SysctlUint32", Func, 0},
+ {"Sysctlnode", Type, 2},
+ {"Sysctlnode.Flags", Field, 2},
+ {"Sysctlnode.Name", Field, 2},
+ {"Sysctlnode.Num", Field, 2},
+ {"Sysctlnode.Un", Field, 2},
+ {"Sysctlnode.Ver", Field, 2},
+ {"Sysctlnode.X__rsvd", Field, 2},
+ {"Sysctlnode.X_sysctl_desc", Field, 2},
+ {"Sysctlnode.X_sysctl_func", Field, 2},
+ {"Sysctlnode.X_sysctl_parent", Field, 2},
+ {"Sysctlnode.X_sysctl_size", Field, 2},
+ {"Sysinfo", Func, 0},
+ {"Sysinfo_t", Type, 0},
+ {"Sysinfo_t.Bufferram", Field, 0},
+ {"Sysinfo_t.Freehigh", Field, 0},
+ {"Sysinfo_t.Freeram", Field, 0},
+ {"Sysinfo_t.Freeswap", Field, 0},
+ {"Sysinfo_t.Loads", Field, 0},
+ {"Sysinfo_t.Pad", Field, 0},
+ {"Sysinfo_t.Pad_cgo_0", Field, 0},
+ {"Sysinfo_t.Pad_cgo_1", Field, 0},
+ {"Sysinfo_t.Procs", Field, 0},
+ {"Sysinfo_t.Sharedram", Field, 0},
+ {"Sysinfo_t.Totalhigh", Field, 0},
+ {"Sysinfo_t.Totalram", Field, 0},
+ {"Sysinfo_t.Totalswap", Field, 0},
+ {"Sysinfo_t.Unit", Field, 0},
+ {"Sysinfo_t.Uptime", Field, 0},
+ {"Sysinfo_t.X_f", Field, 0},
+ {"Systemtime", Type, 0},
+ {"Systemtime.Day", Field, 0},
+ {"Systemtime.DayOfWeek", Field, 0},
+ {"Systemtime.Hour", Field, 0},
+ {"Systemtime.Milliseconds", Field, 0},
+ {"Systemtime.Minute", Field, 0},
+ {"Systemtime.Month", Field, 0},
+ {"Systemtime.Second", Field, 0},
+ {"Systemtime.Year", Field, 0},
+ {"TCGETS", Const, 0},
+ {"TCIFLUSH", Const, 1},
+ {"TCIOFLUSH", Const, 1},
+ {"TCOFLUSH", Const, 1},
+ {"TCPInfo", Type, 1},
+ {"TCPInfo.Advmss", Field, 1},
+ {"TCPInfo.Ato", Field, 1},
+ {"TCPInfo.Backoff", Field, 1},
+ {"TCPInfo.Ca_state", Field, 1},
+ {"TCPInfo.Fackets", Field, 1},
+ {"TCPInfo.Last_ack_recv", Field, 1},
+ {"TCPInfo.Last_ack_sent", Field, 1},
+ {"TCPInfo.Last_data_recv", Field, 1},
+ {"TCPInfo.Last_data_sent", Field, 1},
+ {"TCPInfo.Lost", Field, 1},
+ {"TCPInfo.Options", Field, 1},
+ {"TCPInfo.Pad_cgo_0", Field, 1},
+ {"TCPInfo.Pmtu", Field, 1},
+ {"TCPInfo.Probes", Field, 1},
+ {"TCPInfo.Rcv_mss", Field, 1},
+ {"TCPInfo.Rcv_rtt", Field, 1},
+ {"TCPInfo.Rcv_space", Field, 1},
+ {"TCPInfo.Rcv_ssthresh", Field, 1},
+ {"TCPInfo.Reordering", Field, 1},
+ {"TCPInfo.Retrans", Field, 1},
+ {"TCPInfo.Retransmits", Field, 1},
+ {"TCPInfo.Rto", Field, 1},
+ {"TCPInfo.Rtt", Field, 1},
+ {"TCPInfo.Rttvar", Field, 1},
+ {"TCPInfo.Sacked", Field, 1},
+ {"TCPInfo.Snd_cwnd", Field, 1},
+ {"TCPInfo.Snd_mss", Field, 1},
+ {"TCPInfo.Snd_ssthresh", Field, 1},
+ {"TCPInfo.State", Field, 1},
+ {"TCPInfo.Total_retrans", Field, 1},
+ {"TCPInfo.Unacked", Field, 1},
+ {"TCPKeepalive", Type, 3},
+ {"TCPKeepalive.Interval", Field, 3},
+ {"TCPKeepalive.OnOff", Field, 3},
+ {"TCPKeepalive.Time", Field, 3},
+ {"TCP_CA_NAME_MAX", Const, 0},
+ {"TCP_CONGCTL", Const, 1},
+ {"TCP_CONGESTION", Const, 0},
+ {"TCP_CONNECTIONTIMEOUT", Const, 0},
+ {"TCP_CORK", Const, 0},
+ {"TCP_DEFER_ACCEPT", Const, 0},
+ {"TCP_ENABLE_ECN", Const, 16},
+ {"TCP_INFO", Const, 0},
+ {"TCP_KEEPALIVE", Const, 0},
+ {"TCP_KEEPCNT", Const, 0},
+ {"TCP_KEEPIDLE", Const, 0},
+ {"TCP_KEEPINIT", Const, 1},
+ {"TCP_KEEPINTVL", Const, 0},
+ {"TCP_LINGER2", Const, 0},
+ {"TCP_MAXBURST", Const, 0},
+ {"TCP_MAXHLEN", Const, 0},
+ {"TCP_MAXOLEN", Const, 0},
+ {"TCP_MAXSEG", Const, 0},
+ {"TCP_MAXWIN", Const, 0},
+ {"TCP_MAX_SACK", Const, 0},
+ {"TCP_MAX_WINSHIFT", Const, 0},
+ {"TCP_MD5SIG", Const, 0},
+ {"TCP_MD5SIG_MAXKEYLEN", Const, 0},
+ {"TCP_MINMSS", Const, 0},
+ {"TCP_MINMSSOVERLOAD", Const, 0},
+ {"TCP_MSS", Const, 0},
+ {"TCP_NODELAY", Const, 0},
+ {"TCP_NOOPT", Const, 0},
+ {"TCP_NOPUSH", Const, 0},
+ {"TCP_NOTSENT_LOWAT", Const, 16},
+ {"TCP_NSTATES", Const, 1},
+ {"TCP_QUICKACK", Const, 0},
+ {"TCP_RXT_CONNDROPTIME", Const, 0},
+ {"TCP_RXT_FINDROP", Const, 0},
+ {"TCP_SACK_ENABLE", Const, 1},
+ {"TCP_SENDMOREACKS", Const, 16},
+ {"TCP_SYNCNT", Const, 0},
+ {"TCP_VENDOR", Const, 3},
+ {"TCP_WINDOW_CLAMP", Const, 0},
+ {"TCSAFLUSH", Const, 1},
+ {"TCSETS", Const, 0},
+ {"TF_DISCONNECT", Const, 0},
+ {"TF_REUSE_SOCKET", Const, 0},
+ {"TF_USE_DEFAULT_WORKER", Const, 0},
+ {"TF_USE_KERNEL_APC", Const, 0},
+ {"TF_USE_SYSTEM_THREAD", Const, 0},
+ {"TF_WRITE_BEHIND", Const, 0},
+ {"TH32CS_INHERIT", Const, 4},
+ {"TH32CS_SNAPALL", Const, 4},
+ {"TH32CS_SNAPHEAPLIST", Const, 4},
+ {"TH32CS_SNAPMODULE", Const, 4},
+ {"TH32CS_SNAPMODULE32", Const, 4},
+ {"TH32CS_SNAPPROCESS", Const, 4},
+ {"TH32CS_SNAPTHREAD", Const, 4},
+ {"TIME_ZONE_ID_DAYLIGHT", Const, 0},
+ {"TIME_ZONE_ID_STANDARD", Const, 0},
+ {"TIME_ZONE_ID_UNKNOWN", Const, 0},
+ {"TIOCCBRK", Const, 0},
+ {"TIOCCDTR", Const, 0},
+ {"TIOCCONS", Const, 0},
+ {"TIOCDCDTIMESTAMP", Const, 0},
+ {"TIOCDRAIN", Const, 0},
+ {"TIOCDSIMICROCODE", Const, 0},
+ {"TIOCEXCL", Const, 0},
+ {"TIOCEXT", Const, 0},
+ {"TIOCFLAG_CDTRCTS", Const, 1},
+ {"TIOCFLAG_CLOCAL", Const, 1},
+ {"TIOCFLAG_CRTSCTS", Const, 1},
+ {"TIOCFLAG_MDMBUF", Const, 1},
+ {"TIOCFLAG_PPS", Const, 1},
+ {"TIOCFLAG_SOFTCAR", Const, 1},
+ {"TIOCFLUSH", Const, 0},
+ {"TIOCGDEV", Const, 0},
+ {"TIOCGDRAINWAIT", Const, 0},
+ {"TIOCGETA", Const, 0},
+ {"TIOCGETD", Const, 0},
+ {"TIOCGFLAGS", Const, 1},
+ {"TIOCGICOUNT", Const, 0},
+ {"TIOCGLCKTRMIOS", Const, 0},
+ {"TIOCGLINED", Const, 1},
+ {"TIOCGPGRP", Const, 0},
+ {"TIOCGPTN", Const, 0},
+ {"TIOCGQSIZE", Const, 1},
+ {"TIOCGRANTPT", Const, 1},
+ {"TIOCGRS485", Const, 0},
+ {"TIOCGSERIAL", Const, 0},
+ {"TIOCGSID", Const, 0},
+ {"TIOCGSIZE", Const, 1},
+ {"TIOCGSOFTCAR", Const, 0},
+ {"TIOCGTSTAMP", Const, 1},
+ {"TIOCGWINSZ", Const, 0},
+ {"TIOCINQ", Const, 0},
+ {"TIOCIXOFF", Const, 0},
+ {"TIOCIXON", Const, 0},
+ {"TIOCLINUX", Const, 0},
+ {"TIOCMBIC", Const, 0},
+ {"TIOCMBIS", Const, 0},
+ {"TIOCMGDTRWAIT", Const, 0},
+ {"TIOCMGET", Const, 0},
+ {"TIOCMIWAIT", Const, 0},
+ {"TIOCMODG", Const, 0},
+ {"TIOCMODS", Const, 0},
+ {"TIOCMSDTRWAIT", Const, 0},
+ {"TIOCMSET", Const, 0},
+ {"TIOCM_CAR", Const, 0},
+ {"TIOCM_CD", Const, 0},
+ {"TIOCM_CTS", Const, 0},
+ {"TIOCM_DCD", Const, 0},
+ {"TIOCM_DSR", Const, 0},
+ {"TIOCM_DTR", Const, 0},
+ {"TIOCM_LE", Const, 0},
+ {"TIOCM_RI", Const, 0},
+ {"TIOCM_RNG", Const, 0},
+ {"TIOCM_RTS", Const, 0},
+ {"TIOCM_SR", Const, 0},
+ {"TIOCM_ST", Const, 0},
+ {"TIOCNOTTY", Const, 0},
+ {"TIOCNXCL", Const, 0},
+ {"TIOCOUTQ", Const, 0},
+ {"TIOCPKT", Const, 0},
+ {"TIOCPKT_DATA", Const, 0},
+ {"TIOCPKT_DOSTOP", Const, 0},
+ {"TIOCPKT_FLUSHREAD", Const, 0},
+ {"TIOCPKT_FLUSHWRITE", Const, 0},
+ {"TIOCPKT_IOCTL", Const, 0},
+ {"TIOCPKT_NOSTOP", Const, 0},
+ {"TIOCPKT_START", Const, 0},
+ {"TIOCPKT_STOP", Const, 0},
+ {"TIOCPTMASTER", Const, 0},
+ {"TIOCPTMGET", Const, 1},
+ {"TIOCPTSNAME", Const, 1},
+ {"TIOCPTYGNAME", Const, 0},
+ {"TIOCPTYGRANT", Const, 0},
+ {"TIOCPTYUNLK", Const, 0},
+ {"TIOCRCVFRAME", Const, 1},
+ {"TIOCREMOTE", Const, 0},
+ {"TIOCSBRK", Const, 0},
+ {"TIOCSCONS", Const, 0},
+ {"TIOCSCTTY", Const, 0},
+ {"TIOCSDRAINWAIT", Const, 0},
+ {"TIOCSDTR", Const, 0},
+ {"TIOCSERCONFIG", Const, 0},
+ {"TIOCSERGETLSR", Const, 0},
+ {"TIOCSERGETMULTI", Const, 0},
+ {"TIOCSERGSTRUCT", Const, 0},
+ {"TIOCSERGWILD", Const, 0},
+ {"TIOCSERSETMULTI", Const, 0},
+ {"TIOCSERSWILD", Const, 0},
+ {"TIOCSER_TEMT", Const, 0},
+ {"TIOCSETA", Const, 0},
+ {"TIOCSETAF", Const, 0},
+ {"TIOCSETAW", Const, 0},
+ {"TIOCSETD", Const, 0},
+ {"TIOCSFLAGS", Const, 1},
+ {"TIOCSIG", Const, 0},
+ {"TIOCSLCKTRMIOS", Const, 0},
+ {"TIOCSLINED", Const, 1},
+ {"TIOCSPGRP", Const, 0},
+ {"TIOCSPTLCK", Const, 0},
+ {"TIOCSQSIZE", Const, 1},
+ {"TIOCSRS485", Const, 0},
+ {"TIOCSSERIAL", Const, 0},
+ {"TIOCSSIZE", Const, 1},
+ {"TIOCSSOFTCAR", Const, 0},
+ {"TIOCSTART", Const, 0},
+ {"TIOCSTAT", Const, 0},
+ {"TIOCSTI", Const, 0},
+ {"TIOCSTOP", Const, 0},
+ {"TIOCSTSTAMP", Const, 1},
+ {"TIOCSWINSZ", Const, 0},
+ {"TIOCTIMESTAMP", Const, 0},
+ {"TIOCUCNTL", Const, 0},
+ {"TIOCVHANGUP", Const, 0},
+ {"TIOCXMTFRAME", Const, 1},
+ {"TOKEN_ADJUST_DEFAULT", Const, 0},
+ {"TOKEN_ADJUST_GROUPS", Const, 0},
+ {"TOKEN_ADJUST_PRIVILEGES", Const, 0},
+ {"TOKEN_ADJUST_SESSIONID", Const, 11},
+ {"TOKEN_ALL_ACCESS", Const, 0},
+ {"TOKEN_ASSIGN_PRIMARY", Const, 0},
+ {"TOKEN_DUPLICATE", Const, 0},
+ {"TOKEN_EXECUTE", Const, 0},
+ {"TOKEN_IMPERSONATE", Const, 0},
+ {"TOKEN_QUERY", Const, 0},
+ {"TOKEN_QUERY_SOURCE", Const, 0},
+ {"TOKEN_READ", Const, 0},
+ {"TOKEN_WRITE", Const, 0},
+ {"TOSTOP", Const, 0},
+ {"TRUNCATE_EXISTING", Const, 0},
+ {"TUNATTACHFILTER", Const, 0},
+ {"TUNDETACHFILTER", Const, 0},
+ {"TUNGETFEATURES", Const, 0},
+ {"TUNGETIFF", Const, 0},
+ {"TUNGETSNDBUF", Const, 0},
+ {"TUNGETVNETHDRSZ", Const, 0},
+ {"TUNSETDEBUG", Const, 0},
+ {"TUNSETGROUP", Const, 0},
+ {"TUNSETIFF", Const, 0},
+ {"TUNSETLINK", Const, 0},
+ {"TUNSETNOCSUM", Const, 0},
+ {"TUNSETOFFLOAD", Const, 0},
+ {"TUNSETOWNER", Const, 0},
+ {"TUNSETPERSIST", Const, 0},
+ {"TUNSETSNDBUF", Const, 0},
+ {"TUNSETTXFILTER", Const, 0},
+ {"TUNSETVNETHDRSZ", Const, 0},
+ {"Tee", Func, 0},
+ {"TerminateProcess", Func, 0},
+ {"Termios", Type, 0},
+ {"Termios.Cc", Field, 0},
+ {"Termios.Cflag", Field, 0},
+ {"Termios.Iflag", Field, 0},
+ {"Termios.Ispeed", Field, 0},
+ {"Termios.Lflag", Field, 0},
+ {"Termios.Line", Field, 0},
+ {"Termios.Oflag", Field, 0},
+ {"Termios.Ospeed", Field, 0},
+ {"Termios.Pad_cgo_0", Field, 0},
+ {"Tgkill", Func, 0},
+ {"Time", Func, 0},
+ {"Time_t", Type, 0},
+ {"Times", Func, 0},
+ {"Timespec", Type, 0},
+ {"Timespec.Nsec", Field, 0},
+ {"Timespec.Pad_cgo_0", Field, 2},
+ {"Timespec.Sec", Field, 0},
+ {"TimespecToNsec", Func, 0},
+ {"Timeval", Type, 0},
+ {"Timeval.Pad_cgo_0", Field, 0},
+ {"Timeval.Sec", Field, 0},
+ {"Timeval.Usec", Field, 0},
+ {"Timeval32", Type, 0},
+ {"Timeval32.Sec", Field, 0},
+ {"Timeval32.Usec", Field, 0},
+ {"TimevalToNsec", Func, 0},
+ {"Timex", Type, 0},
+ {"Timex.Calcnt", Field, 0},
+ {"Timex.Constant", Field, 0},
+ {"Timex.Errcnt", Field, 0},
+ {"Timex.Esterror", Field, 0},
+ {"Timex.Freq", Field, 0},
+ {"Timex.Jitcnt", Field, 0},
+ {"Timex.Jitter", Field, 0},
+ {"Timex.Maxerror", Field, 0},
+ {"Timex.Modes", Field, 0},
+ {"Timex.Offset", Field, 0},
+ {"Timex.Pad_cgo_0", Field, 0},
+ {"Timex.Pad_cgo_1", Field, 0},
+ {"Timex.Pad_cgo_2", Field, 0},
+ {"Timex.Pad_cgo_3", Field, 0},
+ {"Timex.Ppsfreq", Field, 0},
+ {"Timex.Precision", Field, 0},
+ {"Timex.Shift", Field, 0},
+ {"Timex.Stabil", Field, 0},
+ {"Timex.Status", Field, 0},
+ {"Timex.Stbcnt", Field, 0},
+ {"Timex.Tai", Field, 0},
+ {"Timex.Tick", Field, 0},
+ {"Timex.Time", Field, 0},
+ {"Timex.Tolerance", Field, 0},
+ {"Timezoneinformation", Type, 0},
+ {"Timezoneinformation.Bias", Field, 0},
+ {"Timezoneinformation.DaylightBias", Field, 0},
+ {"Timezoneinformation.DaylightDate", Field, 0},
+ {"Timezoneinformation.DaylightName", Field, 0},
+ {"Timezoneinformation.StandardBias", Field, 0},
+ {"Timezoneinformation.StandardDate", Field, 0},
+ {"Timezoneinformation.StandardName", Field, 0},
+ {"Tms", Type, 0},
+ {"Tms.Cstime", Field, 0},
+ {"Tms.Cutime", Field, 0},
+ {"Tms.Stime", Field, 0},
+ {"Tms.Utime", Field, 0},
+ {"Token", Type, 0},
+ {"TokenAccessInformation", Const, 0},
+ {"TokenAuditPolicy", Const, 0},
+ {"TokenDefaultDacl", Const, 0},
+ {"TokenElevation", Const, 0},
+ {"TokenElevationType", Const, 0},
+ {"TokenGroups", Const, 0},
+ {"TokenGroupsAndPrivileges", Const, 0},
+ {"TokenHasRestrictions", Const, 0},
+ {"TokenImpersonationLevel", Const, 0},
+ {"TokenIntegrityLevel", Const, 0},
+ {"TokenLinkedToken", Const, 0},
+ {"TokenLogonSid", Const, 0},
+ {"TokenMandatoryPolicy", Const, 0},
+ {"TokenOrigin", Const, 0},
+ {"TokenOwner", Const, 0},
+ {"TokenPrimaryGroup", Const, 0},
+ {"TokenPrivileges", Const, 0},
+ {"TokenRestrictedSids", Const, 0},
+ {"TokenSandBoxInert", Const, 0},
+ {"TokenSessionId", Const, 0},
+ {"TokenSessionReference", Const, 0},
+ {"TokenSource", Const, 0},
+ {"TokenStatistics", Const, 0},
+ {"TokenType", Const, 0},
+ {"TokenUIAccess", Const, 0},
+ {"TokenUser", Const, 0},
+ {"TokenVirtualizationAllowed", Const, 0},
+ {"TokenVirtualizationEnabled", Const, 0},
+ {"Tokenprimarygroup", Type, 0},
+ {"Tokenprimarygroup.PrimaryGroup", Field, 0},
+ {"Tokenuser", Type, 0},
+ {"Tokenuser.User", Field, 0},
+ {"TranslateAccountName", Func, 0},
+ {"TranslateName", Func, 0},
+ {"TransmitFile", Func, 0},
+ {"TransmitFileBuffers", Type, 0},
+ {"TransmitFileBuffers.Head", Field, 0},
+ {"TransmitFileBuffers.HeadLength", Field, 0},
+ {"TransmitFileBuffers.Tail", Field, 0},
+ {"TransmitFileBuffers.TailLength", Field, 0},
+ {"Truncate", Func, 0},
+ {"UNIX_PATH_MAX", Const, 12},
+ {"USAGE_MATCH_TYPE_AND", Const, 0},
+ {"USAGE_MATCH_TYPE_OR", Const, 0},
+ {"UTF16FromString", Func, 1},
+ {"UTF16PtrFromString", Func, 1},
+ {"UTF16ToString", Func, 0},
+ {"Ucred", Type, 0},
+ {"Ucred.Gid", Field, 0},
+ {"Ucred.Pid", Field, 0},
+ {"Ucred.Uid", Field, 0},
+ {"Umask", Func, 0},
+ {"Uname", Func, 0},
+ {"Undelete", Func, 0},
+ {"UnixCredentials", Func, 0},
+ {"UnixRights", Func, 0},
+ {"Unlink", Func, 0},
+ {"Unlinkat", Func, 0},
+ {"UnmapViewOfFile", Func, 0},
+ {"Unmount", Func, 0},
+ {"Unsetenv", Func, 4},
+ {"Unshare", Func, 0},
+ {"UserInfo10", Type, 0},
+ {"UserInfo10.Comment", Field, 0},
+ {"UserInfo10.FullName", Field, 0},
+ {"UserInfo10.Name", Field, 0},
+ {"UserInfo10.UsrComment", Field, 0},
+ {"Ustat", Func, 0},
+ {"Ustat_t", Type, 0},
+ {"Ustat_t.Fname", Field, 0},
+ {"Ustat_t.Fpack", Field, 0},
+ {"Ustat_t.Pad_cgo_0", Field, 0},
+ {"Ustat_t.Pad_cgo_1", Field, 0},
+ {"Ustat_t.Tfree", Field, 0},
+ {"Ustat_t.Tinode", Field, 0},
+ {"Utimbuf", Type, 0},
+ {"Utimbuf.Actime", Field, 0},
+ {"Utimbuf.Modtime", Field, 0},
+ {"Utime", Func, 0},
+ {"Utimes", Func, 0},
+ {"UtimesNano", Func, 1},
+ {"Utsname", Type, 0},
+ {"Utsname.Domainname", Field, 0},
+ {"Utsname.Machine", Field, 0},
+ {"Utsname.Nodename", Field, 0},
+ {"Utsname.Release", Field, 0},
+ {"Utsname.Sysname", Field, 0},
+ {"Utsname.Version", Field, 0},
+ {"VDISCARD", Const, 0},
+ {"VDSUSP", Const, 1},
+ {"VEOF", Const, 0},
+ {"VEOL", Const, 0},
+ {"VEOL2", Const, 0},
+ {"VERASE", Const, 0},
+ {"VERASE2", Const, 1},
+ {"VINTR", Const, 0},
+ {"VKILL", Const, 0},
+ {"VLNEXT", Const, 0},
+ {"VMIN", Const, 0},
+ {"VQUIT", Const, 0},
+ {"VREPRINT", Const, 0},
+ {"VSTART", Const, 0},
+ {"VSTATUS", Const, 1},
+ {"VSTOP", Const, 0},
+ {"VSUSP", Const, 0},
+ {"VSWTC", Const, 0},
+ {"VT0", Const, 1},
+ {"VT1", Const, 1},
+ {"VTDLY", Const, 1},
+ {"VTIME", Const, 0},
+ {"VWERASE", Const, 0},
+ {"VirtualLock", Func, 0},
+ {"VirtualUnlock", Func, 0},
+ {"WAIT_ABANDONED", Const, 0},
+ {"WAIT_FAILED", Const, 0},
+ {"WAIT_OBJECT_0", Const, 0},
+ {"WAIT_TIMEOUT", Const, 0},
+ {"WALL", Const, 0},
+ {"WALLSIG", Const, 1},
+ {"WALTSIG", Const, 1},
+ {"WCLONE", Const, 0},
+ {"WCONTINUED", Const, 0},
+ {"WCOREFLAG", Const, 0},
+ {"WEXITED", Const, 0},
+ {"WLINUXCLONE", Const, 0},
+ {"WNOHANG", Const, 0},
+ {"WNOTHREAD", Const, 0},
+ {"WNOWAIT", Const, 0},
+ {"WNOZOMBIE", Const, 1},
+ {"WOPTSCHECKED", Const, 1},
+ {"WORDSIZE", Const, 0},
+ {"WSABuf", Type, 0},
+ {"WSABuf.Buf", Field, 0},
+ {"WSABuf.Len", Field, 0},
+ {"WSACleanup", Func, 0},
+ {"WSADESCRIPTION_LEN", Const, 0},
+ {"WSAData", Type, 0},
+ {"WSAData.Description", Field, 0},
+ {"WSAData.HighVersion", Field, 0},
+ {"WSAData.MaxSockets", Field, 0},
+ {"WSAData.MaxUdpDg", Field, 0},
+ {"WSAData.SystemStatus", Field, 0},
+ {"WSAData.VendorInfo", Field, 0},
+ {"WSAData.Version", Field, 0},
+ {"WSAEACCES", Const, 2},
+ {"WSAECONNABORTED", Const, 9},
+ {"WSAECONNRESET", Const, 3},
+ {"WSAENOPROTOOPT", Const, 23},
+ {"WSAEnumProtocols", Func, 2},
+ {"WSAID_CONNECTEX", Var, 1},
+ {"WSAIoctl", Func, 0},
+ {"WSAPROTOCOL_LEN", Const, 2},
+ {"WSAProtocolChain", Type, 2},
+ {"WSAProtocolChain.ChainEntries", Field, 2},
+ {"WSAProtocolChain.ChainLen", Field, 2},
+ {"WSAProtocolInfo", Type, 2},
+ {"WSAProtocolInfo.AddressFamily", Field, 2},
+ {"WSAProtocolInfo.CatalogEntryId", Field, 2},
+ {"WSAProtocolInfo.MaxSockAddr", Field, 2},
+ {"WSAProtocolInfo.MessageSize", Field, 2},
+ {"WSAProtocolInfo.MinSockAddr", Field, 2},
+ {"WSAProtocolInfo.NetworkByteOrder", Field, 2},
+ {"WSAProtocolInfo.Protocol", Field, 2},
+ {"WSAProtocolInfo.ProtocolChain", Field, 2},
+ {"WSAProtocolInfo.ProtocolMaxOffset", Field, 2},
+ {"WSAProtocolInfo.ProtocolName", Field, 2},
+ {"WSAProtocolInfo.ProviderFlags", Field, 2},
+ {"WSAProtocolInfo.ProviderId", Field, 2},
+ {"WSAProtocolInfo.ProviderReserved", Field, 2},
+ {"WSAProtocolInfo.SecurityScheme", Field, 2},
+ {"WSAProtocolInfo.ServiceFlags1", Field, 2},
+ {"WSAProtocolInfo.ServiceFlags2", Field, 2},
+ {"WSAProtocolInfo.ServiceFlags3", Field, 2},
+ {"WSAProtocolInfo.ServiceFlags4", Field, 2},
+ {"WSAProtocolInfo.SocketType", Field, 2},
+ {"WSAProtocolInfo.Version", Field, 2},
+ {"WSARecv", Func, 0},
+ {"WSARecvFrom", Func, 0},
+ {"WSASYS_STATUS_LEN", Const, 0},
+ {"WSASend", Func, 0},
+ {"WSASendTo", Func, 0},
+ {"WSASendto", Func, 0},
+ {"WSAStartup", Func, 0},
+ {"WSTOPPED", Const, 0},
+ {"WTRAPPED", Const, 1},
+ {"WUNTRACED", Const, 0},
+ {"Wait4", Func, 0},
+ {"WaitForSingleObject", Func, 0},
+ {"WaitStatus", Type, 0},
+ {"WaitStatus.ExitCode", Field, 0},
+ {"Win32FileAttributeData", Type, 0},
+ {"Win32FileAttributeData.CreationTime", Field, 0},
+ {"Win32FileAttributeData.FileAttributes", Field, 0},
+ {"Win32FileAttributeData.FileSizeHigh", Field, 0},
+ {"Win32FileAttributeData.FileSizeLow", Field, 0},
+ {"Win32FileAttributeData.LastAccessTime", Field, 0},
+ {"Win32FileAttributeData.LastWriteTime", Field, 0},
+ {"Win32finddata", Type, 0},
+ {"Win32finddata.AlternateFileName", Field, 0},
+ {"Win32finddata.CreationTime", Field, 0},
+ {"Win32finddata.FileAttributes", Field, 0},
+ {"Win32finddata.FileName", Field, 0},
+ {"Win32finddata.FileSizeHigh", Field, 0},
+ {"Win32finddata.FileSizeLow", Field, 0},
+ {"Win32finddata.LastAccessTime", Field, 0},
+ {"Win32finddata.LastWriteTime", Field, 0},
+ {"Win32finddata.Reserved0", Field, 0},
+ {"Win32finddata.Reserved1", Field, 0},
+ {"Write", Func, 0},
+ {"WriteConsole", Func, 1},
+ {"WriteFile", Func, 0},
+ {"X509_ASN_ENCODING", Const, 0},
+ {"XCASE", Const, 0},
+ {"XP1_CONNECTIONLESS", Const, 2},
+ {"XP1_CONNECT_DATA", Const, 2},
+ {"XP1_DISCONNECT_DATA", Const, 2},
+ {"XP1_EXPEDITED_DATA", Const, 2},
+ {"XP1_GRACEFUL_CLOSE", Const, 2},
+ {"XP1_GUARANTEED_DELIVERY", Const, 2},
+ {"XP1_GUARANTEED_ORDER", Const, 2},
+ {"XP1_IFS_HANDLES", Const, 2},
+ {"XP1_MESSAGE_ORIENTED", Const, 2},
+ {"XP1_MULTIPOINT_CONTROL_PLANE", Const, 2},
+ {"XP1_MULTIPOINT_DATA_PLANE", Const, 2},
+ {"XP1_PARTIAL_MESSAGE", Const, 2},
+ {"XP1_PSEUDO_STREAM", Const, 2},
+ {"XP1_QOS_SUPPORTED", Const, 2},
+ {"XP1_SAN_SUPPORT_SDP", Const, 2},
+ {"XP1_SUPPORT_BROADCAST", Const, 2},
+ {"XP1_SUPPORT_MULTIPOINT", Const, 2},
+ {"XP1_UNI_RECV", Const, 2},
+ {"XP1_UNI_SEND", Const, 2},
+ },
+ "syscall/js": {
+ {"CopyBytesToGo", Func, 0},
+ {"CopyBytesToJS", Func, 0},
+ {"Error", Type, 0},
+ {"Func", Type, 0},
+ {"FuncOf", Func, 0},
+ {"Global", Func, 0},
+ {"Null", Func, 0},
+ {"Type", Type, 0},
+ {"TypeBoolean", Const, 0},
+ {"TypeFunction", Const, 0},
+ {"TypeNull", Const, 0},
+ {"TypeNumber", Const, 0},
+ {"TypeObject", Const, 0},
+ {"TypeString", Const, 0},
+ {"TypeSymbol", Const, 0},
+ {"TypeUndefined", Const, 0},
+ {"Undefined", Func, 0},
+ {"Value", Type, 0},
+ {"ValueError", Type, 0},
+ {"ValueOf", Func, 0},
+ },
+ "testing": {
+ {"(*B).Cleanup", Method, 14},
+ {"(*B).Elapsed", Method, 20},
+ {"(*B).Error", Method, 0},
+ {"(*B).Errorf", Method, 0},
+ {"(*B).Fail", Method, 0},
+ {"(*B).FailNow", Method, 0},
+ {"(*B).Failed", Method, 0},
+ {"(*B).Fatal", Method, 0},
+ {"(*B).Fatalf", Method, 0},
+ {"(*B).Helper", Method, 9},
+ {"(*B).Log", Method, 0},
+ {"(*B).Logf", Method, 0},
+ {"(*B).Name", Method, 8},
+ {"(*B).ReportAllocs", Method, 1},
+ {"(*B).ReportMetric", Method, 13},
+ {"(*B).ResetTimer", Method, 0},
+ {"(*B).Run", Method, 7},
+ {"(*B).RunParallel", Method, 3},
+ {"(*B).SetBytes", Method, 0},
+ {"(*B).SetParallelism", Method, 3},
+ {"(*B).Setenv", Method, 17},
+ {"(*B).Skip", Method, 1},
+ {"(*B).SkipNow", Method, 1},
+ {"(*B).Skipf", Method, 1},
+ {"(*B).Skipped", Method, 1},
+ {"(*B).StartTimer", Method, 0},
+ {"(*B).StopTimer", Method, 0},
+ {"(*B).TempDir", Method, 15},
+ {"(*F).Add", Method, 18},
+ {"(*F).Cleanup", Method, 18},
+ {"(*F).Error", Method, 18},
+ {"(*F).Errorf", Method, 18},
+ {"(*F).Fail", Method, 18},
+ {"(*F).FailNow", Method, 18},
+ {"(*F).Failed", Method, 18},
+ {"(*F).Fatal", Method, 18},
+ {"(*F).Fatalf", Method, 18},
+ {"(*F).Fuzz", Method, 18},
+ {"(*F).Helper", Method, 18},
+ {"(*F).Log", Method, 18},
+ {"(*F).Logf", Method, 18},
+ {"(*F).Name", Method, 18},
+ {"(*F).Setenv", Method, 18},
+ {"(*F).Skip", Method, 18},
+ {"(*F).SkipNow", Method, 18},
+ {"(*F).Skipf", Method, 18},
+ {"(*F).Skipped", Method, 18},
+ {"(*F).TempDir", Method, 18},
+ {"(*M).Run", Method, 4},
+ {"(*PB).Next", Method, 3},
+ {"(*T).Cleanup", Method, 14},
+ {"(*T).Deadline", Method, 15},
+ {"(*T).Error", Method, 0},
+ {"(*T).Errorf", Method, 0},
+ {"(*T).Fail", Method, 0},
+ {"(*T).FailNow", Method, 0},
+ {"(*T).Failed", Method, 0},
+ {"(*T).Fatal", Method, 0},
+ {"(*T).Fatalf", Method, 0},
+ {"(*T).Helper", Method, 9},
+ {"(*T).Log", Method, 0},
+ {"(*T).Logf", Method, 0},
+ {"(*T).Name", Method, 8},
+ {"(*T).Parallel", Method, 0},
+ {"(*T).Run", Method, 7},
+ {"(*T).Setenv", Method, 17},
+ {"(*T).Skip", Method, 1},
+ {"(*T).SkipNow", Method, 1},
+ {"(*T).Skipf", Method, 1},
+ {"(*T).Skipped", Method, 1},
+ {"(*T).TempDir", Method, 15},
+ {"(BenchmarkResult).AllocedBytesPerOp", Method, 1},
+ {"(BenchmarkResult).AllocsPerOp", Method, 1},
+ {"(BenchmarkResult).MemString", Method, 1},
+ {"(BenchmarkResult).NsPerOp", Method, 0},
+ {"(BenchmarkResult).String", Method, 0},
+ {"AllocsPerRun", Func, 1},
+ {"B", Type, 0},
+ {"B.N", Field, 0},
+ {"Benchmark", Func, 0},
+ {"BenchmarkResult", Type, 0},
+ {"BenchmarkResult.Bytes", Field, 0},
+ {"BenchmarkResult.Extra", Field, 13},
+ {"BenchmarkResult.MemAllocs", Field, 1},
+ {"BenchmarkResult.MemBytes", Field, 1},
+ {"BenchmarkResult.N", Field, 0},
+ {"BenchmarkResult.T", Field, 0},
+ {"Cover", Type, 2},
+ {"Cover.Blocks", Field, 2},
+ {"Cover.Counters", Field, 2},
+ {"Cover.CoveredPackages", Field, 2},
+ {"Cover.Mode", Field, 2},
+ {"CoverBlock", Type, 2},
+ {"CoverBlock.Col0", Field, 2},
+ {"CoverBlock.Col1", Field, 2},
+ {"CoverBlock.Line0", Field, 2},
+ {"CoverBlock.Line1", Field, 2},
+ {"CoverBlock.Stmts", Field, 2},
+ {"CoverMode", Func, 8},
+ {"Coverage", Func, 4},
+ {"F", Type, 18},
+ {"Init", Func, 13},
+ {"InternalBenchmark", Type, 0},
+ {"InternalBenchmark.F", Field, 0},
+ {"InternalBenchmark.Name", Field, 0},
+ {"InternalExample", Type, 0},
+ {"InternalExample.F", Field, 0},
+ {"InternalExample.Name", Field, 0},
+ {"InternalExample.Output", Field, 0},
+ {"InternalExample.Unordered", Field, 7},
+ {"InternalFuzzTarget", Type, 18},
+ {"InternalFuzzTarget.Fn", Field, 18},
+ {"InternalFuzzTarget.Name", Field, 18},
+ {"InternalTest", Type, 0},
+ {"InternalTest.F", Field, 0},
+ {"InternalTest.Name", Field, 0},
+ {"M", Type, 4},
+ {"Main", Func, 0},
+ {"MainStart", Func, 4},
+ {"PB", Type, 3},
+ {"RegisterCover", Func, 2},
+ {"RunBenchmarks", Func, 0},
+ {"RunExamples", Func, 0},
+ {"RunTests", Func, 0},
+ {"Short", Func, 0},
+ {"T", Type, 0},
+ {"TB", Type, 2},
+ {"Testing", Func, 21},
+ {"Verbose", Func, 1},
+ },
+ "testing/fstest": {
+ {"(MapFS).Glob", Method, 16},
+ {"(MapFS).Open", Method, 16},
+ {"(MapFS).ReadDir", Method, 16},
+ {"(MapFS).ReadFile", Method, 16},
+ {"(MapFS).Stat", Method, 16},
+ {"(MapFS).Sub", Method, 16},
+ {"MapFS", Type, 16},
+ {"MapFile", Type, 16},
+ {"MapFile.Data", Field, 16},
+ {"MapFile.ModTime", Field, 16},
+ {"MapFile.Mode", Field, 16},
+ {"MapFile.Sys", Field, 16},
+ {"TestFS", Func, 16},
+ },
+ "testing/iotest": {
+ {"DataErrReader", Func, 0},
+ {"ErrReader", Func, 16},
+ {"ErrTimeout", Var, 0},
+ {"HalfReader", Func, 0},
+ {"NewReadLogger", Func, 0},
+ {"NewWriteLogger", Func, 0},
+ {"OneByteReader", Func, 0},
+ {"TestReader", Func, 16},
+ {"TimeoutReader", Func, 0},
+ {"TruncateWriter", Func, 0},
+ },
+ "testing/quick": {
+ {"(*CheckEqualError).Error", Method, 0},
+ {"(*CheckError).Error", Method, 0},
+ {"(SetupError).Error", Method, 0},
+ {"Check", Func, 0},
+ {"CheckEqual", Func, 0},
+ {"CheckEqualError", Type, 0},
+ {"CheckEqualError.CheckError", Field, 0},
+ {"CheckEqualError.Out1", Field, 0},
+ {"CheckEqualError.Out2", Field, 0},
+ {"CheckError", Type, 0},
+ {"CheckError.Count", Field, 0},
+ {"CheckError.In", Field, 0},
+ {"Config", Type, 0},
+ {"Config.MaxCount", Field, 0},
+ {"Config.MaxCountScale", Field, 0},
+ {"Config.Rand", Field, 0},
+ {"Config.Values", Field, 0},
+ {"Generator", Type, 0},
+ {"SetupError", Type, 0},
+ {"Value", Func, 0},
+ },
+ "testing/slogtest": {
+ {"Run", Func, 22},
+ {"TestHandler", Func, 21},
+ },
+ "text/scanner": {
+ {"(*Position).IsValid", Method, 0},
+ {"(*Scanner).Init", Method, 0},
+ {"(*Scanner).IsValid", Method, 0},
+ {"(*Scanner).Next", Method, 0},
+ {"(*Scanner).Peek", Method, 0},
+ {"(*Scanner).Pos", Method, 0},
+ {"(*Scanner).Scan", Method, 0},
+ {"(*Scanner).TokenText", Method, 0},
+ {"(Position).String", Method, 0},
+ {"(Scanner).String", Method, 0},
+ {"Char", Const, 0},
+ {"Comment", Const, 0},
+ {"EOF", Const, 0},
+ {"Float", Const, 0},
+ {"GoTokens", Const, 0},
+ {"GoWhitespace", Const, 0},
+ {"Ident", Const, 0},
+ {"Int", Const, 0},
+ {"Position", Type, 0},
+ {"Position.Column", Field, 0},
+ {"Position.Filename", Field, 0},
+ {"Position.Line", Field, 0},
+ {"Position.Offset", Field, 0},
+ {"RawString", Const, 0},
+ {"ScanChars", Const, 0},
+ {"ScanComments", Const, 0},
+ {"ScanFloats", Const, 0},
+ {"ScanIdents", Const, 0},
+ {"ScanInts", Const, 0},
+ {"ScanRawStrings", Const, 0},
+ {"ScanStrings", Const, 0},
+ {"Scanner", Type, 0},
+ {"Scanner.Error", Field, 0},
+ {"Scanner.ErrorCount", Field, 0},
+ {"Scanner.IsIdentRune", Field, 4},
+ {"Scanner.Mode", Field, 0},
+ {"Scanner.Position", Field, 0},
+ {"Scanner.Whitespace", Field, 0},
+ {"SkipComments", Const, 0},
+ {"String", Const, 0},
+ {"TokenString", Func, 0},
+ },
+ "text/tabwriter": {
+ {"(*Writer).Flush", Method, 0},
+ {"(*Writer).Init", Method, 0},
+ {"(*Writer).Write", Method, 0},
+ {"AlignRight", Const, 0},
+ {"Debug", Const, 0},
+ {"DiscardEmptyColumns", Const, 0},
+ {"Escape", Const, 0},
+ {"FilterHTML", Const, 0},
+ {"NewWriter", Func, 0},
+ {"StripEscape", Const, 0},
+ {"TabIndent", Const, 0},
+ {"Writer", Type, 0},
+ },
+ "text/template": {
+ {"(*Template).AddParseTree", Method, 0},
+ {"(*Template).Clone", Method, 0},
+ {"(*Template).DefinedTemplates", Method, 5},
+ {"(*Template).Delims", Method, 0},
+ {"(*Template).Execute", Method, 0},
+ {"(*Template).ExecuteTemplate", Method, 0},
+ {"(*Template).Funcs", Method, 0},
+ {"(*Template).Lookup", Method, 0},
+ {"(*Template).Name", Method, 0},
+ {"(*Template).New", Method, 0},
+ {"(*Template).Option", Method, 5},
+ {"(*Template).Parse", Method, 0},
+ {"(*Template).ParseFS", Method, 16},
+ {"(*Template).ParseFiles", Method, 0},
+ {"(*Template).ParseGlob", Method, 0},
+ {"(*Template).Templates", Method, 0},
+ {"(ExecError).Error", Method, 6},
+ {"(ExecError).Unwrap", Method, 13},
+ {"(Template).Copy", Method, 2},
+ {"(Template).ErrorContext", Method, 1},
+ {"ExecError", Type, 6},
+ {"ExecError.Err", Field, 6},
+ {"ExecError.Name", Field, 6},
+ {"FuncMap", Type, 0},
+ {"HTMLEscape", Func, 0},
+ {"HTMLEscapeString", Func, 0},
+ {"HTMLEscaper", Func, 0},
+ {"IsTrue", Func, 6},
+ {"JSEscape", Func, 0},
+ {"JSEscapeString", Func, 0},
+ {"JSEscaper", Func, 0},
+ {"Must", Func, 0},
+ {"New", Func, 0},
+ {"ParseFS", Func, 16},
+ {"ParseFiles", Func, 0},
+ {"ParseGlob", Func, 0},
+ {"Template", Type, 0},
+ {"Template.Tree", Field, 0},
+ {"URLQueryEscaper", Func, 0},
+ },
+ "text/template/parse": {
+ {"(*ActionNode).Copy", Method, 0},
+ {"(*ActionNode).String", Method, 0},
+ {"(*BoolNode).Copy", Method, 0},
+ {"(*BoolNode).String", Method, 0},
+ {"(*BranchNode).Copy", Method, 4},
+ {"(*BranchNode).String", Method, 0},
+ {"(*BreakNode).Copy", Method, 18},
+ {"(*BreakNode).String", Method, 18},
+ {"(*ChainNode).Add", Method, 1},
+ {"(*ChainNode).Copy", Method, 1},
+ {"(*ChainNode).String", Method, 1},
+ {"(*CommandNode).Copy", Method, 0},
+ {"(*CommandNode).String", Method, 0},
+ {"(*CommentNode).Copy", Method, 16},
+ {"(*CommentNode).String", Method, 16},
+ {"(*ContinueNode).Copy", Method, 18},
+ {"(*ContinueNode).String", Method, 18},
+ {"(*DotNode).Copy", Method, 0},
+ {"(*DotNode).String", Method, 0},
+ {"(*DotNode).Type", Method, 0},
+ {"(*FieldNode).Copy", Method, 0},
+ {"(*FieldNode).String", Method, 0},
+ {"(*IdentifierNode).Copy", Method, 0},
+ {"(*IdentifierNode).SetPos", Method, 1},
+ {"(*IdentifierNode).SetTree", Method, 4},
+ {"(*IdentifierNode).String", Method, 0},
+ {"(*IfNode).Copy", Method, 0},
+ {"(*IfNode).String", Method, 0},
+ {"(*ListNode).Copy", Method, 0},
+ {"(*ListNode).CopyList", Method, 0},
+ {"(*ListNode).String", Method, 0},
+ {"(*NilNode).Copy", Method, 1},
+ {"(*NilNode).String", Method, 1},
+ {"(*NilNode).Type", Method, 1},
+ {"(*NumberNode).Copy", Method, 0},
+ {"(*NumberNode).String", Method, 0},
+ {"(*PipeNode).Copy", Method, 0},
+ {"(*PipeNode).CopyPipe", Method, 0},
+ {"(*PipeNode).String", Method, 0},
+ {"(*RangeNode).Copy", Method, 0},
+ {"(*RangeNode).String", Method, 0},
+ {"(*StringNode).Copy", Method, 0},
+ {"(*StringNode).String", Method, 0},
+ {"(*TemplateNode).Copy", Method, 0},
+ {"(*TemplateNode).String", Method, 0},
+ {"(*TextNode).Copy", Method, 0},
+ {"(*TextNode).String", Method, 0},
+ {"(*Tree).Copy", Method, 2},
+ {"(*Tree).ErrorContext", Method, 1},
+ {"(*Tree).Parse", Method, 0},
+ {"(*VariableNode).Copy", Method, 0},
+ {"(*VariableNode).String", Method, 0},
+ {"(*WithNode).Copy", Method, 0},
+ {"(*WithNode).String", Method, 0},
+ {"(ActionNode).Position", Method, 1},
+ {"(ActionNode).Type", Method, 0},
+ {"(BoolNode).Position", Method, 1},
+ {"(BoolNode).Type", Method, 0},
+ {"(BranchNode).Position", Method, 1},
+ {"(BranchNode).Type", Method, 0},
+ {"(BreakNode).Position", Method, 18},
+ {"(BreakNode).Type", Method, 18},
+ {"(ChainNode).Position", Method, 1},
+ {"(ChainNode).Type", Method, 1},
+ {"(CommandNode).Position", Method, 1},
+ {"(CommandNode).Type", Method, 0},
+ {"(CommentNode).Position", Method, 16},
+ {"(CommentNode).Type", Method, 16},
+ {"(ContinueNode).Position", Method, 18},
+ {"(ContinueNode).Type", Method, 18},
+ {"(DotNode).Position", Method, 1},
+ {"(FieldNode).Position", Method, 1},
+ {"(FieldNode).Type", Method, 0},
+ {"(IdentifierNode).Position", Method, 1},
+ {"(IdentifierNode).Type", Method, 0},
+ {"(IfNode).Position", Method, 1},
+ {"(IfNode).Type", Method, 0},
+ {"(ListNode).Position", Method, 1},
+ {"(ListNode).Type", Method, 0},
+ {"(NilNode).Position", Method, 1},
+ {"(NodeType).Type", Method, 0},
+ {"(NumberNode).Position", Method, 1},
+ {"(NumberNode).Type", Method, 0},
+ {"(PipeNode).Position", Method, 1},
+ {"(PipeNode).Type", Method, 0},
+ {"(Pos).Position", Method, 1},
+ {"(RangeNode).Position", Method, 1},
+ {"(RangeNode).Type", Method, 0},
+ {"(StringNode).Position", Method, 1},
+ {"(StringNode).Type", Method, 0},
+ {"(TemplateNode).Position", Method, 1},
+ {"(TemplateNode).Type", Method, 0},
+ {"(TextNode).Position", Method, 1},
+ {"(TextNode).Type", Method, 0},
+ {"(VariableNode).Position", Method, 1},
+ {"(VariableNode).Type", Method, 0},
+ {"(WithNode).Position", Method, 1},
+ {"(WithNode).Type", Method, 0},
+ {"ActionNode", Type, 0},
+ {"ActionNode.Line", Field, 0},
+ {"ActionNode.NodeType", Field, 0},
+ {"ActionNode.Pipe", Field, 0},
+ {"ActionNode.Pos", Field, 1},
+ {"BoolNode", Type, 0},
+ {"BoolNode.NodeType", Field, 0},
+ {"BoolNode.Pos", Field, 1},
+ {"BoolNode.True", Field, 0},
+ {"BranchNode", Type, 0},
+ {"BranchNode.ElseList", Field, 0},
+ {"BranchNode.Line", Field, 0},
+ {"BranchNode.List", Field, 0},
+ {"BranchNode.NodeType", Field, 0},
+ {"BranchNode.Pipe", Field, 0},
+ {"BranchNode.Pos", Field, 1},
+ {"BreakNode", Type, 18},
+ {"BreakNode.Line", Field, 18},
+ {"BreakNode.NodeType", Field, 18},
+ {"BreakNode.Pos", Field, 18},
+ {"ChainNode", Type, 1},
+ {"ChainNode.Field", Field, 1},
+ {"ChainNode.Node", Field, 1},
+ {"ChainNode.NodeType", Field, 1},
+ {"ChainNode.Pos", Field, 1},
+ {"CommandNode", Type, 0},
+ {"CommandNode.Args", Field, 0},
+ {"CommandNode.NodeType", Field, 0},
+ {"CommandNode.Pos", Field, 1},
+ {"CommentNode", Type, 16},
+ {"CommentNode.NodeType", Field, 16},
+ {"CommentNode.Pos", Field, 16},
+ {"CommentNode.Text", Field, 16},
+ {"ContinueNode", Type, 18},
+ {"ContinueNode.Line", Field, 18},
+ {"ContinueNode.NodeType", Field, 18},
+ {"ContinueNode.Pos", Field, 18},
+ {"DotNode", Type, 0},
+ {"DotNode.NodeType", Field, 4},
+ {"DotNode.Pos", Field, 1},
+ {"FieldNode", Type, 0},
+ {"FieldNode.Ident", Field, 0},
+ {"FieldNode.NodeType", Field, 0},
+ {"FieldNode.Pos", Field, 1},
+ {"IdentifierNode", Type, 0},
+ {"IdentifierNode.Ident", Field, 0},
+ {"IdentifierNode.NodeType", Field, 0},
+ {"IdentifierNode.Pos", Field, 1},
+ {"IfNode", Type, 0},
+ {"IfNode.BranchNode", Field, 0},
+ {"IsEmptyTree", Func, 0},
+ {"ListNode", Type, 0},
+ {"ListNode.NodeType", Field, 0},
+ {"ListNode.Nodes", Field, 0},
+ {"ListNode.Pos", Field, 1},
+ {"Mode", Type, 16},
+ {"New", Func, 0},
+ {"NewIdentifier", Func, 0},
+ {"NilNode", Type, 1},
+ {"NilNode.NodeType", Field, 4},
+ {"NilNode.Pos", Field, 1},
+ {"Node", Type, 0},
+ {"NodeAction", Const, 0},
+ {"NodeBool", Const, 0},
+ {"NodeBreak", Const, 18},
+ {"NodeChain", Const, 1},
+ {"NodeCommand", Const, 0},
+ {"NodeComment", Const, 16},
+ {"NodeContinue", Const, 18},
+ {"NodeDot", Const, 0},
+ {"NodeField", Const, 0},
+ {"NodeIdentifier", Const, 0},
+ {"NodeIf", Const, 0},
+ {"NodeList", Const, 0},
+ {"NodeNil", Const, 1},
+ {"NodeNumber", Const, 0},
+ {"NodePipe", Const, 0},
+ {"NodeRange", Const, 0},
+ {"NodeString", Const, 0},
+ {"NodeTemplate", Const, 0},
+ {"NodeText", Const, 0},
+ {"NodeType", Type, 0},
+ {"NodeVariable", Const, 0},
+ {"NodeWith", Const, 0},
+ {"NumberNode", Type, 0},
+ {"NumberNode.Complex128", Field, 0},
+ {"NumberNode.Float64", Field, 0},
+ {"NumberNode.Int64", Field, 0},
+ {"NumberNode.IsComplex", Field, 0},
+ {"NumberNode.IsFloat", Field, 0},
+ {"NumberNode.IsInt", Field, 0},
+ {"NumberNode.IsUint", Field, 0},
+ {"NumberNode.NodeType", Field, 0},
+ {"NumberNode.Pos", Field, 1},
+ {"NumberNode.Text", Field, 0},
+ {"NumberNode.Uint64", Field, 0},
+ {"Parse", Func, 0},
+ {"ParseComments", Const, 16},
+ {"PipeNode", Type, 0},
+ {"PipeNode.Cmds", Field, 0},
+ {"PipeNode.Decl", Field, 0},
+ {"PipeNode.IsAssign", Field, 11},
+ {"PipeNode.Line", Field, 0},
+ {"PipeNode.NodeType", Field, 0},
+ {"PipeNode.Pos", Field, 1},
+ {"Pos", Type, 1},
+ {"RangeNode", Type, 0},
+ {"RangeNode.BranchNode", Field, 0},
+ {"SkipFuncCheck", Const, 17},
+ {"StringNode", Type, 0},
+ {"StringNode.NodeType", Field, 0},
+ {"StringNode.Pos", Field, 1},
+ {"StringNode.Quoted", Field, 0},
+ {"StringNode.Text", Field, 0},
+ {"TemplateNode", Type, 0},
+ {"TemplateNode.Line", Field, 0},
+ {"TemplateNode.Name", Field, 0},
+ {"TemplateNode.NodeType", Field, 0},
+ {"TemplateNode.Pipe", Field, 0},
+ {"TemplateNode.Pos", Field, 1},
+ {"TextNode", Type, 0},
+ {"TextNode.NodeType", Field, 0},
+ {"TextNode.Pos", Field, 1},
+ {"TextNode.Text", Field, 0},
+ {"Tree", Type, 0},
+ {"Tree.Mode", Field, 16},
+ {"Tree.Name", Field, 0},
+ {"Tree.ParseName", Field, 1},
+ {"Tree.Root", Field, 0},
+ {"VariableNode", Type, 0},
+ {"VariableNode.Ident", Field, 0},
+ {"VariableNode.NodeType", Field, 0},
+ {"VariableNode.Pos", Field, 1},
+ {"WithNode", Type, 0},
+ {"WithNode.BranchNode", Field, 0},
+ },
+ "time": {
+ {"(*Location).String", Method, 0},
+ {"(*ParseError).Error", Method, 0},
+ {"(*Ticker).Reset", Method, 15},
+ {"(*Ticker).Stop", Method, 0},
+ {"(*Time).GobDecode", Method, 0},
+ {"(*Time).UnmarshalBinary", Method, 2},
+ {"(*Time).UnmarshalJSON", Method, 0},
+ {"(*Time).UnmarshalText", Method, 2},
+ {"(*Timer).Reset", Method, 1},
+ {"(*Timer).Stop", Method, 0},
+ {"(Duration).Abs", Method, 19},
+ {"(Duration).Hours", Method, 0},
+ {"(Duration).Microseconds", Method, 13},
+ {"(Duration).Milliseconds", Method, 13},
+ {"(Duration).Minutes", Method, 0},
+ {"(Duration).Nanoseconds", Method, 0},
+ {"(Duration).Round", Method, 9},
+ {"(Duration).Seconds", Method, 0},
+ {"(Duration).String", Method, 0},
+ {"(Duration).Truncate", Method, 9},
+ {"(Month).String", Method, 0},
+ {"(Time).Add", Method, 0},
+ {"(Time).AddDate", Method, 0},
+ {"(Time).After", Method, 0},
+ {"(Time).AppendFormat", Method, 5},
+ {"(Time).Before", Method, 0},
+ {"(Time).Clock", Method, 0},
+ {"(Time).Compare", Method, 20},
+ {"(Time).Date", Method, 0},
+ {"(Time).Day", Method, 0},
+ {"(Time).Equal", Method, 0},
+ {"(Time).Format", Method, 0},
+ {"(Time).GoString", Method, 17},
+ {"(Time).GobEncode", Method, 0},
+ {"(Time).Hour", Method, 0},
+ {"(Time).ISOWeek", Method, 0},
+ {"(Time).In", Method, 0},
+ {"(Time).IsDST", Method, 17},
+ {"(Time).IsZero", Method, 0},
+ {"(Time).Local", Method, 0},
+ {"(Time).Location", Method, 0},
+ {"(Time).MarshalBinary", Method, 2},
+ {"(Time).MarshalJSON", Method, 0},
+ {"(Time).MarshalText", Method, 2},
+ {"(Time).Minute", Method, 0},
+ {"(Time).Month", Method, 0},
+ {"(Time).Nanosecond", Method, 0},
+ {"(Time).Round", Method, 1},
+ {"(Time).Second", Method, 0},
+ {"(Time).String", Method, 0},
+ {"(Time).Sub", Method, 0},
+ {"(Time).Truncate", Method, 1},
+ {"(Time).UTC", Method, 0},
+ {"(Time).Unix", Method, 0},
+ {"(Time).UnixMicro", Method, 17},
+ {"(Time).UnixMilli", Method, 17},
+ {"(Time).UnixNano", Method, 0},
+ {"(Time).Weekday", Method, 0},
+ {"(Time).Year", Method, 0},
+ {"(Time).YearDay", Method, 1},
+ {"(Time).Zone", Method, 0},
+ {"(Time).ZoneBounds", Method, 19},
+ {"(Weekday).String", Method, 0},
+ {"ANSIC", Const, 0},
+ {"After", Func, 0},
+ {"AfterFunc", Func, 0},
+ {"April", Const, 0},
+ {"August", Const, 0},
+ {"Date", Func, 0},
+ {"DateOnly", Const, 20},
+ {"DateTime", Const, 20},
+ {"December", Const, 0},
+ {"Duration", Type, 0},
+ {"February", Const, 0},
+ {"FixedZone", Func, 0},
+ {"Friday", Const, 0},
+ {"Hour", Const, 0},
+ {"January", Const, 0},
+ {"July", Const, 0},
+ {"June", Const, 0},
+ {"Kitchen", Const, 0},
+ {"Layout", Const, 17},
+ {"LoadLocation", Func, 0},
+ {"LoadLocationFromTZData", Func, 10},
+ {"Local", Var, 0},
+ {"Location", Type, 0},
+ {"March", Const, 0},
+ {"May", Const, 0},
+ {"Microsecond", Const, 0},
+ {"Millisecond", Const, 0},
+ {"Minute", Const, 0},
+ {"Monday", Const, 0},
+ {"Month", Type, 0},
+ {"Nanosecond", Const, 0},
+ {"NewTicker", Func, 0},
+ {"NewTimer", Func, 0},
+ {"November", Const, 0},
+ {"Now", Func, 0},
+ {"October", Const, 0},
+ {"Parse", Func, 0},
+ {"ParseDuration", Func, 0},
+ {"ParseError", Type, 0},
+ {"ParseError.Layout", Field, 0},
+ {"ParseError.LayoutElem", Field, 0},
+ {"ParseError.Message", Field, 0},
+ {"ParseError.Value", Field, 0},
+ {"ParseError.ValueElem", Field, 0},
+ {"ParseInLocation", Func, 1},
+ {"RFC1123", Const, 0},
+ {"RFC1123Z", Const, 0},
+ {"RFC3339", Const, 0},
+ {"RFC3339Nano", Const, 0},
+ {"RFC822", Const, 0},
+ {"RFC822Z", Const, 0},
+ {"RFC850", Const, 0},
+ {"RubyDate", Const, 0},
+ {"Saturday", Const, 0},
+ {"Second", Const, 0},
+ {"September", Const, 0},
+ {"Since", Func, 0},
+ {"Sleep", Func, 0},
+ {"Stamp", Const, 0},
+ {"StampMicro", Const, 0},
+ {"StampMilli", Const, 0},
+ {"StampNano", Const, 0},
+ {"Sunday", Const, 0},
+ {"Thursday", Const, 0},
+ {"Tick", Func, 0},
+ {"Ticker", Type, 0},
+ {"Ticker.C", Field, 0},
+ {"Time", Type, 0},
+ {"TimeOnly", Const, 20},
+ {"Timer", Type, 0},
+ {"Timer.C", Field, 0},
+ {"Tuesday", Const, 0},
+ {"UTC", Var, 0},
+ {"Unix", Func, 0},
+ {"UnixDate", Const, 0},
+ {"UnixMicro", Func, 17},
+ {"UnixMilli", Func, 17},
+ {"Until", Func, 8},
+ {"Wednesday", Const, 0},
+ {"Weekday", Type, 0},
+ },
+ "unicode": {
+ {"(SpecialCase).ToLower", Method, 0},
+ {"(SpecialCase).ToTitle", Method, 0},
+ {"(SpecialCase).ToUpper", Method, 0},
+ {"ASCII_Hex_Digit", Var, 0},
+ {"Adlam", Var, 7},
+ {"Ahom", Var, 5},
+ {"Anatolian_Hieroglyphs", Var, 5},
+ {"Arabic", Var, 0},
+ {"Armenian", Var, 0},
+ {"Avestan", Var, 0},
+ {"AzeriCase", Var, 0},
+ {"Balinese", Var, 0},
+ {"Bamum", Var, 0},
+ {"Bassa_Vah", Var, 4},
+ {"Batak", Var, 0},
+ {"Bengali", Var, 0},
+ {"Bhaiksuki", Var, 7},
+ {"Bidi_Control", Var, 0},
+ {"Bopomofo", Var, 0},
+ {"Brahmi", Var, 0},
+ {"Braille", Var, 0},
+ {"Buginese", Var, 0},
+ {"Buhid", Var, 0},
+ {"C", Var, 0},
+ {"Canadian_Aboriginal", Var, 0},
+ {"Carian", Var, 0},
+ {"CaseRange", Type, 0},
+ {"CaseRange.Delta", Field, 0},
+ {"CaseRange.Hi", Field, 0},
+ {"CaseRange.Lo", Field, 0},
+ {"CaseRanges", Var, 0},
+ {"Categories", Var, 0},
+ {"Caucasian_Albanian", Var, 4},
+ {"Cc", Var, 0},
+ {"Cf", Var, 0},
+ {"Chakma", Var, 1},
+ {"Cham", Var, 0},
+ {"Cherokee", Var, 0},
+ {"Chorasmian", Var, 16},
+ {"Co", Var, 0},
+ {"Common", Var, 0},
+ {"Coptic", Var, 0},
+ {"Cs", Var, 0},
+ {"Cuneiform", Var, 0},
+ {"Cypriot", Var, 0},
+ {"Cypro_Minoan", Var, 21},
+ {"Cyrillic", Var, 0},
+ {"Dash", Var, 0},
+ {"Deprecated", Var, 0},
+ {"Deseret", Var, 0},
+ {"Devanagari", Var, 0},
+ {"Diacritic", Var, 0},
+ {"Digit", Var, 0},
+ {"Dives_Akuru", Var, 16},
+ {"Dogra", Var, 13},
+ {"Duployan", Var, 4},
+ {"Egyptian_Hieroglyphs", Var, 0},
+ {"Elbasan", Var, 4},
+ {"Elymaic", Var, 14},
+ {"Ethiopic", Var, 0},
+ {"Extender", Var, 0},
+ {"FoldCategory", Var, 0},
+ {"FoldScript", Var, 0},
+ {"Georgian", Var, 0},
+ {"Glagolitic", Var, 0},
+ {"Gothic", Var, 0},
+ {"Grantha", Var, 4},
+ {"GraphicRanges", Var, 0},
+ {"Greek", Var, 0},
+ {"Gujarati", Var, 0},
+ {"Gunjala_Gondi", Var, 13},
+ {"Gurmukhi", Var, 0},
+ {"Han", Var, 0},
+ {"Hangul", Var, 0},
+ {"Hanifi_Rohingya", Var, 13},
+ {"Hanunoo", Var, 0},
+ {"Hatran", Var, 5},
+ {"Hebrew", Var, 0},
+ {"Hex_Digit", Var, 0},
+ {"Hiragana", Var, 0},
+ {"Hyphen", Var, 0},
+ {"IDS_Binary_Operator", Var, 0},
+ {"IDS_Trinary_Operator", Var, 0},
+ {"Ideographic", Var, 0},
+ {"Imperial_Aramaic", Var, 0},
+ {"In", Func, 2},
+ {"Inherited", Var, 0},
+ {"Inscriptional_Pahlavi", Var, 0},
+ {"Inscriptional_Parthian", Var, 0},
+ {"Is", Func, 0},
+ {"IsControl", Func, 0},
+ {"IsDigit", Func, 0},
+ {"IsGraphic", Func, 0},
+ {"IsLetter", Func, 0},
+ {"IsLower", Func, 0},
+ {"IsMark", Func, 0},
+ {"IsNumber", Func, 0},
+ {"IsOneOf", Func, 0},
+ {"IsPrint", Func, 0},
+ {"IsPunct", Func, 0},
+ {"IsSpace", Func, 0},
+ {"IsSymbol", Func, 0},
+ {"IsTitle", Func, 0},
+ {"IsUpper", Func, 0},
+ {"Javanese", Var, 0},
+ {"Join_Control", Var, 0},
+ {"Kaithi", Var, 0},
+ {"Kannada", Var, 0},
+ {"Katakana", Var, 0},
+ {"Kawi", Var, 21},
+ {"Kayah_Li", Var, 0},
+ {"Kharoshthi", Var, 0},
+ {"Khitan_Small_Script", Var, 16},
+ {"Khmer", Var, 0},
+ {"Khojki", Var, 4},
+ {"Khudawadi", Var, 4},
+ {"L", Var, 0},
+ {"Lao", Var, 0},
+ {"Latin", Var, 0},
+ {"Lepcha", Var, 0},
+ {"Letter", Var, 0},
+ {"Limbu", Var, 0},
+ {"Linear_A", Var, 4},
+ {"Linear_B", Var, 0},
+ {"Lisu", Var, 0},
+ {"Ll", Var, 0},
+ {"Lm", Var, 0},
+ {"Lo", Var, 0},
+ {"Logical_Order_Exception", Var, 0},
+ {"Lower", Var, 0},
+ {"LowerCase", Const, 0},
+ {"Lt", Var, 0},
+ {"Lu", Var, 0},
+ {"Lycian", Var, 0},
+ {"Lydian", Var, 0},
+ {"M", Var, 0},
+ {"Mahajani", Var, 4},
+ {"Makasar", Var, 13},
+ {"Malayalam", Var, 0},
+ {"Mandaic", Var, 0},
+ {"Manichaean", Var, 4},
+ {"Marchen", Var, 7},
+ {"Mark", Var, 0},
+ {"Masaram_Gondi", Var, 10},
+ {"MaxASCII", Const, 0},
+ {"MaxCase", Const, 0},
+ {"MaxLatin1", Const, 0},
+ {"MaxRune", Const, 0},
+ {"Mc", Var, 0},
+ {"Me", Var, 0},
+ {"Medefaidrin", Var, 13},
+ {"Meetei_Mayek", Var, 0},
+ {"Mende_Kikakui", Var, 4},
+ {"Meroitic_Cursive", Var, 1},
+ {"Meroitic_Hieroglyphs", Var, 1},
+ {"Miao", Var, 1},
+ {"Mn", Var, 0},
+ {"Modi", Var, 4},
+ {"Mongolian", Var, 0},
+ {"Mro", Var, 4},
+ {"Multani", Var, 5},
+ {"Myanmar", Var, 0},
+ {"N", Var, 0},
+ {"Nabataean", Var, 4},
+ {"Nag_Mundari", Var, 21},
+ {"Nandinagari", Var, 14},
+ {"Nd", Var, 0},
+ {"New_Tai_Lue", Var, 0},
+ {"Newa", Var, 7},
+ {"Nko", Var, 0},
+ {"Nl", Var, 0},
+ {"No", Var, 0},
+ {"Noncharacter_Code_Point", Var, 0},
+ {"Number", Var, 0},
+ {"Nushu", Var, 10},
+ {"Nyiakeng_Puachue_Hmong", Var, 14},
+ {"Ogham", Var, 0},
+ {"Ol_Chiki", Var, 0},
+ {"Old_Hungarian", Var, 5},
+ {"Old_Italic", Var, 0},
+ {"Old_North_Arabian", Var, 4},
+ {"Old_Permic", Var, 4},
+ {"Old_Persian", Var, 0},
+ {"Old_Sogdian", Var, 13},
+ {"Old_South_Arabian", Var, 0},
+ {"Old_Turkic", Var, 0},
+ {"Old_Uyghur", Var, 21},
+ {"Oriya", Var, 0},
+ {"Osage", Var, 7},
+ {"Osmanya", Var, 0},
+ {"Other", Var, 0},
+ {"Other_Alphabetic", Var, 0},
+ {"Other_Default_Ignorable_Code_Point", Var, 0},
+ {"Other_Grapheme_Extend", Var, 0},
+ {"Other_ID_Continue", Var, 0},
+ {"Other_ID_Start", Var, 0},
+ {"Other_Lowercase", Var, 0},
+ {"Other_Math", Var, 0},
+ {"Other_Uppercase", Var, 0},
+ {"P", Var, 0},
+ {"Pahawh_Hmong", Var, 4},
+ {"Palmyrene", Var, 4},
+ {"Pattern_Syntax", Var, 0},
+ {"Pattern_White_Space", Var, 0},
+ {"Pau_Cin_Hau", Var, 4},
+ {"Pc", Var, 0},
+ {"Pd", Var, 0},
+ {"Pe", Var, 0},
+ {"Pf", Var, 0},
+ {"Phags_Pa", Var, 0},
+ {"Phoenician", Var, 0},
+ {"Pi", Var, 0},
+ {"Po", Var, 0},
+ {"Prepended_Concatenation_Mark", Var, 7},
+ {"PrintRanges", Var, 0},
+ {"Properties", Var, 0},
+ {"Ps", Var, 0},
+ {"Psalter_Pahlavi", Var, 4},
+ {"Punct", Var, 0},
+ {"Quotation_Mark", Var, 0},
+ {"Radical", Var, 0},
+ {"Range16", Type, 0},
+ {"Range16.Hi", Field, 0},
+ {"Range16.Lo", Field, 0},
+ {"Range16.Stride", Field, 0},
+ {"Range32", Type, 0},
+ {"Range32.Hi", Field, 0},
+ {"Range32.Lo", Field, 0},
+ {"Range32.Stride", Field, 0},
+ {"RangeTable", Type, 0},
+ {"RangeTable.LatinOffset", Field, 1},
+ {"RangeTable.R16", Field, 0},
+ {"RangeTable.R32", Field, 0},
+ {"Regional_Indicator", Var, 10},
+ {"Rejang", Var, 0},
+ {"ReplacementChar", Const, 0},
+ {"Runic", Var, 0},
+ {"S", Var, 0},
+ {"STerm", Var, 0},
+ {"Samaritan", Var, 0},
+ {"Saurashtra", Var, 0},
+ {"Sc", Var, 0},
+ {"Scripts", Var, 0},
+ {"Sentence_Terminal", Var, 7},
+ {"Sharada", Var, 1},
+ {"Shavian", Var, 0},
+ {"Siddham", Var, 4},
+ {"SignWriting", Var, 5},
+ {"SimpleFold", Func, 0},
+ {"Sinhala", Var, 0},
+ {"Sk", Var, 0},
+ {"Sm", Var, 0},
+ {"So", Var, 0},
+ {"Soft_Dotted", Var, 0},
+ {"Sogdian", Var, 13},
+ {"Sora_Sompeng", Var, 1},
+ {"Soyombo", Var, 10},
+ {"Space", Var, 0},
+ {"SpecialCase", Type, 0},
+ {"Sundanese", Var, 0},
+ {"Syloti_Nagri", Var, 0},
+ {"Symbol", Var, 0},
+ {"Syriac", Var, 0},
+ {"Tagalog", Var, 0},
+ {"Tagbanwa", Var, 0},
+ {"Tai_Le", Var, 0},
+ {"Tai_Tham", Var, 0},
+ {"Tai_Viet", Var, 0},
+ {"Takri", Var, 1},
+ {"Tamil", Var, 0},
+ {"Tangsa", Var, 21},
+ {"Tangut", Var, 7},
+ {"Telugu", Var, 0},
+ {"Terminal_Punctuation", Var, 0},
+ {"Thaana", Var, 0},
+ {"Thai", Var, 0},
+ {"Tibetan", Var, 0},
+ {"Tifinagh", Var, 0},
+ {"Tirhuta", Var, 4},
+ {"Title", Var, 0},
+ {"TitleCase", Const, 0},
+ {"To", Func, 0},
+ {"ToLower", Func, 0},
+ {"ToTitle", Func, 0},
+ {"ToUpper", Func, 0},
+ {"Toto", Var, 21},
+ {"TurkishCase", Var, 0},
+ {"Ugaritic", Var, 0},
+ {"Unified_Ideograph", Var, 0},
+ {"Upper", Var, 0},
+ {"UpperCase", Const, 0},
+ {"UpperLower", Const, 0},
+ {"Vai", Var, 0},
+ {"Variation_Selector", Var, 0},
+ {"Version", Const, 0},
+ {"Vithkuqi", Var, 21},
+ {"Wancho", Var, 14},
+ {"Warang_Citi", Var, 4},
+ {"White_Space", Var, 0},
+ {"Yezidi", Var, 16},
+ {"Yi", Var, 0},
+ {"Z", Var, 0},
+ {"Zanabazar_Square", Var, 10},
+ {"Zl", Var, 0},
+ {"Zp", Var, 0},
+ {"Zs", Var, 0},
+ },
+ "unicode/utf16": {
+ {"AppendRune", Func, 20},
+ {"Decode", Func, 0},
+ {"DecodeRune", Func, 0},
+ {"Encode", Func, 0},
+ {"EncodeRune", Func, 0},
+ {"IsSurrogate", Func, 0},
+ {"RuneLen", Func, 23},
+ },
+ "unicode/utf8": {
+ {"AppendRune", Func, 18},
+ {"DecodeLastRune", Func, 0},
+ {"DecodeLastRuneInString", Func, 0},
+ {"DecodeRune", Func, 0},
+ {"DecodeRuneInString", Func, 0},
+ {"EncodeRune", Func, 0},
+ {"FullRune", Func, 0},
+ {"FullRuneInString", Func, 0},
+ {"MaxRune", Const, 0},
+ {"RuneCount", Func, 0},
+ {"RuneCountInString", Func, 0},
+ {"RuneError", Const, 0},
+ {"RuneLen", Func, 0},
+ {"RuneSelf", Const, 0},
+ {"RuneStart", Func, 0},
+ {"UTFMax", Const, 0},
+ {"Valid", Func, 0},
+ {"ValidRune", Func, 1},
+ {"ValidString", Func, 0},
+ },
+ "unique": {
+ {"(Handle).Value", Method, 23},
+ {"Handle", Type, 23},
+ {"Make", Func, 23},
+ },
+ "unsafe": {
+ {"Add", Func, 0},
+ {"Alignof", Func, 0},
+ {"Offsetof", Func, 0},
+ {"Pointer", Type, 0},
+ {"Sizeof", Func, 0},
+ {"Slice", Func, 0},
+ {"SliceData", Func, 0},
+ {"String", Func, 0},
+ {"StringData", Func, 0},
+ },
+}
diff --git a/vendor/golang.org/x/tools/internal/stdlib/stdlib.go b/vendor/golang.org/x/tools/internal/stdlib/stdlib.go
new file mode 100644
index 0000000000..98904017f2
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/stdlib/stdlib.go
@@ -0,0 +1,97 @@
+// 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.
+
+//go:generate go run generate.go
+
+// Package stdlib provides a table of all exported symbols in the
+// standard library, along with the version at which they first
+// appeared.
+package stdlib
+
+import (
+ "fmt"
+ "strings"
+)
+
+type Symbol struct {
+ Name string
+ Kind Kind
+ Version Version // Go version that first included the symbol
+}
+
+// A Kind indicates the kind of a symbol:
+// function, variable, constant, type, and so on.
+type Kind int8
+
+const (
+ Invalid Kind = iota // Example name:
+ Type // "Buffer"
+ Func // "Println"
+ Var // "EOF"
+ Const // "Pi"
+ Field // "Point.X"
+ Method // "(*Buffer).Grow"
+)
+
+func (kind Kind) String() string {
+ return [...]string{
+ Invalid: "invalid",
+ Type: "type",
+ Func: "func",
+ Var: "var",
+ Const: "const",
+ Field: "field",
+ Method: "method",
+ }[kind]
+}
+
+// A Version represents a version of Go of the form "go1.%d".
+type Version int8
+
+// String returns a version string of the form "go1.23", without allocating.
+func (v Version) String() string { return versions[v] }
+
+var versions [30]string // (increase constant as needed)
+
+func init() {
+ for i := range versions {
+ versions[i] = fmt.Sprintf("go1.%d", i)
+ }
+}
+
+// HasPackage reports whether the specified package path is part of
+// the standard library's public API.
+func HasPackage(path string) bool {
+ _, ok := PackageSymbols[path]
+ return ok
+}
+
+// SplitField splits the field symbol name into type and field
+// components. It must be called only on Field symbols.
+//
+// Example: "File.Package" -> ("File", "Package")
+func (sym *Symbol) SplitField() (typename, name string) {
+ if sym.Kind != Field {
+ panic("not a field")
+ }
+ typename, name, _ = strings.Cut(sym.Name, ".")
+ return
+}
+
+// SplitMethod splits the method symbol name into pointer, receiver,
+// and method components. It must be called only on Method symbols.
+//
+// Example: "(*Buffer).Grow" -> (true, "Buffer", "Grow")
+func (sym *Symbol) SplitMethod() (ptr bool, recv, name string) {
+ if sym.Kind != Method {
+ panic("not a method")
+ }
+ recv, name, _ = strings.Cut(sym.Name, ".")
+ recv = recv[len("(") : len(recv)-len(")")]
+ ptr = recv[0] == '*'
+ if ptr {
+ recv = recv[len("*"):]
+ }
+ return
+}
diff --git a/vendor/golang.org/x/tools/internal/tokeninternal/tokeninternal.go b/vendor/golang.org/x/tools/internal/tokeninternal/tokeninternal.go
deleted file mode 100644
index 7e638ec24f..0000000000
--- a/vendor/golang.org/x/tools/internal/tokeninternal/tokeninternal.go
+++ /dev/null
@@ -1,151 +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.
-
-// package tokeninternal provides access to some internal features of the token
-// package.
-package tokeninternal
-
-import (
- "fmt"
- "go/token"
- "sort"
- "sync"
- "unsafe"
-)
-
-// GetLines returns the table of line-start offsets from a token.File.
-func GetLines(file *token.File) []int {
- // token.File has a Lines method on Go 1.21 and later.
- if file, ok := (interface{})(file).(interface{ Lines() []int }); ok {
- return file.Lines()
- }
-
- // This declaration must match that of token.File.
- // This creates a risk of dependency skew.
- // For now we check that the size of the two
- // declarations is the same, on the (fragile) assumption
- // that future changes would add fields.
- type tokenFile119 struct {
- _ string
- _ int
- _ int
- mu sync.Mutex // we're not complete monsters
- lines []int
- _ []struct{}
- }
- type tokenFile118 struct {
- _ *token.FileSet // deleted in go1.19
- tokenFile119
- }
-
- type uP = unsafe.Pointer
- switch unsafe.Sizeof(*file) {
- case unsafe.Sizeof(tokenFile118{}):
- var ptr *tokenFile118
- *(*uP)(uP(&ptr)) = uP(file)
- ptr.mu.Lock()
- defer ptr.mu.Unlock()
- return ptr.lines
-
- case unsafe.Sizeof(tokenFile119{}):
- var ptr *tokenFile119
- *(*uP)(uP(&ptr)) = uP(file)
- ptr.mu.Lock()
- defer ptr.mu.Unlock()
- return ptr.lines
-
- default:
- panic("unexpected token.File size")
- }
-}
-
-// AddExistingFiles adds the specified files to the FileSet if they
-// are not already present. It panics if any pair of files in the
-// resulting FileSet would overlap.
-func AddExistingFiles(fset *token.FileSet, files []*token.File) {
- // Punch through the FileSet encapsulation.
- type tokenFileSet struct {
- // This type remained essentially consistent from go1.16 to go1.21.
- mutex sync.RWMutex
- base int
- files []*token.File
- _ *token.File // changed to atomic.Pointer[token.File] in go1.19
- }
-
- // If the size of token.FileSet changes, this will fail to compile.
- const delta = int64(unsafe.Sizeof(tokenFileSet{})) - int64(unsafe.Sizeof(token.FileSet{}))
- var _ [-delta * delta]int
-
- type uP = unsafe.Pointer
- var ptr *tokenFileSet
- *(*uP)(uP(&ptr)) = uP(fset)
- ptr.mutex.Lock()
- defer ptr.mutex.Unlock()
-
- // Merge and sort.
- newFiles := append(ptr.files, files...)
- sort.Slice(newFiles, func(i, j int) bool {
- return newFiles[i].Base() < newFiles[j].Base()
- })
-
- // Reject overlapping files.
- // Discard adjacent identical files.
- out := newFiles[:0]
- for i, file := range newFiles {
- if i > 0 {
- prev := newFiles[i-1]
- if file == prev {
- continue
- }
- if prev.Base()+prev.Size()+1 > file.Base() {
- panic(fmt.Sprintf("file %s (%d-%d) overlaps with file %s (%d-%d)",
- prev.Name(), prev.Base(), prev.Base()+prev.Size(),
- file.Name(), file.Base(), file.Base()+file.Size()))
- }
- }
- out = append(out, file)
- }
- newFiles = out
-
- ptr.files = newFiles
-
- // Advance FileSet.Base().
- if len(newFiles) > 0 {
- last := newFiles[len(newFiles)-1]
- newBase := last.Base() + last.Size() + 1
- if ptr.base < newBase {
- ptr.base = newBase
- }
- }
-}
-
-// FileSetFor returns a new FileSet containing a sequence of new Files with
-// the same base, size, and line as the input files, for use in APIs that
-// require a FileSet.
-//
-// Precondition: the input files must be non-overlapping, and sorted in order
-// of their Base.
-func FileSetFor(files ...*token.File) *token.FileSet {
- fset := token.NewFileSet()
- for _, f := range files {
- f2 := fset.AddFile(f.Name(), f.Base(), f.Size())
- lines := GetLines(f)
- f2.SetLines(lines)
- }
- return fset
-}
-
-// CloneFileSet creates a new FileSet holding all files in fset. It does not
-// create copies of the token.Files in fset: they are added to the resulting
-// FileSet unmodified.
-func CloneFileSet(fset *token.FileSet) *token.FileSet {
- var files []*token.File
- fset.Iterate(func(f *token.File) bool {
- files = append(files, f)
- return true
- })
- newFileSet := token.NewFileSet()
- AddExistingFiles(newFileSet, files)
- return newFileSet
-}
diff --git a/vendor/golang.org/x/tools/internal/typeparams/common.go b/vendor/golang.org/x/tools/internal/typeparams/common.go
index d0d0649fe2..0b84acc5c7 100644
--- a/vendor/golang.org/x/tools/internal/typeparams/common.go
+++ b/vendor/golang.org/x/tools/internal/typeparams/common.go
@@ -2,20 +2,10 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// Package typeparams contains common utilities for writing tools that interact
-// with generic Go code, as introduced with Go 1.18.
-//
-// Many of the types and functions in this package are proxies for the new APIs
-// introduced in the standard library with Go 1.18. For example, the
-// typeparams.Union type is an alias for go/types.Union, and the ForTypeSpec
-// function returns the value of the go/ast.TypeSpec.TypeParams field. At Go
-// versions older than 1.18 these helpers are implemented as stubs, allowing
-// users of this package to write code that handles generic constructs inline,
-// even if the Go version being used to compile does not support generics.
-//
-// Additionally, this package contains common utilities for working with the
-// new generic constructs, to supplement the standard library APIs. Notably,
-// the StructuralTerms API computes a minimal representation of the structural
+// Package typeparams contains common utilities for writing tools that
+// interact with generic Go code, as introduced with Go 1.18. It
+// supplements the standard library APIs. Notably, the StructuralTerms
+// API computes a minimal representation of the structural
// restrictions on a type parameter.
//
// An external version of these APIs is available in the
@@ -23,7 +13,6 @@
package typeparams
import (
- "fmt"
"go/ast"
"go/token"
"go/types"
@@ -42,7 +31,7 @@ func UnpackIndexExpr(n ast.Node) (x ast.Expr, lbrack token.Pos, indices []ast.Ex
switch e := n.(type) {
case *ast.IndexExpr:
return e.X, e.Lbrack, []ast.Expr{e.Index}, e.Rbrack
- case *IndexListExpr:
+ case *ast.IndexListExpr:
return e.X, e.Lbrack, e.Indices, e.Rbrack
}
return nil, token.NoPos, nil, token.NoPos
@@ -63,7 +52,7 @@ func PackIndexExpr(x ast.Expr, lbrack token.Pos, indices []ast.Expr, rbrack toke
Rbrack: rbrack,
}
default:
- return &IndexListExpr{
+ return &ast.IndexListExpr{
X: x,
Lbrack: lbrack,
Indices: indices,
@@ -72,73 +61,17 @@ func PackIndexExpr(x ast.Expr, lbrack token.Pos, indices []ast.Expr, rbrack toke
}
}
-// IsTypeParam reports whether t is a type parameter.
+// IsTypeParam reports whether t is a type parameter (or an alias of one).
func IsTypeParam(t types.Type) bool {
- _, ok := t.(*TypeParam)
+ _, ok := types.Unalias(t).(*types.TypeParam)
return ok
}
-// OriginMethod returns the origin method associated with the method fn.
-// For methods on a non-generic receiver base type, this is just
-// fn. However, for methods with a generic receiver, OriginMethod returns the
-// corresponding method in the method set of the origin type.
-//
-// As a special case, if fn is not a method (has no receiver), OriginMethod
-// returns fn.
-func OriginMethod(fn *types.Func) *types.Func {
- recv := fn.Type().(*types.Signature).Recv()
- if recv == nil {
- return fn
- }
- base := recv.Type()
- p, isPtr := base.(*types.Pointer)
- if isPtr {
- base = p.Elem()
- }
- named, isNamed := base.(*types.Named)
- if !isNamed {
- // Receiver is a *types.Interface.
- return fn
- }
- if ForNamed(named).Len() == 0 {
- // Receiver base has no type parameters, so we can avoid the lookup below.
- return fn
- }
- orig := NamedTypeOrigin(named)
- gfn, _, _ := types.LookupFieldOrMethod(orig, true, fn.Pkg(), fn.Name())
-
- // This is a fix for a gopls crash (#60628) due to a go/types bug (#60634). In:
- // package p
- // type T *int
- // func (*T) f() {}
- // LookupFieldOrMethod(T, true, p, f)=nil, but NewMethodSet(*T)={(*T).f}.
- // Here we make them consistent by force.
- // (The go/types bug is general, but this workaround is reached only
- // for generic T thanks to the early return above.)
- if gfn == nil {
- mset := types.NewMethodSet(types.NewPointer(orig))
- for i := 0; i < mset.Len(); i++ {
- m := mset.At(i)
- if m.Obj().Id() == fn.Id() {
- gfn = m.Obj()
- break
- }
- }
- }
-
- // In golang/go#61196, we observe another crash, this time inexplicable.
- if gfn == nil {
- panic(fmt.Sprintf("missing origin method for %s.%s; named == origin: %t, named.NumMethods(): %d, origin.NumMethods(): %d", named, fn, named == orig, named.NumMethods(), orig.NumMethods()))
- }
-
- return gfn.(*types.Func)
-}
-
// GenericAssignableTo is a generalization of types.AssignableTo that
// implements the following rule for uninstantiated generic types:
//
// If V and T are generic named types, then V is considered assignable to T if,
-// for every possible instantation of V[A_1, ..., A_N], the instantiation
+// for every possible instantiation of V[A_1, ..., A_N], the instantiation
// T[A_1, ..., A_N] is valid and V[A_1, ..., A_N] implements T[A_1, ..., A_N].
//
// If T has structural constraints, they must be satisfied by V.
@@ -157,7 +90,10 @@ func OriginMethod(fn *types.Func) *types.Func {
//
// In this case, GenericAssignableTo reports that instantiations of Container
// are assignable to the corresponding instantiation of Interface.
-func GenericAssignableTo(ctxt *Context, V, T types.Type) bool {
+func GenericAssignableTo(ctxt *types.Context, V, T types.Type) bool {
+ V = types.Unalias(V)
+ T = types.Unalias(T)
+
// If V and T are not both named, or do not have matching non-empty type
// parameter lists, fall back on types.AssignableTo.
@@ -167,9 +103,9 @@ func GenericAssignableTo(ctxt *Context, V, T types.Type) bool {
return types.AssignableTo(V, T)
}
- vtparams := ForNamed(VN)
- ttparams := ForNamed(TN)
- if vtparams.Len() == 0 || vtparams.Len() != ttparams.Len() || NamedTypeArgs(VN).Len() != 0 || NamedTypeArgs(TN).Len() != 0 {
+ vtparams := VN.TypeParams()
+ ttparams := TN.TypeParams()
+ if vtparams.Len() == 0 || vtparams.Len() != ttparams.Len() || VN.TypeArgs().Len() != 0 || TN.TypeArgs().Len() != 0 {
return types.AssignableTo(V, T)
}
@@ -182,7 +118,7 @@ func GenericAssignableTo(ctxt *Context, V, T types.Type) bool {
// Minor optimization: ensure we share a context across the two
// instantiations below.
if ctxt == nil {
- ctxt = NewContext()
+ ctxt = types.NewContext()
}
var targs []types.Type
@@ -190,12 +126,12 @@ func GenericAssignableTo(ctxt *Context, V, T types.Type) bool {
targs = append(targs, vtparams.At(i))
}
- vinst, err := Instantiate(ctxt, V, targs, true)
+ vinst, err := types.Instantiate(ctxt, V, targs, true)
if err != nil {
panic("type parameters should satisfy their own constraints")
}
- tinst, err := Instantiate(ctxt, T, targs, true)
+ tinst, err := types.Instantiate(ctxt, T, targs, true)
if err != nil {
return false
}
diff --git a/vendor/golang.org/x/tools/internal/typeparams/coretype.go b/vendor/golang.org/x/tools/internal/typeparams/coretype.go
index 71248209ee..6e83c6fb1a 100644
--- a/vendor/golang.org/x/tools/internal/typeparams/coretype.go
+++ b/vendor/golang.org/x/tools/internal/typeparams/coretype.go
@@ -5,6 +5,7 @@
package typeparams
import (
+ "fmt"
"go/types"
)
@@ -17,7 +18,7 @@ func CoreType(T types.Type) types.Type {
return U // for non-interface types,
}
- terms, err := _NormalTerms(U)
+ terms, err := NormalTerms(U)
if len(terms) == 0 || err != nil {
// len(terms) -> empty type set of interface.
// err != nil => U is invalid, exceeds complexity bounds, or has an empty type set.
@@ -63,7 +64,7 @@ func CoreType(T types.Type) types.Type {
return ch
}
-// _NormalTerms returns a slice of terms representing the normalized structural
+// NormalTerms returns a slice of terms representing the normalized structural
// type restrictions of a type, if any.
//
// For all types other than *types.TypeParam, *types.Interface, and
@@ -93,30 +94,57 @@ func CoreType(T types.Type) types.Type {
// expands to ~string|~[]byte|int|string, which reduces to ~string|~[]byte|int,
// which when intersected with C (~string|~int) yields ~string|int.
//
-// _NormalTerms computes these expansions and reductions, producing a
+// NormalTerms computes these expansions and reductions, producing a
// "normalized" form of the embeddings. A structural restriction is normalized
// if it is a single union containing no interface terms, and is minimal in the
// sense that removing any term changes the set of types satisfying the
// constraint. It is left as a proof for the reader that, modulo sorting, there
// is exactly one such normalized form.
//
-// Because the minimal representation always takes this form, _NormalTerms
+// Because the minimal representation always takes this form, NormalTerms
// returns a slice of tilde terms corresponding to the terms of the union in
// the normalized structural restriction. An error is returned if the type is
// invalid, exceeds complexity bounds, or has an empty type set. In the latter
-// case, _NormalTerms returns ErrEmptyTypeSet.
+// case, NormalTerms returns ErrEmptyTypeSet.
//
-// _NormalTerms makes no guarantees about the order of terms, except that it
+// NormalTerms makes no guarantees about the order of terms, except that it
// is deterministic.
-func _NormalTerms(typ types.Type) ([]*Term, error) {
- switch typ := typ.(type) {
- case *TypeParam:
+func NormalTerms(typ types.Type) ([]*types.Term, error) {
+ switch typ := typ.Underlying().(type) {
+ case *types.TypeParam:
return StructuralTerms(typ)
- case *Union:
+ case *types.Union:
return UnionTermSet(typ)
case *types.Interface:
return InterfaceTermSet(typ)
default:
- return []*Term{NewTerm(false, typ)}, nil
+ return []*types.Term{types.NewTerm(false, typ)}, nil
}
}
+
+// Deref returns the type of the variable pointed to by t,
+// if t's core type is a pointer; otherwise it returns t.
+//
+// Do not assume that Deref(T)==T implies T is not a pointer:
+// consider "type T *T", for example.
+//
+// TODO(adonovan): ideally this would live in typesinternal, but that
+// creates an import cycle. Move there when we melt this package down.
+func Deref(t types.Type) types.Type {
+ if ptr, ok := CoreType(t).(*types.Pointer); ok {
+ return ptr.Elem()
+ }
+ return t
+}
+
+// MustDeref returns the type of the variable pointed to by t.
+// It panics if t's core type is not a pointer.
+//
+// TODO(adonovan): ideally this would live in typesinternal, but that
+// creates an import cycle. Move there when we melt this package down.
+func MustDeref(t types.Type) types.Type {
+ if ptr, ok := CoreType(t).(*types.Pointer); ok {
+ return ptr.Elem()
+ }
+ panic(fmt.Sprintf("%v is not a pointer", t))
+}
diff --git a/vendor/golang.org/x/tools/internal/typeparams/enabled_go117.go b/vendor/golang.org/x/tools/internal/typeparams/enabled_go117.go
deleted file mode 100644
index 18212390e1..0000000000
--- a/vendor/golang.org/x/tools/internal/typeparams/enabled_go117.go
+++ /dev/null
@@ -1,12 +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.
-
-//go:build !go1.18
-// +build !go1.18
-
-package typeparams
-
-// Enabled reports whether type parameters are enabled in the current build
-// environment.
-const Enabled = false
diff --git a/vendor/golang.org/x/tools/internal/typeparams/enabled_go118.go b/vendor/golang.org/x/tools/internal/typeparams/enabled_go118.go
deleted file mode 100644
index d67148823c..0000000000
--- a/vendor/golang.org/x/tools/internal/typeparams/enabled_go118.go
+++ /dev/null
@@ -1,15 +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.
-
-//go:build go1.18
-// +build go1.18
-
-package typeparams
-
-// Note: this constant is in a separate file as this is the only acceptable
-// diff between the <1.18 API of this package and the 1.18 API.
-
-// Enabled reports whether type parameters are enabled in the current build
-// environment.
-const Enabled = true
diff --git a/vendor/golang.org/x/tools/internal/typeparams/free.go b/vendor/golang.org/x/tools/internal/typeparams/free.go
new file mode 100644
index 0000000000..0ade5c2949
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typeparams/free.go
@@ -0,0 +1,131 @@
+// Copyright 2024 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 typeparams
+
+import (
+ "go/types"
+
+ "golang.org/x/tools/internal/aliases"
+)
+
+// Free is a memoization of the set of free type parameters within a
+// type. It makes a sequence of calls to [Free.Has] for overlapping
+// types more efficient. The zero value is ready for use.
+//
+// NOTE: Adapted from go/types/infer.go. If it is later exported, factor.
+type Free struct {
+ seen map[types.Type]bool
+}
+
+// Has reports whether the specified type has a free type parameter.
+func (w *Free) Has(typ types.Type) (res bool) {
+ // detect cycles
+ if x, ok := w.seen[typ]; ok {
+ return x
+ }
+ if w.seen == nil {
+ w.seen = make(map[types.Type]bool)
+ }
+ w.seen[typ] = false
+ defer func() {
+ w.seen[typ] = res
+ }()
+
+ switch t := typ.(type) {
+ case nil, *types.Basic: // TODO(gri) should nil be handled here?
+ break
+
+ case *types.Alias:
+ if aliases.TypeParams(t).Len() > aliases.TypeArgs(t).Len() {
+ return true // This is an uninstantiated Alias.
+ }
+ // The expansion of an alias can have free type parameters,
+ // whether or not the alias itself has type parameters:
+ //
+ // func _[K comparable]() {
+ // type Set = map[K]bool // free(Set) = {K}
+ // type MapTo[V] = map[K]V // free(Map[foo]) = {V}
+ // }
+ //
+ // So, we must Unalias.
+ return w.Has(types.Unalias(t))
+
+ case *types.Array:
+ return w.Has(t.Elem())
+
+ case *types.Slice:
+ return w.Has(t.Elem())
+
+ case *types.Struct:
+ for i, n := 0, t.NumFields(); i < n; i++ {
+ if w.Has(t.Field(i).Type()) {
+ return true
+ }
+ }
+
+ case *types.Pointer:
+ return w.Has(t.Elem())
+
+ case *types.Tuple:
+ n := t.Len()
+ for i := 0; i < n; i++ {
+ if w.Has(t.At(i).Type()) {
+ return true
+ }
+ }
+
+ case *types.Signature:
+ // t.tparams may not be nil if we are looking at a signature
+ // of a generic function type (or an interface method) that is
+ // part of the type we're testing. We don't care about these type
+ // parameters.
+ // Similarly, the receiver of a method may declare (rather than
+ // use) type parameters, we don't care about those either.
+ // Thus, we only need to look at the input and result parameters.
+ return w.Has(t.Params()) || w.Has(t.Results())
+
+ case *types.Interface:
+ for i, n := 0, t.NumMethods(); i < n; i++ {
+ if w.Has(t.Method(i).Type()) {
+ return true
+ }
+ }
+ terms, err := InterfaceTermSet(t)
+ if err != nil {
+ return false // ill typed
+ }
+ for _, term := range terms {
+ if w.Has(term.Type()) {
+ return true
+ }
+ }
+
+ case *types.Map:
+ return w.Has(t.Key()) || w.Has(t.Elem())
+
+ case *types.Chan:
+ return w.Has(t.Elem())
+
+ case *types.Named:
+ args := t.TypeArgs()
+ if params := t.TypeParams(); params.Len() > args.Len() {
+ return true // this is an uninstantiated named type.
+ }
+ for i, n := 0, args.Len(); i < n; i++ {
+ if w.Has(args.At(i)) {
+ return true
+ }
+ }
+ return w.Has(t.Underlying()) // recurse for types local to parameterized functions
+
+ case *types.TypeParam:
+ return true
+
+ default:
+ panic(t) // unreachable
+ }
+
+ return false
+}
diff --git a/vendor/golang.org/x/tools/internal/typeparams/normalize.go b/vendor/golang.org/x/tools/internal/typeparams/normalize.go
index 9c631b6512..93c80fdc96 100644
--- a/vendor/golang.org/x/tools/internal/typeparams/normalize.go
+++ b/vendor/golang.org/x/tools/internal/typeparams/normalize.go
@@ -60,7 +60,7 @@ var ErrEmptyTypeSet = errors.New("empty type set")
//
// StructuralTerms makes no guarantees about the order of terms, except that it
// is deterministic.
-func StructuralTerms(tparam *TypeParam) ([]*Term, error) {
+func StructuralTerms(tparam *types.TypeParam) ([]*types.Term, error) {
constraint := tparam.Constraint()
if constraint == nil {
return nil, fmt.Errorf("%s has nil constraint", tparam)
@@ -78,7 +78,7 @@ func StructuralTerms(tparam *TypeParam) ([]*Term, error) {
//
// See the documentation of StructuralTerms for more information on
// normalization.
-func InterfaceTermSet(iface *types.Interface) ([]*Term, error) {
+func InterfaceTermSet(iface *types.Interface) ([]*types.Term, error) {
return computeTermSet(iface)
}
@@ -88,11 +88,11 @@ func InterfaceTermSet(iface *types.Interface) ([]*Term, error) {
//
// See the documentation of StructuralTerms for more information on
// normalization.
-func UnionTermSet(union *Union) ([]*Term, error) {
+func UnionTermSet(union *types.Union) ([]*types.Term, error) {
return computeTermSet(union)
}
-func computeTermSet(typ types.Type) ([]*Term, error) {
+func computeTermSet(typ types.Type) ([]*types.Term, error) {
tset, err := computeTermSetInternal(typ, make(map[types.Type]*termSet), 0)
if err != nil {
return nil, err
@@ -103,9 +103,9 @@ func computeTermSet(typ types.Type) ([]*Term, error) {
if tset.terms.isAll() {
return nil, nil
}
- var terms []*Term
+ var terms []*types.Term
for _, term := range tset.terms {
- terms = append(terms, NewTerm(term.tilde, term.typ))
+ terms = append(terms, types.NewTerm(term.tilde, term.typ))
}
return terms, nil
}
@@ -162,7 +162,7 @@ func computeTermSetInternal(t types.Type, seen map[types.Type]*termSet, depth in
tset.terms = allTermlist
for i := 0; i < u.NumEmbeddeds(); i++ {
embedded := u.EmbeddedType(i)
- if _, ok := embedded.Underlying().(*TypeParam); ok {
+ if _, ok := embedded.Underlying().(*types.TypeParam); ok {
return nil, fmt.Errorf("invalid embedded type %T", embedded)
}
tset2, err := computeTermSetInternal(embedded, seen, depth+1)
@@ -171,7 +171,7 @@ func computeTermSetInternal(t types.Type, seen map[types.Type]*termSet, depth in
}
tset.terms = tset.terms.intersect(tset2.terms)
}
- case *Union:
+ case *types.Union:
// The term set of a union is the union of term sets of its terms.
tset.terms = nil
for i := 0; i < u.Len(); i++ {
@@ -184,7 +184,7 @@ func computeTermSetInternal(t types.Type, seen map[types.Type]*termSet, depth in
return nil, err
}
terms = tset2.terms
- case *TypeParam, *Union:
+ case *types.TypeParam, *types.Union:
// A stand-alone type parameter or union is not permitted as union
// term.
return nil, fmt.Errorf("invalid union term %T", t)
@@ -199,7 +199,7 @@ func computeTermSetInternal(t types.Type, seen map[types.Type]*termSet, depth in
return nil, fmt.Errorf("exceeded max term count %d", maxTermCount)
}
}
- case *TypeParam:
+ case *types.TypeParam:
panic("unreachable")
default:
// For all other types, the term set is just a single non-tilde term
diff --git a/vendor/golang.org/x/tools/internal/typeparams/typeparams_go117.go b/vendor/golang.org/x/tools/internal/typeparams/typeparams_go117.go
deleted file mode 100644
index 7ed86e1711..0000000000
--- a/vendor/golang.org/x/tools/internal/typeparams/typeparams_go117.go
+++ /dev/null
@@ -1,197 +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.
-
-//go:build !go1.18
-// +build !go1.18
-
-package typeparams
-
-import (
- "go/ast"
- "go/token"
- "go/types"
-)
-
-func unsupported() {
- panic("type parameters are unsupported at this go version")
-}
-
-// IndexListExpr is a placeholder type, as type parameters are not supported at
-// this Go version. Its methods panic on use.
-type IndexListExpr struct {
- ast.Expr
- X ast.Expr // expression
- Lbrack token.Pos // position of "["
- Indices []ast.Expr // index expressions
- Rbrack token.Pos // position of "]"
-}
-
-// ForTypeSpec returns an empty field list, as type parameters on not supported
-// at this Go version.
-func ForTypeSpec(*ast.TypeSpec) *ast.FieldList {
- return nil
-}
-
-// ForFuncType returns an empty field list, as type parameters are not
-// supported at this Go version.
-func ForFuncType(*ast.FuncType) *ast.FieldList {
- return nil
-}
-
-// TypeParam is a placeholder type, as type parameters are not supported at
-// this Go version. Its methods panic on use.
-type TypeParam struct{ types.Type }
-
-func (*TypeParam) Index() int { unsupported(); return 0 }
-func (*TypeParam) Constraint() types.Type { unsupported(); return nil }
-func (*TypeParam) Obj() *types.TypeName { unsupported(); return nil }
-
-// TypeParamList is a placeholder for an empty type parameter list.
-type TypeParamList struct{}
-
-func (*TypeParamList) Len() int { return 0 }
-func (*TypeParamList) At(int) *TypeParam { unsupported(); return nil }
-
-// TypeList is a placeholder for an empty type list.
-type TypeList struct{}
-
-func (*TypeList) Len() int { return 0 }
-func (*TypeList) At(int) types.Type { unsupported(); return nil }
-
-// NewTypeParam is unsupported at this Go version, and panics.
-func NewTypeParam(name *types.TypeName, constraint types.Type) *TypeParam {
- unsupported()
- return nil
-}
-
-// SetTypeParamConstraint is unsupported at this Go version, and panics.
-func SetTypeParamConstraint(tparam *TypeParam, constraint types.Type) {
- unsupported()
-}
-
-// NewSignatureType calls types.NewSignature, panicking if recvTypeParams or
-// typeParams is non-empty.
-func NewSignatureType(recv *types.Var, recvTypeParams, typeParams []*TypeParam, params, results *types.Tuple, variadic bool) *types.Signature {
- if len(recvTypeParams) != 0 || len(typeParams) != 0 {
- panic("signatures cannot have type parameters at this Go version")
- }
- return types.NewSignature(recv, params, results, variadic)
-}
-
-// ForSignature returns an empty slice.
-func ForSignature(*types.Signature) *TypeParamList {
- return nil
-}
-
-// RecvTypeParams returns a nil slice.
-func RecvTypeParams(sig *types.Signature) *TypeParamList {
- return nil
-}
-
-// IsComparable returns false, as no interfaces are type-restricted at this Go
-// version.
-func IsComparable(*types.Interface) bool {
- return false
-}
-
-// IsMethodSet returns true, as no interfaces are type-restricted at this Go
-// version.
-func IsMethodSet(*types.Interface) bool {
- return true
-}
-
-// IsImplicit returns false, as no interfaces are implicit at this Go version.
-func IsImplicit(*types.Interface) bool {
- return false
-}
-
-// MarkImplicit does nothing, because this Go version does not have implicit
-// interfaces.
-func MarkImplicit(*types.Interface) {}
-
-// ForNamed returns an empty type parameter list, as type parameters are not
-// supported at this Go version.
-func ForNamed(*types.Named) *TypeParamList {
- return nil
-}
-
-// SetForNamed panics if tparams is non-empty.
-func SetForNamed(_ *types.Named, tparams []*TypeParam) {
- if len(tparams) > 0 {
- unsupported()
- }
-}
-
-// NamedTypeArgs returns nil.
-func NamedTypeArgs(*types.Named) *TypeList {
- return nil
-}
-
-// NamedTypeOrigin is the identity method at this Go version.
-func NamedTypeOrigin(named *types.Named) *types.Named {
- return named
-}
-
-// Term holds information about a structural type restriction.
-type Term struct {
- tilde bool
- typ types.Type
-}
-
-func (m *Term) Tilde() bool { return m.tilde }
-func (m *Term) Type() types.Type { return m.typ }
-func (m *Term) String() string {
- pre := ""
- if m.tilde {
- pre = "~"
- }
- return pre + m.typ.String()
-}
-
-// NewTerm is unsupported at this Go version, and panics.
-func NewTerm(tilde bool, typ types.Type) *Term {
- return &Term{tilde, typ}
-}
-
-// Union is a placeholder type, as type parameters are not supported at this Go
-// version. Its methods panic on use.
-type Union struct{ types.Type }
-
-func (*Union) Len() int { return 0 }
-func (*Union) Term(i int) *Term { unsupported(); return nil }
-
-// NewUnion is unsupported at this Go version, and panics.
-func NewUnion(terms []*Term) *Union {
- unsupported()
- return nil
-}
-
-// InitInstanceInfo is a noop at this Go version.
-func InitInstanceInfo(*types.Info) {}
-
-// Instance is a placeholder type, as type parameters are not supported at this
-// Go version.
-type Instance struct {
- TypeArgs *TypeList
- Type types.Type
-}
-
-// GetInstances returns a nil map, as type parameters are not supported at this
-// Go version.
-func GetInstances(info *types.Info) map[*ast.Ident]Instance { return nil }
-
-// Context is a placeholder type, as type parameters are not supported at
-// this Go version.
-type Context struct{}
-
-// NewContext returns a placeholder Context instance.
-func NewContext() *Context {
- return &Context{}
-}
-
-// Instantiate is unsupported on this Go version, and panics.
-func Instantiate(ctxt *Context, typ types.Type, targs []types.Type, validate bool) (types.Type, error) {
- unsupported()
- return nil, nil
-}
diff --git a/vendor/golang.org/x/tools/internal/typeparams/typeparams_go118.go b/vendor/golang.org/x/tools/internal/typeparams/typeparams_go118.go
deleted file mode 100644
index cf301af1db..0000000000
--- a/vendor/golang.org/x/tools/internal/typeparams/typeparams_go118.go
+++ /dev/null
@@ -1,151 +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.
-
-//go:build go1.18
-// +build go1.18
-
-package typeparams
-
-import (
- "go/ast"
- "go/types"
-)
-
-// IndexListExpr is an alias for ast.IndexListExpr.
-type IndexListExpr = ast.IndexListExpr
-
-// ForTypeSpec returns n.TypeParams.
-func ForTypeSpec(n *ast.TypeSpec) *ast.FieldList {
- if n == nil {
- return nil
- }
- return n.TypeParams
-}
-
-// ForFuncType returns n.TypeParams.
-func ForFuncType(n *ast.FuncType) *ast.FieldList {
- if n == nil {
- return nil
- }
- return n.TypeParams
-}
-
-// TypeParam is an alias for types.TypeParam
-type TypeParam = types.TypeParam
-
-// TypeParamList is an alias for types.TypeParamList
-type TypeParamList = types.TypeParamList
-
-// TypeList is an alias for types.TypeList
-type TypeList = types.TypeList
-
-// NewTypeParam calls types.NewTypeParam.
-func NewTypeParam(name *types.TypeName, constraint types.Type) *TypeParam {
- return types.NewTypeParam(name, constraint)
-}
-
-// SetTypeParamConstraint calls tparam.SetConstraint(constraint).
-func SetTypeParamConstraint(tparam *TypeParam, constraint types.Type) {
- tparam.SetConstraint(constraint)
-}
-
-// NewSignatureType calls types.NewSignatureType.
-func NewSignatureType(recv *types.Var, recvTypeParams, typeParams []*TypeParam, params, results *types.Tuple, variadic bool) *types.Signature {
- return types.NewSignatureType(recv, recvTypeParams, typeParams, params, results, variadic)
-}
-
-// ForSignature returns sig.TypeParams()
-func ForSignature(sig *types.Signature) *TypeParamList {
- return sig.TypeParams()
-}
-
-// RecvTypeParams returns sig.RecvTypeParams().
-func RecvTypeParams(sig *types.Signature) *TypeParamList {
- return sig.RecvTypeParams()
-}
-
-// IsComparable calls iface.IsComparable().
-func IsComparable(iface *types.Interface) bool {
- return iface.IsComparable()
-}
-
-// IsMethodSet calls iface.IsMethodSet().
-func IsMethodSet(iface *types.Interface) bool {
- return iface.IsMethodSet()
-}
-
-// IsImplicit calls iface.IsImplicit().
-func IsImplicit(iface *types.Interface) bool {
- return iface.IsImplicit()
-}
-
-// MarkImplicit calls iface.MarkImplicit().
-func MarkImplicit(iface *types.Interface) {
- iface.MarkImplicit()
-}
-
-// ForNamed extracts the (possibly empty) type parameter object list from
-// named.
-func ForNamed(named *types.Named) *TypeParamList {
- return named.TypeParams()
-}
-
-// SetForNamed sets the type params tparams on n. Each tparam must be of
-// dynamic type *types.TypeParam.
-func SetForNamed(n *types.Named, tparams []*TypeParam) {
- n.SetTypeParams(tparams)
-}
-
-// NamedTypeArgs returns named.TypeArgs().
-func NamedTypeArgs(named *types.Named) *TypeList {
- return named.TypeArgs()
-}
-
-// NamedTypeOrigin returns named.Orig().
-func NamedTypeOrigin(named *types.Named) *types.Named {
- return named.Origin()
-}
-
-// Term is an alias for types.Term.
-type Term = types.Term
-
-// NewTerm calls types.NewTerm.
-func NewTerm(tilde bool, typ types.Type) *Term {
- return types.NewTerm(tilde, typ)
-}
-
-// Union is an alias for types.Union
-type Union = types.Union
-
-// NewUnion calls types.NewUnion.
-func NewUnion(terms []*Term) *Union {
- return types.NewUnion(terms)
-}
-
-// InitInstanceInfo initializes info to record information about type and
-// function instances.
-func InitInstanceInfo(info *types.Info) {
- info.Instances = make(map[*ast.Ident]types.Instance)
-}
-
-// Instance is an alias for types.Instance.
-type Instance = types.Instance
-
-// GetInstances returns info.Instances.
-func GetInstances(info *types.Info) map[*ast.Ident]Instance {
- return info.Instances
-}
-
-// Context is an alias for types.Context.
-type Context = types.Context
-
-// NewContext calls types.NewContext.
-func NewContext() *Context {
- return types.NewContext()
-}
-
-// Instantiate calls types.Instantiate.
-func Instantiate(ctxt *Context, typ types.Type, targs []types.Type, validate bool) (types.Type, error) {
- return types.Instantiate(ctxt, typ, targs, validate)
-}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/element.go b/vendor/golang.org/x/tools/internal/typesinternal/element.go
new file mode 100644
index 0000000000..4957f02164
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typesinternal/element.go
@@ -0,0 +1,133 @@
+// Copyright 2024 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 typesinternal
+
+import (
+ "fmt"
+ "go/types"
+
+ "golang.org/x/tools/go/types/typeutil"
+)
+
+// ForEachElement calls f for type T and each type reachable from its
+// type through reflection. It does this by recursively stripping off
+// type constructors; in addition, for each named type N, the type *N
+// is added to the result as it may have additional methods.
+//
+// The caller must provide an initially empty set used to de-duplicate
+// identical types, potentially across multiple calls to ForEachElement.
+// (Its final value holds all the elements seen, matching the arguments
+// passed to f.)
+//
+// TODO(adonovan): share/harmonize with go/callgraph/rta.
+func ForEachElement(rtypes *typeutil.Map, msets *typeutil.MethodSetCache, T types.Type, f func(types.Type)) {
+ var visit func(T types.Type, skip bool)
+ visit = func(T types.Type, skip bool) {
+ if !skip {
+ if seen, _ := rtypes.Set(T, true).(bool); seen {
+ return // de-dup
+ }
+
+ f(T) // notify caller of new element type
+ }
+
+ // Recursion over signatures of each method.
+ tmset := msets.MethodSet(T)
+ for i := 0; i < tmset.Len(); i++ {
+ sig := tmset.At(i).Type().(*types.Signature)
+ // It is tempting to call visit(sig, false)
+ // but, as noted in golang.org/cl/65450043,
+ // the Signature.Recv field is ignored by
+ // types.Identical and typeutil.Map, which
+ // is confusing at best.
+ //
+ // More importantly, the true signature rtype
+ // reachable from a method using reflection
+ // has no receiver but an extra ordinary parameter.
+ // For the Read method of io.Reader we want:
+ // func(Reader, []byte) (int, error)
+ // but here sig is:
+ // func([]byte) (int, error)
+ // with .Recv = Reader (though it is hard to
+ // notice because it doesn't affect Signature.String
+ // or types.Identical).
+ //
+ // TODO(adonovan): construct and visit the correct
+ // non-method signature with an extra parameter
+ // (though since unnamed func types have no methods
+ // there is essentially no actual demand for this).
+ //
+ // TODO(adonovan): document whether or not it is
+ // safe to skip non-exported methods (as RTA does).
+ visit(sig.Params(), true) // skip the Tuple
+ visit(sig.Results(), true) // skip the Tuple
+ }
+
+ switch T := T.(type) {
+ case *types.Alias:
+ visit(types.Unalias(T), skip) // emulates the pre-Alias behavior
+
+ case *types.Basic:
+ // nop
+
+ case *types.Interface:
+ // nop---handled by recursion over method set.
+
+ case *types.Pointer:
+ visit(T.Elem(), false)
+
+ case *types.Slice:
+ visit(T.Elem(), false)
+
+ case *types.Chan:
+ visit(T.Elem(), false)
+
+ case *types.Map:
+ visit(T.Key(), false)
+ visit(T.Elem(), false)
+
+ case *types.Signature:
+ if T.Recv() != nil {
+ panic(fmt.Sprintf("Signature %s has Recv %s", T, T.Recv()))
+ }
+ visit(T.Params(), true) // skip the Tuple
+ visit(T.Results(), true) // skip the Tuple
+
+ case *types.Named:
+ // A pointer-to-named type can be derived from a named
+ // type via reflection. It may have methods too.
+ visit(types.NewPointer(T), false)
+
+ // Consider 'type T struct{S}' where S has methods.
+ // Reflection provides no way to get from T to struct{S},
+ // only to S, so the method set of struct{S} is unwanted,
+ // so set 'skip' flag during recursion.
+ visit(T.Underlying(), true) // skip the unnamed type
+
+ case *types.Array:
+ visit(T.Elem(), false)
+
+ case *types.Struct:
+ for i, n := 0, T.NumFields(); i < n; i++ {
+ // TODO(adonovan): document whether or not
+ // it is safe to skip non-exported fields.
+ visit(T.Field(i).Type(), false)
+ }
+
+ case *types.Tuple:
+ for i, n := 0, T.Len(); i < n; i++ {
+ visit(T.At(i).Type(), false)
+ }
+
+ case *types.TypeParam, *types.Union:
+ // forEachReachable must not be called on parameterized types.
+ panic(T)
+
+ default:
+ panic(T)
+ }
+ }
+ visit(T, false)
+}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/errorcode.go b/vendor/golang.org/x/tools/internal/typesinternal/errorcode.go
index 07484073a5..131caab284 100644
--- a/vendor/golang.org/x/tools/internal/typesinternal/errorcode.go
+++ b/vendor/golang.org/x/tools/internal/typesinternal/errorcode.go
@@ -167,7 +167,7 @@ const (
UntypedNilUse
// WrongAssignCount occurs when the number of values on the right-hand side
- // of an assignment or or initialization expression does not match the number
+ // of an assignment or initialization expression does not match the number
// of variables on the left-hand side.
//
// Example:
@@ -838,7 +838,7 @@ const (
// InvalidCap occurs when an argument to the cap built-in function is not of
// supported type.
//
- // See https://golang.org/ref/spec#Lengthand_capacity for information on
+ // See https://golang.org/ref/spec#Length_and_capacity for information on
// which underlying types are supported as arguments to cap and len.
//
// Example:
@@ -859,7 +859,7 @@ const (
// InvalidCopy occurs when the arguments are not of slice type or do not
// have compatible type.
//
- // See https://golang.org/ref/spec#Appendingand_copying_slices for more
+ // See https://golang.org/ref/spec#Appending_and_copying_slices for more
// information on the type requirements for the copy built-in.
//
// Example:
@@ -897,7 +897,7 @@ const (
// InvalidLen occurs when an argument to the len built-in function is not of
// supported type.
//
- // See https://golang.org/ref/spec#Lengthand_capacity for information on
+ // See https://golang.org/ref/spec#Length_and_capacity for information on
// which underlying types are supported as arguments to cap and len.
//
// Example:
@@ -914,7 +914,7 @@ const (
// InvalidMake occurs when make is called with an unsupported type argument.
//
- // See https://golang.org/ref/spec#Makingslices_maps_and_channels for
+ // See https://golang.org/ref/spec#Making_slices_maps_and_channels for
// information on the types that may be created using make.
//
// Example:
@@ -1449,10 +1449,10 @@ const (
NotAGenericType
// WrongTypeArgCount occurs when a type or function is instantiated with an
- // incorrent number of type arguments, including when a generic type or
+ // incorrect number of type arguments, including when a generic type or
// function is used without instantiation.
//
- // Errors inolving failed type inference are assigned other error codes.
+ // Errors involving failed type inference are assigned other error codes.
//
// Example:
// type T[p any] int
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/objectpath.go b/vendor/golang.org/x/tools/internal/typesinternal/objectpath.go
deleted file mode 100644
index 5e96e89557..0000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/objectpath.go
+++ /dev/null
@@ -1,24 +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.
-
-package typesinternal
-
-import "go/types"
-
-// This file contains back doors that allow gopls to avoid method sorting when
-// using the objectpath package.
-//
-// This is performance-critical in certain repositories, but changing the
-// behavior of the objectpath package is still being discussed in
-// golang/go#61443. If we decide to remove the sorting in objectpath we can
-// simply delete these back doors. Otherwise, we should add a new API to
-// objectpath that allows controlling the sorting.
-
-// SkipEncoderMethodSorting marks enc (which must be an *objectpath.Encoder) as
-// not requiring sorted methods.
-var SkipEncoderMethodSorting func(enc interface{})
-
-// ObjectpathObject is like objectpath.Object, but allows suppressing method
-// sorting.
-var ObjectpathObject func(pkg *types.Package, p string, skipMethodSorting bool) (types.Object, error)
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/recv.go b/vendor/golang.org/x/tools/internal/typesinternal/recv.go
new file mode 100644
index 0000000000..ba6f4f4ebd
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typesinternal/recv.go
@@ -0,0 +1,41 @@
+// Copyright 2024 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 typesinternal
+
+import (
+ "go/types"
+)
+
+// ReceiverNamed returns the named type (if any) associated with the
+// type of recv, which may be of the form N or *N, or aliases thereof.
+// It also reports whether a Pointer was present.
+func ReceiverNamed(recv *types.Var) (isPtr bool, named *types.Named) {
+ t := recv.Type()
+ if ptr, ok := types.Unalias(t).(*types.Pointer); ok {
+ isPtr = true
+ t = ptr.Elem()
+ }
+ named, _ = types.Unalias(t).(*types.Named)
+ return
+}
+
+// Unpointer returns T given *T or an alias thereof.
+// For all other types it is the identity function.
+// It does not look at underlying types.
+// The result may be an alias.
+//
+// Use this function to strip off the optional pointer on a receiver
+// in a field or method selection, without losing the named type
+// (which is needed to compute the method set).
+//
+// See also [typeparams.MustDeref], which removes one level of
+// indirection from the type, regardless of named types (analogous to
+// a LOAD instruction).
+func Unpointer(t types.Type) types.Type {
+ if ptr, ok := types.Unalias(t).(*types.Pointer); ok {
+ return ptr.Elem()
+ }
+ return t
+}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/toonew.go b/vendor/golang.org/x/tools/internal/typesinternal/toonew.go
new file mode 100644
index 0000000000..cc86487eaa
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typesinternal/toonew.go
@@ -0,0 +1,89 @@
+// Copyright 2024 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 typesinternal
+
+import (
+ "go/types"
+
+ "golang.org/x/tools/internal/stdlib"
+ "golang.org/x/tools/internal/versions"
+)
+
+// TooNewStdSymbols computes the set of package-level symbols
+// exported by pkg that are not available at the specified version.
+// The result maps each symbol to its minimum version.
+//
+// The pkg is allowed to contain type errors.
+func TooNewStdSymbols(pkg *types.Package, version string) map[types.Object]string {
+ disallowed := make(map[types.Object]string)
+
+ // Pass 1: package-level symbols.
+ symbols := stdlib.PackageSymbols[pkg.Path()]
+ for _, sym := range symbols {
+ symver := sym.Version.String()
+ if versions.Before(version, symver) {
+ switch sym.Kind {
+ case stdlib.Func, stdlib.Var, stdlib.Const, stdlib.Type:
+ disallowed[pkg.Scope().Lookup(sym.Name)] = symver
+ }
+ }
+ }
+
+ // Pass 2: fields and methods.
+ //
+ // We allow fields and methods if their associated type is
+ // disallowed, as otherwise we would report false positives
+ // for compatibility shims. Consider:
+ //
+ // //go:build go1.22
+ // type T struct { F std.Real } // correct new API
+ //
+ // //go:build !go1.22
+ // type T struct { F fake } // shim
+ // type fake struct { ... }
+ // func (fake) M () {}
+ //
+ // These alternative declarations of T use either the std.Real
+ // type, introduced in go1.22, or a fake type, for the field
+ // F. (The fakery could be arbitrarily deep, involving more
+ // nested fields and methods than are shown here.) Clients
+ // that use the compatibility shim T will compile with any
+ // version of go, whether older or newer than go1.22, but only
+ // the newer version will use the std.Real implementation.
+ //
+ // Now consider a reference to method M in new(T).F.M() in a
+ // module that requires a minimum of go1.21. The analysis may
+ // occur using a version of Go higher than 1.21, selecting the
+ // first version of T, so the method M is Real.M. This would
+ // spuriously cause the analyzer to report a reference to a
+ // too-new symbol even though this expression compiles just
+ // fine (with the fake implementation) using go1.21.
+ for _, sym := range symbols {
+ symVersion := sym.Version.String()
+ if !versions.Before(version, symVersion) {
+ continue // allowed
+ }
+
+ var obj types.Object
+ switch sym.Kind {
+ case stdlib.Field:
+ typename, name := sym.SplitField()
+ if t := pkg.Scope().Lookup(typename); t != nil && disallowed[t] == "" {
+ obj, _, _ = types.LookupFieldOrMethod(t.Type(), false, pkg, name)
+ }
+
+ case stdlib.Method:
+ ptr, recvname, name := sym.SplitMethod()
+ if t := pkg.Scope().Lookup(recvname); t != nil && disallowed[t] == "" {
+ obj, _, _ = types.LookupFieldOrMethod(t.Type(), ptr, pkg, name)
+ }
+ }
+ if obj != nil {
+ disallowed[obj] = symVersion
+ }
+ }
+
+ return disallowed
+}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/types.go b/vendor/golang.org/x/tools/internal/typesinternal/types.go
index ce7d4351b2..df3ea52125 100644
--- a/vendor/golang.org/x/tools/internal/typesinternal/types.go
+++ b/vendor/golang.org/x/tools/internal/typesinternal/types.go
@@ -11,6 +11,8 @@ import (
"go/types"
"reflect"
"unsafe"
+
+ "golang.org/x/tools/internal/aliases"
)
func SetUsesCgo(conf *types.Config) bool {
@@ -49,4 +51,71 @@ func ReadGo116ErrorData(err types.Error) (code ErrorCode, start, end token.Pos,
return ErrorCode(data[0]), token.Pos(data[1]), token.Pos(data[2]), true
}
-var SetGoVersion = func(conf *types.Config, version string) bool { return false }
+// NameRelativeTo returns a types.Qualifier that qualifies members of
+// all packages other than pkg, using only the package name.
+// (By contrast, [types.RelativeTo] uses the complete package path,
+// which is often excessive.)
+//
+// If pkg is nil, it is equivalent to [*types.Package.Name].
+func NameRelativeTo(pkg *types.Package) types.Qualifier {
+ return func(other *types.Package) string {
+ if pkg != nil && pkg == other {
+ return "" // same package; unqualified
+ }
+ return other.Name()
+ }
+}
+
+// A NamedOrAlias is a [types.Type] that is named (as
+// defined by the spec) and capable of bearing type parameters: it
+// abstracts aliases ([types.Alias]) and defined types
+// ([types.Named]).
+//
+// Every type declared by an explicit "type" declaration is a
+// NamedOrAlias. (Built-in type symbols may additionally
+// have type [types.Basic], which is not a NamedOrAlias,
+// though the spec regards them as "named".)
+//
+// NamedOrAlias cannot expose the Origin method, because
+// [types.Alias.Origin] and [types.Named.Origin] have different
+// (covariant) result types; use [Origin] instead.
+type NamedOrAlias interface {
+ types.Type
+ Obj() *types.TypeName
+}
+
+// TypeParams is a light shim around t.TypeParams().
+// (go/types.Alias).TypeParams requires >= 1.23.
+func TypeParams(t NamedOrAlias) *types.TypeParamList {
+ switch t := t.(type) {
+ case *types.Alias:
+ return aliases.TypeParams(t)
+ case *types.Named:
+ return t.TypeParams()
+ }
+ return nil
+}
+
+// TypeArgs is a light shim around t.TypeArgs().
+// (go/types.Alias).TypeArgs requires >= 1.23.
+func TypeArgs(t NamedOrAlias) *types.TypeList {
+ switch t := t.(type) {
+ case *types.Alias:
+ return aliases.TypeArgs(t)
+ case *types.Named:
+ return t.TypeArgs()
+ }
+ return nil
+}
+
+// Origin returns the generic type of the Named or Alias type t if it
+// is instantiated, otherwise it returns t.
+func Origin(t NamedOrAlias) NamedOrAlias {
+ switch t := t.(type) {
+ case *types.Alias:
+ return aliases.Origin(t)
+ case *types.Named:
+ return t.Origin()
+ }
+ return t
+}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/types_118.go b/vendor/golang.org/x/tools/internal/typesinternal/types_118.go
deleted file mode 100644
index a42b072a67..0000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/types_118.go
+++ /dev/null
@@ -1,19 +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.
-
-//go:build go1.18
-// +build go1.18
-
-package typesinternal
-
-import (
- "go/types"
-)
-
-func init() {
- SetGoVersion = func(conf *types.Config, version string) bool {
- conf.GoVersion = version
- return true
- }
-}
diff --git a/vendor/golang.org/x/tools/internal/versions/constraint.go b/vendor/golang.org/x/tools/internal/versions/constraint.go
new file mode 100644
index 0000000000..179063d484
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/versions/constraint.go
@@ -0,0 +1,13 @@
+// Copyright 2024 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 versions
+
+import "go/build/constraint"
+
+// ConstraintGoVersion is constraint.GoVersion (if built with go1.21+).
+// Otherwise nil.
+//
+// Deprecate once x/tools is after go1.21.
+var ConstraintGoVersion func(x constraint.Expr) string
diff --git a/vendor/golang.org/x/tools/internal/versions/constraint_go121.go b/vendor/golang.org/x/tools/internal/versions/constraint_go121.go
new file mode 100644
index 0000000000..38011407d5
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/versions/constraint_go121.go
@@ -0,0 +1,14 @@
+// Copyright 2024 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 go1.21
+// +build go1.21
+
+package versions
+
+import "go/build/constraint"
+
+func init() {
+ ConstraintGoVersion = constraint.GoVersion
+}
diff --git a/vendor/golang.org/x/tools/internal/versions/features.go b/vendor/golang.org/x/tools/internal/versions/features.go
new file mode 100644
index 0000000000..b53f178616
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/versions/features.go
@@ -0,0 +1,43 @@
+// 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.
+
+package versions
+
+// This file contains predicates for working with file versions to
+// decide when a tool should consider a language feature enabled.
+
+// GoVersions that features in x/tools can be gated to.
+const (
+ Go1_18 = "go1.18"
+ Go1_19 = "go1.19"
+ Go1_20 = "go1.20"
+ Go1_21 = "go1.21"
+ Go1_22 = "go1.22"
+)
+
+// Future is an invalid unknown Go version sometime in the future.
+// Do not use directly with Compare.
+const Future = ""
+
+// AtLeast reports whether the file version v comes after a Go release.
+//
+// Use this predicate to enable a behavior once a certain Go release
+// has happened (and stays enabled in the future).
+func AtLeast(v, release string) bool {
+ if v == Future {
+ return true // an unknown future version is always after y.
+ }
+ return Compare(Lang(v), Lang(release)) >= 0
+}
+
+// Before reports whether the file version v is strictly before a Go release.
+//
+// Use this predicate to disable a behavior once a certain Go release
+// has happened (and stays enabled in the future).
+func Before(v, release string) bool {
+ if v == Future {
+ return false // an unknown future version happens after y.
+ }
+ return Compare(Lang(v), Lang(release)) < 0
+}
diff --git a/vendor/golang.org/x/tools/internal/versions/gover.go b/vendor/golang.org/x/tools/internal/versions/gover.go
new file mode 100644
index 0000000000..bbabcd22e9
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/versions/gover.go
@@ -0,0 +1,172 @@
+// 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.
+
+// This is a fork of internal/gover for use by x/tools until
+// go1.21 and earlier are no longer supported by x/tools.
+
+package versions
+
+import "strings"
+
+// A gover is a parsed Go gover: major[.Minor[.Patch]][kind[pre]]
+// The numbers are the original decimal strings to avoid integer overflows
+// and since there is very little actual math. (Probably overflow doesn't matter in practice,
+// but at the time this code was written, there was an existing test that used
+// go1.99999999999, which does not fit in an int on 32-bit platforms.
+// The "big decimal" representation avoids the problem entirely.)
+type gover struct {
+ major string // decimal
+ minor string // decimal or ""
+ patch string // decimal or ""
+ kind string // "", "alpha", "beta", "rc"
+ pre string // decimal or ""
+}
+
+// compare returns -1, 0, or +1 depending on whether
+// x < y, x == y, or x > y, interpreted as toolchain versions.
+// The versions x and y must not begin with a "go" prefix: just "1.21" not "go1.21".
+// Malformed versions compare less than well-formed versions and equal to each other.
+// The language version "1.21" compares less than the release candidate and eventual releases "1.21rc1" and "1.21.0".
+func compare(x, y string) int {
+ vx := parse(x)
+ vy := parse(y)
+
+ if c := cmpInt(vx.major, vy.major); c != 0 {
+ return c
+ }
+ if c := cmpInt(vx.minor, vy.minor); c != 0 {
+ return c
+ }
+ if c := cmpInt(vx.patch, vy.patch); c != 0 {
+ return c
+ }
+ if c := strings.Compare(vx.kind, vy.kind); c != 0 { // "" < alpha < beta < rc
+ return c
+ }
+ if c := cmpInt(vx.pre, vy.pre); c != 0 {
+ return c
+ }
+ return 0
+}
+
+// lang returns the Go language version. For example, lang("1.2.3") == "1.2".
+func lang(x string) string {
+ v := parse(x)
+ if v.minor == "" || v.major == "1" && v.minor == "0" {
+ return v.major
+ }
+ return v.major + "." + v.minor
+}
+
+// isValid reports whether the version x is valid.
+func isValid(x string) bool {
+ return parse(x) != gover{}
+}
+
+// parse parses the Go version string x into a version.
+// It returns the zero version if x is malformed.
+func parse(x string) gover {
+ var v gover
+
+ // Parse major version.
+ var ok bool
+ v.major, x, ok = cutInt(x)
+ if !ok {
+ return gover{}
+ }
+ if x == "" {
+ // Interpret "1" as "1.0.0".
+ v.minor = "0"
+ v.patch = "0"
+ return v
+ }
+
+ // Parse . before minor version.
+ if x[0] != '.' {
+ return gover{}
+ }
+
+ // Parse minor version.
+ v.minor, x, ok = cutInt(x[1:])
+ if !ok {
+ return gover{}
+ }
+ if x == "" {
+ // Patch missing is same as "0" for older versions.
+ // Starting in Go 1.21, patch missing is different from explicit .0.
+ if cmpInt(v.minor, "21") < 0 {
+ v.patch = "0"
+ }
+ return v
+ }
+
+ // Parse patch if present.
+ if x[0] == '.' {
+ v.patch, x, ok = cutInt(x[1:])
+ if !ok || x != "" {
+ // Note that we are disallowing prereleases (alpha, beta, rc) for patch releases here (x != "").
+ // Allowing them would be a bit confusing because we already have:
+ // 1.21 < 1.21rc1
+ // But a prerelease of a patch would have the opposite effect:
+ // 1.21.3rc1 < 1.21.3
+ // We've never needed them before, so let's not start now.
+ return gover{}
+ }
+ return v
+ }
+
+ // Parse prerelease.
+ i := 0
+ for i < len(x) && (x[i] < '0' || '9' < x[i]) {
+ if x[i] < 'a' || 'z' < x[i] {
+ return gover{}
+ }
+ i++
+ }
+ if i == 0 {
+ return gover{}
+ }
+ v.kind, x = x[:i], x[i:]
+ if x == "" {
+ return v
+ }
+ v.pre, x, ok = cutInt(x)
+ if !ok || x != "" {
+ return gover{}
+ }
+
+ return v
+}
+
+// cutInt scans the leading decimal number at the start of x to an integer
+// and returns that value and the rest of the string.
+func cutInt(x string) (n, rest string, ok bool) {
+ i := 0
+ for i < len(x) && '0' <= x[i] && x[i] <= '9' {
+ i++
+ }
+ if i == 0 || x[0] == '0' && i != 1 { // no digits or unnecessary leading zero
+ return "", "", false
+ }
+ return x[:i], x[i:], true
+}
+
+// cmpInt returns cmp.Compare(x, y) interpreting x and y as decimal numbers.
+// (Copied from golang.org/x/mod/semver's compareInt.)
+func cmpInt(x, y string) int {
+ if x == y {
+ return 0
+ }
+ if len(x) < len(y) {
+ return -1
+ }
+ if len(x) > len(y) {
+ return +1
+ }
+ if x < y {
+ return -1
+ } else {
+ return +1
+ }
+}
diff --git a/vendor/golang.org/x/tools/internal/versions/types.go b/vendor/golang.org/x/tools/internal/versions/types.go
new file mode 100644
index 0000000000..0fc10ce4eb
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/versions/types.go
@@ -0,0 +1,33 @@
+// 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.
+
+package versions
+
+import (
+ "go/ast"
+ "go/types"
+)
+
+// FileVersion returns a file's Go version.
+// The reported version is an unknown Future version if a
+// version cannot be determined.
+func FileVersion(info *types.Info, file *ast.File) string {
+ // In tools built with Go >= 1.22, the Go version of a file
+ // follow a cascades of sources:
+ // 1) types.Info.FileVersion, which follows the cascade:
+ // 1.a) file version (ast.File.GoVersion),
+ // 1.b) the package version (types.Config.GoVersion), or
+ // 2) is some unknown Future version.
+ //
+ // File versions require a valid package version to be provided to types
+ // in Config.GoVersion. Config.GoVersion is either from the package's module
+ // or the toolchain (go run). This value should be provided by go/packages
+ // or unitchecker.Config.GoVersion.
+ if v := info.FileVersions[file]; IsValid(v) {
+ return v
+ }
+ // Note: we could instead return runtime.Version() [if valid].
+ // This would act as a max version on what a tool can support.
+ return Future
+}
diff --git a/vendor/golang.org/x/tools/internal/versions/versions.go b/vendor/golang.org/x/tools/internal/versions/versions.go
new file mode 100644
index 0000000000..8d1f7453db
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/versions/versions.go
@@ -0,0 +1,57 @@
+// 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.
+
+package versions
+
+import (
+ "strings"
+)
+
+// Note: If we use build tags to use go/versions when go >=1.22,
+// we run into go.dev/issue/53737. Under some operations users would see an
+// import of "go/versions" even if they would not compile the file.
+// For example, during `go get -u ./...` (go.dev/issue/64490) we do not try to include
+// For this reason, this library just a clone of go/versions for the moment.
+
+// Lang returns the Go language version for version x.
+// If x is not a valid version, Lang returns the empty string.
+// For example:
+//
+// Lang("go1.21rc2") = "go1.21"
+// Lang("go1.21.2") = "go1.21"
+// Lang("go1.21") = "go1.21"
+// Lang("go1") = "go1"
+// Lang("bad") = ""
+// Lang("1.21") = ""
+func Lang(x string) string {
+ v := lang(stripGo(x))
+ if v == "" {
+ return ""
+ }
+ return x[:2+len(v)] // "go"+v without allocation
+}
+
+// Compare returns -1, 0, or +1 depending on whether
+// x < y, x == y, or x > y, interpreted as Go versions.
+// The versions x and y must begin with a "go" prefix: "go1.21" not "1.21".
+// Invalid versions, including the empty string, compare less than
+// valid versions and equal to each other.
+// The language version "go1.21" compares less than the
+// release candidate and eventual releases "go1.21rc1" and "go1.21.0".
+// Custom toolchain suffixes are ignored during comparison:
+// "go1.21.0" and "go1.21.0-bigcorp" are equal.
+func Compare(x, y string) int { return compare(stripGo(x), stripGo(y)) }
+
+// IsValid reports whether the version x is valid.
+func IsValid(x string) bool { return isValid(stripGo(x)) }
+
+// stripGo converts from a "go1.21" version to a "1.21" version.
+// If v does not start with "go", stripGo returns the empty string (a known invalid version).
+func stripGo(v string) string {
+ v, _, _ = strings.Cut(v, "-") // strip -bigcorp suffix.
+ if len(v) < 2 || v[:2] != "go" {
+ return ""
+ }
+ return v[2:]
+}
diff --git a/vendor/google.golang.org/appengine/internal/api.go b/vendor/google.golang.org/appengine/internal/api.go
deleted file mode 100644
index 0569f5dd43..0000000000
--- a/vendor/google.golang.org/appengine/internal/api.go
+++ /dev/null
@@ -1,653 +0,0 @@
-// Copyright 2011 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-//go:build !appengine
-// +build !appengine
-
-package internal
-
-import (
- "bytes"
- "context"
- "errors"
- "fmt"
- "io/ioutil"
- "log"
- "net"
- "net/http"
- "net/url"
- "os"
- "runtime"
- "strconv"
- "strings"
- "sync"
- "sync/atomic"
- "time"
-
- "github.com/golang/protobuf/proto"
-
- basepb "google.golang.org/appengine/internal/base"
- logpb "google.golang.org/appengine/internal/log"
- remotepb "google.golang.org/appengine/internal/remote_api"
-)
-
-const (
- apiPath = "/rpc_http"
-)
-
-var (
- // Incoming headers.
- ticketHeader = http.CanonicalHeaderKey("X-AppEngine-API-Ticket")
- dapperHeader = http.CanonicalHeaderKey("X-Google-DapperTraceInfo")
- traceHeader = http.CanonicalHeaderKey("X-Cloud-Trace-Context")
- curNamespaceHeader = http.CanonicalHeaderKey("X-AppEngine-Current-Namespace")
- userIPHeader = http.CanonicalHeaderKey("X-AppEngine-User-IP")
- remoteAddrHeader = http.CanonicalHeaderKey("X-AppEngine-Remote-Addr")
- devRequestIdHeader = http.CanonicalHeaderKey("X-Appengine-Dev-Request-Id")
-
- // Outgoing headers.
- apiEndpointHeader = http.CanonicalHeaderKey("X-Google-RPC-Service-Endpoint")
- apiEndpointHeaderValue = []string{"app-engine-apis"}
- apiMethodHeader = http.CanonicalHeaderKey("X-Google-RPC-Service-Method")
- apiMethodHeaderValue = []string{"/VMRemoteAPI.CallRemoteAPI"}
- apiDeadlineHeader = http.CanonicalHeaderKey("X-Google-RPC-Service-Deadline")
- apiContentType = http.CanonicalHeaderKey("Content-Type")
- apiContentTypeValue = []string{"application/octet-stream"}
- logFlushHeader = http.CanonicalHeaderKey("X-AppEngine-Log-Flush-Count")
-
- apiHTTPClient = &http.Client{
- Transport: &http.Transport{
- Proxy: http.ProxyFromEnvironment,
- Dial: limitDial,
- MaxIdleConns: 1000,
- MaxIdleConnsPerHost: 10000,
- IdleConnTimeout: 90 * time.Second,
- },
- }
-)
-
-func apiURL(ctx context.Context) *url.URL {
- host, port := "appengine.googleapis.internal", "10001"
- if h := os.Getenv("API_HOST"); h != "" {
- host = h
- }
- if hostOverride := ctx.Value(apiHostOverrideKey); hostOverride != nil {
- host = hostOverride.(string)
- }
- if p := os.Getenv("API_PORT"); p != "" {
- port = p
- }
- if portOverride := ctx.Value(apiPortOverrideKey); portOverride != nil {
- port = portOverride.(string)
- }
- return &url.URL{
- Scheme: "http",
- Host: host + ":" + port,
- Path: apiPath,
- }
-}
-
-// Middleware wraps an http handler so that it can make GAE API calls
-func Middleware(next http.Handler) http.Handler {
- return handleHTTPMiddleware(executeRequestSafelyMiddleware(next))
-}
-
-func handleHTTPMiddleware(next http.Handler) http.Handler {
- return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- c := &aeContext{
- req: r,
- outHeader: w.Header(),
- }
- r = r.WithContext(withContext(r.Context(), c))
- c.req = r
-
- stopFlushing := make(chan int)
-
- // Patch up RemoteAddr so it looks reasonable.
- if addr := r.Header.Get(userIPHeader); addr != "" {
- r.RemoteAddr = addr
- } else if addr = r.Header.Get(remoteAddrHeader); addr != "" {
- r.RemoteAddr = addr
- } else {
- // Should not normally reach here, but pick a sensible default anyway.
- r.RemoteAddr = "127.0.0.1"
- }
- // The address in the headers will most likely be of these forms:
- // 123.123.123.123
- // 2001:db8::1
- // net/http.Request.RemoteAddr is specified to be in "IP:port" form.
- if _, _, err := net.SplitHostPort(r.RemoteAddr); err != nil {
- // Assume the remote address is only a host; add a default port.
- r.RemoteAddr = net.JoinHostPort(r.RemoteAddr, "80")
- }
-
- if logToLogservice() {
- // Start goroutine responsible for flushing app logs.
- // This is done after adding c to ctx.m (and stopped before removing it)
- // because flushing logs requires making an API call.
- go c.logFlusher(stopFlushing)
- }
-
- next.ServeHTTP(c, r)
- c.outHeader = nil // make sure header changes aren't respected any more
-
- flushed := make(chan struct{})
- if logToLogservice() {
- stopFlushing <- 1 // any logging beyond this point will be dropped
-
- // Flush any pending logs asynchronously.
- c.pendingLogs.Lock()
- flushes := c.pendingLogs.flushes
- if len(c.pendingLogs.lines) > 0 {
- flushes++
- }
- c.pendingLogs.Unlock()
- go func() {
- defer close(flushed)
- // Force a log flush, because with very short requests we
- // may not ever flush logs.
- c.flushLog(true)
- }()
- w.Header().Set(logFlushHeader, strconv.Itoa(flushes))
- }
-
- // Avoid nil Write call if c.Write is never called.
- if c.outCode != 0 {
- w.WriteHeader(c.outCode)
- }
- if c.outBody != nil {
- w.Write(c.outBody)
- }
- if logToLogservice() {
- // Wait for the last flush to complete before returning,
- // otherwise the security ticket will not be valid.
- <-flushed
- }
- })
-}
-
-func executeRequestSafelyMiddleware(next http.Handler) http.Handler {
- return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- defer func() {
- if x := recover(); x != nil {
- c := w.(*aeContext)
- logf(c, 4, "%s", renderPanic(x)) // 4 == critical
- c.outCode = 500
- }
- }()
-
- next.ServeHTTP(w, r)
- })
-}
-
-func renderPanic(x interface{}) string {
- buf := make([]byte, 16<<10) // 16 KB should be plenty
- buf = buf[:runtime.Stack(buf, false)]
-
- // Remove the first few stack frames:
- // this func
- // the recover closure in the caller
- // That will root the stack trace at the site of the panic.
- const (
- skipStart = "internal.renderPanic"
- skipFrames = 2
- )
- start := bytes.Index(buf, []byte(skipStart))
- p := start
- for i := 0; i < skipFrames*2 && p+1 < len(buf); i++ {
- p = bytes.IndexByte(buf[p+1:], '\n') + p + 1
- if p < 0 {
- break
- }
- }
- if p >= 0 {
- // buf[start:p+1] is the block to remove.
- // Copy buf[p+1:] over buf[start:] and shrink buf.
- copy(buf[start:], buf[p+1:])
- buf = buf[:len(buf)-(p+1-start)]
- }
-
- // Add panic heading.
- head := fmt.Sprintf("panic: %v\n\n", x)
- if len(head) > len(buf) {
- // Extremely unlikely to happen.
- return head
- }
- copy(buf[len(head):], buf)
- copy(buf, head)
-
- return string(buf)
-}
-
-// aeContext represents the aeContext of an in-flight HTTP request.
-// It implements the appengine.Context and http.ResponseWriter interfaces.
-type aeContext struct {
- req *http.Request
-
- outCode int
- outHeader http.Header
- outBody []byte
-
- pendingLogs struct {
- sync.Mutex
- lines []*logpb.UserAppLogLine
- flushes int
- }
-}
-
-var contextKey = "holds a *context"
-
-// jointContext joins two contexts in a superficial way.
-// It takes values and timeouts from a base context, and only values from another context.
-type jointContext struct {
- base context.Context
- valuesOnly context.Context
-}
-
-func (c jointContext) Deadline() (time.Time, bool) {
- return c.base.Deadline()
-}
-
-func (c jointContext) Done() <-chan struct{} {
- return c.base.Done()
-}
-
-func (c jointContext) Err() error {
- return c.base.Err()
-}
-
-func (c jointContext) Value(key interface{}) interface{} {
- if val := c.base.Value(key); val != nil {
- return val
- }
- return c.valuesOnly.Value(key)
-}
-
-// fromContext returns the App Engine context or nil if ctx is not
-// derived from an App Engine context.
-func fromContext(ctx context.Context) *aeContext {
- c, _ := ctx.Value(&contextKey).(*aeContext)
- return c
-}
-
-func withContext(parent context.Context, c *aeContext) context.Context {
- ctx := context.WithValue(parent, &contextKey, c)
- if ns := c.req.Header.Get(curNamespaceHeader); ns != "" {
- ctx = withNamespace(ctx, ns)
- }
- return ctx
-}
-
-func toContext(c *aeContext) context.Context {
- return withContext(context.Background(), c)
-}
-
-func IncomingHeaders(ctx context.Context) http.Header {
- if c := fromContext(ctx); c != nil {
- return c.req.Header
- }
- return nil
-}
-
-func ReqContext(req *http.Request) context.Context {
- return req.Context()
-}
-
-func WithContext(parent context.Context, req *http.Request) context.Context {
- return jointContext{
- base: parent,
- valuesOnly: req.Context(),
- }
-}
-
-// RegisterTestRequest registers the HTTP request req for testing, such that
-// any API calls are sent to the provided URL.
-// It should only be used by aetest package.
-func RegisterTestRequest(req *http.Request, apiURL *url.URL, appID string) *http.Request {
- ctx := req.Context()
- ctx = withAPIHostOverride(ctx, apiURL.Hostname())
- ctx = withAPIPortOverride(ctx, apiURL.Port())
- ctx = WithAppIDOverride(ctx, appID)
-
- // use the unregistered request as a placeholder so that withContext can read the headers
- c := &aeContext{req: req}
- c.req = req.WithContext(withContext(ctx, c))
- return c.req
-}
-
-var errTimeout = &CallError{
- Detail: "Deadline exceeded",
- Code: int32(remotepb.RpcError_CANCELLED),
- Timeout: true,
-}
-
-func (c *aeContext) Header() http.Header { return c.outHeader }
-
-// Copied from $GOROOT/src/pkg/net/http/transfer.go. Some response status
-// codes do not permit a response body (nor response entity headers such as
-// Content-Length, Content-Type, etc).
-func bodyAllowedForStatus(status int) bool {
- switch {
- case status >= 100 && status <= 199:
- return false
- case status == 204:
- return false
- case status == 304:
- return false
- }
- return true
-}
-
-func (c *aeContext) Write(b []byte) (int, error) {
- if c.outCode == 0 {
- c.WriteHeader(http.StatusOK)
- }
- if len(b) > 0 && !bodyAllowedForStatus(c.outCode) {
- return 0, http.ErrBodyNotAllowed
- }
- c.outBody = append(c.outBody, b...)
- return len(b), nil
-}
-
-func (c *aeContext) WriteHeader(code int) {
- if c.outCode != 0 {
- logf(c, 3, "WriteHeader called multiple times on request.") // error level
- return
- }
- c.outCode = code
-}
-
-func post(ctx context.Context, body []byte, timeout time.Duration) (b []byte, err error) {
- apiURL := apiURL(ctx)
- hreq := &http.Request{
- Method: "POST",
- URL: apiURL,
- Header: http.Header{
- apiEndpointHeader: apiEndpointHeaderValue,
- apiMethodHeader: apiMethodHeaderValue,
- apiContentType: apiContentTypeValue,
- apiDeadlineHeader: []string{strconv.FormatFloat(timeout.Seconds(), 'f', -1, 64)},
- },
- Body: ioutil.NopCloser(bytes.NewReader(body)),
- ContentLength: int64(len(body)),
- Host: apiURL.Host,
- }
- c := fromContext(ctx)
- if c != nil {
- if info := c.req.Header.Get(dapperHeader); info != "" {
- hreq.Header.Set(dapperHeader, info)
- }
- if info := c.req.Header.Get(traceHeader); info != "" {
- hreq.Header.Set(traceHeader, info)
- }
- }
-
- tr := apiHTTPClient.Transport.(*http.Transport)
-
- var timedOut int32 // atomic; set to 1 if timed out
- t := time.AfterFunc(timeout, func() {
- atomic.StoreInt32(&timedOut, 1)
- tr.CancelRequest(hreq)
- })
- defer t.Stop()
- defer func() {
- // Check if timeout was exceeded.
- if atomic.LoadInt32(&timedOut) != 0 {
- err = errTimeout
- }
- }()
-
- hresp, err := apiHTTPClient.Do(hreq)
- if err != nil {
- return nil, &CallError{
- Detail: fmt.Sprintf("service bridge HTTP failed: %v", err),
- Code: int32(remotepb.RpcError_UNKNOWN),
- }
- }
- defer hresp.Body.Close()
- hrespBody, err := ioutil.ReadAll(hresp.Body)
- if hresp.StatusCode != 200 {
- return nil, &CallError{
- Detail: fmt.Sprintf("service bridge returned HTTP %d (%q)", hresp.StatusCode, hrespBody),
- Code: int32(remotepb.RpcError_UNKNOWN),
- }
- }
- if err != nil {
- return nil, &CallError{
- Detail: fmt.Sprintf("service bridge response bad: %v", err),
- Code: int32(remotepb.RpcError_UNKNOWN),
- }
- }
- return hrespBody, nil
-}
-
-func Call(ctx context.Context, service, method string, in, out proto.Message) error {
- if ns := NamespaceFromContext(ctx); ns != "" {
- if fn, ok := NamespaceMods[service]; ok {
- fn(in, ns)
- }
- }
-
- if f, ctx, ok := callOverrideFromContext(ctx); ok {
- return f(ctx, service, method, in, out)
- }
-
- // Handle already-done contexts quickly.
- select {
- case <-ctx.Done():
- return ctx.Err()
- default:
- }
-
- c := fromContext(ctx)
-
- // Apply transaction modifications if we're in a transaction.
- if t := transactionFromContext(ctx); t != nil {
- if t.finished {
- return errors.New("transaction aeContext has expired")
- }
- applyTransaction(in, &t.transaction)
- }
-
- // Default RPC timeout is 60s.
- timeout := 60 * time.Second
- if deadline, ok := ctx.Deadline(); ok {
- timeout = deadline.Sub(time.Now())
- }
-
- data, err := proto.Marshal(in)
- if err != nil {
- return err
- }
-
- ticket := ""
- if c != nil {
- ticket = c.req.Header.Get(ticketHeader)
- if dri := c.req.Header.Get(devRequestIdHeader); IsDevAppServer() && dri != "" {
- ticket = dri
- }
- }
- req := &remotepb.Request{
- ServiceName: &service,
- Method: &method,
- Request: data,
- RequestId: &ticket,
- }
- hreqBody, err := proto.Marshal(req)
- if err != nil {
- return err
- }
-
- hrespBody, err := post(ctx, hreqBody, timeout)
- if err != nil {
- return err
- }
-
- res := &remotepb.Response{}
- if err := proto.Unmarshal(hrespBody, res); err != nil {
- return err
- }
- if res.RpcError != nil {
- ce := &CallError{
- Detail: res.RpcError.GetDetail(),
- Code: *res.RpcError.Code,
- }
- switch remotepb.RpcError_ErrorCode(ce.Code) {
- case remotepb.RpcError_CANCELLED, remotepb.RpcError_DEADLINE_EXCEEDED:
- ce.Timeout = true
- }
- return ce
- }
- if res.ApplicationError != nil {
- return &APIError{
- Service: *req.ServiceName,
- Detail: res.ApplicationError.GetDetail(),
- Code: *res.ApplicationError.Code,
- }
- }
- if res.Exception != nil || res.JavaException != nil {
- // This shouldn't happen, but let's be defensive.
- return &CallError{
- Detail: "service bridge returned exception",
- Code: int32(remotepb.RpcError_UNKNOWN),
- }
- }
- return proto.Unmarshal(res.Response, out)
-}
-
-func (c *aeContext) Request() *http.Request {
- return c.req
-}
-
-func (c *aeContext) addLogLine(ll *logpb.UserAppLogLine) {
- // Truncate long log lines.
- // TODO(dsymonds): Check if this is still necessary.
- const lim = 8 << 10
- if len(*ll.Message) > lim {
- suffix := fmt.Sprintf("...(length %d)", len(*ll.Message))
- ll.Message = proto.String((*ll.Message)[:lim-len(suffix)] + suffix)
- }
-
- c.pendingLogs.Lock()
- c.pendingLogs.lines = append(c.pendingLogs.lines, ll)
- c.pendingLogs.Unlock()
-}
-
-var logLevelName = map[int64]string{
- 0: "DEBUG",
- 1: "INFO",
- 2: "WARNING",
- 3: "ERROR",
- 4: "CRITICAL",
-}
-
-func logf(c *aeContext, level int64, format string, args ...interface{}) {
- if c == nil {
- panic("not an App Engine aeContext")
- }
- s := fmt.Sprintf(format, args...)
- s = strings.TrimRight(s, "\n") // Remove any trailing newline characters.
- if logToLogservice() {
- c.addLogLine(&logpb.UserAppLogLine{
- TimestampUsec: proto.Int64(time.Now().UnixNano() / 1e3),
- Level: &level,
- Message: &s,
- })
- }
- // Log to stdout if not deployed
- if !IsSecondGen() {
- log.Print(logLevelName[level] + ": " + s)
- }
-}
-
-// flushLog attempts to flush any pending logs to the appserver.
-// It should not be called concurrently.
-func (c *aeContext) flushLog(force bool) (flushed bool) {
- c.pendingLogs.Lock()
- // Grab up to 30 MB. We can get away with up to 32 MB, but let's be cautious.
- n, rem := 0, 30<<20
- for ; n < len(c.pendingLogs.lines); n++ {
- ll := c.pendingLogs.lines[n]
- // Each log line will require about 3 bytes of overhead.
- nb := proto.Size(ll) + 3
- if nb > rem {
- break
- }
- rem -= nb
- }
- lines := c.pendingLogs.lines[:n]
- c.pendingLogs.lines = c.pendingLogs.lines[n:]
- c.pendingLogs.Unlock()
-
- if len(lines) == 0 && !force {
- // Nothing to flush.
- return false
- }
-
- rescueLogs := false
- defer func() {
- if rescueLogs {
- c.pendingLogs.Lock()
- c.pendingLogs.lines = append(lines, c.pendingLogs.lines...)
- c.pendingLogs.Unlock()
- }
- }()
-
- buf, err := proto.Marshal(&logpb.UserAppLogGroup{
- LogLine: lines,
- })
- if err != nil {
- log.Printf("internal.flushLog: marshaling UserAppLogGroup: %v", err)
- rescueLogs = true
- return false
- }
-
- req := &logpb.FlushRequest{
- Logs: buf,
- }
- res := &basepb.VoidProto{}
- c.pendingLogs.Lock()
- c.pendingLogs.flushes++
- c.pendingLogs.Unlock()
- if err := Call(toContext(c), "logservice", "Flush", req, res); err != nil {
- log.Printf("internal.flushLog: Flush RPC: %v", err)
- rescueLogs = true
- return false
- }
- return true
-}
-
-const (
- // Log flushing parameters.
- flushInterval = 1 * time.Second
- forceFlushInterval = 60 * time.Second
-)
-
-func (c *aeContext) logFlusher(stop <-chan int) {
- lastFlush := time.Now()
- tick := time.NewTicker(flushInterval)
- for {
- select {
- case <-stop:
- // Request finished.
- tick.Stop()
- return
- case <-tick.C:
- force := time.Now().Sub(lastFlush) > forceFlushInterval
- if c.flushLog(force) {
- lastFlush = time.Now()
- }
- }
- }
-}
-
-func ContextForTesting(req *http.Request) context.Context {
- return toContext(&aeContext{req: req})
-}
-
-func logToLogservice() bool {
- // TODO: replace logservice with json structured logs to $LOG_DIR/app.log.json
- // where $LOG_DIR is /var/log in prod and some tmpdir in dev
- return os.Getenv("LOG_TO_LOGSERVICE") != "0"
-}
diff --git a/vendor/google.golang.org/appengine/internal/api_classic.go b/vendor/google.golang.org/appengine/internal/api_classic.go
deleted file mode 100644
index 87c33c798e..0000000000
--- a/vendor/google.golang.org/appengine/internal/api_classic.go
+++ /dev/null
@@ -1,170 +0,0 @@
-// Copyright 2015 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-//go:build appengine
-// +build appengine
-
-package internal
-
-import (
- "context"
- "errors"
- "fmt"
- "net/http"
- "time"
-
- "appengine"
- "appengine_internal"
- basepb "appengine_internal/base"
-
- "github.com/golang/protobuf/proto"
-)
-
-var contextKey = "holds an appengine.Context"
-
-// fromContext returns the App Engine context or nil if ctx is not
-// derived from an App Engine context.
-func fromContext(ctx context.Context) appengine.Context {
- c, _ := ctx.Value(&contextKey).(appengine.Context)
- return c
-}
-
-// This is only for classic App Engine adapters.
-func ClassicContextFromContext(ctx context.Context) (appengine.Context, error) {
- c := fromContext(ctx)
- if c == nil {
- return nil, errNotAppEngineContext
- }
- return c, nil
-}
-
-func withContext(parent context.Context, c appengine.Context) context.Context {
- ctx := context.WithValue(parent, &contextKey, c)
-
- s := &basepb.StringProto{}
- c.Call("__go__", "GetNamespace", &basepb.VoidProto{}, s, nil)
- if ns := s.GetValue(); ns != "" {
- ctx = NamespacedContext(ctx, ns)
- }
-
- return ctx
-}
-
-func IncomingHeaders(ctx context.Context) http.Header {
- if c := fromContext(ctx); c != nil {
- if req, ok := c.Request().(*http.Request); ok {
- return req.Header
- }
- }
- return nil
-}
-
-func ReqContext(req *http.Request) context.Context {
- return WithContext(context.Background(), req)
-}
-
-func WithContext(parent context.Context, req *http.Request) context.Context {
- c := appengine.NewContext(req)
- return withContext(parent, c)
-}
-
-type testingContext struct {
- appengine.Context
-
- req *http.Request
-}
-
-func (t *testingContext) FullyQualifiedAppID() string { return "dev~testcontext" }
-func (t *testingContext) Call(service, method string, _, _ appengine_internal.ProtoMessage, _ *appengine_internal.CallOptions) error {
- if service == "__go__" && method == "GetNamespace" {
- return nil
- }
- return fmt.Errorf("testingContext: unsupported Call")
-}
-func (t *testingContext) Request() interface{} { return t.req }
-
-func ContextForTesting(req *http.Request) context.Context {
- return withContext(context.Background(), &testingContext{req: req})
-}
-
-func Call(ctx context.Context, service, method string, in, out proto.Message) error {
- if ns := NamespaceFromContext(ctx); ns != "" {
- if fn, ok := NamespaceMods[service]; ok {
- fn(in, ns)
- }
- }
-
- if f, ctx, ok := callOverrideFromContext(ctx); ok {
- return f(ctx, service, method, in, out)
- }
-
- // Handle already-done contexts quickly.
- select {
- case <-ctx.Done():
- return ctx.Err()
- default:
- }
-
- c := fromContext(ctx)
- if c == nil {
- // Give a good error message rather than a panic lower down.
- return errNotAppEngineContext
- }
-
- // Apply transaction modifications if we're in a transaction.
- if t := transactionFromContext(ctx); t != nil {
- if t.finished {
- return errors.New("transaction context has expired")
- }
- applyTransaction(in, &t.transaction)
- }
-
- var opts *appengine_internal.CallOptions
- if d, ok := ctx.Deadline(); ok {
- opts = &appengine_internal.CallOptions{
- Timeout: d.Sub(time.Now()),
- }
- }
-
- err := c.Call(service, method, in, out, opts)
- switch v := err.(type) {
- case *appengine_internal.APIError:
- return &APIError{
- Service: v.Service,
- Detail: v.Detail,
- Code: v.Code,
- }
- case *appengine_internal.CallError:
- return &CallError{
- Detail: v.Detail,
- Code: v.Code,
- Timeout: v.Timeout,
- }
- }
- return err
-}
-
-func Middleware(next http.Handler) http.Handler {
- panic("Middleware called; this should be impossible")
-}
-
-func logf(c appengine.Context, level int64, format string, args ...interface{}) {
- var fn func(format string, args ...interface{})
- switch level {
- case 0:
- fn = c.Debugf
- case 1:
- fn = c.Infof
- case 2:
- fn = c.Warningf
- case 3:
- fn = c.Errorf
- case 4:
- fn = c.Criticalf
- default:
- // This shouldn't happen.
- fn = c.Criticalf
- }
- fn(format, args...)
-}
diff --git a/vendor/google.golang.org/appengine/internal/api_common.go b/vendor/google.golang.org/appengine/internal/api_common.go
deleted file mode 100644
index 5b95c13d92..0000000000
--- a/vendor/google.golang.org/appengine/internal/api_common.go
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright 2015 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package internal
-
-import (
- "context"
- "errors"
- "os"
-
- "github.com/golang/protobuf/proto"
-)
-
-type ctxKey string
-
-func (c ctxKey) String() string {
- return "appengine context key: " + string(c)
-}
-
-var errNotAppEngineContext = errors.New("not an App Engine context")
-
-type CallOverrideFunc func(ctx context.Context, service, method string, in, out proto.Message) error
-
-var callOverrideKey = "holds []CallOverrideFunc"
-
-func WithCallOverride(ctx context.Context, f CallOverrideFunc) context.Context {
- // We avoid appending to any existing call override
- // so we don't risk overwriting a popped stack below.
- var cofs []CallOverrideFunc
- if uf, ok := ctx.Value(&callOverrideKey).([]CallOverrideFunc); ok {
- cofs = append(cofs, uf...)
- }
- cofs = append(cofs, f)
- return context.WithValue(ctx, &callOverrideKey, cofs)
-}
-
-func callOverrideFromContext(ctx context.Context) (CallOverrideFunc, context.Context, bool) {
- cofs, _ := ctx.Value(&callOverrideKey).([]CallOverrideFunc)
- if len(cofs) == 0 {
- return nil, nil, false
- }
- // We found a list of overrides; grab the last, and reconstitute a
- // context that will hide it.
- f := cofs[len(cofs)-1]
- ctx = context.WithValue(ctx, &callOverrideKey, cofs[:len(cofs)-1])
- return f, ctx, true
-}
-
-type logOverrideFunc func(level int64, format string, args ...interface{})
-
-var logOverrideKey = "holds a logOverrideFunc"
-
-func WithLogOverride(ctx context.Context, f logOverrideFunc) context.Context {
- return context.WithValue(ctx, &logOverrideKey, f)
-}
-
-var appIDOverrideKey = "holds a string, being the full app ID"
-
-func WithAppIDOverride(ctx context.Context, appID string) context.Context {
- return context.WithValue(ctx, &appIDOverrideKey, appID)
-}
-
-var apiHostOverrideKey = ctxKey("holds a string, being the alternate API_HOST")
-
-func withAPIHostOverride(ctx context.Context, apiHost string) context.Context {
- return context.WithValue(ctx, apiHostOverrideKey, apiHost)
-}
-
-var apiPortOverrideKey = ctxKey("holds a string, being the alternate API_PORT")
-
-func withAPIPortOverride(ctx context.Context, apiPort string) context.Context {
- return context.WithValue(ctx, apiPortOverrideKey, apiPort)
-}
-
-var namespaceKey = "holds the namespace string"
-
-func withNamespace(ctx context.Context, ns string) context.Context {
- return context.WithValue(ctx, &namespaceKey, ns)
-}
-
-func NamespaceFromContext(ctx context.Context) string {
- // If there's no namespace, return the empty string.
- ns, _ := ctx.Value(&namespaceKey).(string)
- return ns
-}
-
-// FullyQualifiedAppID returns the fully-qualified application ID.
-// This may contain a partition prefix (e.g. "s~" for High Replication apps),
-// or a domain prefix (e.g. "example.com:").
-func FullyQualifiedAppID(ctx context.Context) string {
- if id, ok := ctx.Value(&appIDOverrideKey).(string); ok {
- return id
- }
- return fullyQualifiedAppID(ctx)
-}
-
-func Logf(ctx context.Context, level int64, format string, args ...interface{}) {
- if f, ok := ctx.Value(&logOverrideKey).(logOverrideFunc); ok {
- f(level, format, args...)
- return
- }
- c := fromContext(ctx)
- if c == nil {
- panic(errNotAppEngineContext)
- }
- logf(c, level, format, args...)
-}
-
-// NamespacedContext wraps a Context to support namespaces.
-func NamespacedContext(ctx context.Context, namespace string) context.Context {
- return withNamespace(ctx, namespace)
-}
-
-// SetTestEnv sets the env variables for testing background ticket in Flex.
-func SetTestEnv() func() {
- var environ = []struct {
- key, value string
- }{
- {"GAE_LONG_APP_ID", "my-app-id"},
- {"GAE_MINOR_VERSION", "067924799508853122"},
- {"GAE_MODULE_INSTANCE", "0"},
- {"GAE_MODULE_NAME", "default"},
- {"GAE_MODULE_VERSION", "20150612t184001"},
- }
-
- for _, v := range environ {
- old := os.Getenv(v.key)
- os.Setenv(v.key, v.value)
- v.value = old
- }
- return func() { // Restore old environment after the test completes.
- for _, v := range environ {
- if v.value == "" {
- os.Unsetenv(v.key)
- continue
- }
- os.Setenv(v.key, v.value)
- }
- }
-}
diff --git a/vendor/google.golang.org/appengine/internal/app_id.go b/vendor/google.golang.org/appengine/internal/app_id.go
deleted file mode 100644
index 11df8c07b5..0000000000
--- a/vendor/google.golang.org/appengine/internal/app_id.go
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2011 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package internal
-
-import (
- "strings"
-)
-
-func parseFullAppID(appid string) (partition, domain, displayID string) {
- if i := strings.Index(appid, "~"); i != -1 {
- partition, appid = appid[:i], appid[i+1:]
- }
- if i := strings.Index(appid, ":"); i != -1 {
- domain, appid = appid[:i], appid[i+1:]
- }
- return partition, domain, appid
-}
-
-// appID returns "appid" or "domain.com:appid".
-func appID(fullAppID string) string {
- _, dom, dis := parseFullAppID(fullAppID)
- if dom != "" {
- return dom + ":" + dis
- }
- return dis
-}
diff --git a/vendor/google.golang.org/appengine/internal/base/api_base.pb.go b/vendor/google.golang.org/appengine/internal/base/api_base.pb.go
deleted file mode 100644
index db4777e68e..0000000000
--- a/vendor/google.golang.org/appengine/internal/base/api_base.pb.go
+++ /dev/null
@@ -1,308 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google.golang.org/appengine/internal/base/api_base.proto
-
-package base
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type StringProto struct {
- Value *string `protobuf:"bytes,1,req,name=value" json:"value,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *StringProto) Reset() { *m = StringProto{} }
-func (m *StringProto) String() string { return proto.CompactTextString(m) }
-func (*StringProto) ProtoMessage() {}
-func (*StringProto) Descriptor() ([]byte, []int) {
- return fileDescriptor_api_base_9d49f8792e0c1140, []int{0}
-}
-func (m *StringProto) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_StringProto.Unmarshal(m, b)
-}
-func (m *StringProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_StringProto.Marshal(b, m, deterministic)
-}
-func (dst *StringProto) XXX_Merge(src proto.Message) {
- xxx_messageInfo_StringProto.Merge(dst, src)
-}
-func (m *StringProto) XXX_Size() int {
- return xxx_messageInfo_StringProto.Size(m)
-}
-func (m *StringProto) XXX_DiscardUnknown() {
- xxx_messageInfo_StringProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_StringProto proto.InternalMessageInfo
-
-func (m *StringProto) GetValue() string {
- if m != nil && m.Value != nil {
- return *m.Value
- }
- return ""
-}
-
-type Integer32Proto struct {
- Value *int32 `protobuf:"varint,1,req,name=value" json:"value,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Integer32Proto) Reset() { *m = Integer32Proto{} }
-func (m *Integer32Proto) String() string { return proto.CompactTextString(m) }
-func (*Integer32Proto) ProtoMessage() {}
-func (*Integer32Proto) Descriptor() ([]byte, []int) {
- return fileDescriptor_api_base_9d49f8792e0c1140, []int{1}
-}
-func (m *Integer32Proto) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Integer32Proto.Unmarshal(m, b)
-}
-func (m *Integer32Proto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Integer32Proto.Marshal(b, m, deterministic)
-}
-func (dst *Integer32Proto) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Integer32Proto.Merge(dst, src)
-}
-func (m *Integer32Proto) XXX_Size() int {
- return xxx_messageInfo_Integer32Proto.Size(m)
-}
-func (m *Integer32Proto) XXX_DiscardUnknown() {
- xxx_messageInfo_Integer32Proto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Integer32Proto proto.InternalMessageInfo
-
-func (m *Integer32Proto) GetValue() int32 {
- if m != nil && m.Value != nil {
- return *m.Value
- }
- return 0
-}
-
-type Integer64Proto struct {
- Value *int64 `protobuf:"varint,1,req,name=value" json:"value,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Integer64Proto) Reset() { *m = Integer64Proto{} }
-func (m *Integer64Proto) String() string { return proto.CompactTextString(m) }
-func (*Integer64Proto) ProtoMessage() {}
-func (*Integer64Proto) Descriptor() ([]byte, []int) {
- return fileDescriptor_api_base_9d49f8792e0c1140, []int{2}
-}
-func (m *Integer64Proto) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Integer64Proto.Unmarshal(m, b)
-}
-func (m *Integer64Proto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Integer64Proto.Marshal(b, m, deterministic)
-}
-func (dst *Integer64Proto) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Integer64Proto.Merge(dst, src)
-}
-func (m *Integer64Proto) XXX_Size() int {
- return xxx_messageInfo_Integer64Proto.Size(m)
-}
-func (m *Integer64Proto) XXX_DiscardUnknown() {
- xxx_messageInfo_Integer64Proto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Integer64Proto proto.InternalMessageInfo
-
-func (m *Integer64Proto) GetValue() int64 {
- if m != nil && m.Value != nil {
- return *m.Value
- }
- return 0
-}
-
-type BoolProto struct {
- Value *bool `protobuf:"varint,1,req,name=value" json:"value,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *BoolProto) Reset() { *m = BoolProto{} }
-func (m *BoolProto) String() string { return proto.CompactTextString(m) }
-func (*BoolProto) ProtoMessage() {}
-func (*BoolProto) Descriptor() ([]byte, []int) {
- return fileDescriptor_api_base_9d49f8792e0c1140, []int{3}
-}
-func (m *BoolProto) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_BoolProto.Unmarshal(m, b)
-}
-func (m *BoolProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_BoolProto.Marshal(b, m, deterministic)
-}
-func (dst *BoolProto) XXX_Merge(src proto.Message) {
- xxx_messageInfo_BoolProto.Merge(dst, src)
-}
-func (m *BoolProto) XXX_Size() int {
- return xxx_messageInfo_BoolProto.Size(m)
-}
-func (m *BoolProto) XXX_DiscardUnknown() {
- xxx_messageInfo_BoolProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_BoolProto proto.InternalMessageInfo
-
-func (m *BoolProto) GetValue() bool {
- if m != nil && m.Value != nil {
- return *m.Value
- }
- return false
-}
-
-type DoubleProto struct {
- Value *float64 `protobuf:"fixed64,1,req,name=value" json:"value,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *DoubleProto) Reset() { *m = DoubleProto{} }
-func (m *DoubleProto) String() string { return proto.CompactTextString(m) }
-func (*DoubleProto) ProtoMessage() {}
-func (*DoubleProto) Descriptor() ([]byte, []int) {
- return fileDescriptor_api_base_9d49f8792e0c1140, []int{4}
-}
-func (m *DoubleProto) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_DoubleProto.Unmarshal(m, b)
-}
-func (m *DoubleProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_DoubleProto.Marshal(b, m, deterministic)
-}
-func (dst *DoubleProto) XXX_Merge(src proto.Message) {
- xxx_messageInfo_DoubleProto.Merge(dst, src)
-}
-func (m *DoubleProto) XXX_Size() int {
- return xxx_messageInfo_DoubleProto.Size(m)
-}
-func (m *DoubleProto) XXX_DiscardUnknown() {
- xxx_messageInfo_DoubleProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_DoubleProto proto.InternalMessageInfo
-
-func (m *DoubleProto) GetValue() float64 {
- if m != nil && m.Value != nil {
- return *m.Value
- }
- return 0
-}
-
-type BytesProto struct {
- Value []byte `protobuf:"bytes,1,req,name=value" json:"value,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *BytesProto) Reset() { *m = BytesProto{} }
-func (m *BytesProto) String() string { return proto.CompactTextString(m) }
-func (*BytesProto) ProtoMessage() {}
-func (*BytesProto) Descriptor() ([]byte, []int) {
- return fileDescriptor_api_base_9d49f8792e0c1140, []int{5}
-}
-func (m *BytesProto) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_BytesProto.Unmarshal(m, b)
-}
-func (m *BytesProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_BytesProto.Marshal(b, m, deterministic)
-}
-func (dst *BytesProto) XXX_Merge(src proto.Message) {
- xxx_messageInfo_BytesProto.Merge(dst, src)
-}
-func (m *BytesProto) XXX_Size() int {
- return xxx_messageInfo_BytesProto.Size(m)
-}
-func (m *BytesProto) XXX_DiscardUnknown() {
- xxx_messageInfo_BytesProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_BytesProto proto.InternalMessageInfo
-
-func (m *BytesProto) GetValue() []byte {
- if m != nil {
- return m.Value
- }
- return nil
-}
-
-type VoidProto struct {
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *VoidProto) Reset() { *m = VoidProto{} }
-func (m *VoidProto) String() string { return proto.CompactTextString(m) }
-func (*VoidProto) ProtoMessage() {}
-func (*VoidProto) Descriptor() ([]byte, []int) {
- return fileDescriptor_api_base_9d49f8792e0c1140, []int{6}
-}
-func (m *VoidProto) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_VoidProto.Unmarshal(m, b)
-}
-func (m *VoidProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_VoidProto.Marshal(b, m, deterministic)
-}
-func (dst *VoidProto) XXX_Merge(src proto.Message) {
- xxx_messageInfo_VoidProto.Merge(dst, src)
-}
-func (m *VoidProto) XXX_Size() int {
- return xxx_messageInfo_VoidProto.Size(m)
-}
-func (m *VoidProto) XXX_DiscardUnknown() {
- xxx_messageInfo_VoidProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_VoidProto proto.InternalMessageInfo
-
-func init() {
- proto.RegisterType((*StringProto)(nil), "appengine.base.StringProto")
- proto.RegisterType((*Integer32Proto)(nil), "appengine.base.Integer32Proto")
- proto.RegisterType((*Integer64Proto)(nil), "appengine.base.Integer64Proto")
- proto.RegisterType((*BoolProto)(nil), "appengine.base.BoolProto")
- proto.RegisterType((*DoubleProto)(nil), "appengine.base.DoubleProto")
- proto.RegisterType((*BytesProto)(nil), "appengine.base.BytesProto")
- proto.RegisterType((*VoidProto)(nil), "appengine.base.VoidProto")
-}
-
-func init() {
- proto.RegisterFile("google.golang.org/appengine/internal/base/api_base.proto", fileDescriptor_api_base_9d49f8792e0c1140)
-}
-
-var fileDescriptor_api_base_9d49f8792e0c1140 = []byte{
- // 199 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0xcf, 0x3f, 0x4b, 0xc6, 0x30,
- 0x10, 0x06, 0x70, 0x5a, 0xad, 0xb4, 0x57, 0xe9, 0x20, 0x0e, 0x1d, 0xb5, 0x05, 0x71, 0x4a, 0x40,
- 0x45, 0x9c, 0x83, 0x8b, 0x9b, 0x28, 0x38, 0xb8, 0x48, 0x8a, 0xc7, 0x11, 0x08, 0xb9, 0x90, 0xa6,
- 0x82, 0xdf, 0x5e, 0xda, 0xd2, 0xfa, 0xc2, 0x9b, 0xed, 0xfe, 0xfc, 0xe0, 0xe1, 0x81, 0x27, 0x62,
- 0x26, 0x8b, 0x82, 0xd8, 0x6a, 0x47, 0x82, 0x03, 0x49, 0xed, 0x3d, 0x3a, 0x32, 0x0e, 0xa5, 0x71,
- 0x11, 0x83, 0xd3, 0x56, 0x0e, 0x7a, 0x44, 0xa9, 0xbd, 0xf9, 0x9a, 0x07, 0xe1, 0x03, 0x47, 0xbe,
- 0x68, 0x76, 0x27, 0xe6, 0x6b, 0xd7, 0x43, 0xfd, 0x1e, 0x83, 0x71, 0xf4, 0xba, 0xbc, 0x2f, 0xa1,
- 0xf8, 0xd1, 0x76, 0xc2, 0x36, 0xbb, 0xca, 0x6f, 0xab, 0xb7, 0x75, 0xe9, 0x6e, 0xa0, 0x79, 0x71,
- 0x11, 0x09, 0xc3, 0xfd, 0x5d, 0xc2, 0x15, 0xc7, 0xee, 0xf1, 0x21, 0xe1, 0x4e, 0x36, 0x77, 0x0d,
- 0x95, 0x62, 0xb6, 0x09, 0x52, 0x6e, 0xa4, 0x87, 0xfa, 0x99, 0xa7, 0xc1, 0x62, 0x02, 0x65, 0xff,
- 0x79, 0xa0, 0x7e, 0x23, 0x8e, 0xab, 0x69, 0x0f, 0xcd, 0xb9, 0xca, 0xcb, 0xdd, 0xd5, 0x50, 0x7d,
- 0xb0, 0xf9, 0x5e, 0x98, 0x3a, 0xfb, 0x3c, 0x9d, 0x9b, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xba,
- 0x37, 0x25, 0xea, 0x44, 0x01, 0x00, 0x00,
-}
diff --git a/vendor/google.golang.org/appengine/internal/base/api_base.proto b/vendor/google.golang.org/appengine/internal/base/api_base.proto
deleted file mode 100644
index 56cd7a3cad..0000000000
--- a/vendor/google.golang.org/appengine/internal/base/api_base.proto
+++ /dev/null
@@ -1,33 +0,0 @@
-// Built-in base types for API calls. Primarily useful as return types.
-
-syntax = "proto2";
-option go_package = "base";
-
-package appengine.base;
-
-message StringProto {
- required string value = 1;
-}
-
-message Integer32Proto {
- required int32 value = 1;
-}
-
-message Integer64Proto {
- required int64 value = 1;
-}
-
-message BoolProto {
- required bool value = 1;
-}
-
-message DoubleProto {
- required double value = 1;
-}
-
-message BytesProto {
- required bytes value = 1 [ctype=CORD];
-}
-
-message VoidProto {
-}
diff --git a/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go b/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go
deleted file mode 100644
index 2fb7482896..0000000000
--- a/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go
+++ /dev/null
@@ -1,4367 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google.golang.org/appengine/internal/datastore/datastore_v3.proto
-
-package datastore
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type Property_Meaning int32
-
-const (
- Property_NO_MEANING Property_Meaning = 0
- Property_BLOB Property_Meaning = 14
- Property_TEXT Property_Meaning = 15
- Property_BYTESTRING Property_Meaning = 16
- Property_ATOM_CATEGORY Property_Meaning = 1
- Property_ATOM_LINK Property_Meaning = 2
- Property_ATOM_TITLE Property_Meaning = 3
- Property_ATOM_CONTENT Property_Meaning = 4
- Property_ATOM_SUMMARY Property_Meaning = 5
- Property_ATOM_AUTHOR Property_Meaning = 6
- Property_GD_WHEN Property_Meaning = 7
- Property_GD_EMAIL Property_Meaning = 8
- Property_GEORSS_POINT Property_Meaning = 9
- Property_GD_IM Property_Meaning = 10
- Property_GD_PHONENUMBER Property_Meaning = 11
- Property_GD_POSTALADDRESS Property_Meaning = 12
- Property_GD_RATING Property_Meaning = 13
- Property_BLOBKEY Property_Meaning = 17
- Property_ENTITY_PROTO Property_Meaning = 19
- Property_INDEX_VALUE Property_Meaning = 18
-)
-
-var Property_Meaning_name = map[int32]string{
- 0: "NO_MEANING",
- 14: "BLOB",
- 15: "TEXT",
- 16: "BYTESTRING",
- 1: "ATOM_CATEGORY",
- 2: "ATOM_LINK",
- 3: "ATOM_TITLE",
- 4: "ATOM_CONTENT",
- 5: "ATOM_SUMMARY",
- 6: "ATOM_AUTHOR",
- 7: "GD_WHEN",
- 8: "GD_EMAIL",
- 9: "GEORSS_POINT",
- 10: "GD_IM",
- 11: "GD_PHONENUMBER",
- 12: "GD_POSTALADDRESS",
- 13: "GD_RATING",
- 17: "BLOBKEY",
- 19: "ENTITY_PROTO",
- 18: "INDEX_VALUE",
-}
-var Property_Meaning_value = map[string]int32{
- "NO_MEANING": 0,
- "BLOB": 14,
- "TEXT": 15,
- "BYTESTRING": 16,
- "ATOM_CATEGORY": 1,
- "ATOM_LINK": 2,
- "ATOM_TITLE": 3,
- "ATOM_CONTENT": 4,
- "ATOM_SUMMARY": 5,
- "ATOM_AUTHOR": 6,
- "GD_WHEN": 7,
- "GD_EMAIL": 8,
- "GEORSS_POINT": 9,
- "GD_IM": 10,
- "GD_PHONENUMBER": 11,
- "GD_POSTALADDRESS": 12,
- "GD_RATING": 13,
- "BLOBKEY": 17,
- "ENTITY_PROTO": 19,
- "INDEX_VALUE": 18,
-}
-
-func (x Property_Meaning) Enum() *Property_Meaning {
- p := new(Property_Meaning)
- *p = x
- return p
-}
-func (x Property_Meaning) String() string {
- return proto.EnumName(Property_Meaning_name, int32(x))
-}
-func (x *Property_Meaning) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(Property_Meaning_value, data, "Property_Meaning")
- if err != nil {
- return err
- }
- *x = Property_Meaning(value)
- return nil
-}
-func (Property_Meaning) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{2, 0}
-}
-
-type Property_FtsTokenizationOption int32
-
-const (
- Property_HTML Property_FtsTokenizationOption = 1
- Property_ATOM Property_FtsTokenizationOption = 2
-)
-
-var Property_FtsTokenizationOption_name = map[int32]string{
- 1: "HTML",
- 2: "ATOM",
-}
-var Property_FtsTokenizationOption_value = map[string]int32{
- "HTML": 1,
- "ATOM": 2,
-}
-
-func (x Property_FtsTokenizationOption) Enum() *Property_FtsTokenizationOption {
- p := new(Property_FtsTokenizationOption)
- *p = x
- return p
-}
-func (x Property_FtsTokenizationOption) String() string {
- return proto.EnumName(Property_FtsTokenizationOption_name, int32(x))
-}
-func (x *Property_FtsTokenizationOption) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(Property_FtsTokenizationOption_value, data, "Property_FtsTokenizationOption")
- if err != nil {
- return err
- }
- *x = Property_FtsTokenizationOption(value)
- return nil
-}
-func (Property_FtsTokenizationOption) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{2, 1}
-}
-
-type EntityProto_Kind int32
-
-const (
- EntityProto_GD_CONTACT EntityProto_Kind = 1
- EntityProto_GD_EVENT EntityProto_Kind = 2
- EntityProto_GD_MESSAGE EntityProto_Kind = 3
-)
-
-var EntityProto_Kind_name = map[int32]string{
- 1: "GD_CONTACT",
- 2: "GD_EVENT",
- 3: "GD_MESSAGE",
-}
-var EntityProto_Kind_value = map[string]int32{
- "GD_CONTACT": 1,
- "GD_EVENT": 2,
- "GD_MESSAGE": 3,
-}
-
-func (x EntityProto_Kind) Enum() *EntityProto_Kind {
- p := new(EntityProto_Kind)
- *p = x
- return p
-}
-func (x EntityProto_Kind) String() string {
- return proto.EnumName(EntityProto_Kind_name, int32(x))
-}
-func (x *EntityProto_Kind) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(EntityProto_Kind_value, data, "EntityProto_Kind")
- if err != nil {
- return err
- }
- *x = EntityProto_Kind(value)
- return nil
-}
-func (EntityProto_Kind) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{6, 0}
-}
-
-type Index_Property_Direction int32
-
-const (
- Index_Property_ASCENDING Index_Property_Direction = 1
- Index_Property_DESCENDING Index_Property_Direction = 2
-)
-
-var Index_Property_Direction_name = map[int32]string{
- 1: "ASCENDING",
- 2: "DESCENDING",
-}
-var Index_Property_Direction_value = map[string]int32{
- "ASCENDING": 1,
- "DESCENDING": 2,
-}
-
-func (x Index_Property_Direction) Enum() *Index_Property_Direction {
- p := new(Index_Property_Direction)
- *p = x
- return p
-}
-func (x Index_Property_Direction) String() string {
- return proto.EnumName(Index_Property_Direction_name, int32(x))
-}
-func (x *Index_Property_Direction) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(Index_Property_Direction_value, data, "Index_Property_Direction")
- if err != nil {
- return err
- }
- *x = Index_Property_Direction(value)
- return nil
-}
-func (Index_Property_Direction) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{8, 0, 0}
-}
-
-type CompositeIndex_State int32
-
-const (
- CompositeIndex_WRITE_ONLY CompositeIndex_State = 1
- CompositeIndex_READ_WRITE CompositeIndex_State = 2
- CompositeIndex_DELETED CompositeIndex_State = 3
- CompositeIndex_ERROR CompositeIndex_State = 4
-)
-
-var CompositeIndex_State_name = map[int32]string{
- 1: "WRITE_ONLY",
- 2: "READ_WRITE",
- 3: "DELETED",
- 4: "ERROR",
-}
-var CompositeIndex_State_value = map[string]int32{
- "WRITE_ONLY": 1,
- "READ_WRITE": 2,
- "DELETED": 3,
- "ERROR": 4,
-}
-
-func (x CompositeIndex_State) Enum() *CompositeIndex_State {
- p := new(CompositeIndex_State)
- *p = x
- return p
-}
-func (x CompositeIndex_State) String() string {
- return proto.EnumName(CompositeIndex_State_name, int32(x))
-}
-func (x *CompositeIndex_State) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(CompositeIndex_State_value, data, "CompositeIndex_State")
- if err != nil {
- return err
- }
- *x = CompositeIndex_State(value)
- return nil
-}
-func (CompositeIndex_State) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{9, 0}
-}
-
-type Snapshot_Status int32
-
-const (
- Snapshot_INACTIVE Snapshot_Status = 0
- Snapshot_ACTIVE Snapshot_Status = 1
-)
-
-var Snapshot_Status_name = map[int32]string{
- 0: "INACTIVE",
- 1: "ACTIVE",
-}
-var Snapshot_Status_value = map[string]int32{
- "INACTIVE": 0,
- "ACTIVE": 1,
-}
-
-func (x Snapshot_Status) Enum() *Snapshot_Status {
- p := new(Snapshot_Status)
- *p = x
- return p
-}
-func (x Snapshot_Status) String() string {
- return proto.EnumName(Snapshot_Status_name, int32(x))
-}
-func (x *Snapshot_Status) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(Snapshot_Status_value, data, "Snapshot_Status")
- if err != nil {
- return err
- }
- *x = Snapshot_Status(value)
- return nil
-}
-func (Snapshot_Status) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{12, 0}
-}
-
-type Query_Hint int32
-
-const (
- Query_ORDER_FIRST Query_Hint = 1
- Query_ANCESTOR_FIRST Query_Hint = 2
- Query_FILTER_FIRST Query_Hint = 3
-)
-
-var Query_Hint_name = map[int32]string{
- 1: "ORDER_FIRST",
- 2: "ANCESTOR_FIRST",
- 3: "FILTER_FIRST",
-}
-var Query_Hint_value = map[string]int32{
- "ORDER_FIRST": 1,
- "ANCESTOR_FIRST": 2,
- "FILTER_FIRST": 3,
-}
-
-func (x Query_Hint) Enum() *Query_Hint {
- p := new(Query_Hint)
- *p = x
- return p
-}
-func (x Query_Hint) String() string {
- return proto.EnumName(Query_Hint_name, int32(x))
-}
-func (x *Query_Hint) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(Query_Hint_value, data, "Query_Hint")
- if err != nil {
- return err
- }
- *x = Query_Hint(value)
- return nil
-}
-func (Query_Hint) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 0}
-}
-
-type Query_Filter_Operator int32
-
-const (
- Query_Filter_LESS_THAN Query_Filter_Operator = 1
- Query_Filter_LESS_THAN_OR_EQUAL Query_Filter_Operator = 2
- Query_Filter_GREATER_THAN Query_Filter_Operator = 3
- Query_Filter_GREATER_THAN_OR_EQUAL Query_Filter_Operator = 4
- Query_Filter_EQUAL Query_Filter_Operator = 5
- Query_Filter_IN Query_Filter_Operator = 6
- Query_Filter_EXISTS Query_Filter_Operator = 7
-)
-
-var Query_Filter_Operator_name = map[int32]string{
- 1: "LESS_THAN",
- 2: "LESS_THAN_OR_EQUAL",
- 3: "GREATER_THAN",
- 4: "GREATER_THAN_OR_EQUAL",
- 5: "EQUAL",
- 6: "IN",
- 7: "EXISTS",
-}
-var Query_Filter_Operator_value = map[string]int32{
- "LESS_THAN": 1,
- "LESS_THAN_OR_EQUAL": 2,
- "GREATER_THAN": 3,
- "GREATER_THAN_OR_EQUAL": 4,
- "EQUAL": 5,
- "IN": 6,
- "EXISTS": 7,
-}
-
-func (x Query_Filter_Operator) Enum() *Query_Filter_Operator {
- p := new(Query_Filter_Operator)
- *p = x
- return p
-}
-func (x Query_Filter_Operator) String() string {
- return proto.EnumName(Query_Filter_Operator_name, int32(x))
-}
-func (x *Query_Filter_Operator) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(Query_Filter_Operator_value, data, "Query_Filter_Operator")
- if err != nil {
- return err
- }
- *x = Query_Filter_Operator(value)
- return nil
-}
-func (Query_Filter_Operator) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 0, 0}
-}
-
-type Query_Order_Direction int32
-
-const (
- Query_Order_ASCENDING Query_Order_Direction = 1
- Query_Order_DESCENDING Query_Order_Direction = 2
-)
-
-var Query_Order_Direction_name = map[int32]string{
- 1: "ASCENDING",
- 2: "DESCENDING",
-}
-var Query_Order_Direction_value = map[string]int32{
- "ASCENDING": 1,
- "DESCENDING": 2,
-}
-
-func (x Query_Order_Direction) Enum() *Query_Order_Direction {
- p := new(Query_Order_Direction)
- *p = x
- return p
-}
-func (x Query_Order_Direction) String() string {
- return proto.EnumName(Query_Order_Direction_name, int32(x))
-}
-func (x *Query_Order_Direction) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(Query_Order_Direction_value, data, "Query_Order_Direction")
- if err != nil {
- return err
- }
- *x = Query_Order_Direction(value)
- return nil
-}
-func (Query_Order_Direction) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 1, 0}
-}
-
-type Error_ErrorCode int32
-
-const (
- Error_BAD_REQUEST Error_ErrorCode = 1
- Error_CONCURRENT_TRANSACTION Error_ErrorCode = 2
- Error_INTERNAL_ERROR Error_ErrorCode = 3
- Error_NEED_INDEX Error_ErrorCode = 4
- Error_TIMEOUT Error_ErrorCode = 5
- Error_PERMISSION_DENIED Error_ErrorCode = 6
- Error_BIGTABLE_ERROR Error_ErrorCode = 7
- Error_COMMITTED_BUT_STILL_APPLYING Error_ErrorCode = 8
- Error_CAPABILITY_DISABLED Error_ErrorCode = 9
- Error_TRY_ALTERNATE_BACKEND Error_ErrorCode = 10
- Error_SAFE_TIME_TOO_OLD Error_ErrorCode = 11
-)
-
-var Error_ErrorCode_name = map[int32]string{
- 1: "BAD_REQUEST",
- 2: "CONCURRENT_TRANSACTION",
- 3: "INTERNAL_ERROR",
- 4: "NEED_INDEX",
- 5: "TIMEOUT",
- 6: "PERMISSION_DENIED",
- 7: "BIGTABLE_ERROR",
- 8: "COMMITTED_BUT_STILL_APPLYING",
- 9: "CAPABILITY_DISABLED",
- 10: "TRY_ALTERNATE_BACKEND",
- 11: "SAFE_TIME_TOO_OLD",
-}
-var Error_ErrorCode_value = map[string]int32{
- "BAD_REQUEST": 1,
- "CONCURRENT_TRANSACTION": 2,
- "INTERNAL_ERROR": 3,
- "NEED_INDEX": 4,
- "TIMEOUT": 5,
- "PERMISSION_DENIED": 6,
- "BIGTABLE_ERROR": 7,
- "COMMITTED_BUT_STILL_APPLYING": 8,
- "CAPABILITY_DISABLED": 9,
- "TRY_ALTERNATE_BACKEND": 10,
- "SAFE_TIME_TOO_OLD": 11,
-}
-
-func (x Error_ErrorCode) Enum() *Error_ErrorCode {
- p := new(Error_ErrorCode)
- *p = x
- return p
-}
-func (x Error_ErrorCode) String() string {
- return proto.EnumName(Error_ErrorCode_name, int32(x))
-}
-func (x *Error_ErrorCode) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(Error_ErrorCode_value, data, "Error_ErrorCode")
- if err != nil {
- return err
- }
- *x = Error_ErrorCode(value)
- return nil
-}
-func (Error_ErrorCode) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{19, 0}
-}
-
-type PutRequest_AutoIdPolicy int32
-
-const (
- PutRequest_CURRENT PutRequest_AutoIdPolicy = 0
- PutRequest_SEQUENTIAL PutRequest_AutoIdPolicy = 1
-)
-
-var PutRequest_AutoIdPolicy_name = map[int32]string{
- 0: "CURRENT",
- 1: "SEQUENTIAL",
-}
-var PutRequest_AutoIdPolicy_value = map[string]int32{
- "CURRENT": 0,
- "SEQUENTIAL": 1,
-}
-
-func (x PutRequest_AutoIdPolicy) Enum() *PutRequest_AutoIdPolicy {
- p := new(PutRequest_AutoIdPolicy)
- *p = x
- return p
-}
-func (x PutRequest_AutoIdPolicy) String() string {
- return proto.EnumName(PutRequest_AutoIdPolicy_name, int32(x))
-}
-func (x *PutRequest_AutoIdPolicy) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(PutRequest_AutoIdPolicy_value, data, "PutRequest_AutoIdPolicy")
- if err != nil {
- return err
- }
- *x = PutRequest_AutoIdPolicy(value)
- return nil
-}
-func (PutRequest_AutoIdPolicy) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{23, 0}
-}
-
-type BeginTransactionRequest_TransactionMode int32
-
-const (
- BeginTransactionRequest_UNKNOWN BeginTransactionRequest_TransactionMode = 0
- BeginTransactionRequest_READ_ONLY BeginTransactionRequest_TransactionMode = 1
- BeginTransactionRequest_READ_WRITE BeginTransactionRequest_TransactionMode = 2
-)
-
-var BeginTransactionRequest_TransactionMode_name = map[int32]string{
- 0: "UNKNOWN",
- 1: "READ_ONLY",
- 2: "READ_WRITE",
-}
-var BeginTransactionRequest_TransactionMode_value = map[string]int32{
- "UNKNOWN": 0,
- "READ_ONLY": 1,
- "READ_WRITE": 2,
-}
-
-func (x BeginTransactionRequest_TransactionMode) Enum() *BeginTransactionRequest_TransactionMode {
- p := new(BeginTransactionRequest_TransactionMode)
- *p = x
- return p
-}
-func (x BeginTransactionRequest_TransactionMode) String() string {
- return proto.EnumName(BeginTransactionRequest_TransactionMode_name, int32(x))
-}
-func (x *BeginTransactionRequest_TransactionMode) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(BeginTransactionRequest_TransactionMode_value, data, "BeginTransactionRequest_TransactionMode")
- if err != nil {
- return err
- }
- *x = BeginTransactionRequest_TransactionMode(value)
- return nil
-}
-func (BeginTransactionRequest_TransactionMode) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{36, 0}
-}
-
-type Action struct {
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Action) Reset() { *m = Action{} }
-func (m *Action) String() string { return proto.CompactTextString(m) }
-func (*Action) ProtoMessage() {}
-func (*Action) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{0}
-}
-func (m *Action) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Action.Unmarshal(m, b)
-}
-func (m *Action) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Action.Marshal(b, m, deterministic)
-}
-func (dst *Action) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Action.Merge(dst, src)
-}
-func (m *Action) XXX_Size() int {
- return xxx_messageInfo_Action.Size(m)
-}
-func (m *Action) XXX_DiscardUnknown() {
- xxx_messageInfo_Action.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Action proto.InternalMessageInfo
-
-type PropertyValue struct {
- Int64Value *int64 `protobuf:"varint,1,opt,name=int64Value" json:"int64Value,omitempty"`
- BooleanValue *bool `protobuf:"varint,2,opt,name=booleanValue" json:"booleanValue,omitempty"`
- StringValue *string `protobuf:"bytes,3,opt,name=stringValue" json:"stringValue,omitempty"`
- DoubleValue *float64 `protobuf:"fixed64,4,opt,name=doubleValue" json:"doubleValue,omitempty"`
- Pointvalue *PropertyValue_PointValue `protobuf:"group,5,opt,name=PointValue,json=pointvalue" json:"pointvalue,omitempty"`
- Uservalue *PropertyValue_UserValue `protobuf:"group,8,opt,name=UserValue,json=uservalue" json:"uservalue,omitempty"`
- Referencevalue *PropertyValue_ReferenceValue `protobuf:"group,12,opt,name=ReferenceValue,json=referencevalue" json:"referencevalue,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PropertyValue) Reset() { *m = PropertyValue{} }
-func (m *PropertyValue) String() string { return proto.CompactTextString(m) }
-func (*PropertyValue) ProtoMessage() {}
-func (*PropertyValue) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1}
-}
-func (m *PropertyValue) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PropertyValue.Unmarshal(m, b)
-}
-func (m *PropertyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PropertyValue.Marshal(b, m, deterministic)
-}
-func (dst *PropertyValue) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PropertyValue.Merge(dst, src)
-}
-func (m *PropertyValue) XXX_Size() int {
- return xxx_messageInfo_PropertyValue.Size(m)
-}
-func (m *PropertyValue) XXX_DiscardUnknown() {
- xxx_messageInfo_PropertyValue.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PropertyValue proto.InternalMessageInfo
-
-func (m *PropertyValue) GetInt64Value() int64 {
- if m != nil && m.Int64Value != nil {
- return *m.Int64Value
- }
- return 0
-}
-
-func (m *PropertyValue) GetBooleanValue() bool {
- if m != nil && m.BooleanValue != nil {
- return *m.BooleanValue
- }
- return false
-}
-
-func (m *PropertyValue) GetStringValue() string {
- if m != nil && m.StringValue != nil {
- return *m.StringValue
- }
- return ""
-}
-
-func (m *PropertyValue) GetDoubleValue() float64 {
- if m != nil && m.DoubleValue != nil {
- return *m.DoubleValue
- }
- return 0
-}
-
-func (m *PropertyValue) GetPointvalue() *PropertyValue_PointValue {
- if m != nil {
- return m.Pointvalue
- }
- return nil
-}
-
-func (m *PropertyValue) GetUservalue() *PropertyValue_UserValue {
- if m != nil {
- return m.Uservalue
- }
- return nil
-}
-
-func (m *PropertyValue) GetReferencevalue() *PropertyValue_ReferenceValue {
- if m != nil {
- return m.Referencevalue
- }
- return nil
-}
-
-type PropertyValue_PointValue struct {
- X *float64 `protobuf:"fixed64,6,req,name=x" json:"x,omitempty"`
- Y *float64 `protobuf:"fixed64,7,req,name=y" json:"y,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PropertyValue_PointValue) Reset() { *m = PropertyValue_PointValue{} }
-func (m *PropertyValue_PointValue) String() string { return proto.CompactTextString(m) }
-func (*PropertyValue_PointValue) ProtoMessage() {}
-func (*PropertyValue_PointValue) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 0}
-}
-func (m *PropertyValue_PointValue) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PropertyValue_PointValue.Unmarshal(m, b)
-}
-func (m *PropertyValue_PointValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PropertyValue_PointValue.Marshal(b, m, deterministic)
-}
-func (dst *PropertyValue_PointValue) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PropertyValue_PointValue.Merge(dst, src)
-}
-func (m *PropertyValue_PointValue) XXX_Size() int {
- return xxx_messageInfo_PropertyValue_PointValue.Size(m)
-}
-func (m *PropertyValue_PointValue) XXX_DiscardUnknown() {
- xxx_messageInfo_PropertyValue_PointValue.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PropertyValue_PointValue proto.InternalMessageInfo
-
-func (m *PropertyValue_PointValue) GetX() float64 {
- if m != nil && m.X != nil {
- return *m.X
- }
- return 0
-}
-
-func (m *PropertyValue_PointValue) GetY() float64 {
- if m != nil && m.Y != nil {
- return *m.Y
- }
- return 0
-}
-
-type PropertyValue_UserValue struct {
- Email *string `protobuf:"bytes,9,req,name=email" json:"email,omitempty"`
- AuthDomain *string `protobuf:"bytes,10,req,name=auth_domain,json=authDomain" json:"auth_domain,omitempty"`
- Nickname *string `protobuf:"bytes,11,opt,name=nickname" json:"nickname,omitempty"`
- FederatedIdentity *string `protobuf:"bytes,21,opt,name=federated_identity,json=federatedIdentity" json:"federated_identity,omitempty"`
- FederatedProvider *string `protobuf:"bytes,22,opt,name=federated_provider,json=federatedProvider" json:"federated_provider,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PropertyValue_UserValue) Reset() { *m = PropertyValue_UserValue{} }
-func (m *PropertyValue_UserValue) String() string { return proto.CompactTextString(m) }
-func (*PropertyValue_UserValue) ProtoMessage() {}
-func (*PropertyValue_UserValue) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 1}
-}
-func (m *PropertyValue_UserValue) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PropertyValue_UserValue.Unmarshal(m, b)
-}
-func (m *PropertyValue_UserValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PropertyValue_UserValue.Marshal(b, m, deterministic)
-}
-func (dst *PropertyValue_UserValue) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PropertyValue_UserValue.Merge(dst, src)
-}
-func (m *PropertyValue_UserValue) XXX_Size() int {
- return xxx_messageInfo_PropertyValue_UserValue.Size(m)
-}
-func (m *PropertyValue_UserValue) XXX_DiscardUnknown() {
- xxx_messageInfo_PropertyValue_UserValue.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PropertyValue_UserValue proto.InternalMessageInfo
-
-func (m *PropertyValue_UserValue) GetEmail() string {
- if m != nil && m.Email != nil {
- return *m.Email
- }
- return ""
-}
-
-func (m *PropertyValue_UserValue) GetAuthDomain() string {
- if m != nil && m.AuthDomain != nil {
- return *m.AuthDomain
- }
- return ""
-}
-
-func (m *PropertyValue_UserValue) GetNickname() string {
- if m != nil && m.Nickname != nil {
- return *m.Nickname
- }
- return ""
-}
-
-func (m *PropertyValue_UserValue) GetFederatedIdentity() string {
- if m != nil && m.FederatedIdentity != nil {
- return *m.FederatedIdentity
- }
- return ""
-}
-
-func (m *PropertyValue_UserValue) GetFederatedProvider() string {
- if m != nil && m.FederatedProvider != nil {
- return *m.FederatedProvider
- }
- return ""
-}
-
-type PropertyValue_ReferenceValue struct {
- App *string `protobuf:"bytes,13,req,name=app" json:"app,omitempty"`
- NameSpace *string `protobuf:"bytes,20,opt,name=name_space,json=nameSpace" json:"name_space,omitempty"`
- Pathelement []*PropertyValue_ReferenceValue_PathElement `protobuf:"group,14,rep,name=PathElement,json=pathelement" json:"pathelement,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PropertyValue_ReferenceValue) Reset() { *m = PropertyValue_ReferenceValue{} }
-func (m *PropertyValue_ReferenceValue) String() string { return proto.CompactTextString(m) }
-func (*PropertyValue_ReferenceValue) ProtoMessage() {}
-func (*PropertyValue_ReferenceValue) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 2}
-}
-func (m *PropertyValue_ReferenceValue) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PropertyValue_ReferenceValue.Unmarshal(m, b)
-}
-func (m *PropertyValue_ReferenceValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PropertyValue_ReferenceValue.Marshal(b, m, deterministic)
-}
-func (dst *PropertyValue_ReferenceValue) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PropertyValue_ReferenceValue.Merge(dst, src)
-}
-func (m *PropertyValue_ReferenceValue) XXX_Size() int {
- return xxx_messageInfo_PropertyValue_ReferenceValue.Size(m)
-}
-func (m *PropertyValue_ReferenceValue) XXX_DiscardUnknown() {
- xxx_messageInfo_PropertyValue_ReferenceValue.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PropertyValue_ReferenceValue proto.InternalMessageInfo
-
-func (m *PropertyValue_ReferenceValue) GetApp() string {
- if m != nil && m.App != nil {
- return *m.App
- }
- return ""
-}
-
-func (m *PropertyValue_ReferenceValue) GetNameSpace() string {
- if m != nil && m.NameSpace != nil {
- return *m.NameSpace
- }
- return ""
-}
-
-func (m *PropertyValue_ReferenceValue) GetPathelement() []*PropertyValue_ReferenceValue_PathElement {
- if m != nil {
- return m.Pathelement
- }
- return nil
-}
-
-type PropertyValue_ReferenceValue_PathElement struct {
- Type *string `protobuf:"bytes,15,req,name=type" json:"type,omitempty"`
- Id *int64 `protobuf:"varint,16,opt,name=id" json:"id,omitempty"`
- Name *string `protobuf:"bytes,17,opt,name=name" json:"name,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PropertyValue_ReferenceValue_PathElement) Reset() {
- *m = PropertyValue_ReferenceValue_PathElement{}
-}
-func (m *PropertyValue_ReferenceValue_PathElement) String() string { return proto.CompactTextString(m) }
-func (*PropertyValue_ReferenceValue_PathElement) ProtoMessage() {}
-func (*PropertyValue_ReferenceValue_PathElement) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 2, 0}
-}
-func (m *PropertyValue_ReferenceValue_PathElement) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Unmarshal(m, b)
-}
-func (m *PropertyValue_ReferenceValue_PathElement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Marshal(b, m, deterministic)
-}
-func (dst *PropertyValue_ReferenceValue_PathElement) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Merge(dst, src)
-}
-func (m *PropertyValue_ReferenceValue_PathElement) XXX_Size() int {
- return xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Size(m)
-}
-func (m *PropertyValue_ReferenceValue_PathElement) XXX_DiscardUnknown() {
- xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PropertyValue_ReferenceValue_PathElement proto.InternalMessageInfo
-
-func (m *PropertyValue_ReferenceValue_PathElement) GetType() string {
- if m != nil && m.Type != nil {
- return *m.Type
- }
- return ""
-}
-
-func (m *PropertyValue_ReferenceValue_PathElement) GetId() int64 {
- if m != nil && m.Id != nil {
- return *m.Id
- }
- return 0
-}
-
-func (m *PropertyValue_ReferenceValue_PathElement) GetName() string {
- if m != nil && m.Name != nil {
- return *m.Name
- }
- return ""
-}
-
-type Property struct {
- Meaning *Property_Meaning `protobuf:"varint,1,opt,name=meaning,enum=appengine.Property_Meaning,def=0" json:"meaning,omitempty"`
- MeaningUri *string `protobuf:"bytes,2,opt,name=meaning_uri,json=meaningUri" json:"meaning_uri,omitempty"`
- Name *string `protobuf:"bytes,3,req,name=name" json:"name,omitempty"`
- Value *PropertyValue `protobuf:"bytes,5,req,name=value" json:"value,omitempty"`
- Multiple *bool `protobuf:"varint,4,req,name=multiple" json:"multiple,omitempty"`
- Searchable *bool `protobuf:"varint,6,opt,name=searchable,def=0" json:"searchable,omitempty"`
- FtsTokenizationOption *Property_FtsTokenizationOption `protobuf:"varint,8,opt,name=fts_tokenization_option,json=ftsTokenizationOption,enum=appengine.Property_FtsTokenizationOption" json:"fts_tokenization_option,omitempty"`
- Locale *string `protobuf:"bytes,9,opt,name=locale,def=en" json:"locale,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Property) Reset() { *m = Property{} }
-func (m *Property) String() string { return proto.CompactTextString(m) }
-func (*Property) ProtoMessage() {}
-func (*Property) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{2}
-}
-func (m *Property) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Property.Unmarshal(m, b)
-}
-func (m *Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Property.Marshal(b, m, deterministic)
-}
-func (dst *Property) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Property.Merge(dst, src)
-}
-func (m *Property) XXX_Size() int {
- return xxx_messageInfo_Property.Size(m)
-}
-func (m *Property) XXX_DiscardUnknown() {
- xxx_messageInfo_Property.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Property proto.InternalMessageInfo
-
-const Default_Property_Meaning Property_Meaning = Property_NO_MEANING
-const Default_Property_Searchable bool = false
-const Default_Property_Locale string = "en"
-
-func (m *Property) GetMeaning() Property_Meaning {
- if m != nil && m.Meaning != nil {
- return *m.Meaning
- }
- return Default_Property_Meaning
-}
-
-func (m *Property) GetMeaningUri() string {
- if m != nil && m.MeaningUri != nil {
- return *m.MeaningUri
- }
- return ""
-}
-
-func (m *Property) GetName() string {
- if m != nil && m.Name != nil {
- return *m.Name
- }
- return ""
-}
-
-func (m *Property) GetValue() *PropertyValue {
- if m != nil {
- return m.Value
- }
- return nil
-}
-
-func (m *Property) GetMultiple() bool {
- if m != nil && m.Multiple != nil {
- return *m.Multiple
- }
- return false
-}
-
-func (m *Property) GetSearchable() bool {
- if m != nil && m.Searchable != nil {
- return *m.Searchable
- }
- return Default_Property_Searchable
-}
-
-func (m *Property) GetFtsTokenizationOption() Property_FtsTokenizationOption {
- if m != nil && m.FtsTokenizationOption != nil {
- return *m.FtsTokenizationOption
- }
- return Property_HTML
-}
-
-func (m *Property) GetLocale() string {
- if m != nil && m.Locale != nil {
- return *m.Locale
- }
- return Default_Property_Locale
-}
-
-type Path struct {
- Element []*Path_Element `protobuf:"group,1,rep,name=Element,json=element" json:"element,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Path) Reset() { *m = Path{} }
-func (m *Path) String() string { return proto.CompactTextString(m) }
-func (*Path) ProtoMessage() {}
-func (*Path) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{3}
-}
-func (m *Path) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Path.Unmarshal(m, b)
-}
-func (m *Path) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Path.Marshal(b, m, deterministic)
-}
-func (dst *Path) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Path.Merge(dst, src)
-}
-func (m *Path) XXX_Size() int {
- return xxx_messageInfo_Path.Size(m)
-}
-func (m *Path) XXX_DiscardUnknown() {
- xxx_messageInfo_Path.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Path proto.InternalMessageInfo
-
-func (m *Path) GetElement() []*Path_Element {
- if m != nil {
- return m.Element
- }
- return nil
-}
-
-type Path_Element struct {
- Type *string `protobuf:"bytes,2,req,name=type" json:"type,omitempty"`
- Id *int64 `protobuf:"varint,3,opt,name=id" json:"id,omitempty"`
- Name *string `protobuf:"bytes,4,opt,name=name" json:"name,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Path_Element) Reset() { *m = Path_Element{} }
-func (m *Path_Element) String() string { return proto.CompactTextString(m) }
-func (*Path_Element) ProtoMessage() {}
-func (*Path_Element) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{3, 0}
-}
-func (m *Path_Element) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Path_Element.Unmarshal(m, b)
-}
-func (m *Path_Element) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Path_Element.Marshal(b, m, deterministic)
-}
-func (dst *Path_Element) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Path_Element.Merge(dst, src)
-}
-func (m *Path_Element) XXX_Size() int {
- return xxx_messageInfo_Path_Element.Size(m)
-}
-func (m *Path_Element) XXX_DiscardUnknown() {
- xxx_messageInfo_Path_Element.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Path_Element proto.InternalMessageInfo
-
-func (m *Path_Element) GetType() string {
- if m != nil && m.Type != nil {
- return *m.Type
- }
- return ""
-}
-
-func (m *Path_Element) GetId() int64 {
- if m != nil && m.Id != nil {
- return *m.Id
- }
- return 0
-}
-
-func (m *Path_Element) GetName() string {
- if m != nil && m.Name != nil {
- return *m.Name
- }
- return ""
-}
-
-type Reference struct {
- App *string `protobuf:"bytes,13,req,name=app" json:"app,omitempty"`
- NameSpace *string `protobuf:"bytes,20,opt,name=name_space,json=nameSpace" json:"name_space,omitempty"`
- Path *Path `protobuf:"bytes,14,req,name=path" json:"path,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Reference) Reset() { *m = Reference{} }
-func (m *Reference) String() string { return proto.CompactTextString(m) }
-func (*Reference) ProtoMessage() {}
-func (*Reference) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{4}
-}
-func (m *Reference) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Reference.Unmarshal(m, b)
-}
-func (m *Reference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Reference.Marshal(b, m, deterministic)
-}
-func (dst *Reference) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Reference.Merge(dst, src)
-}
-func (m *Reference) XXX_Size() int {
- return xxx_messageInfo_Reference.Size(m)
-}
-func (m *Reference) XXX_DiscardUnknown() {
- xxx_messageInfo_Reference.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Reference proto.InternalMessageInfo
-
-func (m *Reference) GetApp() string {
- if m != nil && m.App != nil {
- return *m.App
- }
- return ""
-}
-
-func (m *Reference) GetNameSpace() string {
- if m != nil && m.NameSpace != nil {
- return *m.NameSpace
- }
- return ""
-}
-
-func (m *Reference) GetPath() *Path {
- if m != nil {
- return m.Path
- }
- return nil
-}
-
-type User struct {
- Email *string `protobuf:"bytes,1,req,name=email" json:"email,omitempty"`
- AuthDomain *string `protobuf:"bytes,2,req,name=auth_domain,json=authDomain" json:"auth_domain,omitempty"`
- Nickname *string `protobuf:"bytes,3,opt,name=nickname" json:"nickname,omitempty"`
- FederatedIdentity *string `protobuf:"bytes,6,opt,name=federated_identity,json=federatedIdentity" json:"federated_identity,omitempty"`
- FederatedProvider *string `protobuf:"bytes,7,opt,name=federated_provider,json=federatedProvider" json:"federated_provider,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *User) Reset() { *m = User{} }
-func (m *User) String() string { return proto.CompactTextString(m) }
-func (*User) ProtoMessage() {}
-func (*User) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{5}
-}
-func (m *User) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_User.Unmarshal(m, b)
-}
-func (m *User) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_User.Marshal(b, m, deterministic)
-}
-func (dst *User) XXX_Merge(src proto.Message) {
- xxx_messageInfo_User.Merge(dst, src)
-}
-func (m *User) XXX_Size() int {
- return xxx_messageInfo_User.Size(m)
-}
-func (m *User) XXX_DiscardUnknown() {
- xxx_messageInfo_User.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_User proto.InternalMessageInfo
-
-func (m *User) GetEmail() string {
- if m != nil && m.Email != nil {
- return *m.Email
- }
- return ""
-}
-
-func (m *User) GetAuthDomain() string {
- if m != nil && m.AuthDomain != nil {
- return *m.AuthDomain
- }
- return ""
-}
-
-func (m *User) GetNickname() string {
- if m != nil && m.Nickname != nil {
- return *m.Nickname
- }
- return ""
-}
-
-func (m *User) GetFederatedIdentity() string {
- if m != nil && m.FederatedIdentity != nil {
- return *m.FederatedIdentity
- }
- return ""
-}
-
-func (m *User) GetFederatedProvider() string {
- if m != nil && m.FederatedProvider != nil {
- return *m.FederatedProvider
- }
- return ""
-}
-
-type EntityProto struct {
- Key *Reference `protobuf:"bytes,13,req,name=key" json:"key,omitempty"`
- EntityGroup *Path `protobuf:"bytes,16,req,name=entity_group,json=entityGroup" json:"entity_group,omitempty"`
- Owner *User `protobuf:"bytes,17,opt,name=owner" json:"owner,omitempty"`
- Kind *EntityProto_Kind `protobuf:"varint,4,opt,name=kind,enum=appengine.EntityProto_Kind" json:"kind,omitempty"`
- KindUri *string `protobuf:"bytes,5,opt,name=kind_uri,json=kindUri" json:"kind_uri,omitempty"`
- Property []*Property `protobuf:"bytes,14,rep,name=property" json:"property,omitempty"`
- RawProperty []*Property `protobuf:"bytes,15,rep,name=raw_property,json=rawProperty" json:"raw_property,omitempty"`
- Rank *int32 `protobuf:"varint,18,opt,name=rank" json:"rank,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *EntityProto) Reset() { *m = EntityProto{} }
-func (m *EntityProto) String() string { return proto.CompactTextString(m) }
-func (*EntityProto) ProtoMessage() {}
-func (*EntityProto) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{6}
-}
-func (m *EntityProto) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_EntityProto.Unmarshal(m, b)
-}
-func (m *EntityProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_EntityProto.Marshal(b, m, deterministic)
-}
-func (dst *EntityProto) XXX_Merge(src proto.Message) {
- xxx_messageInfo_EntityProto.Merge(dst, src)
-}
-func (m *EntityProto) XXX_Size() int {
- return xxx_messageInfo_EntityProto.Size(m)
-}
-func (m *EntityProto) XXX_DiscardUnknown() {
- xxx_messageInfo_EntityProto.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EntityProto proto.InternalMessageInfo
-
-func (m *EntityProto) GetKey() *Reference {
- if m != nil {
- return m.Key
- }
- return nil
-}
-
-func (m *EntityProto) GetEntityGroup() *Path {
- if m != nil {
- return m.EntityGroup
- }
- return nil
-}
-
-func (m *EntityProto) GetOwner() *User {
- if m != nil {
- return m.Owner
- }
- return nil
-}
-
-func (m *EntityProto) GetKind() EntityProto_Kind {
- if m != nil && m.Kind != nil {
- return *m.Kind
- }
- return EntityProto_GD_CONTACT
-}
-
-func (m *EntityProto) GetKindUri() string {
- if m != nil && m.KindUri != nil {
- return *m.KindUri
- }
- return ""
-}
-
-func (m *EntityProto) GetProperty() []*Property {
- if m != nil {
- return m.Property
- }
- return nil
-}
-
-func (m *EntityProto) GetRawProperty() []*Property {
- if m != nil {
- return m.RawProperty
- }
- return nil
-}
-
-func (m *EntityProto) GetRank() int32 {
- if m != nil && m.Rank != nil {
- return *m.Rank
- }
- return 0
-}
-
-type CompositeProperty struct {
- IndexId *int64 `protobuf:"varint,1,req,name=index_id,json=indexId" json:"index_id,omitempty"`
- Value []string `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *CompositeProperty) Reset() { *m = CompositeProperty{} }
-func (m *CompositeProperty) String() string { return proto.CompactTextString(m) }
-func (*CompositeProperty) ProtoMessage() {}
-func (*CompositeProperty) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{7}
-}
-func (m *CompositeProperty) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_CompositeProperty.Unmarshal(m, b)
-}
-func (m *CompositeProperty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_CompositeProperty.Marshal(b, m, deterministic)
-}
-func (dst *CompositeProperty) XXX_Merge(src proto.Message) {
- xxx_messageInfo_CompositeProperty.Merge(dst, src)
-}
-func (m *CompositeProperty) XXX_Size() int {
- return xxx_messageInfo_CompositeProperty.Size(m)
-}
-func (m *CompositeProperty) XXX_DiscardUnknown() {
- xxx_messageInfo_CompositeProperty.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CompositeProperty proto.InternalMessageInfo
-
-func (m *CompositeProperty) GetIndexId() int64 {
- if m != nil && m.IndexId != nil {
- return *m.IndexId
- }
- return 0
-}
-
-func (m *CompositeProperty) GetValue() []string {
- if m != nil {
- return m.Value
- }
- return nil
-}
-
-type Index struct {
- EntityType *string `protobuf:"bytes,1,req,name=entity_type,json=entityType" json:"entity_type,omitempty"`
- Ancestor *bool `protobuf:"varint,5,req,name=ancestor" json:"ancestor,omitempty"`
- Property []*Index_Property `protobuf:"group,2,rep,name=Property,json=property" json:"property,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Index) Reset() { *m = Index{} }
-func (m *Index) String() string { return proto.CompactTextString(m) }
-func (*Index) ProtoMessage() {}
-func (*Index) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{8}
-}
-func (m *Index) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Index.Unmarshal(m, b)
-}
-func (m *Index) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Index.Marshal(b, m, deterministic)
-}
-func (dst *Index) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Index.Merge(dst, src)
-}
-func (m *Index) XXX_Size() int {
- return xxx_messageInfo_Index.Size(m)
-}
-func (m *Index) XXX_DiscardUnknown() {
- xxx_messageInfo_Index.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Index proto.InternalMessageInfo
-
-func (m *Index) GetEntityType() string {
- if m != nil && m.EntityType != nil {
- return *m.EntityType
- }
- return ""
-}
-
-func (m *Index) GetAncestor() bool {
- if m != nil && m.Ancestor != nil {
- return *m.Ancestor
- }
- return false
-}
-
-func (m *Index) GetProperty() []*Index_Property {
- if m != nil {
- return m.Property
- }
- return nil
-}
-
-type Index_Property struct {
- Name *string `protobuf:"bytes,3,req,name=name" json:"name,omitempty"`
- Direction *Index_Property_Direction `protobuf:"varint,4,opt,name=direction,enum=appengine.Index_Property_Direction,def=1" json:"direction,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Index_Property) Reset() { *m = Index_Property{} }
-func (m *Index_Property) String() string { return proto.CompactTextString(m) }
-func (*Index_Property) ProtoMessage() {}
-func (*Index_Property) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{8, 0}
-}
-func (m *Index_Property) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Index_Property.Unmarshal(m, b)
-}
-func (m *Index_Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Index_Property.Marshal(b, m, deterministic)
-}
-func (dst *Index_Property) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Index_Property.Merge(dst, src)
-}
-func (m *Index_Property) XXX_Size() int {
- return xxx_messageInfo_Index_Property.Size(m)
-}
-func (m *Index_Property) XXX_DiscardUnknown() {
- xxx_messageInfo_Index_Property.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Index_Property proto.InternalMessageInfo
-
-const Default_Index_Property_Direction Index_Property_Direction = Index_Property_ASCENDING
-
-func (m *Index_Property) GetName() string {
- if m != nil && m.Name != nil {
- return *m.Name
- }
- return ""
-}
-
-func (m *Index_Property) GetDirection() Index_Property_Direction {
- if m != nil && m.Direction != nil {
- return *m.Direction
- }
- return Default_Index_Property_Direction
-}
-
-type CompositeIndex struct {
- AppId *string `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
- Id *int64 `protobuf:"varint,2,req,name=id" json:"id,omitempty"`
- Definition *Index `protobuf:"bytes,3,req,name=definition" json:"definition,omitempty"`
- State *CompositeIndex_State `protobuf:"varint,4,req,name=state,enum=appengine.CompositeIndex_State" json:"state,omitempty"`
- OnlyUseIfRequired *bool `protobuf:"varint,6,opt,name=only_use_if_required,json=onlyUseIfRequired,def=0" json:"only_use_if_required,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *CompositeIndex) Reset() { *m = CompositeIndex{} }
-func (m *CompositeIndex) String() string { return proto.CompactTextString(m) }
-func (*CompositeIndex) ProtoMessage() {}
-func (*CompositeIndex) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{9}
-}
-func (m *CompositeIndex) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_CompositeIndex.Unmarshal(m, b)
-}
-func (m *CompositeIndex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_CompositeIndex.Marshal(b, m, deterministic)
-}
-func (dst *CompositeIndex) XXX_Merge(src proto.Message) {
- xxx_messageInfo_CompositeIndex.Merge(dst, src)
-}
-func (m *CompositeIndex) XXX_Size() int {
- return xxx_messageInfo_CompositeIndex.Size(m)
-}
-func (m *CompositeIndex) XXX_DiscardUnknown() {
- xxx_messageInfo_CompositeIndex.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CompositeIndex proto.InternalMessageInfo
-
-const Default_CompositeIndex_OnlyUseIfRequired bool = false
-
-func (m *CompositeIndex) GetAppId() string {
- if m != nil && m.AppId != nil {
- return *m.AppId
- }
- return ""
-}
-
-func (m *CompositeIndex) GetId() int64 {
- if m != nil && m.Id != nil {
- return *m.Id
- }
- return 0
-}
-
-func (m *CompositeIndex) GetDefinition() *Index {
- if m != nil {
- return m.Definition
- }
- return nil
-}
-
-func (m *CompositeIndex) GetState() CompositeIndex_State {
- if m != nil && m.State != nil {
- return *m.State
- }
- return CompositeIndex_WRITE_ONLY
-}
-
-func (m *CompositeIndex) GetOnlyUseIfRequired() bool {
- if m != nil && m.OnlyUseIfRequired != nil {
- return *m.OnlyUseIfRequired
- }
- return Default_CompositeIndex_OnlyUseIfRequired
-}
-
-type IndexPostfix struct {
- IndexValue []*IndexPostfix_IndexValue `protobuf:"bytes,1,rep,name=index_value,json=indexValue" json:"index_value,omitempty"`
- Key *Reference `protobuf:"bytes,2,opt,name=key" json:"key,omitempty"`
- Before *bool `protobuf:"varint,3,opt,name=before,def=1" json:"before,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *IndexPostfix) Reset() { *m = IndexPostfix{} }
-func (m *IndexPostfix) String() string { return proto.CompactTextString(m) }
-func (*IndexPostfix) ProtoMessage() {}
-func (*IndexPostfix) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{10}
-}
-func (m *IndexPostfix) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_IndexPostfix.Unmarshal(m, b)
-}
-func (m *IndexPostfix) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_IndexPostfix.Marshal(b, m, deterministic)
-}
-func (dst *IndexPostfix) XXX_Merge(src proto.Message) {
- xxx_messageInfo_IndexPostfix.Merge(dst, src)
-}
-func (m *IndexPostfix) XXX_Size() int {
- return xxx_messageInfo_IndexPostfix.Size(m)
-}
-func (m *IndexPostfix) XXX_DiscardUnknown() {
- xxx_messageInfo_IndexPostfix.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_IndexPostfix proto.InternalMessageInfo
-
-const Default_IndexPostfix_Before bool = true
-
-func (m *IndexPostfix) GetIndexValue() []*IndexPostfix_IndexValue {
- if m != nil {
- return m.IndexValue
- }
- return nil
-}
-
-func (m *IndexPostfix) GetKey() *Reference {
- if m != nil {
- return m.Key
- }
- return nil
-}
-
-func (m *IndexPostfix) GetBefore() bool {
- if m != nil && m.Before != nil {
- return *m.Before
- }
- return Default_IndexPostfix_Before
-}
-
-type IndexPostfix_IndexValue struct {
- PropertyName *string `protobuf:"bytes,1,req,name=property_name,json=propertyName" json:"property_name,omitempty"`
- Value *PropertyValue `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *IndexPostfix_IndexValue) Reset() { *m = IndexPostfix_IndexValue{} }
-func (m *IndexPostfix_IndexValue) String() string { return proto.CompactTextString(m) }
-func (*IndexPostfix_IndexValue) ProtoMessage() {}
-func (*IndexPostfix_IndexValue) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{10, 0}
-}
-func (m *IndexPostfix_IndexValue) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_IndexPostfix_IndexValue.Unmarshal(m, b)
-}
-func (m *IndexPostfix_IndexValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_IndexPostfix_IndexValue.Marshal(b, m, deterministic)
-}
-func (dst *IndexPostfix_IndexValue) XXX_Merge(src proto.Message) {
- xxx_messageInfo_IndexPostfix_IndexValue.Merge(dst, src)
-}
-func (m *IndexPostfix_IndexValue) XXX_Size() int {
- return xxx_messageInfo_IndexPostfix_IndexValue.Size(m)
-}
-func (m *IndexPostfix_IndexValue) XXX_DiscardUnknown() {
- xxx_messageInfo_IndexPostfix_IndexValue.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_IndexPostfix_IndexValue proto.InternalMessageInfo
-
-func (m *IndexPostfix_IndexValue) GetPropertyName() string {
- if m != nil && m.PropertyName != nil {
- return *m.PropertyName
- }
- return ""
-}
-
-func (m *IndexPostfix_IndexValue) GetValue() *PropertyValue {
- if m != nil {
- return m.Value
- }
- return nil
-}
-
-type IndexPosition struct {
- Key *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
- Before *bool `protobuf:"varint,2,opt,name=before,def=1" json:"before,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *IndexPosition) Reset() { *m = IndexPosition{} }
-func (m *IndexPosition) String() string { return proto.CompactTextString(m) }
-func (*IndexPosition) ProtoMessage() {}
-func (*IndexPosition) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{11}
-}
-func (m *IndexPosition) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_IndexPosition.Unmarshal(m, b)
-}
-func (m *IndexPosition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_IndexPosition.Marshal(b, m, deterministic)
-}
-func (dst *IndexPosition) XXX_Merge(src proto.Message) {
- xxx_messageInfo_IndexPosition.Merge(dst, src)
-}
-func (m *IndexPosition) XXX_Size() int {
- return xxx_messageInfo_IndexPosition.Size(m)
-}
-func (m *IndexPosition) XXX_DiscardUnknown() {
- xxx_messageInfo_IndexPosition.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_IndexPosition proto.InternalMessageInfo
-
-const Default_IndexPosition_Before bool = true
-
-func (m *IndexPosition) GetKey() string {
- if m != nil && m.Key != nil {
- return *m.Key
- }
- return ""
-}
-
-func (m *IndexPosition) GetBefore() bool {
- if m != nil && m.Before != nil {
- return *m.Before
- }
- return Default_IndexPosition_Before
-}
-
-type Snapshot struct {
- Ts *int64 `protobuf:"varint,1,req,name=ts" json:"ts,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Snapshot) Reset() { *m = Snapshot{} }
-func (m *Snapshot) String() string { return proto.CompactTextString(m) }
-func (*Snapshot) ProtoMessage() {}
-func (*Snapshot) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{12}
-}
-func (m *Snapshot) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Snapshot.Unmarshal(m, b)
-}
-func (m *Snapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Snapshot.Marshal(b, m, deterministic)
-}
-func (dst *Snapshot) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Snapshot.Merge(dst, src)
-}
-func (m *Snapshot) XXX_Size() int {
- return xxx_messageInfo_Snapshot.Size(m)
-}
-func (m *Snapshot) XXX_DiscardUnknown() {
- xxx_messageInfo_Snapshot.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Snapshot proto.InternalMessageInfo
-
-func (m *Snapshot) GetTs() int64 {
- if m != nil && m.Ts != nil {
- return *m.Ts
- }
- return 0
-}
-
-type InternalHeader struct {
- Qos *string `protobuf:"bytes,1,opt,name=qos" json:"qos,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *InternalHeader) Reset() { *m = InternalHeader{} }
-func (m *InternalHeader) String() string { return proto.CompactTextString(m) }
-func (*InternalHeader) ProtoMessage() {}
-func (*InternalHeader) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{13}
-}
-func (m *InternalHeader) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_InternalHeader.Unmarshal(m, b)
-}
-func (m *InternalHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_InternalHeader.Marshal(b, m, deterministic)
-}
-func (dst *InternalHeader) XXX_Merge(src proto.Message) {
- xxx_messageInfo_InternalHeader.Merge(dst, src)
-}
-func (m *InternalHeader) XXX_Size() int {
- return xxx_messageInfo_InternalHeader.Size(m)
-}
-func (m *InternalHeader) XXX_DiscardUnknown() {
- xxx_messageInfo_InternalHeader.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_InternalHeader proto.InternalMessageInfo
-
-func (m *InternalHeader) GetQos() string {
- if m != nil && m.Qos != nil {
- return *m.Qos
- }
- return ""
-}
-
-type Transaction struct {
- Header *InternalHeader `protobuf:"bytes,4,opt,name=header" json:"header,omitempty"`
- Handle *uint64 `protobuf:"fixed64,1,req,name=handle" json:"handle,omitempty"`
- App *string `protobuf:"bytes,2,req,name=app" json:"app,omitempty"`
- MarkChanges *bool `protobuf:"varint,3,opt,name=mark_changes,json=markChanges,def=0" json:"mark_changes,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Transaction) Reset() { *m = Transaction{} }
-func (m *Transaction) String() string { return proto.CompactTextString(m) }
-func (*Transaction) ProtoMessage() {}
-func (*Transaction) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{14}
-}
-func (m *Transaction) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Transaction.Unmarshal(m, b)
-}
-func (m *Transaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Transaction.Marshal(b, m, deterministic)
-}
-func (dst *Transaction) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Transaction.Merge(dst, src)
-}
-func (m *Transaction) XXX_Size() int {
- return xxx_messageInfo_Transaction.Size(m)
-}
-func (m *Transaction) XXX_DiscardUnknown() {
- xxx_messageInfo_Transaction.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Transaction proto.InternalMessageInfo
-
-const Default_Transaction_MarkChanges bool = false
-
-func (m *Transaction) GetHeader() *InternalHeader {
- if m != nil {
- return m.Header
- }
- return nil
-}
-
-func (m *Transaction) GetHandle() uint64 {
- if m != nil && m.Handle != nil {
- return *m.Handle
- }
- return 0
-}
-
-func (m *Transaction) GetApp() string {
- if m != nil && m.App != nil {
- return *m.App
- }
- return ""
-}
-
-func (m *Transaction) GetMarkChanges() bool {
- if m != nil && m.MarkChanges != nil {
- return *m.MarkChanges
- }
- return Default_Transaction_MarkChanges
-}
-
-type Query struct {
- Header *InternalHeader `protobuf:"bytes,39,opt,name=header" json:"header,omitempty"`
- App *string `protobuf:"bytes,1,req,name=app" json:"app,omitempty"`
- NameSpace *string `protobuf:"bytes,29,opt,name=name_space,json=nameSpace" json:"name_space,omitempty"`
- Kind *string `protobuf:"bytes,3,opt,name=kind" json:"kind,omitempty"`
- Ancestor *Reference `protobuf:"bytes,17,opt,name=ancestor" json:"ancestor,omitempty"`
- Filter []*Query_Filter `protobuf:"group,4,rep,name=Filter,json=filter" json:"filter,omitempty"`
- SearchQuery *string `protobuf:"bytes,8,opt,name=search_query,json=searchQuery" json:"search_query,omitempty"`
- Order []*Query_Order `protobuf:"group,9,rep,name=Order,json=order" json:"order,omitempty"`
- Hint *Query_Hint `protobuf:"varint,18,opt,name=hint,enum=appengine.Query_Hint" json:"hint,omitempty"`
- Count *int32 `protobuf:"varint,23,opt,name=count" json:"count,omitempty"`
- Offset *int32 `protobuf:"varint,12,opt,name=offset,def=0" json:"offset,omitempty"`
- Limit *int32 `protobuf:"varint,16,opt,name=limit" json:"limit,omitempty"`
- CompiledCursor *CompiledCursor `protobuf:"bytes,30,opt,name=compiled_cursor,json=compiledCursor" json:"compiled_cursor,omitempty"`
- EndCompiledCursor *CompiledCursor `protobuf:"bytes,31,opt,name=end_compiled_cursor,json=endCompiledCursor" json:"end_compiled_cursor,omitempty"`
- CompositeIndex []*CompositeIndex `protobuf:"bytes,19,rep,name=composite_index,json=compositeIndex" json:"composite_index,omitempty"`
- RequirePerfectPlan *bool `protobuf:"varint,20,opt,name=require_perfect_plan,json=requirePerfectPlan,def=0" json:"require_perfect_plan,omitempty"`
- KeysOnly *bool `protobuf:"varint,21,opt,name=keys_only,json=keysOnly,def=0" json:"keys_only,omitempty"`
- Transaction *Transaction `protobuf:"bytes,22,opt,name=transaction" json:"transaction,omitempty"`
- Compile *bool `protobuf:"varint,25,opt,name=compile,def=0" json:"compile,omitempty"`
- FailoverMs *int64 `protobuf:"varint,26,opt,name=failover_ms,json=failoverMs" json:"failover_ms,omitempty"`
- Strong *bool `protobuf:"varint,32,opt,name=strong" json:"strong,omitempty"`
- PropertyName []string `protobuf:"bytes,33,rep,name=property_name,json=propertyName" json:"property_name,omitempty"`
- GroupByPropertyName []string `protobuf:"bytes,34,rep,name=group_by_property_name,json=groupByPropertyName" json:"group_by_property_name,omitempty"`
- Distinct *bool `protobuf:"varint,24,opt,name=distinct" json:"distinct,omitempty"`
- MinSafeTimeSeconds *int64 `protobuf:"varint,35,opt,name=min_safe_time_seconds,json=minSafeTimeSeconds" json:"min_safe_time_seconds,omitempty"`
- SafeReplicaName []string `protobuf:"bytes,36,rep,name=safe_replica_name,json=safeReplicaName" json:"safe_replica_name,omitempty"`
- PersistOffset *bool `protobuf:"varint,37,opt,name=persist_offset,json=persistOffset,def=0" json:"persist_offset,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Query) Reset() { *m = Query{} }
-func (m *Query) String() string { return proto.CompactTextString(m) }
-func (*Query) ProtoMessage() {}
-func (*Query) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15}
-}
-func (m *Query) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Query.Unmarshal(m, b)
-}
-func (m *Query) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Query.Marshal(b, m, deterministic)
-}
-func (dst *Query) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Query.Merge(dst, src)
-}
-func (m *Query) XXX_Size() int {
- return xxx_messageInfo_Query.Size(m)
-}
-func (m *Query) XXX_DiscardUnknown() {
- xxx_messageInfo_Query.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Query proto.InternalMessageInfo
-
-const Default_Query_Offset int32 = 0
-const Default_Query_RequirePerfectPlan bool = false
-const Default_Query_KeysOnly bool = false
-const Default_Query_Compile bool = false
-const Default_Query_PersistOffset bool = false
-
-func (m *Query) GetHeader() *InternalHeader {
- if m != nil {
- return m.Header
- }
- return nil
-}
-
-func (m *Query) GetApp() string {
- if m != nil && m.App != nil {
- return *m.App
- }
- return ""
-}
-
-func (m *Query) GetNameSpace() string {
- if m != nil && m.NameSpace != nil {
- return *m.NameSpace
- }
- return ""
-}
-
-func (m *Query) GetKind() string {
- if m != nil && m.Kind != nil {
- return *m.Kind
- }
- return ""
-}
-
-func (m *Query) GetAncestor() *Reference {
- if m != nil {
- return m.Ancestor
- }
- return nil
-}
-
-func (m *Query) GetFilter() []*Query_Filter {
- if m != nil {
- return m.Filter
- }
- return nil
-}
-
-func (m *Query) GetSearchQuery() string {
- if m != nil && m.SearchQuery != nil {
- return *m.SearchQuery
- }
- return ""
-}
-
-func (m *Query) GetOrder() []*Query_Order {
- if m != nil {
- return m.Order
- }
- return nil
-}
-
-func (m *Query) GetHint() Query_Hint {
- if m != nil && m.Hint != nil {
- return *m.Hint
- }
- return Query_ORDER_FIRST
-}
-
-func (m *Query) GetCount() int32 {
- if m != nil && m.Count != nil {
- return *m.Count
- }
- return 0
-}
-
-func (m *Query) GetOffset() int32 {
- if m != nil && m.Offset != nil {
- return *m.Offset
- }
- return Default_Query_Offset
-}
-
-func (m *Query) GetLimit() int32 {
- if m != nil && m.Limit != nil {
- return *m.Limit
- }
- return 0
-}
-
-func (m *Query) GetCompiledCursor() *CompiledCursor {
- if m != nil {
- return m.CompiledCursor
- }
- return nil
-}
-
-func (m *Query) GetEndCompiledCursor() *CompiledCursor {
- if m != nil {
- return m.EndCompiledCursor
- }
- return nil
-}
-
-func (m *Query) GetCompositeIndex() []*CompositeIndex {
- if m != nil {
- return m.CompositeIndex
- }
- return nil
-}
-
-func (m *Query) GetRequirePerfectPlan() bool {
- if m != nil && m.RequirePerfectPlan != nil {
- return *m.RequirePerfectPlan
- }
- return Default_Query_RequirePerfectPlan
-}
-
-func (m *Query) GetKeysOnly() bool {
- if m != nil && m.KeysOnly != nil {
- return *m.KeysOnly
- }
- return Default_Query_KeysOnly
-}
-
-func (m *Query) GetTransaction() *Transaction {
- if m != nil {
- return m.Transaction
- }
- return nil
-}
-
-func (m *Query) GetCompile() bool {
- if m != nil && m.Compile != nil {
- return *m.Compile
- }
- return Default_Query_Compile
-}
-
-func (m *Query) GetFailoverMs() int64 {
- if m != nil && m.FailoverMs != nil {
- return *m.FailoverMs
- }
- return 0
-}
-
-func (m *Query) GetStrong() bool {
- if m != nil && m.Strong != nil {
- return *m.Strong
- }
- return false
-}
-
-func (m *Query) GetPropertyName() []string {
- if m != nil {
- return m.PropertyName
- }
- return nil
-}
-
-func (m *Query) GetGroupByPropertyName() []string {
- if m != nil {
- return m.GroupByPropertyName
- }
- return nil
-}
-
-func (m *Query) GetDistinct() bool {
- if m != nil && m.Distinct != nil {
- return *m.Distinct
- }
- return false
-}
-
-func (m *Query) GetMinSafeTimeSeconds() int64 {
- if m != nil && m.MinSafeTimeSeconds != nil {
- return *m.MinSafeTimeSeconds
- }
- return 0
-}
-
-func (m *Query) GetSafeReplicaName() []string {
- if m != nil {
- return m.SafeReplicaName
- }
- return nil
-}
-
-func (m *Query) GetPersistOffset() bool {
- if m != nil && m.PersistOffset != nil {
- return *m.PersistOffset
- }
- return Default_Query_PersistOffset
-}
-
-type Query_Filter struct {
- Op *Query_Filter_Operator `protobuf:"varint,6,req,name=op,enum=appengine.Query_Filter_Operator" json:"op,omitempty"`
- Property []*Property `protobuf:"bytes,14,rep,name=property" json:"property,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Query_Filter) Reset() { *m = Query_Filter{} }
-func (m *Query_Filter) String() string { return proto.CompactTextString(m) }
-func (*Query_Filter) ProtoMessage() {}
-func (*Query_Filter) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 0}
-}
-func (m *Query_Filter) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Query_Filter.Unmarshal(m, b)
-}
-func (m *Query_Filter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Query_Filter.Marshal(b, m, deterministic)
-}
-func (dst *Query_Filter) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Query_Filter.Merge(dst, src)
-}
-func (m *Query_Filter) XXX_Size() int {
- return xxx_messageInfo_Query_Filter.Size(m)
-}
-func (m *Query_Filter) XXX_DiscardUnknown() {
- xxx_messageInfo_Query_Filter.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Query_Filter proto.InternalMessageInfo
-
-func (m *Query_Filter) GetOp() Query_Filter_Operator {
- if m != nil && m.Op != nil {
- return *m.Op
- }
- return Query_Filter_LESS_THAN
-}
-
-func (m *Query_Filter) GetProperty() []*Property {
- if m != nil {
- return m.Property
- }
- return nil
-}
-
-type Query_Order struct {
- Property *string `protobuf:"bytes,10,req,name=property" json:"property,omitempty"`
- Direction *Query_Order_Direction `protobuf:"varint,11,opt,name=direction,enum=appengine.Query_Order_Direction,def=1" json:"direction,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Query_Order) Reset() { *m = Query_Order{} }
-func (m *Query_Order) String() string { return proto.CompactTextString(m) }
-func (*Query_Order) ProtoMessage() {}
-func (*Query_Order) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 1}
-}
-func (m *Query_Order) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Query_Order.Unmarshal(m, b)
-}
-func (m *Query_Order) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Query_Order.Marshal(b, m, deterministic)
-}
-func (dst *Query_Order) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Query_Order.Merge(dst, src)
-}
-func (m *Query_Order) XXX_Size() int {
- return xxx_messageInfo_Query_Order.Size(m)
-}
-func (m *Query_Order) XXX_DiscardUnknown() {
- xxx_messageInfo_Query_Order.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Query_Order proto.InternalMessageInfo
-
-const Default_Query_Order_Direction Query_Order_Direction = Query_Order_ASCENDING
-
-func (m *Query_Order) GetProperty() string {
- if m != nil && m.Property != nil {
- return *m.Property
- }
- return ""
-}
-
-func (m *Query_Order) GetDirection() Query_Order_Direction {
- if m != nil && m.Direction != nil {
- return *m.Direction
- }
- return Default_Query_Order_Direction
-}
-
-type CompiledQuery struct {
- Primaryscan *CompiledQuery_PrimaryScan `protobuf:"group,1,req,name=PrimaryScan,json=primaryscan" json:"primaryscan,omitempty"`
- Mergejoinscan []*CompiledQuery_MergeJoinScan `protobuf:"group,7,rep,name=MergeJoinScan,json=mergejoinscan" json:"mergejoinscan,omitempty"`
- IndexDef *Index `protobuf:"bytes,21,opt,name=index_def,json=indexDef" json:"index_def,omitempty"`
- Offset *int32 `protobuf:"varint,10,opt,name=offset,def=0" json:"offset,omitempty"`
- Limit *int32 `protobuf:"varint,11,opt,name=limit" json:"limit,omitempty"`
- KeysOnly *bool `protobuf:"varint,12,req,name=keys_only,json=keysOnly" json:"keys_only,omitempty"`
- PropertyName []string `protobuf:"bytes,24,rep,name=property_name,json=propertyName" json:"property_name,omitempty"`
- DistinctInfixSize *int32 `protobuf:"varint,25,opt,name=distinct_infix_size,json=distinctInfixSize" json:"distinct_infix_size,omitempty"`
- Entityfilter *CompiledQuery_EntityFilter `protobuf:"group,13,opt,name=EntityFilter,json=entityfilter" json:"entityfilter,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *CompiledQuery) Reset() { *m = CompiledQuery{} }
-func (m *CompiledQuery) String() string { return proto.CompactTextString(m) }
-func (*CompiledQuery) ProtoMessage() {}
-func (*CompiledQuery) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16}
-}
-func (m *CompiledQuery) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_CompiledQuery.Unmarshal(m, b)
-}
-func (m *CompiledQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_CompiledQuery.Marshal(b, m, deterministic)
-}
-func (dst *CompiledQuery) XXX_Merge(src proto.Message) {
- xxx_messageInfo_CompiledQuery.Merge(dst, src)
-}
-func (m *CompiledQuery) XXX_Size() int {
- return xxx_messageInfo_CompiledQuery.Size(m)
-}
-func (m *CompiledQuery) XXX_DiscardUnknown() {
- xxx_messageInfo_CompiledQuery.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CompiledQuery proto.InternalMessageInfo
-
-const Default_CompiledQuery_Offset int32 = 0
-
-func (m *CompiledQuery) GetPrimaryscan() *CompiledQuery_PrimaryScan {
- if m != nil {
- return m.Primaryscan
- }
- return nil
-}
-
-func (m *CompiledQuery) GetMergejoinscan() []*CompiledQuery_MergeJoinScan {
- if m != nil {
- return m.Mergejoinscan
- }
- return nil
-}
-
-func (m *CompiledQuery) GetIndexDef() *Index {
- if m != nil {
- return m.IndexDef
- }
- return nil
-}
-
-func (m *CompiledQuery) GetOffset() int32 {
- if m != nil && m.Offset != nil {
- return *m.Offset
- }
- return Default_CompiledQuery_Offset
-}
-
-func (m *CompiledQuery) GetLimit() int32 {
- if m != nil && m.Limit != nil {
- return *m.Limit
- }
- return 0
-}
-
-func (m *CompiledQuery) GetKeysOnly() bool {
- if m != nil && m.KeysOnly != nil {
- return *m.KeysOnly
- }
- return false
-}
-
-func (m *CompiledQuery) GetPropertyName() []string {
- if m != nil {
- return m.PropertyName
- }
- return nil
-}
-
-func (m *CompiledQuery) GetDistinctInfixSize() int32 {
- if m != nil && m.DistinctInfixSize != nil {
- return *m.DistinctInfixSize
- }
- return 0
-}
-
-func (m *CompiledQuery) GetEntityfilter() *CompiledQuery_EntityFilter {
- if m != nil {
- return m.Entityfilter
- }
- return nil
-}
-
-type CompiledQuery_PrimaryScan struct {
- IndexName *string `protobuf:"bytes,2,opt,name=index_name,json=indexName" json:"index_name,omitempty"`
- StartKey *string `protobuf:"bytes,3,opt,name=start_key,json=startKey" json:"start_key,omitempty"`
- StartInclusive *bool `protobuf:"varint,4,opt,name=start_inclusive,json=startInclusive" json:"start_inclusive,omitempty"`
- EndKey *string `protobuf:"bytes,5,opt,name=end_key,json=endKey" json:"end_key,omitempty"`
- EndInclusive *bool `protobuf:"varint,6,opt,name=end_inclusive,json=endInclusive" json:"end_inclusive,omitempty"`
- StartPostfixValue []string `protobuf:"bytes,22,rep,name=start_postfix_value,json=startPostfixValue" json:"start_postfix_value,omitempty"`
- EndPostfixValue []string `protobuf:"bytes,23,rep,name=end_postfix_value,json=endPostfixValue" json:"end_postfix_value,omitempty"`
- EndUnappliedLogTimestampUs *int64 `protobuf:"varint,19,opt,name=end_unapplied_log_timestamp_us,json=endUnappliedLogTimestampUs" json:"end_unapplied_log_timestamp_us,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *CompiledQuery_PrimaryScan) Reset() { *m = CompiledQuery_PrimaryScan{} }
-func (m *CompiledQuery_PrimaryScan) String() string { return proto.CompactTextString(m) }
-func (*CompiledQuery_PrimaryScan) ProtoMessage() {}
-func (*CompiledQuery_PrimaryScan) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16, 0}
-}
-func (m *CompiledQuery_PrimaryScan) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_CompiledQuery_PrimaryScan.Unmarshal(m, b)
-}
-func (m *CompiledQuery_PrimaryScan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_CompiledQuery_PrimaryScan.Marshal(b, m, deterministic)
-}
-func (dst *CompiledQuery_PrimaryScan) XXX_Merge(src proto.Message) {
- xxx_messageInfo_CompiledQuery_PrimaryScan.Merge(dst, src)
-}
-func (m *CompiledQuery_PrimaryScan) XXX_Size() int {
- return xxx_messageInfo_CompiledQuery_PrimaryScan.Size(m)
-}
-func (m *CompiledQuery_PrimaryScan) XXX_DiscardUnknown() {
- xxx_messageInfo_CompiledQuery_PrimaryScan.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CompiledQuery_PrimaryScan proto.InternalMessageInfo
-
-func (m *CompiledQuery_PrimaryScan) GetIndexName() string {
- if m != nil && m.IndexName != nil {
- return *m.IndexName
- }
- return ""
-}
-
-func (m *CompiledQuery_PrimaryScan) GetStartKey() string {
- if m != nil && m.StartKey != nil {
- return *m.StartKey
- }
- return ""
-}
-
-func (m *CompiledQuery_PrimaryScan) GetStartInclusive() bool {
- if m != nil && m.StartInclusive != nil {
- return *m.StartInclusive
- }
- return false
-}
-
-func (m *CompiledQuery_PrimaryScan) GetEndKey() string {
- if m != nil && m.EndKey != nil {
- return *m.EndKey
- }
- return ""
-}
-
-func (m *CompiledQuery_PrimaryScan) GetEndInclusive() bool {
- if m != nil && m.EndInclusive != nil {
- return *m.EndInclusive
- }
- return false
-}
-
-func (m *CompiledQuery_PrimaryScan) GetStartPostfixValue() []string {
- if m != nil {
- return m.StartPostfixValue
- }
- return nil
-}
-
-func (m *CompiledQuery_PrimaryScan) GetEndPostfixValue() []string {
- if m != nil {
- return m.EndPostfixValue
- }
- return nil
-}
-
-func (m *CompiledQuery_PrimaryScan) GetEndUnappliedLogTimestampUs() int64 {
- if m != nil && m.EndUnappliedLogTimestampUs != nil {
- return *m.EndUnappliedLogTimestampUs
- }
- return 0
-}
-
-type CompiledQuery_MergeJoinScan struct {
- IndexName *string `protobuf:"bytes,8,req,name=index_name,json=indexName" json:"index_name,omitempty"`
- PrefixValue []string `protobuf:"bytes,9,rep,name=prefix_value,json=prefixValue" json:"prefix_value,omitempty"`
- ValuePrefix *bool `protobuf:"varint,20,opt,name=value_prefix,json=valuePrefix,def=0" json:"value_prefix,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *CompiledQuery_MergeJoinScan) Reset() { *m = CompiledQuery_MergeJoinScan{} }
-func (m *CompiledQuery_MergeJoinScan) String() string { return proto.CompactTextString(m) }
-func (*CompiledQuery_MergeJoinScan) ProtoMessage() {}
-func (*CompiledQuery_MergeJoinScan) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16, 1}
-}
-func (m *CompiledQuery_MergeJoinScan) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_CompiledQuery_MergeJoinScan.Unmarshal(m, b)
-}
-func (m *CompiledQuery_MergeJoinScan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_CompiledQuery_MergeJoinScan.Marshal(b, m, deterministic)
-}
-func (dst *CompiledQuery_MergeJoinScan) XXX_Merge(src proto.Message) {
- xxx_messageInfo_CompiledQuery_MergeJoinScan.Merge(dst, src)
-}
-func (m *CompiledQuery_MergeJoinScan) XXX_Size() int {
- return xxx_messageInfo_CompiledQuery_MergeJoinScan.Size(m)
-}
-func (m *CompiledQuery_MergeJoinScan) XXX_DiscardUnknown() {
- xxx_messageInfo_CompiledQuery_MergeJoinScan.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CompiledQuery_MergeJoinScan proto.InternalMessageInfo
-
-const Default_CompiledQuery_MergeJoinScan_ValuePrefix bool = false
-
-func (m *CompiledQuery_MergeJoinScan) GetIndexName() string {
- if m != nil && m.IndexName != nil {
- return *m.IndexName
- }
- return ""
-}
-
-func (m *CompiledQuery_MergeJoinScan) GetPrefixValue() []string {
- if m != nil {
- return m.PrefixValue
- }
- return nil
-}
-
-func (m *CompiledQuery_MergeJoinScan) GetValuePrefix() bool {
- if m != nil && m.ValuePrefix != nil {
- return *m.ValuePrefix
- }
- return Default_CompiledQuery_MergeJoinScan_ValuePrefix
-}
-
-type CompiledQuery_EntityFilter struct {
- Distinct *bool `protobuf:"varint,14,opt,name=distinct,def=0" json:"distinct,omitempty"`
- Kind *string `protobuf:"bytes,17,opt,name=kind" json:"kind,omitempty"`
- Ancestor *Reference `protobuf:"bytes,18,opt,name=ancestor" json:"ancestor,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *CompiledQuery_EntityFilter) Reset() { *m = CompiledQuery_EntityFilter{} }
-func (m *CompiledQuery_EntityFilter) String() string { return proto.CompactTextString(m) }
-func (*CompiledQuery_EntityFilter) ProtoMessage() {}
-func (*CompiledQuery_EntityFilter) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16, 2}
-}
-func (m *CompiledQuery_EntityFilter) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_CompiledQuery_EntityFilter.Unmarshal(m, b)
-}
-func (m *CompiledQuery_EntityFilter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_CompiledQuery_EntityFilter.Marshal(b, m, deterministic)
-}
-func (dst *CompiledQuery_EntityFilter) XXX_Merge(src proto.Message) {
- xxx_messageInfo_CompiledQuery_EntityFilter.Merge(dst, src)
-}
-func (m *CompiledQuery_EntityFilter) XXX_Size() int {
- return xxx_messageInfo_CompiledQuery_EntityFilter.Size(m)
-}
-func (m *CompiledQuery_EntityFilter) XXX_DiscardUnknown() {
- xxx_messageInfo_CompiledQuery_EntityFilter.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CompiledQuery_EntityFilter proto.InternalMessageInfo
-
-const Default_CompiledQuery_EntityFilter_Distinct bool = false
-
-func (m *CompiledQuery_EntityFilter) GetDistinct() bool {
- if m != nil && m.Distinct != nil {
- return *m.Distinct
- }
- return Default_CompiledQuery_EntityFilter_Distinct
-}
-
-func (m *CompiledQuery_EntityFilter) GetKind() string {
- if m != nil && m.Kind != nil {
- return *m.Kind
- }
- return ""
-}
-
-func (m *CompiledQuery_EntityFilter) GetAncestor() *Reference {
- if m != nil {
- return m.Ancestor
- }
- return nil
-}
-
-type CompiledCursor struct {
- Position *CompiledCursor_Position `protobuf:"group,2,opt,name=Position,json=position" json:"position,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *CompiledCursor) Reset() { *m = CompiledCursor{} }
-func (m *CompiledCursor) String() string { return proto.CompactTextString(m) }
-func (*CompiledCursor) ProtoMessage() {}
-func (*CompiledCursor) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{17}
-}
-func (m *CompiledCursor) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_CompiledCursor.Unmarshal(m, b)
-}
-func (m *CompiledCursor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_CompiledCursor.Marshal(b, m, deterministic)
-}
-func (dst *CompiledCursor) XXX_Merge(src proto.Message) {
- xxx_messageInfo_CompiledCursor.Merge(dst, src)
-}
-func (m *CompiledCursor) XXX_Size() int {
- return xxx_messageInfo_CompiledCursor.Size(m)
-}
-func (m *CompiledCursor) XXX_DiscardUnknown() {
- xxx_messageInfo_CompiledCursor.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CompiledCursor proto.InternalMessageInfo
-
-func (m *CompiledCursor) GetPosition() *CompiledCursor_Position {
- if m != nil {
- return m.Position
- }
- return nil
-}
-
-type CompiledCursor_Position struct {
- StartKey *string `protobuf:"bytes,27,opt,name=start_key,json=startKey" json:"start_key,omitempty"`
- Indexvalue []*CompiledCursor_Position_IndexValue `protobuf:"group,29,rep,name=IndexValue,json=indexvalue" json:"indexvalue,omitempty"`
- Key *Reference `protobuf:"bytes,32,opt,name=key" json:"key,omitempty"`
- StartInclusive *bool `protobuf:"varint,28,opt,name=start_inclusive,json=startInclusive,def=1" json:"start_inclusive,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *CompiledCursor_Position) Reset() { *m = CompiledCursor_Position{} }
-func (m *CompiledCursor_Position) String() string { return proto.CompactTextString(m) }
-func (*CompiledCursor_Position) ProtoMessage() {}
-func (*CompiledCursor_Position) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{17, 0}
-}
-func (m *CompiledCursor_Position) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_CompiledCursor_Position.Unmarshal(m, b)
-}
-func (m *CompiledCursor_Position) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_CompiledCursor_Position.Marshal(b, m, deterministic)
-}
-func (dst *CompiledCursor_Position) XXX_Merge(src proto.Message) {
- xxx_messageInfo_CompiledCursor_Position.Merge(dst, src)
-}
-func (m *CompiledCursor_Position) XXX_Size() int {
- return xxx_messageInfo_CompiledCursor_Position.Size(m)
-}
-func (m *CompiledCursor_Position) XXX_DiscardUnknown() {
- xxx_messageInfo_CompiledCursor_Position.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CompiledCursor_Position proto.InternalMessageInfo
-
-const Default_CompiledCursor_Position_StartInclusive bool = true
-
-func (m *CompiledCursor_Position) GetStartKey() string {
- if m != nil && m.StartKey != nil {
- return *m.StartKey
- }
- return ""
-}
-
-func (m *CompiledCursor_Position) GetIndexvalue() []*CompiledCursor_Position_IndexValue {
- if m != nil {
- return m.Indexvalue
- }
- return nil
-}
-
-func (m *CompiledCursor_Position) GetKey() *Reference {
- if m != nil {
- return m.Key
- }
- return nil
-}
-
-func (m *CompiledCursor_Position) GetStartInclusive() bool {
- if m != nil && m.StartInclusive != nil {
- return *m.StartInclusive
- }
- return Default_CompiledCursor_Position_StartInclusive
-}
-
-type CompiledCursor_Position_IndexValue struct {
- Property *string `protobuf:"bytes,30,opt,name=property" json:"property,omitempty"`
- Value *PropertyValue `protobuf:"bytes,31,req,name=value" json:"value,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *CompiledCursor_Position_IndexValue) Reset() { *m = CompiledCursor_Position_IndexValue{} }
-func (m *CompiledCursor_Position_IndexValue) String() string { return proto.CompactTextString(m) }
-func (*CompiledCursor_Position_IndexValue) ProtoMessage() {}
-func (*CompiledCursor_Position_IndexValue) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{17, 0, 0}
-}
-func (m *CompiledCursor_Position_IndexValue) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_CompiledCursor_Position_IndexValue.Unmarshal(m, b)
-}
-func (m *CompiledCursor_Position_IndexValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_CompiledCursor_Position_IndexValue.Marshal(b, m, deterministic)
-}
-func (dst *CompiledCursor_Position_IndexValue) XXX_Merge(src proto.Message) {
- xxx_messageInfo_CompiledCursor_Position_IndexValue.Merge(dst, src)
-}
-func (m *CompiledCursor_Position_IndexValue) XXX_Size() int {
- return xxx_messageInfo_CompiledCursor_Position_IndexValue.Size(m)
-}
-func (m *CompiledCursor_Position_IndexValue) XXX_DiscardUnknown() {
- xxx_messageInfo_CompiledCursor_Position_IndexValue.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CompiledCursor_Position_IndexValue proto.InternalMessageInfo
-
-func (m *CompiledCursor_Position_IndexValue) GetProperty() string {
- if m != nil && m.Property != nil {
- return *m.Property
- }
- return ""
-}
-
-func (m *CompiledCursor_Position_IndexValue) GetValue() *PropertyValue {
- if m != nil {
- return m.Value
- }
- return nil
-}
-
-type Cursor struct {
- Cursor *uint64 `protobuf:"fixed64,1,req,name=cursor" json:"cursor,omitempty"`
- App *string `protobuf:"bytes,2,opt,name=app" json:"app,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Cursor) Reset() { *m = Cursor{} }
-func (m *Cursor) String() string { return proto.CompactTextString(m) }
-func (*Cursor) ProtoMessage() {}
-func (*Cursor) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{18}
-}
-func (m *Cursor) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Cursor.Unmarshal(m, b)
-}
-func (m *Cursor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Cursor.Marshal(b, m, deterministic)
-}
-func (dst *Cursor) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Cursor.Merge(dst, src)
-}
-func (m *Cursor) XXX_Size() int {
- return xxx_messageInfo_Cursor.Size(m)
-}
-func (m *Cursor) XXX_DiscardUnknown() {
- xxx_messageInfo_Cursor.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Cursor proto.InternalMessageInfo
-
-func (m *Cursor) GetCursor() uint64 {
- if m != nil && m.Cursor != nil {
- return *m.Cursor
- }
- return 0
-}
-
-func (m *Cursor) GetApp() string {
- if m != nil && m.App != nil {
- return *m.App
- }
- return ""
-}
-
-type Error struct {
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Error) Reset() { *m = Error{} }
-func (m *Error) String() string { return proto.CompactTextString(m) }
-func (*Error) ProtoMessage() {}
-func (*Error) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{19}
-}
-func (m *Error) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Error.Unmarshal(m, b)
-}
-func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Error.Marshal(b, m, deterministic)
-}
-func (dst *Error) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Error.Merge(dst, src)
-}
-func (m *Error) XXX_Size() int {
- return xxx_messageInfo_Error.Size(m)
-}
-func (m *Error) XXX_DiscardUnknown() {
- xxx_messageInfo_Error.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Error proto.InternalMessageInfo
-
-type Cost struct {
- IndexWrites *int32 `protobuf:"varint,1,opt,name=index_writes,json=indexWrites" json:"index_writes,omitempty"`
- IndexWriteBytes *int32 `protobuf:"varint,2,opt,name=index_write_bytes,json=indexWriteBytes" json:"index_write_bytes,omitempty"`
- EntityWrites *int32 `protobuf:"varint,3,opt,name=entity_writes,json=entityWrites" json:"entity_writes,omitempty"`
- EntityWriteBytes *int32 `protobuf:"varint,4,opt,name=entity_write_bytes,json=entityWriteBytes" json:"entity_write_bytes,omitempty"`
- Commitcost *Cost_CommitCost `protobuf:"group,5,opt,name=CommitCost,json=commitcost" json:"commitcost,omitempty"`
- ApproximateStorageDelta *int32 `protobuf:"varint,8,opt,name=approximate_storage_delta,json=approximateStorageDelta" json:"approximate_storage_delta,omitempty"`
- IdSequenceUpdates *int32 `protobuf:"varint,9,opt,name=id_sequence_updates,json=idSequenceUpdates" json:"id_sequence_updates,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Cost) Reset() { *m = Cost{} }
-func (m *Cost) String() string { return proto.CompactTextString(m) }
-func (*Cost) ProtoMessage() {}
-func (*Cost) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{20}
-}
-func (m *Cost) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Cost.Unmarshal(m, b)
-}
-func (m *Cost) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Cost.Marshal(b, m, deterministic)
-}
-func (dst *Cost) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Cost.Merge(dst, src)
-}
-func (m *Cost) XXX_Size() int {
- return xxx_messageInfo_Cost.Size(m)
-}
-func (m *Cost) XXX_DiscardUnknown() {
- xxx_messageInfo_Cost.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Cost proto.InternalMessageInfo
-
-func (m *Cost) GetIndexWrites() int32 {
- if m != nil && m.IndexWrites != nil {
- return *m.IndexWrites
- }
- return 0
-}
-
-func (m *Cost) GetIndexWriteBytes() int32 {
- if m != nil && m.IndexWriteBytes != nil {
- return *m.IndexWriteBytes
- }
- return 0
-}
-
-func (m *Cost) GetEntityWrites() int32 {
- if m != nil && m.EntityWrites != nil {
- return *m.EntityWrites
- }
- return 0
-}
-
-func (m *Cost) GetEntityWriteBytes() int32 {
- if m != nil && m.EntityWriteBytes != nil {
- return *m.EntityWriteBytes
- }
- return 0
-}
-
-func (m *Cost) GetCommitcost() *Cost_CommitCost {
- if m != nil {
- return m.Commitcost
- }
- return nil
-}
-
-func (m *Cost) GetApproximateStorageDelta() int32 {
- if m != nil && m.ApproximateStorageDelta != nil {
- return *m.ApproximateStorageDelta
- }
- return 0
-}
-
-func (m *Cost) GetIdSequenceUpdates() int32 {
- if m != nil && m.IdSequenceUpdates != nil {
- return *m.IdSequenceUpdates
- }
- return 0
-}
-
-type Cost_CommitCost struct {
- RequestedEntityPuts *int32 `protobuf:"varint,6,opt,name=requested_entity_puts,json=requestedEntityPuts" json:"requested_entity_puts,omitempty"`
- RequestedEntityDeletes *int32 `protobuf:"varint,7,opt,name=requested_entity_deletes,json=requestedEntityDeletes" json:"requested_entity_deletes,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Cost_CommitCost) Reset() { *m = Cost_CommitCost{} }
-func (m *Cost_CommitCost) String() string { return proto.CompactTextString(m) }
-func (*Cost_CommitCost) ProtoMessage() {}
-func (*Cost_CommitCost) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{20, 0}
-}
-func (m *Cost_CommitCost) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Cost_CommitCost.Unmarshal(m, b)
-}
-func (m *Cost_CommitCost) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Cost_CommitCost.Marshal(b, m, deterministic)
-}
-func (dst *Cost_CommitCost) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Cost_CommitCost.Merge(dst, src)
-}
-func (m *Cost_CommitCost) XXX_Size() int {
- return xxx_messageInfo_Cost_CommitCost.Size(m)
-}
-func (m *Cost_CommitCost) XXX_DiscardUnknown() {
- xxx_messageInfo_Cost_CommitCost.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Cost_CommitCost proto.InternalMessageInfo
-
-func (m *Cost_CommitCost) GetRequestedEntityPuts() int32 {
- if m != nil && m.RequestedEntityPuts != nil {
- return *m.RequestedEntityPuts
- }
- return 0
-}
-
-func (m *Cost_CommitCost) GetRequestedEntityDeletes() int32 {
- if m != nil && m.RequestedEntityDeletes != nil {
- return *m.RequestedEntityDeletes
- }
- return 0
-}
-
-type GetRequest struct {
- Header *InternalHeader `protobuf:"bytes,6,opt,name=header" json:"header,omitempty"`
- Key []*Reference `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
- Transaction *Transaction `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"`
- FailoverMs *int64 `protobuf:"varint,3,opt,name=failover_ms,json=failoverMs" json:"failover_ms,omitempty"`
- Strong *bool `protobuf:"varint,4,opt,name=strong" json:"strong,omitempty"`
- AllowDeferred *bool `protobuf:"varint,5,opt,name=allow_deferred,json=allowDeferred,def=0" json:"allow_deferred,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *GetRequest) Reset() { *m = GetRequest{} }
-func (m *GetRequest) String() string { return proto.CompactTextString(m) }
-func (*GetRequest) ProtoMessage() {}
-func (*GetRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{21}
-}
-func (m *GetRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_GetRequest.Unmarshal(m, b)
-}
-func (m *GetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_GetRequest.Marshal(b, m, deterministic)
-}
-func (dst *GetRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_GetRequest.Merge(dst, src)
-}
-func (m *GetRequest) XXX_Size() int {
- return xxx_messageInfo_GetRequest.Size(m)
-}
-func (m *GetRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_GetRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GetRequest proto.InternalMessageInfo
-
-const Default_GetRequest_AllowDeferred bool = false
-
-func (m *GetRequest) GetHeader() *InternalHeader {
- if m != nil {
- return m.Header
- }
- return nil
-}
-
-func (m *GetRequest) GetKey() []*Reference {
- if m != nil {
- return m.Key
- }
- return nil
-}
-
-func (m *GetRequest) GetTransaction() *Transaction {
- if m != nil {
- return m.Transaction
- }
- return nil
-}
-
-func (m *GetRequest) GetFailoverMs() int64 {
- if m != nil && m.FailoverMs != nil {
- return *m.FailoverMs
- }
- return 0
-}
-
-func (m *GetRequest) GetStrong() bool {
- if m != nil && m.Strong != nil {
- return *m.Strong
- }
- return false
-}
-
-func (m *GetRequest) GetAllowDeferred() bool {
- if m != nil && m.AllowDeferred != nil {
- return *m.AllowDeferred
- }
- return Default_GetRequest_AllowDeferred
-}
-
-type GetResponse struct {
- Entity []*GetResponse_Entity `protobuf:"group,1,rep,name=Entity,json=entity" json:"entity,omitempty"`
- Deferred []*Reference `protobuf:"bytes,5,rep,name=deferred" json:"deferred,omitempty"`
- InOrder *bool `protobuf:"varint,6,opt,name=in_order,json=inOrder,def=1" json:"in_order,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *GetResponse) Reset() { *m = GetResponse{} }
-func (m *GetResponse) String() string { return proto.CompactTextString(m) }
-func (*GetResponse) ProtoMessage() {}
-func (*GetResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{22}
-}
-func (m *GetResponse) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_GetResponse.Unmarshal(m, b)
-}
-func (m *GetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_GetResponse.Marshal(b, m, deterministic)
-}
-func (dst *GetResponse) XXX_Merge(src proto.Message) {
- xxx_messageInfo_GetResponse.Merge(dst, src)
-}
-func (m *GetResponse) XXX_Size() int {
- return xxx_messageInfo_GetResponse.Size(m)
-}
-func (m *GetResponse) XXX_DiscardUnknown() {
- xxx_messageInfo_GetResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GetResponse proto.InternalMessageInfo
-
-const Default_GetResponse_InOrder bool = true
-
-func (m *GetResponse) GetEntity() []*GetResponse_Entity {
- if m != nil {
- return m.Entity
- }
- return nil
-}
-
-func (m *GetResponse) GetDeferred() []*Reference {
- if m != nil {
- return m.Deferred
- }
- return nil
-}
-
-func (m *GetResponse) GetInOrder() bool {
- if m != nil && m.InOrder != nil {
- return *m.InOrder
- }
- return Default_GetResponse_InOrder
-}
-
-type GetResponse_Entity struct {
- Entity *EntityProto `protobuf:"bytes,2,opt,name=entity" json:"entity,omitempty"`
- Key *Reference `protobuf:"bytes,4,opt,name=key" json:"key,omitempty"`
- Version *int64 `protobuf:"varint,3,opt,name=version" json:"version,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *GetResponse_Entity) Reset() { *m = GetResponse_Entity{} }
-func (m *GetResponse_Entity) String() string { return proto.CompactTextString(m) }
-func (*GetResponse_Entity) ProtoMessage() {}
-func (*GetResponse_Entity) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{22, 0}
-}
-func (m *GetResponse_Entity) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_GetResponse_Entity.Unmarshal(m, b)
-}
-func (m *GetResponse_Entity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_GetResponse_Entity.Marshal(b, m, deterministic)
-}
-func (dst *GetResponse_Entity) XXX_Merge(src proto.Message) {
- xxx_messageInfo_GetResponse_Entity.Merge(dst, src)
-}
-func (m *GetResponse_Entity) XXX_Size() int {
- return xxx_messageInfo_GetResponse_Entity.Size(m)
-}
-func (m *GetResponse_Entity) XXX_DiscardUnknown() {
- xxx_messageInfo_GetResponse_Entity.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GetResponse_Entity proto.InternalMessageInfo
-
-func (m *GetResponse_Entity) GetEntity() *EntityProto {
- if m != nil {
- return m.Entity
- }
- return nil
-}
-
-func (m *GetResponse_Entity) GetKey() *Reference {
- if m != nil {
- return m.Key
- }
- return nil
-}
-
-func (m *GetResponse_Entity) GetVersion() int64 {
- if m != nil && m.Version != nil {
- return *m.Version
- }
- return 0
-}
-
-type PutRequest struct {
- Header *InternalHeader `protobuf:"bytes,11,opt,name=header" json:"header,omitempty"`
- Entity []*EntityProto `protobuf:"bytes,1,rep,name=entity" json:"entity,omitempty"`
- Transaction *Transaction `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"`
- CompositeIndex []*CompositeIndex `protobuf:"bytes,3,rep,name=composite_index,json=compositeIndex" json:"composite_index,omitempty"`
- Trusted *bool `protobuf:"varint,4,opt,name=trusted,def=0" json:"trusted,omitempty"`
- Force *bool `protobuf:"varint,7,opt,name=force,def=0" json:"force,omitempty"`
- MarkChanges *bool `protobuf:"varint,8,opt,name=mark_changes,json=markChanges,def=0" json:"mark_changes,omitempty"`
- Snapshot []*Snapshot `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"`
- AutoIdPolicy *PutRequest_AutoIdPolicy `protobuf:"varint,10,opt,name=auto_id_policy,json=autoIdPolicy,enum=appengine.PutRequest_AutoIdPolicy,def=0" json:"auto_id_policy,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PutRequest) Reset() { *m = PutRequest{} }
-func (m *PutRequest) String() string { return proto.CompactTextString(m) }
-func (*PutRequest) ProtoMessage() {}
-func (*PutRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{23}
-}
-func (m *PutRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PutRequest.Unmarshal(m, b)
-}
-func (m *PutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PutRequest.Marshal(b, m, deterministic)
-}
-func (dst *PutRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PutRequest.Merge(dst, src)
-}
-func (m *PutRequest) XXX_Size() int {
- return xxx_messageInfo_PutRequest.Size(m)
-}
-func (m *PutRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_PutRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PutRequest proto.InternalMessageInfo
-
-const Default_PutRequest_Trusted bool = false
-const Default_PutRequest_Force bool = false
-const Default_PutRequest_MarkChanges bool = false
-const Default_PutRequest_AutoIdPolicy PutRequest_AutoIdPolicy = PutRequest_CURRENT
-
-func (m *PutRequest) GetHeader() *InternalHeader {
- if m != nil {
- return m.Header
- }
- return nil
-}
-
-func (m *PutRequest) GetEntity() []*EntityProto {
- if m != nil {
- return m.Entity
- }
- return nil
-}
-
-func (m *PutRequest) GetTransaction() *Transaction {
- if m != nil {
- return m.Transaction
- }
- return nil
-}
-
-func (m *PutRequest) GetCompositeIndex() []*CompositeIndex {
- if m != nil {
- return m.CompositeIndex
- }
- return nil
-}
-
-func (m *PutRequest) GetTrusted() bool {
- if m != nil && m.Trusted != nil {
- return *m.Trusted
- }
- return Default_PutRequest_Trusted
-}
-
-func (m *PutRequest) GetForce() bool {
- if m != nil && m.Force != nil {
- return *m.Force
- }
- return Default_PutRequest_Force
-}
-
-func (m *PutRequest) GetMarkChanges() bool {
- if m != nil && m.MarkChanges != nil {
- return *m.MarkChanges
- }
- return Default_PutRequest_MarkChanges
-}
-
-func (m *PutRequest) GetSnapshot() []*Snapshot {
- if m != nil {
- return m.Snapshot
- }
- return nil
-}
-
-func (m *PutRequest) GetAutoIdPolicy() PutRequest_AutoIdPolicy {
- if m != nil && m.AutoIdPolicy != nil {
- return *m.AutoIdPolicy
- }
- return Default_PutRequest_AutoIdPolicy
-}
-
-type PutResponse struct {
- Key []*Reference `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
- Cost *Cost `protobuf:"bytes,2,opt,name=cost" json:"cost,omitempty"`
- Version []int64 `protobuf:"varint,3,rep,name=version" json:"version,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PutResponse) Reset() { *m = PutResponse{} }
-func (m *PutResponse) String() string { return proto.CompactTextString(m) }
-func (*PutResponse) ProtoMessage() {}
-func (*PutResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{24}
-}
-func (m *PutResponse) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PutResponse.Unmarshal(m, b)
-}
-func (m *PutResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PutResponse.Marshal(b, m, deterministic)
-}
-func (dst *PutResponse) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PutResponse.Merge(dst, src)
-}
-func (m *PutResponse) XXX_Size() int {
- return xxx_messageInfo_PutResponse.Size(m)
-}
-func (m *PutResponse) XXX_DiscardUnknown() {
- xxx_messageInfo_PutResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PutResponse proto.InternalMessageInfo
-
-func (m *PutResponse) GetKey() []*Reference {
- if m != nil {
- return m.Key
- }
- return nil
-}
-
-func (m *PutResponse) GetCost() *Cost {
- if m != nil {
- return m.Cost
- }
- return nil
-}
-
-func (m *PutResponse) GetVersion() []int64 {
- if m != nil {
- return m.Version
- }
- return nil
-}
-
-type TouchRequest struct {
- Header *InternalHeader `protobuf:"bytes,10,opt,name=header" json:"header,omitempty"`
- Key []*Reference `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
- CompositeIndex []*CompositeIndex `protobuf:"bytes,2,rep,name=composite_index,json=compositeIndex" json:"composite_index,omitempty"`
- Force *bool `protobuf:"varint,3,opt,name=force,def=0" json:"force,omitempty"`
- Snapshot []*Snapshot `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *TouchRequest) Reset() { *m = TouchRequest{} }
-func (m *TouchRequest) String() string { return proto.CompactTextString(m) }
-func (*TouchRequest) ProtoMessage() {}
-func (*TouchRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{25}
-}
-func (m *TouchRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_TouchRequest.Unmarshal(m, b)
-}
-func (m *TouchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_TouchRequest.Marshal(b, m, deterministic)
-}
-func (dst *TouchRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_TouchRequest.Merge(dst, src)
-}
-func (m *TouchRequest) XXX_Size() int {
- return xxx_messageInfo_TouchRequest.Size(m)
-}
-func (m *TouchRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_TouchRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_TouchRequest proto.InternalMessageInfo
-
-const Default_TouchRequest_Force bool = false
-
-func (m *TouchRequest) GetHeader() *InternalHeader {
- if m != nil {
- return m.Header
- }
- return nil
-}
-
-func (m *TouchRequest) GetKey() []*Reference {
- if m != nil {
- return m.Key
- }
- return nil
-}
-
-func (m *TouchRequest) GetCompositeIndex() []*CompositeIndex {
- if m != nil {
- return m.CompositeIndex
- }
- return nil
-}
-
-func (m *TouchRequest) GetForce() bool {
- if m != nil && m.Force != nil {
- return *m.Force
- }
- return Default_TouchRequest_Force
-}
-
-func (m *TouchRequest) GetSnapshot() []*Snapshot {
- if m != nil {
- return m.Snapshot
- }
- return nil
-}
-
-type TouchResponse struct {
- Cost *Cost `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *TouchResponse) Reset() { *m = TouchResponse{} }
-func (m *TouchResponse) String() string { return proto.CompactTextString(m) }
-func (*TouchResponse) ProtoMessage() {}
-func (*TouchResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{26}
-}
-func (m *TouchResponse) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_TouchResponse.Unmarshal(m, b)
-}
-func (m *TouchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_TouchResponse.Marshal(b, m, deterministic)
-}
-func (dst *TouchResponse) XXX_Merge(src proto.Message) {
- xxx_messageInfo_TouchResponse.Merge(dst, src)
-}
-func (m *TouchResponse) XXX_Size() int {
- return xxx_messageInfo_TouchResponse.Size(m)
-}
-func (m *TouchResponse) XXX_DiscardUnknown() {
- xxx_messageInfo_TouchResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_TouchResponse proto.InternalMessageInfo
-
-func (m *TouchResponse) GetCost() *Cost {
- if m != nil {
- return m.Cost
- }
- return nil
-}
-
-type DeleteRequest struct {
- Header *InternalHeader `protobuf:"bytes,10,opt,name=header" json:"header,omitempty"`
- Key []*Reference `protobuf:"bytes,6,rep,name=key" json:"key,omitempty"`
- Transaction *Transaction `protobuf:"bytes,5,opt,name=transaction" json:"transaction,omitempty"`
- Trusted *bool `protobuf:"varint,4,opt,name=trusted,def=0" json:"trusted,omitempty"`
- Force *bool `protobuf:"varint,7,opt,name=force,def=0" json:"force,omitempty"`
- MarkChanges *bool `protobuf:"varint,8,opt,name=mark_changes,json=markChanges,def=0" json:"mark_changes,omitempty"`
- Snapshot []*Snapshot `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *DeleteRequest) Reset() { *m = DeleteRequest{} }
-func (m *DeleteRequest) String() string { return proto.CompactTextString(m) }
-func (*DeleteRequest) ProtoMessage() {}
-func (*DeleteRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{27}
-}
-func (m *DeleteRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_DeleteRequest.Unmarshal(m, b)
-}
-func (m *DeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_DeleteRequest.Marshal(b, m, deterministic)
-}
-func (dst *DeleteRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_DeleteRequest.Merge(dst, src)
-}
-func (m *DeleteRequest) XXX_Size() int {
- return xxx_messageInfo_DeleteRequest.Size(m)
-}
-func (m *DeleteRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_DeleteRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_DeleteRequest proto.InternalMessageInfo
-
-const Default_DeleteRequest_Trusted bool = false
-const Default_DeleteRequest_Force bool = false
-const Default_DeleteRequest_MarkChanges bool = false
-
-func (m *DeleteRequest) GetHeader() *InternalHeader {
- if m != nil {
- return m.Header
- }
- return nil
-}
-
-func (m *DeleteRequest) GetKey() []*Reference {
- if m != nil {
- return m.Key
- }
- return nil
-}
-
-func (m *DeleteRequest) GetTransaction() *Transaction {
- if m != nil {
- return m.Transaction
- }
- return nil
-}
-
-func (m *DeleteRequest) GetTrusted() bool {
- if m != nil && m.Trusted != nil {
- return *m.Trusted
- }
- return Default_DeleteRequest_Trusted
-}
-
-func (m *DeleteRequest) GetForce() bool {
- if m != nil && m.Force != nil {
- return *m.Force
- }
- return Default_DeleteRequest_Force
-}
-
-func (m *DeleteRequest) GetMarkChanges() bool {
- if m != nil && m.MarkChanges != nil {
- return *m.MarkChanges
- }
- return Default_DeleteRequest_MarkChanges
-}
-
-func (m *DeleteRequest) GetSnapshot() []*Snapshot {
- if m != nil {
- return m.Snapshot
- }
- return nil
-}
-
-type DeleteResponse struct {
- Cost *Cost `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"`
- Version []int64 `protobuf:"varint,3,rep,name=version" json:"version,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *DeleteResponse) Reset() { *m = DeleteResponse{} }
-func (m *DeleteResponse) String() string { return proto.CompactTextString(m) }
-func (*DeleteResponse) ProtoMessage() {}
-func (*DeleteResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{28}
-}
-func (m *DeleteResponse) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_DeleteResponse.Unmarshal(m, b)
-}
-func (m *DeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_DeleteResponse.Marshal(b, m, deterministic)
-}
-func (dst *DeleteResponse) XXX_Merge(src proto.Message) {
- xxx_messageInfo_DeleteResponse.Merge(dst, src)
-}
-func (m *DeleteResponse) XXX_Size() int {
- return xxx_messageInfo_DeleteResponse.Size(m)
-}
-func (m *DeleteResponse) XXX_DiscardUnknown() {
- xxx_messageInfo_DeleteResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_DeleteResponse proto.InternalMessageInfo
-
-func (m *DeleteResponse) GetCost() *Cost {
- if m != nil {
- return m.Cost
- }
- return nil
-}
-
-func (m *DeleteResponse) GetVersion() []int64 {
- if m != nil {
- return m.Version
- }
- return nil
-}
-
-type NextRequest struct {
- Header *InternalHeader `protobuf:"bytes,5,opt,name=header" json:"header,omitempty"`
- Cursor *Cursor `protobuf:"bytes,1,req,name=cursor" json:"cursor,omitempty"`
- Count *int32 `protobuf:"varint,2,opt,name=count" json:"count,omitempty"`
- Offset *int32 `protobuf:"varint,4,opt,name=offset,def=0" json:"offset,omitempty"`
- Compile *bool `protobuf:"varint,3,opt,name=compile,def=0" json:"compile,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *NextRequest) Reset() { *m = NextRequest{} }
-func (m *NextRequest) String() string { return proto.CompactTextString(m) }
-func (*NextRequest) ProtoMessage() {}
-func (*NextRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{29}
-}
-func (m *NextRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_NextRequest.Unmarshal(m, b)
-}
-func (m *NextRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_NextRequest.Marshal(b, m, deterministic)
-}
-func (dst *NextRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_NextRequest.Merge(dst, src)
-}
-func (m *NextRequest) XXX_Size() int {
- return xxx_messageInfo_NextRequest.Size(m)
-}
-func (m *NextRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_NextRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_NextRequest proto.InternalMessageInfo
-
-const Default_NextRequest_Offset int32 = 0
-const Default_NextRequest_Compile bool = false
-
-func (m *NextRequest) GetHeader() *InternalHeader {
- if m != nil {
- return m.Header
- }
- return nil
-}
-
-func (m *NextRequest) GetCursor() *Cursor {
- if m != nil {
- return m.Cursor
- }
- return nil
-}
-
-func (m *NextRequest) GetCount() int32 {
- if m != nil && m.Count != nil {
- return *m.Count
- }
- return 0
-}
-
-func (m *NextRequest) GetOffset() int32 {
- if m != nil && m.Offset != nil {
- return *m.Offset
- }
- return Default_NextRequest_Offset
-}
-
-func (m *NextRequest) GetCompile() bool {
- if m != nil && m.Compile != nil {
- return *m.Compile
- }
- return Default_NextRequest_Compile
-}
-
-type QueryResult struct {
- Cursor *Cursor `protobuf:"bytes,1,opt,name=cursor" json:"cursor,omitempty"`
- Result []*EntityProto `protobuf:"bytes,2,rep,name=result" json:"result,omitempty"`
- SkippedResults *int32 `protobuf:"varint,7,opt,name=skipped_results,json=skippedResults" json:"skipped_results,omitempty"`
- MoreResults *bool `protobuf:"varint,3,req,name=more_results,json=moreResults" json:"more_results,omitempty"`
- KeysOnly *bool `protobuf:"varint,4,opt,name=keys_only,json=keysOnly" json:"keys_only,omitempty"`
- IndexOnly *bool `protobuf:"varint,9,opt,name=index_only,json=indexOnly" json:"index_only,omitempty"`
- SmallOps *bool `protobuf:"varint,10,opt,name=small_ops,json=smallOps" json:"small_ops,omitempty"`
- CompiledQuery *CompiledQuery `protobuf:"bytes,5,opt,name=compiled_query,json=compiledQuery" json:"compiled_query,omitempty"`
- CompiledCursor *CompiledCursor `protobuf:"bytes,6,opt,name=compiled_cursor,json=compiledCursor" json:"compiled_cursor,omitempty"`
- Index []*CompositeIndex `protobuf:"bytes,8,rep,name=index" json:"index,omitempty"`
- Version []int64 `protobuf:"varint,11,rep,name=version" json:"version,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *QueryResult) Reset() { *m = QueryResult{} }
-func (m *QueryResult) String() string { return proto.CompactTextString(m) }
-func (*QueryResult) ProtoMessage() {}
-func (*QueryResult) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{30}
-}
-func (m *QueryResult) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_QueryResult.Unmarshal(m, b)
-}
-func (m *QueryResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_QueryResult.Marshal(b, m, deterministic)
-}
-func (dst *QueryResult) XXX_Merge(src proto.Message) {
- xxx_messageInfo_QueryResult.Merge(dst, src)
-}
-func (m *QueryResult) XXX_Size() int {
- return xxx_messageInfo_QueryResult.Size(m)
-}
-func (m *QueryResult) XXX_DiscardUnknown() {
- xxx_messageInfo_QueryResult.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryResult proto.InternalMessageInfo
-
-func (m *QueryResult) GetCursor() *Cursor {
- if m != nil {
- return m.Cursor
- }
- return nil
-}
-
-func (m *QueryResult) GetResult() []*EntityProto {
- if m != nil {
- return m.Result
- }
- return nil
-}
-
-func (m *QueryResult) GetSkippedResults() int32 {
- if m != nil && m.SkippedResults != nil {
- return *m.SkippedResults
- }
- return 0
-}
-
-func (m *QueryResult) GetMoreResults() bool {
- if m != nil && m.MoreResults != nil {
- return *m.MoreResults
- }
- return false
-}
-
-func (m *QueryResult) GetKeysOnly() bool {
- if m != nil && m.KeysOnly != nil {
- return *m.KeysOnly
- }
- return false
-}
-
-func (m *QueryResult) GetIndexOnly() bool {
- if m != nil && m.IndexOnly != nil {
- return *m.IndexOnly
- }
- return false
-}
-
-func (m *QueryResult) GetSmallOps() bool {
- if m != nil && m.SmallOps != nil {
- return *m.SmallOps
- }
- return false
-}
-
-func (m *QueryResult) GetCompiledQuery() *CompiledQuery {
- if m != nil {
- return m.CompiledQuery
- }
- return nil
-}
-
-func (m *QueryResult) GetCompiledCursor() *CompiledCursor {
- if m != nil {
- return m.CompiledCursor
- }
- return nil
-}
-
-func (m *QueryResult) GetIndex() []*CompositeIndex {
- if m != nil {
- return m.Index
- }
- return nil
-}
-
-func (m *QueryResult) GetVersion() []int64 {
- if m != nil {
- return m.Version
- }
- return nil
-}
-
-type AllocateIdsRequest struct {
- Header *InternalHeader `protobuf:"bytes,4,opt,name=header" json:"header,omitempty"`
- ModelKey *Reference `protobuf:"bytes,1,opt,name=model_key,json=modelKey" json:"model_key,omitempty"`
- Size *int64 `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
- Max *int64 `protobuf:"varint,3,opt,name=max" json:"max,omitempty"`
- Reserve []*Reference `protobuf:"bytes,5,rep,name=reserve" json:"reserve,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *AllocateIdsRequest) Reset() { *m = AllocateIdsRequest{} }
-func (m *AllocateIdsRequest) String() string { return proto.CompactTextString(m) }
-func (*AllocateIdsRequest) ProtoMessage() {}
-func (*AllocateIdsRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{31}
-}
-func (m *AllocateIdsRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_AllocateIdsRequest.Unmarshal(m, b)
-}
-func (m *AllocateIdsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_AllocateIdsRequest.Marshal(b, m, deterministic)
-}
-func (dst *AllocateIdsRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_AllocateIdsRequest.Merge(dst, src)
-}
-func (m *AllocateIdsRequest) XXX_Size() int {
- return xxx_messageInfo_AllocateIdsRequest.Size(m)
-}
-func (m *AllocateIdsRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_AllocateIdsRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_AllocateIdsRequest proto.InternalMessageInfo
-
-func (m *AllocateIdsRequest) GetHeader() *InternalHeader {
- if m != nil {
- return m.Header
- }
- return nil
-}
-
-func (m *AllocateIdsRequest) GetModelKey() *Reference {
- if m != nil {
- return m.ModelKey
- }
- return nil
-}
-
-func (m *AllocateIdsRequest) GetSize() int64 {
- if m != nil && m.Size != nil {
- return *m.Size
- }
- return 0
-}
-
-func (m *AllocateIdsRequest) GetMax() int64 {
- if m != nil && m.Max != nil {
- return *m.Max
- }
- return 0
-}
-
-func (m *AllocateIdsRequest) GetReserve() []*Reference {
- if m != nil {
- return m.Reserve
- }
- return nil
-}
-
-type AllocateIdsResponse struct {
- Start *int64 `protobuf:"varint,1,req,name=start" json:"start,omitempty"`
- End *int64 `protobuf:"varint,2,req,name=end" json:"end,omitempty"`
- Cost *Cost `protobuf:"bytes,3,opt,name=cost" json:"cost,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *AllocateIdsResponse) Reset() { *m = AllocateIdsResponse{} }
-func (m *AllocateIdsResponse) String() string { return proto.CompactTextString(m) }
-func (*AllocateIdsResponse) ProtoMessage() {}
-func (*AllocateIdsResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{32}
-}
-func (m *AllocateIdsResponse) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_AllocateIdsResponse.Unmarshal(m, b)
-}
-func (m *AllocateIdsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_AllocateIdsResponse.Marshal(b, m, deterministic)
-}
-func (dst *AllocateIdsResponse) XXX_Merge(src proto.Message) {
- xxx_messageInfo_AllocateIdsResponse.Merge(dst, src)
-}
-func (m *AllocateIdsResponse) XXX_Size() int {
- return xxx_messageInfo_AllocateIdsResponse.Size(m)
-}
-func (m *AllocateIdsResponse) XXX_DiscardUnknown() {
- xxx_messageInfo_AllocateIdsResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_AllocateIdsResponse proto.InternalMessageInfo
-
-func (m *AllocateIdsResponse) GetStart() int64 {
- if m != nil && m.Start != nil {
- return *m.Start
- }
- return 0
-}
-
-func (m *AllocateIdsResponse) GetEnd() int64 {
- if m != nil && m.End != nil {
- return *m.End
- }
- return 0
-}
-
-func (m *AllocateIdsResponse) GetCost() *Cost {
- if m != nil {
- return m.Cost
- }
- return nil
-}
-
-type CompositeIndices struct {
- Index []*CompositeIndex `protobuf:"bytes,1,rep,name=index" json:"index,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *CompositeIndices) Reset() { *m = CompositeIndices{} }
-func (m *CompositeIndices) String() string { return proto.CompactTextString(m) }
-func (*CompositeIndices) ProtoMessage() {}
-func (*CompositeIndices) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{33}
-}
-func (m *CompositeIndices) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_CompositeIndices.Unmarshal(m, b)
-}
-func (m *CompositeIndices) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_CompositeIndices.Marshal(b, m, deterministic)
-}
-func (dst *CompositeIndices) XXX_Merge(src proto.Message) {
- xxx_messageInfo_CompositeIndices.Merge(dst, src)
-}
-func (m *CompositeIndices) XXX_Size() int {
- return xxx_messageInfo_CompositeIndices.Size(m)
-}
-func (m *CompositeIndices) XXX_DiscardUnknown() {
- xxx_messageInfo_CompositeIndices.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CompositeIndices proto.InternalMessageInfo
-
-func (m *CompositeIndices) GetIndex() []*CompositeIndex {
- if m != nil {
- return m.Index
- }
- return nil
-}
-
-type AddActionsRequest struct {
- Header *InternalHeader `protobuf:"bytes,3,opt,name=header" json:"header,omitempty"`
- Transaction *Transaction `protobuf:"bytes,1,req,name=transaction" json:"transaction,omitempty"`
- Action []*Action `protobuf:"bytes,2,rep,name=action" json:"action,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *AddActionsRequest) Reset() { *m = AddActionsRequest{} }
-func (m *AddActionsRequest) String() string { return proto.CompactTextString(m) }
-func (*AddActionsRequest) ProtoMessage() {}
-func (*AddActionsRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{34}
-}
-func (m *AddActionsRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_AddActionsRequest.Unmarshal(m, b)
-}
-func (m *AddActionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_AddActionsRequest.Marshal(b, m, deterministic)
-}
-func (dst *AddActionsRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_AddActionsRequest.Merge(dst, src)
-}
-func (m *AddActionsRequest) XXX_Size() int {
- return xxx_messageInfo_AddActionsRequest.Size(m)
-}
-func (m *AddActionsRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_AddActionsRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_AddActionsRequest proto.InternalMessageInfo
-
-func (m *AddActionsRequest) GetHeader() *InternalHeader {
- if m != nil {
- return m.Header
- }
- return nil
-}
-
-func (m *AddActionsRequest) GetTransaction() *Transaction {
- if m != nil {
- return m.Transaction
- }
- return nil
-}
-
-func (m *AddActionsRequest) GetAction() []*Action {
- if m != nil {
- return m.Action
- }
- return nil
-}
-
-type AddActionsResponse struct {
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *AddActionsResponse) Reset() { *m = AddActionsResponse{} }
-func (m *AddActionsResponse) String() string { return proto.CompactTextString(m) }
-func (*AddActionsResponse) ProtoMessage() {}
-func (*AddActionsResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{35}
-}
-func (m *AddActionsResponse) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_AddActionsResponse.Unmarshal(m, b)
-}
-func (m *AddActionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_AddActionsResponse.Marshal(b, m, deterministic)
-}
-func (dst *AddActionsResponse) XXX_Merge(src proto.Message) {
- xxx_messageInfo_AddActionsResponse.Merge(dst, src)
-}
-func (m *AddActionsResponse) XXX_Size() int {
- return xxx_messageInfo_AddActionsResponse.Size(m)
-}
-func (m *AddActionsResponse) XXX_DiscardUnknown() {
- xxx_messageInfo_AddActionsResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_AddActionsResponse proto.InternalMessageInfo
-
-type BeginTransactionRequest struct {
- Header *InternalHeader `protobuf:"bytes,3,opt,name=header" json:"header,omitempty"`
- App *string `protobuf:"bytes,1,req,name=app" json:"app,omitempty"`
- AllowMultipleEg *bool `protobuf:"varint,2,opt,name=allow_multiple_eg,json=allowMultipleEg,def=0" json:"allow_multiple_eg,omitempty"`
- DatabaseId *string `protobuf:"bytes,4,opt,name=database_id,json=databaseId" json:"database_id,omitempty"`
- Mode *BeginTransactionRequest_TransactionMode `protobuf:"varint,5,opt,name=mode,enum=appengine.BeginTransactionRequest_TransactionMode,def=0" json:"mode,omitempty"`
- PreviousTransaction *Transaction `protobuf:"bytes,7,opt,name=previous_transaction,json=previousTransaction" json:"previous_transaction,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *BeginTransactionRequest) Reset() { *m = BeginTransactionRequest{} }
-func (m *BeginTransactionRequest) String() string { return proto.CompactTextString(m) }
-func (*BeginTransactionRequest) ProtoMessage() {}
-func (*BeginTransactionRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{36}
-}
-func (m *BeginTransactionRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_BeginTransactionRequest.Unmarshal(m, b)
-}
-func (m *BeginTransactionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_BeginTransactionRequest.Marshal(b, m, deterministic)
-}
-func (dst *BeginTransactionRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_BeginTransactionRequest.Merge(dst, src)
-}
-func (m *BeginTransactionRequest) XXX_Size() int {
- return xxx_messageInfo_BeginTransactionRequest.Size(m)
-}
-func (m *BeginTransactionRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_BeginTransactionRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_BeginTransactionRequest proto.InternalMessageInfo
-
-const Default_BeginTransactionRequest_AllowMultipleEg bool = false
-const Default_BeginTransactionRequest_Mode BeginTransactionRequest_TransactionMode = BeginTransactionRequest_UNKNOWN
-
-func (m *BeginTransactionRequest) GetHeader() *InternalHeader {
- if m != nil {
- return m.Header
- }
- return nil
-}
-
-func (m *BeginTransactionRequest) GetApp() string {
- if m != nil && m.App != nil {
- return *m.App
- }
- return ""
-}
-
-func (m *BeginTransactionRequest) GetAllowMultipleEg() bool {
- if m != nil && m.AllowMultipleEg != nil {
- return *m.AllowMultipleEg
- }
- return Default_BeginTransactionRequest_AllowMultipleEg
-}
-
-func (m *BeginTransactionRequest) GetDatabaseId() string {
- if m != nil && m.DatabaseId != nil {
- return *m.DatabaseId
- }
- return ""
-}
-
-func (m *BeginTransactionRequest) GetMode() BeginTransactionRequest_TransactionMode {
- if m != nil && m.Mode != nil {
- return *m.Mode
- }
- return Default_BeginTransactionRequest_Mode
-}
-
-func (m *BeginTransactionRequest) GetPreviousTransaction() *Transaction {
- if m != nil {
- return m.PreviousTransaction
- }
- return nil
-}
-
-type CommitResponse struct {
- Cost *Cost `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"`
- Version []*CommitResponse_Version `protobuf:"group,3,rep,name=Version,json=version" json:"version,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *CommitResponse) Reset() { *m = CommitResponse{} }
-func (m *CommitResponse) String() string { return proto.CompactTextString(m) }
-func (*CommitResponse) ProtoMessage() {}
-func (*CommitResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{37}
-}
-func (m *CommitResponse) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_CommitResponse.Unmarshal(m, b)
-}
-func (m *CommitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_CommitResponse.Marshal(b, m, deterministic)
-}
-func (dst *CommitResponse) XXX_Merge(src proto.Message) {
- xxx_messageInfo_CommitResponse.Merge(dst, src)
-}
-func (m *CommitResponse) XXX_Size() int {
- return xxx_messageInfo_CommitResponse.Size(m)
-}
-func (m *CommitResponse) XXX_DiscardUnknown() {
- xxx_messageInfo_CommitResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CommitResponse proto.InternalMessageInfo
-
-func (m *CommitResponse) GetCost() *Cost {
- if m != nil {
- return m.Cost
- }
- return nil
-}
-
-func (m *CommitResponse) GetVersion() []*CommitResponse_Version {
- if m != nil {
- return m.Version
- }
- return nil
-}
-
-type CommitResponse_Version struct {
- RootEntityKey *Reference `protobuf:"bytes,4,req,name=root_entity_key,json=rootEntityKey" json:"root_entity_key,omitempty"`
- Version *int64 `protobuf:"varint,5,req,name=version" json:"version,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *CommitResponse_Version) Reset() { *m = CommitResponse_Version{} }
-func (m *CommitResponse_Version) String() string { return proto.CompactTextString(m) }
-func (*CommitResponse_Version) ProtoMessage() {}
-func (*CommitResponse_Version) Descriptor() ([]byte, []int) {
- return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{37, 0}
-}
-func (m *CommitResponse_Version) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_CommitResponse_Version.Unmarshal(m, b)
-}
-func (m *CommitResponse_Version) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_CommitResponse_Version.Marshal(b, m, deterministic)
-}
-func (dst *CommitResponse_Version) XXX_Merge(src proto.Message) {
- xxx_messageInfo_CommitResponse_Version.Merge(dst, src)
-}
-func (m *CommitResponse_Version) XXX_Size() int {
- return xxx_messageInfo_CommitResponse_Version.Size(m)
-}
-func (m *CommitResponse_Version) XXX_DiscardUnknown() {
- xxx_messageInfo_CommitResponse_Version.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CommitResponse_Version proto.InternalMessageInfo
-
-func (m *CommitResponse_Version) GetRootEntityKey() *Reference {
- if m != nil {
- return m.RootEntityKey
- }
- return nil
-}
-
-func (m *CommitResponse_Version) GetVersion() int64 {
- if m != nil && m.Version != nil {
- return *m.Version
- }
- return 0
-}
-
-func init() {
- proto.RegisterType((*Action)(nil), "appengine.Action")
- proto.RegisterType((*PropertyValue)(nil), "appengine.PropertyValue")
- proto.RegisterType((*PropertyValue_PointValue)(nil), "appengine.PropertyValue.PointValue")
- proto.RegisterType((*PropertyValue_UserValue)(nil), "appengine.PropertyValue.UserValue")
- proto.RegisterType((*PropertyValue_ReferenceValue)(nil), "appengine.PropertyValue.ReferenceValue")
- proto.RegisterType((*PropertyValue_ReferenceValue_PathElement)(nil), "appengine.PropertyValue.ReferenceValue.PathElement")
- proto.RegisterType((*Property)(nil), "appengine.Property")
- proto.RegisterType((*Path)(nil), "appengine.Path")
- proto.RegisterType((*Path_Element)(nil), "appengine.Path.Element")
- proto.RegisterType((*Reference)(nil), "appengine.Reference")
- proto.RegisterType((*User)(nil), "appengine.User")
- proto.RegisterType((*EntityProto)(nil), "appengine.EntityProto")
- proto.RegisterType((*CompositeProperty)(nil), "appengine.CompositeProperty")
- proto.RegisterType((*Index)(nil), "appengine.Index")
- proto.RegisterType((*Index_Property)(nil), "appengine.Index.Property")
- proto.RegisterType((*CompositeIndex)(nil), "appengine.CompositeIndex")
- proto.RegisterType((*IndexPostfix)(nil), "appengine.IndexPostfix")
- proto.RegisterType((*IndexPostfix_IndexValue)(nil), "appengine.IndexPostfix.IndexValue")
- proto.RegisterType((*IndexPosition)(nil), "appengine.IndexPosition")
- proto.RegisterType((*Snapshot)(nil), "appengine.Snapshot")
- proto.RegisterType((*InternalHeader)(nil), "appengine.InternalHeader")
- proto.RegisterType((*Transaction)(nil), "appengine.Transaction")
- proto.RegisterType((*Query)(nil), "appengine.Query")
- proto.RegisterType((*Query_Filter)(nil), "appengine.Query.Filter")
- proto.RegisterType((*Query_Order)(nil), "appengine.Query.Order")
- proto.RegisterType((*CompiledQuery)(nil), "appengine.CompiledQuery")
- proto.RegisterType((*CompiledQuery_PrimaryScan)(nil), "appengine.CompiledQuery.PrimaryScan")
- proto.RegisterType((*CompiledQuery_MergeJoinScan)(nil), "appengine.CompiledQuery.MergeJoinScan")
- proto.RegisterType((*CompiledQuery_EntityFilter)(nil), "appengine.CompiledQuery.EntityFilter")
- proto.RegisterType((*CompiledCursor)(nil), "appengine.CompiledCursor")
- proto.RegisterType((*CompiledCursor_Position)(nil), "appengine.CompiledCursor.Position")
- proto.RegisterType((*CompiledCursor_Position_IndexValue)(nil), "appengine.CompiledCursor.Position.IndexValue")
- proto.RegisterType((*Cursor)(nil), "appengine.Cursor")
- proto.RegisterType((*Error)(nil), "appengine.Error")
- proto.RegisterType((*Cost)(nil), "appengine.Cost")
- proto.RegisterType((*Cost_CommitCost)(nil), "appengine.Cost.CommitCost")
- proto.RegisterType((*GetRequest)(nil), "appengine.GetRequest")
- proto.RegisterType((*GetResponse)(nil), "appengine.GetResponse")
- proto.RegisterType((*GetResponse_Entity)(nil), "appengine.GetResponse.Entity")
- proto.RegisterType((*PutRequest)(nil), "appengine.PutRequest")
- proto.RegisterType((*PutResponse)(nil), "appengine.PutResponse")
- proto.RegisterType((*TouchRequest)(nil), "appengine.TouchRequest")
- proto.RegisterType((*TouchResponse)(nil), "appengine.TouchResponse")
- proto.RegisterType((*DeleteRequest)(nil), "appengine.DeleteRequest")
- proto.RegisterType((*DeleteResponse)(nil), "appengine.DeleteResponse")
- proto.RegisterType((*NextRequest)(nil), "appengine.NextRequest")
- proto.RegisterType((*QueryResult)(nil), "appengine.QueryResult")
- proto.RegisterType((*AllocateIdsRequest)(nil), "appengine.AllocateIdsRequest")
- proto.RegisterType((*AllocateIdsResponse)(nil), "appengine.AllocateIdsResponse")
- proto.RegisterType((*CompositeIndices)(nil), "appengine.CompositeIndices")
- proto.RegisterType((*AddActionsRequest)(nil), "appengine.AddActionsRequest")
- proto.RegisterType((*AddActionsResponse)(nil), "appengine.AddActionsResponse")
- proto.RegisterType((*BeginTransactionRequest)(nil), "appengine.BeginTransactionRequest")
- proto.RegisterType((*CommitResponse)(nil), "appengine.CommitResponse")
- proto.RegisterType((*CommitResponse_Version)(nil), "appengine.CommitResponse.Version")
-}
-
-func init() {
- proto.RegisterFile("google.golang.org/appengine/internal/datastore/datastore_v3.proto", fileDescriptor_datastore_v3_83b17b80c34f6179)
-}
-
-var fileDescriptor_datastore_v3_83b17b80c34f6179 = []byte{
- // 4156 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xcd, 0x73, 0xe3, 0x46,
- 0x76, 0x37, 0xc1, 0xef, 0x47, 0x89, 0x82, 0x5a, 0xf3, 0xc1, 0xa1, 0x3f, 0x46, 0xc6, 0xac, 0x6d,
- 0xd9, 0x6b, 0x73, 0x6c, 0xf9, 0x23, 0x5b, 0x4a, 0x76, 0x1d, 0x4a, 0xc4, 0x68, 0x90, 0xa1, 0x48,
- 0xb9, 0x09, 0xd9, 0x9e, 0x5c, 0x50, 0x18, 0xa2, 0x29, 0x21, 0x43, 0x02, 0x30, 0x00, 0x6a, 0x46,
- 0x93, 0xe4, 0x90, 0x4b, 0x2a, 0x55, 0x5b, 0xa9, 0x1c, 0x92, 0x4a, 0x25, 0xf9, 0x07, 0x72, 0xc8,
- 0x39, 0x95, 0xaa, 0x54, 0xf6, 0x98, 0x5b, 0x0e, 0x7b, 0xc9, 0x31, 0x95, 0x73, 0xf2, 0x27, 0x24,
- 0x39, 0xa4, 0xfa, 0x75, 0x03, 0x02, 0x28, 0x4a, 0x23, 0x6d, 0xf6, 0x90, 0x13, 0xd1, 0xef, 0xfd,
- 0xba, 0xf1, 0xfa, 0xf5, 0xfb, 0x6c, 0x10, 0xba, 0xc7, 0xbe, 0x7f, 0x3c, 0x65, 0x9d, 0x63, 0x7f,
- 0x6a, 0x7b, 0xc7, 0x1d, 0x3f, 0x3c, 0x7e, 0x68, 0x07, 0x01, 0xf3, 0x8e, 0x5d, 0x8f, 0x3d, 0x74,
- 0xbd, 0x98, 0x85, 0x9e, 0x3d, 0x7d, 0xe8, 0xd8, 0xb1, 0x1d, 0xc5, 0x7e, 0xc8, 0xce, 0x9f, 0xac,
- 0xd3, 0xcf, 0x3b, 0x41, 0xe8, 0xc7, 0x3e, 0xa9, 0xa7, 0x13, 0xb4, 0x1a, 0x54, 0xba, 0xe3, 0xd8,
- 0xf5, 0x3d, 0xed, 0x1f, 0x2b, 0xb0, 0x7a, 0x18, 0xfa, 0x01, 0x0b, 0xe3, 0xb3, 0x6f, 0xed, 0xe9,
- 0x9c, 0x91, 0x77, 0x00, 0x5c, 0x2f, 0xfe, 0xea, 0x0b, 0x1c, 0xb5, 0x0a, 0x9b, 0x85, 0xad, 0x22,
- 0xcd, 0x50, 0x88, 0x06, 0x2b, 0xcf, 0x7c, 0x7f, 0xca, 0x6c, 0x4f, 0x20, 0x94, 0xcd, 0xc2, 0x56,
- 0x8d, 0xe6, 0x68, 0x64, 0x13, 0x1a, 0x51, 0x1c, 0xba, 0xde, 0xb1, 0x80, 0x14, 0x37, 0x0b, 0x5b,
- 0x75, 0x9a, 0x25, 0x71, 0x84, 0xe3, 0xcf, 0x9f, 0x4d, 0x99, 0x40, 0x94, 0x36, 0x0b, 0x5b, 0x05,
- 0x9a, 0x25, 0x91, 0x3d, 0x80, 0xc0, 0x77, 0xbd, 0xf8, 0x14, 0x01, 0xe5, 0xcd, 0xc2, 0x16, 0x6c,
- 0x3f, 0xe8, 0xa4, 0x7b, 0xe8, 0xe4, 0xa4, 0xee, 0x1c, 0x72, 0x28, 0x3e, 0xd2, 0xcc, 0x34, 0xf2,
- 0xdb, 0x50, 0x9f, 0x47, 0x2c, 0x14, 0x6b, 0xd4, 0x70, 0x0d, 0xed, 0xd2, 0x35, 0x8e, 0x22, 0x16,
- 0x8a, 0x25, 0xce, 0x27, 0x91, 0x21, 0x34, 0x43, 0x36, 0x61, 0x21, 0xf3, 0xc6, 0x4c, 0x2c, 0xb3,
- 0x82, 0xcb, 0x7c, 0x70, 0xe9, 0x32, 0x34, 0x81, 0x8b, 0xb5, 0x16, 0xa6, 0xb7, 0xb7, 0x00, 0xce,
- 0x85, 0x25, 0x2b, 0x50, 0x78, 0xd9, 0xaa, 0x6c, 0x2a, 0x5b, 0x05, 0x5a, 0x78, 0xc9, 0x47, 0x67,
- 0xad, 0xaa, 0x18, 0x9d, 0xb5, 0xff, 0xa9, 0x00, 0xf5, 0x54, 0x26, 0x72, 0x0b, 0xca, 0x6c, 0x66,
- 0xbb, 0xd3, 0x56, 0x7d, 0x53, 0xd9, 0xaa, 0x53, 0x31, 0x20, 0xf7, 0xa1, 0x61, 0xcf, 0xe3, 0x13,
- 0xcb, 0xf1, 0x67, 0xb6, 0xeb, 0xb5, 0x00, 0x79, 0xc0, 0x49, 0x3d, 0xa4, 0x90, 0x36, 0xd4, 0x3c,
- 0x77, 0xfc, 0xdc, 0xb3, 0x67, 0xac, 0xd5, 0xc0, 0x73, 0x48, 0xc7, 0xe4, 0x13, 0x20, 0x13, 0xe6,
- 0xb0, 0xd0, 0x8e, 0x99, 0x63, 0xb9, 0x0e, 0xf3, 0x62, 0x37, 0x3e, 0x6b, 0xdd, 0x46, 0xd4, 0x7a,
- 0xca, 0x31, 0x24, 0x23, 0x0f, 0x0f, 0x42, 0xff, 0xd4, 0x75, 0x58, 0xd8, 0xba, 0xb3, 0x00, 0x3f,
- 0x94, 0x8c, 0xf6, 0xbf, 0x17, 0xa0, 0x99, 0xd7, 0x05, 0x51, 0xa1, 0x68, 0x07, 0x41, 0x6b, 0x15,
- 0xa5, 0xe4, 0x8f, 0xe4, 0x6d, 0x00, 0x2e, 0x8a, 0x15, 0x05, 0xf6, 0x98, 0xb5, 0x6e, 0xe1, 0x5a,
- 0x75, 0x4e, 0x19, 0x71, 0x02, 0x39, 0x82, 0x46, 0x60, 0xc7, 0x27, 0x6c, 0xca, 0x66, 0xcc, 0x8b,
- 0x5b, 0xcd, 0xcd, 0xe2, 0x16, 0x6c, 0x7f, 0x7e, 0x4d, 0xd5, 0x77, 0x0e, 0xed, 0xf8, 0x44, 0x17,
- 0x53, 0x69, 0x76, 0x9d, 0xb6, 0x0e, 0x8d, 0x0c, 0x8f, 0x10, 0x28, 0xc5, 0x67, 0x01, 0x6b, 0xad,
- 0xa1, 0x5c, 0xf8, 0x4c, 0x9a, 0xa0, 0xb8, 0x4e, 0x4b, 0x45, 0xf3, 0x57, 0x5c, 0x87, 0x63, 0x50,
- 0x87, 0xeb, 0x28, 0x22, 0x3e, 0x6b, 0xff, 0x51, 0x86, 0x5a, 0x22, 0x00, 0xe9, 0x42, 0x75, 0xc6,
- 0x6c, 0xcf, 0xf5, 0x8e, 0xd1, 0x69, 0x9a, 0xdb, 0x6f, 0x2e, 0x11, 0xb3, 0x73, 0x20, 0x20, 0x3b,
- 0x30, 0x18, 0x5a, 0x07, 0x7a, 0x77, 0x60, 0x0c, 0xf6, 0x69, 0x32, 0x8f, 0x1f, 0xa6, 0x7c, 0xb4,
- 0xe6, 0xa1, 0x8b, 0x9e, 0x55, 0xa7, 0x20, 0x49, 0x47, 0xa1, 0x9b, 0x0a, 0x51, 0x14, 0x82, 0xe2,
- 0x21, 0x76, 0xa0, 0x9c, 0xb8, 0x88, 0xb2, 0xd5, 0xd8, 0x6e, 0x5d, 0xa6, 0x1c, 0x2a, 0x60, 0xdc,
- 0x20, 0x66, 0xf3, 0x69, 0xec, 0x06, 0x53, 0xee, 0x76, 0xca, 0x56, 0x8d, 0xa6, 0x63, 0xf2, 0x1e,
- 0x40, 0xc4, 0xec, 0x70, 0x7c, 0x62, 0x3f, 0x9b, 0xb2, 0x56, 0x85, 0x7b, 0xf6, 0x4e, 0x79, 0x62,
- 0x4f, 0x23, 0x46, 0x33, 0x0c, 0x62, 0xc3, 0xdd, 0x49, 0x1c, 0x59, 0xb1, 0xff, 0x9c, 0x79, 0xee,
- 0x2b, 0x9b, 0x07, 0x12, 0xcb, 0x0f, 0xf8, 0x0f, 0xfa, 0x58, 0x73, 0xfb, 0xc3, 0x65, 0x5b, 0x7f,
- 0x14, 0x47, 0x66, 0x66, 0xc6, 0x10, 0x27, 0xd0, 0xdb, 0x93, 0x65, 0x64, 0xd2, 0x86, 0xca, 0xd4,
- 0x1f, 0xdb, 0x53, 0xd6, 0xaa, 0x73, 0x2d, 0xec, 0x28, 0xcc, 0xa3, 0x92, 0xa2, 0xfd, 0xb3, 0x02,
- 0x55, 0xa9, 0x47, 0xd2, 0x84, 0x8c, 0x26, 0xd5, 0x37, 0x48, 0x0d, 0x4a, 0xbb, 0xfd, 0xe1, 0xae,
- 0xda, 0xe4, 0x4f, 0xa6, 0xfe, 0xbd, 0xa9, 0xae, 0x71, 0xcc, 0xee, 0x53, 0x53, 0x1f, 0x99, 0x94,
- 0x63, 0x54, 0xb2, 0x0e, 0xab, 0x5d, 0x73, 0x78, 0x60, 0xed, 0x75, 0x4d, 0x7d, 0x7f, 0x48, 0x9f,
- 0xaa, 0x05, 0xb2, 0x0a, 0x75, 0x24, 0xf5, 0x8d, 0xc1, 0x13, 0x55, 0xe1, 0x33, 0x70, 0x68, 0x1a,
- 0x66, 0x5f, 0x57, 0x8b, 0x44, 0x85, 0x15, 0x31, 0x63, 0x38, 0x30, 0xf5, 0x81, 0xa9, 0x96, 0x52,
- 0xca, 0xe8, 0xe8, 0xe0, 0xa0, 0x4b, 0x9f, 0xaa, 0x65, 0xb2, 0x06, 0x0d, 0xa4, 0x74, 0x8f, 0xcc,
- 0xc7, 0x43, 0xaa, 0x56, 0x48, 0x03, 0xaa, 0xfb, 0x3d, 0xeb, 0xbb, 0xc7, 0xfa, 0x40, 0xad, 0x92,
- 0x15, 0xa8, 0xed, 0xf7, 0x2c, 0xfd, 0xa0, 0x6b, 0xf4, 0xd5, 0x1a, 0x9f, 0xbd, 0xaf, 0x0f, 0xe9,
- 0x68, 0x64, 0x1d, 0x0e, 0x8d, 0x81, 0xa9, 0xd6, 0x49, 0x1d, 0xca, 0xfb, 0x3d, 0xcb, 0x38, 0x50,
- 0x81, 0x10, 0x68, 0xee, 0xf7, 0xac, 0xc3, 0xc7, 0xc3, 0x81, 0x3e, 0x38, 0x3a, 0xd8, 0xd5, 0xa9,
- 0xda, 0x20, 0xb7, 0x40, 0xe5, 0xb4, 0xe1, 0xc8, 0xec, 0xf6, 0xbb, 0xbd, 0x1e, 0xd5, 0x47, 0x23,
- 0x75, 0x85, 0x4b, 0xbd, 0xdf, 0xb3, 0x68, 0xd7, 0xe4, 0xfb, 0x5a, 0xe5, 0x2f, 0xe4, 0x7b, 0x7f,
- 0xa2, 0x3f, 0x55, 0xd7, 0xf9, 0x2b, 0xf4, 0x81, 0x69, 0x98, 0x4f, 0xad, 0x43, 0x3a, 0x34, 0x87,
- 0xea, 0x06, 0x17, 0xd0, 0x18, 0xf4, 0xf4, 0xef, 0xad, 0x6f, 0xbb, 0xfd, 0x23, 0x5d, 0x25, 0xda,
- 0x8f, 0xe1, 0xf6, 0xd2, 0x33, 0xe1, 0xaa, 0x7b, 0x6c, 0x1e, 0xf4, 0xd5, 0x02, 0x7f, 0xe2, 0x9b,
- 0x52, 0x15, 0xed, 0x0f, 0xa0, 0xc4, 0x5d, 0x86, 0x7c, 0x06, 0xd5, 0xc4, 0x1b, 0x0b, 0xe8, 0x8d,
- 0x77, 0xb3, 0x67, 0x6d, 0xc7, 0x27, 0x9d, 0xc4, 0xe3, 0x12, 0x5c, 0xbb, 0x0b, 0xd5, 0x45, 0x4f,
- 0x53, 0x2e, 0x78, 0x5a, 0xf1, 0x82, 0xa7, 0x95, 0x32, 0x9e, 0x66, 0x43, 0x3d, 0xf5, 0xed, 0x9b,
- 0x47, 0x91, 0x07, 0x50, 0xe2, 0xde, 0xdf, 0x6a, 0xa2, 0x87, 0xac, 0x2d, 0x08, 0x4c, 0x91, 0xa9,
- 0xfd, 0x43, 0x01, 0x4a, 0x3c, 0xda, 0x9e, 0x07, 0xda, 0xc2, 0x15, 0x81, 0x56, 0xb9, 0x32, 0xd0,
- 0x16, 0xaf, 0x15, 0x68, 0x2b, 0x37, 0x0b, 0xb4, 0xd5, 0x4b, 0x02, 0xad, 0xf6, 0x67, 0x45, 0x68,
- 0xe8, 0x38, 0xf3, 0x10, 0x13, 0xfd, 0xfb, 0x50, 0x7c, 0xce, 0xce, 0x50, 0x3f, 0x8d, 0xed, 0x5b,
- 0x99, 0xdd, 0xa6, 0x2a, 0xa4, 0x1c, 0x40, 0xb6, 0x61, 0x45, 0xbc, 0xd0, 0x3a, 0x0e, 0xfd, 0x79,
- 0xd0, 0x52, 0x97, 0xab, 0xa7, 0x21, 0x40, 0xfb, 0x1c, 0x43, 0xde, 0x83, 0xb2, 0xff, 0xc2, 0x63,
- 0x21, 0xc6, 0xc1, 0x3c, 0x98, 0x2b, 0x8f, 0x0a, 0x2e, 0x79, 0x08, 0xa5, 0xe7, 0xae, 0xe7, 0xe0,
- 0x19, 0xe6, 0x23, 0x61, 0x46, 0xd0, 0xce, 0x13, 0xd7, 0x73, 0x28, 0x02, 0xc9, 0x3d, 0xa8, 0xf1,
- 0x5f, 0x8c, 0x7b, 0x65, 0xdc, 0x68, 0x95, 0x8f, 0x79, 0xd0, 0x7b, 0x08, 0xb5, 0x40, 0xc6, 0x10,
- 0x4c, 0x00, 0x8d, 0xed, 0x8d, 0x25, 0xe1, 0x85, 0xa6, 0x20, 0xf2, 0x15, 0xac, 0x84, 0xf6, 0x0b,
- 0x2b, 0x9d, 0xb4, 0x76, 0xf9, 0xa4, 0x46, 0x68, 0xbf, 0x48, 0x23, 0x38, 0x81, 0x52, 0x68, 0x7b,
- 0xcf, 0x5b, 0x64, 0xb3, 0xb0, 0x55, 0xa6, 0xf8, 0xac, 0x7d, 0x01, 0x25, 0x2e, 0x25, 0x8f, 0x08,
- 0xfb, 0x3d, 0xf4, 0xff, 0xee, 0x9e, 0xa9, 0x16, 0x12, 0x7f, 0xfe, 0x96, 0x47, 0x03, 0x45, 0x72,
- 0x0f, 0xf4, 0xd1, 0xa8, 0xbb, 0xaf, 0xab, 0x45, 0xad, 0x07, 0xeb, 0x7b, 0xfe, 0x2c, 0xf0, 0x23,
- 0x37, 0x66, 0xe9, 0xf2, 0xf7, 0xa0, 0xe6, 0x7a, 0x0e, 0x7b, 0x69, 0xb9, 0x0e, 0x9a, 0x56, 0x91,
- 0x56, 0x71, 0x6c, 0x38, 0xdc, 0xe4, 0x4e, 0x65, 0x31, 0x55, 0xe4, 0x26, 0x87, 0x03, 0xed, 0x2f,
- 0x15, 0x28, 0x1b, 0x1c, 0xc1, 0x8d, 0x4f, 0x9e, 0x14, 0x7a, 0x8f, 0x30, 0x4c, 0x10, 0x24, 0x93,
- 0xfb, 0x50, 0x1b, 0x6a, 0xb6, 0x37, 0x66, 0xbc, 0xe2, 0xc3, 0x3c, 0x50, 0xa3, 0xe9, 0x98, 0x7c,
- 0x99, 0xd1, 0x9f, 0x82, 0x2e, 0x7b, 0x2f, 0xa3, 0x0a, 0x7c, 0xc1, 0x12, 0x2d, 0xb6, 0xff, 0xaa,
- 0x90, 0x49, 0x6e, 0xcb, 0x12, 0x4f, 0x1f, 0xea, 0x8e, 0x1b, 0x32, 0xac, 0x23, 0xe5, 0x41, 0x3f,
- 0xb8, 0x74, 0xe1, 0x4e, 0x2f, 0x81, 0xee, 0xd4, 0xbb, 0xa3, 0x3d, 0x7d, 0xd0, 0xe3, 0x99, 0xef,
- 0x7c, 0x01, 0xed, 0x23, 0xa8, 0xa7, 0x10, 0x0c, 0xc7, 0x09, 0x48, 0x2d, 0x70, 0xf5, 0xf6, 0xf4,
- 0x74, 0xac, 0x68, 0x7f, 0xad, 0x40, 0x33, 0xd5, 0xaf, 0xd0, 0xd0, 0x6d, 0xa8, 0xd8, 0x41, 0x90,
- 0xa8, 0xb6, 0x4e, 0xcb, 0x76, 0x10, 0x18, 0x8e, 0x8c, 0x2d, 0x0a, 0x6a, 0x9b, 0xc7, 0x96, 0x4f,
- 0x01, 0x1c, 0x36, 0x71, 0x3d, 0x17, 0x85, 0x2e, 0xa2, 0xc1, 0xab, 0x8b, 0x42, 0xd3, 0x0c, 0x86,
- 0x7c, 0x09, 0xe5, 0x28, 0xb6, 0x63, 0x91, 0x2b, 0x9b, 0xdb, 0xf7, 0x33, 0xe0, 0xbc, 0x08, 0x9d,
- 0x11, 0x87, 0x51, 0x81, 0x26, 0x5f, 0xc1, 0x2d, 0xdf, 0x9b, 0x9e, 0x59, 0xf3, 0x88, 0x59, 0xee,
- 0xc4, 0x0a, 0xd9, 0x0f, 0x73, 0x37, 0x64, 0x4e, 0x3e, 0xa7, 0xae, 0x73, 0xc8, 0x51, 0xc4, 0x8c,
- 0x09, 0x95, 0x7c, 0xed, 0x6b, 0x28, 0xe3, 0x3a, 0x7c, 0xcf, 0xdf, 0x51, 0xc3, 0xd4, 0xad, 0xe1,
- 0xa0, 0xff, 0x54, 0xe8, 0x80, 0xea, 0xdd, 0x9e, 0x85, 0x44, 0x55, 0xe1, 0xc1, 0xbe, 0xa7, 0xf7,
- 0x75, 0x53, 0xef, 0xa9, 0x45, 0x9e, 0x3d, 0x74, 0x4a, 0x87, 0x54, 0x2d, 0x69, 0xff, 0x53, 0x80,
- 0x15, 0x94, 0xe7, 0xd0, 0x8f, 0xe2, 0x89, 0xfb, 0x92, 0xec, 0x41, 0x43, 0x98, 0xdd, 0xa9, 0x2c,
- 0xe8, 0xb9, 0x33, 0x68, 0x8b, 0x7b, 0x96, 0x68, 0x31, 0x90, 0x75, 0xb4, 0x9b, 0x3e, 0x27, 0x21,
- 0x45, 0x41, 0xa7, 0xbf, 0x22, 0xa4, 0xbc, 0x05, 0x95, 0x67, 0x6c, 0xe2, 0x87, 0x22, 0x04, 0xd6,
- 0x76, 0x4a, 0x71, 0x38, 0x67, 0x54, 0xd2, 0xda, 0x36, 0xc0, 0xf9, 0xfa, 0xe4, 0x01, 0xac, 0x26,
- 0xc6, 0x66, 0xa1, 0x71, 0x89, 0x93, 0x5b, 0x49, 0x88, 0x83, 0x5c, 0x75, 0xa3, 0x5c, 0xab, 0xba,
- 0xd1, 0xbe, 0x86, 0xd5, 0x64, 0x3f, 0xe2, 0xfc, 0x54, 0x21, 0x79, 0x01, 0x63, 0xca, 0x82, 0x8c,
- 0xca, 0x45, 0x19, 0xb5, 0x9f, 0x41, 0x6d, 0xe4, 0xd9, 0x41, 0x74, 0xe2, 0xc7, 0xdc, 0x7a, 0xe2,
- 0x48, 0xfa, 0xaa, 0x12, 0x47, 0x9a, 0x06, 0x15, 0x7e, 0x38, 0xf3, 0x88, 0xbb, 0xbf, 0x31, 0xe8,
- 0xee, 0x99, 0xc6, 0xb7, 0xba, 0xfa, 0x06, 0x01, 0xa8, 0xc8, 0xe7, 0x82, 0xa6, 0x41, 0xd3, 0x90,
- 0xed, 0xd8, 0x63, 0x66, 0x3b, 0x2c, 0xe4, 0x12, 0xfc, 0xe0, 0x47, 0x89, 0x04, 0x3f, 0xf8, 0x91,
- 0xf6, 0x17, 0x05, 0x68, 0x98, 0xa1, 0xed, 0x45, 0xb6, 0x30, 0xf7, 0xcf, 0xa0, 0x72, 0x82, 0x58,
- 0x74, 0xa3, 0xc6, 0x82, 0x7f, 0x66, 0x17, 0xa3, 0x12, 0x48, 0xee, 0x40, 0xe5, 0xc4, 0xf6, 0x9c,
- 0xa9, 0xd0, 0x5a, 0x85, 0xca, 0x51, 0x92, 0x1b, 0x95, 0xf3, 0xdc, 0xb8, 0x05, 0x2b, 0x33, 0x3b,
- 0x7c, 0x6e, 0x8d, 0x4f, 0x6c, 0xef, 0x98, 0x45, 0xf2, 0x60, 0xa4, 0x05, 0x36, 0x38, 0x6b, 0x4f,
- 0x70, 0xb4, 0xbf, 0x5f, 0x81, 0xf2, 0x37, 0x73, 0x16, 0x9e, 0x65, 0x04, 0xfa, 0xe0, 0xba, 0x02,
- 0xc9, 0x17, 0x17, 0x2e, 0x4b, 0xca, 0x6f, 0x2f, 0x26, 0x65, 0x22, 0x53, 0x84, 0xc8, 0x95, 0x22,
- 0x0b, 0x7c, 0x9a, 0x09, 0x63, 0xeb, 0x57, 0xd8, 0xda, 0x79, 0x70, 0x7b, 0x08, 0x95, 0x89, 0x3b,
- 0x8d, 0x51, 0x75, 0x8b, 0xd5, 0x08, 0xee, 0xa5, 0xf3, 0x08, 0xd9, 0x54, 0xc2, 0xc8, 0xbb, 0xb0,
- 0x22, 0x2a, 0x59, 0xeb, 0x07, 0xce, 0xc6, 0x82, 0x95, 0xf7, 0xa6, 0x48, 0x13, 0xbb, 0xff, 0x18,
- 0xca, 0x7e, 0xc8, 0x37, 0x5f, 0xc7, 0x25, 0xef, 0x5c, 0x58, 0x72, 0xc8, 0xb9, 0x54, 0x80, 0xc8,
- 0x87, 0x50, 0x3a, 0x71, 0xbd, 0x18, 0xb3, 0x46, 0x73, 0xfb, 0xf6, 0x05, 0xf0, 0x63, 0xd7, 0x8b,
- 0x29, 0x42, 0x78, 0x98, 0x1f, 0xfb, 0x73, 0x2f, 0x6e, 0xdd, 0xc5, 0x0c, 0x23, 0x06, 0xe4, 0x1e,
- 0x54, 0xfc, 0xc9, 0x24, 0x62, 0x31, 0x76, 0x96, 0xe5, 0x9d, 0xc2, 0xa7, 0x54, 0x12, 0xf8, 0x84,
- 0xa9, 0x3b, 0x73, 0x63, 0xec, 0x43, 0xca, 0x54, 0x0c, 0xc8, 0x2e, 0xac, 0x8d, 0xfd, 0x59, 0xe0,
- 0x4e, 0x99, 0x63, 0x8d, 0xe7, 0x61, 0xe4, 0x87, 0xad, 0x77, 0x2e, 0x1c, 0xd3, 0x9e, 0x44, 0xec,
- 0x21, 0x80, 0x36, 0xc7, 0xb9, 0x31, 0x31, 0x60, 0x83, 0x79, 0x8e, 0xb5, 0xb8, 0xce, 0xfd, 0xd7,
- 0xad, 0xb3, 0xce, 0x3c, 0x27, 0x4f, 0x4a, 0xc4, 0xc1, 0x48, 0x68, 0x61, 0xcc, 0x68, 0x6d, 0x60,
- 0x90, 0xb9, 0x77, 0x69, 0xac, 0x14, 0xe2, 0x64, 0xc2, 0xf7, 0x6f, 0xc0, 0x2d, 0x19, 0x22, 0xad,
- 0x80, 0x85, 0x13, 0x36, 0x8e, 0xad, 0x60, 0x6a, 0x7b, 0x58, 0xca, 0xa5, 0xc6, 0x4a, 0x24, 0xe4,
- 0x50, 0x20, 0x0e, 0xa7, 0xb6, 0x47, 0x34, 0xa8, 0x3f, 0x67, 0x67, 0x91, 0xc5, 0x23, 0x29, 0x76,
- 0xae, 0x29, 0xba, 0xc6, 0xe9, 0x43, 0x6f, 0x7a, 0x46, 0x7e, 0x02, 0x8d, 0xf8, 0xdc, 0xdb, 0xb0,
- 0x61, 0x6d, 0xe4, 0x4e, 0x35, 0xe3, 0x8b, 0x34, 0x0b, 0x25, 0xf7, 0xa1, 0x2a, 0x35, 0xd4, 0xba,
- 0x97, 0x5d, 0x3b, 0xa1, 0xf2, 0xc4, 0x3c, 0xb1, 0xdd, 0xa9, 0x7f, 0xca, 0x42, 0x6b, 0x16, 0xb5,
- 0xda, 0xe2, 0xb6, 0x24, 0x21, 0x1d, 0x44, 0xdc, 0x4f, 0xa3, 0x38, 0xf4, 0xbd, 0xe3, 0xd6, 0x26,
- 0xde, 0x93, 0xc8, 0xd1, 0xc5, 0xe0, 0xf7, 0x2e, 0x66, 0xfe, 0x7c, 0xf0, 0xfb, 0x1c, 0xee, 0x60,
- 0x65, 0x66, 0x3d, 0x3b, 0xb3, 0xf2, 0x68, 0x0d, 0xd1, 0x1b, 0xc8, 0xdd, 0x3d, 0x3b, 0xcc, 0x4e,
- 0x6a, 0x43, 0xcd, 0x71, 0xa3, 0xd8, 0xf5, 0xc6, 0x71, 0xab, 0x85, 0xef, 0x4c, 0xc7, 0xe4, 0x33,
- 0xb8, 0x3d, 0x73, 0x3d, 0x2b, 0xb2, 0x27, 0xcc, 0x8a, 0x5d, 0xee, 0x9b, 0x6c, 0xec, 0x7b, 0x4e,
- 0xd4, 0x7a, 0x80, 0x82, 0x93, 0x99, 0xeb, 0x8d, 0xec, 0x09, 0x33, 0xdd, 0x19, 0x1b, 0x09, 0x0e,
- 0xf9, 0x08, 0xd6, 0x11, 0x1e, 0xb2, 0x60, 0xea, 0x8e, 0x6d, 0xf1, 0xfa, 0x1f, 0xe1, 0xeb, 0xd7,
- 0x38, 0x83, 0x0a, 0x3a, 0xbe, 0xfa, 0x63, 0x68, 0x06, 0x2c, 0x8c, 0xdc, 0x28, 0xb6, 0xa4, 0x45,
- 0xbf, 0x97, 0xd5, 0xda, 0xaa, 0x64, 0x0e, 0x91, 0xd7, 0xfe, 0xcf, 0x02, 0x54, 0x84, 0x73, 0x92,
- 0x4f, 0x41, 0xf1, 0x03, 0xbc, 0x06, 0x69, 0x6e, 0x6f, 0x5e, 0xe2, 0xc1, 0x9d, 0x61, 0xc0, 0xeb,
- 0x5e, 0x3f, 0xa4, 0x8a, 0x1f, 0xdc, 0xb8, 0x28, 0xd4, 0xfe, 0x10, 0x6a, 0xc9, 0x02, 0xbc, 0xbc,
- 0xe8, 0xeb, 0xa3, 0x91, 0x65, 0x3e, 0xee, 0x0e, 0xd4, 0x02, 0xb9, 0x03, 0x24, 0x1d, 0x5a, 0x43,
- 0x6a, 0xe9, 0xdf, 0x1c, 0x75, 0xfb, 0xaa, 0x82, 0x5d, 0x1a, 0xd5, 0xbb, 0xa6, 0x4e, 0x05, 0xb2,
- 0x48, 0xee, 0xc1, 0xed, 0x2c, 0xe5, 0x1c, 0x5c, 0xc2, 0x14, 0x8c, 0x8f, 0x65, 0x52, 0x01, 0xc5,
- 0x18, 0xa8, 0x15, 0x9e, 0x16, 0xf4, 0xef, 0x8d, 0x91, 0x39, 0x52, 0xab, 0xed, 0xbf, 0x29, 0x40,
- 0x19, 0xc3, 0x06, 0x3f, 0x9f, 0x54, 0x72, 0x71, 0x5d, 0x73, 0x5e, 0xb9, 0x1a, 0xd9, 0x92, 0xaa,
- 0x81, 0x01, 0x65, 0x73, 0x79, 0xf4, 0xf9, 0xb5, 0xd6, 0x53, 0x3f, 0x85, 0x12, 0x8f, 0x52, 0xbc,
- 0x43, 0x1c, 0xd2, 0x9e, 0x4e, 0xad, 0x47, 0x06, 0x1d, 0xf1, 0x2a, 0x97, 0x40, 0xb3, 0x3b, 0xd8,
- 0xd3, 0x47, 0xe6, 0x30, 0xa1, 0xa1, 0x56, 0x1e, 0x19, 0x7d, 0x33, 0x45, 0x15, 0xb5, 0x9f, 0xd7,
- 0x60, 0x35, 0x89, 0x09, 0x22, 0x82, 0x3e, 0x82, 0x46, 0x10, 0xba, 0x33, 0x3b, 0x3c, 0x8b, 0xc6,
- 0xb6, 0x87, 0x49, 0x01, 0xb6, 0x7f, 0xb4, 0x24, 0xaa, 0x88, 0x1d, 0x1d, 0x0a, 0xec, 0x68, 0x6c,
- 0x7b, 0x34, 0x3b, 0x91, 0xf4, 0x61, 0x75, 0xc6, 0xc2, 0x63, 0xf6, 0x7b, 0xbe, 0xeb, 0xe1, 0x4a,
- 0x55, 0x8c, 0xc8, 0xef, 0x5f, 0xba, 0xd2, 0x01, 0x47, 0xff, 0x8e, 0xef, 0x7a, 0xb8, 0x56, 0x7e,
- 0x32, 0xf9, 0x04, 0xea, 0xa2, 0x12, 0x72, 0xd8, 0x04, 0x63, 0xc5, 0xb2, 0xda, 0x4f, 0xd4, 0xe8,
- 0x3d, 0x36, 0xc9, 0xc4, 0x65, 0xb8, 0x34, 0x2e, 0x37, 0xb2, 0x71, 0xf9, 0xcd, 0x6c, 0x2c, 0x5a,
- 0x11, 0x55, 0x78, 0x1a, 0x84, 0x2e, 0x38, 0x7c, 0x6b, 0x89, 0xc3, 0x77, 0x60, 0x23, 0xf1, 0x55,
- 0xcb, 0xf5, 0x26, 0xee, 0x4b, 0x2b, 0x72, 0x5f, 0x89, 0xd8, 0x53, 0xa6, 0xeb, 0x09, 0xcb, 0xe0,
- 0x9c, 0x91, 0xfb, 0x8a, 0x11, 0x23, 0xe9, 0xe0, 0x64, 0x0e, 0x5c, 0xc5, 0xab, 0xc9, 0xf7, 0x2e,
- 0x55, 0x8f, 0x68, 0xbe, 0x64, 0x46, 0xcc, 0x4d, 0x6d, 0xff, 0x52, 0x81, 0x46, 0xe6, 0x1c, 0x78,
- 0xf6, 0x16, 0xca, 0x42, 0x61, 0xc5, 0x55, 0x94, 0x50, 0x1f, 0x4a, 0xfa, 0x26, 0xd4, 0xa3, 0xd8,
- 0x0e, 0x63, 0x8b, 0x17, 0x57, 0xb2, 0xdd, 0x45, 0xc2, 0x13, 0x76, 0x46, 0x3e, 0x80, 0x35, 0xc1,
- 0x74, 0xbd, 0xf1, 0x74, 0x1e, 0xb9, 0xa7, 0xa2, 0x99, 0xaf, 0xd1, 0x26, 0x92, 0x8d, 0x84, 0x4a,
- 0xee, 0x42, 0x95, 0x67, 0x21, 0xbe, 0x86, 0x68, 0xfa, 0x2a, 0xcc, 0x73, 0xf8, 0x0a, 0x0f, 0x60,
- 0x95, 0x33, 0xce, 0xe7, 0x57, 0xc4, 0x2d, 0x33, 0xf3, 0x9c, 0xf3, 0xd9, 0x1d, 0xd8, 0x10, 0xaf,
- 0x09, 0x44, 0xf1, 0x2a, 0x2b, 0xdc, 0x3b, 0xa8, 0xd8, 0x75, 0x64, 0xc9, 0xb2, 0x56, 0x14, 0x9c,
- 0x1f, 0x01, 0xcf, 0x5e, 0x0b, 0xe8, 0xbb, 0x22, 0x94, 0x31, 0xcf, 0xc9, 0x61, 0x77, 0xe1, 0x1d,
- 0x8e, 0x9d, 0x7b, 0x76, 0x10, 0x4c, 0x5d, 0xe6, 0x58, 0x53, 0xff, 0x18, 0x43, 0x66, 0x14, 0xdb,
- 0xb3, 0xc0, 0x9a, 0x47, 0xad, 0x0d, 0x0c, 0x99, 0x6d, 0xe6, 0x39, 0x47, 0x09, 0xa8, 0xef, 0x1f,
- 0x9b, 0x09, 0xe4, 0x28, 0x6a, 0xff, 0x3e, 0xac, 0xe6, 0xec, 0x71, 0x41, 0xa7, 0x35, 0x74, 0xfe,
- 0x8c, 0x4e, 0xdf, 0x85, 0x95, 0x20, 0x64, 0xe7, 0xa2, 0xd5, 0x51, 0xb4, 0x86, 0xa0, 0x09, 0xb1,
- 0xb6, 0x60, 0x05, 0x79, 0x96, 0x20, 0xe6, 0xf3, 0x63, 0x03, 0x59, 0x87, 0xc8, 0x69, 0xbf, 0x80,
- 0x95, 0xec, 0x69, 0x93, 0x77, 0x33, 0x69, 0xa1, 0x99, 0xcb, 0x93, 0x69, 0x76, 0x48, 0x2a, 0xb2,
- 0xf5, 0x4b, 0x2a, 0x32, 0x72, 0x9d, 0x8a, 0x4c, 0xfb, 0x2f, 0xd9, 0x9c, 0x65, 0x2a, 0x84, 0x9f,
- 0x41, 0x2d, 0x90, 0xf5, 0x38, 0x5a, 0x52, 0xfe, 0x12, 0x3e, 0x0f, 0xee, 0x24, 0x95, 0x3b, 0x4d,
- 0xe7, 0xb4, 0xff, 0x56, 0x81, 0x5a, 0x5a, 0xd0, 0xe7, 0x2c, 0xef, 0xcd, 0x05, 0xcb, 0x3b, 0x90,
- 0x1a, 0x16, 0x0a, 0x7c, 0x1b, 0xa3, 0xc5, 0x27, 0xaf, 0x7f, 0xd7, 0xc5, 0xb6, 0xe7, 0x34, 0xdb,
- 0xf6, 0x6c, 0xbe, 0xae, 0xed, 0xf9, 0xe4, 0xa2, 0xc1, 0xbf, 0x95, 0xe9, 0x2d, 0x16, 0xcc, 0xbe,
- 0xfd, 0x7d, 0xae, 0x0f, 0xca, 0x26, 0x84, 0x77, 0xc4, 0x7e, 0xd2, 0x84, 0x90, 0xb6, 0x3f, 0xf7,
- 0xaf, 0xd7, 0xfe, 0x6c, 0x43, 0x45, 0xea, 0xfc, 0x0e, 0x54, 0x64, 0x4d, 0x27, 0x1b, 0x04, 0x31,
- 0x3a, 0x6f, 0x10, 0x0a, 0xb2, 0x4e, 0xd7, 0x7e, 0xae, 0x40, 0x59, 0x0f, 0x43, 0x3f, 0xd4, 0xfe,
- 0x48, 0x81, 0x3a, 0x3e, 0xed, 0xf9, 0x0e, 0xe3, 0xd9, 0x60, 0xb7, 0xdb, 0xb3, 0xa8, 0xfe, 0xcd,
- 0x91, 0x8e, 0xd9, 0xa0, 0x0d, 0x77, 0xf6, 0x86, 0x83, 0xbd, 0x23, 0x4a, 0xf5, 0x81, 0x69, 0x99,
- 0xb4, 0x3b, 0x18, 0xf1, 0xb6, 0x67, 0x38, 0x50, 0x15, 0x9e, 0x29, 0x8c, 0x81, 0xa9, 0xd3, 0x41,
- 0xb7, 0x6f, 0x89, 0x56, 0xb4, 0x88, 0x77, 0xb3, 0xba, 0xde, 0xb3, 0xf0, 0xd6, 0x51, 0x2d, 0xf1,
- 0x96, 0xd5, 0x34, 0x0e, 0xf4, 0xe1, 0x91, 0xa9, 0x96, 0xc9, 0x6d, 0x58, 0x3f, 0xd4, 0xe9, 0x81,
- 0x31, 0x1a, 0x19, 0xc3, 0x81, 0xd5, 0xd3, 0x07, 0x86, 0xde, 0x53, 0x2b, 0x7c, 0x9d, 0x5d, 0x63,
- 0xdf, 0xec, 0xee, 0xf6, 0x75, 0xb9, 0x4e, 0x95, 0x6c, 0xc2, 0x5b, 0x7b, 0xc3, 0x83, 0x03, 0xc3,
- 0x34, 0xf5, 0x9e, 0xb5, 0x7b, 0x64, 0x5a, 0x23, 0xd3, 0xe8, 0xf7, 0xad, 0xee, 0xe1, 0x61, 0xff,
- 0x29, 0x4f, 0x60, 0x35, 0x72, 0x17, 0x36, 0xf6, 0xba, 0x87, 0xdd, 0x5d, 0xa3, 0x6f, 0x98, 0x4f,
- 0xad, 0x9e, 0x31, 0xe2, 0xf3, 0x7b, 0x6a, 0x9d, 0x27, 0x6c, 0x93, 0x3e, 0xb5, 0xba, 0x7d, 0x14,
- 0xcd, 0xd4, 0xad, 0xdd, 0xee, 0xde, 0x13, 0x7d, 0xd0, 0x53, 0x81, 0x0b, 0x30, 0xea, 0x3e, 0xd2,
- 0x2d, 0x2e, 0x92, 0x65, 0x0e, 0x87, 0xd6, 0xb0, 0xdf, 0x53, 0x1b, 0xda, 0xbf, 0x14, 0xa1, 0xb4,
- 0xe7, 0x47, 0x31, 0xf7, 0x46, 0xe1, 0xac, 0x2f, 0x42, 0x37, 0x66, 0xa2, 0x7f, 0x2b, 0x53, 0xd1,
- 0x4b, 0x7f, 0x87, 0x24, 0x1e, 0x50, 0x32, 0x10, 0xeb, 0xd9, 0x19, 0xc7, 0x29, 0x88, 0x5b, 0x3b,
- 0xc7, 0xed, 0x72, 0xb2, 0x88, 0x68, 0x78, 0x85, 0x23, 0xd7, 0x2b, 0x22, 0x4e, 0x06, 0x61, 0xb9,
- 0xe0, 0xc7, 0x40, 0xb2, 0x20, 0xb9, 0x62, 0x09, 0x91, 0x6a, 0x06, 0x29, 0x96, 0xdc, 0x01, 0x18,
- 0xfb, 0xb3, 0x99, 0x1b, 0x8f, 0xfd, 0x28, 0x96, 0x5f, 0xc8, 0xda, 0x39, 0x63, 0x8f, 0x62, 0x6e,
- 0xf1, 0x33, 0x37, 0xe6, 0x8f, 0x34, 0x83, 0x26, 0x3b, 0x70, 0xcf, 0x0e, 0x82, 0xd0, 0x7f, 0xe9,
- 0xce, 0xec, 0x98, 0x59, 0xdc, 0x73, 0xed, 0x63, 0x66, 0x39, 0x6c, 0x1a, 0xdb, 0xd8, 0x13, 0x95,
- 0xe9, 0xdd, 0x0c, 0x60, 0x24, 0xf8, 0x3d, 0xce, 0xe6, 0x71, 0xd7, 0x75, 0xac, 0x88, 0xfd, 0x30,
- 0xe7, 0x1e, 0x60, 0xcd, 0x03, 0xc7, 0xe6, 0x62, 0xd6, 0x45, 0x96, 0x72, 0x9d, 0x91, 0xe4, 0x1c,
- 0x09, 0x46, 0xfb, 0x15, 0xc0, 0xb9, 0x14, 0x64, 0x1b, 0x6e, 0xf3, 0x3a, 0x9e, 0x45, 0x31, 0x73,
- 0x2c, 0xb9, 0xdb, 0x60, 0x1e, 0x47, 0x18, 0xe2, 0xcb, 0x74, 0x23, 0x65, 0xca, 0x9b, 0xc2, 0x79,
- 0x1c, 0x91, 0x9f, 0x40, 0xeb, 0xc2, 0x1c, 0x87, 0x4d, 0x19, 0x7f, 0x6d, 0x15, 0xa7, 0xdd, 0x59,
- 0x98, 0xd6, 0x13, 0x5c, 0xed, 0x4f, 0x14, 0x80, 0x7d, 0x16, 0x53, 0xc1, 0xcd, 0x34, 0xb6, 0x95,
- 0xeb, 0x36, 0xb6, 0xef, 0x27, 0x17, 0x08, 0xc5, 0xab, 0x63, 0xc0, 0x42, 0x97, 0xa1, 0xdc, 0xa4,
- 0xcb, 0xc8, 0x35, 0x11, 0xc5, 0x2b, 0x9a, 0x88, 0x52, 0xae, 0x89, 0xf8, 0x18, 0x9a, 0xf6, 0x74,
- 0xea, 0xbf, 0xe0, 0x05, 0x0d, 0x0b, 0x43, 0xe6, 0xa0, 0x11, 0x9c, 0xd7, 0xdb, 0xc8, 0xec, 0x49,
- 0x9e, 0xf6, 0xe7, 0x0a, 0x34, 0x50, 0x15, 0x51, 0xe0, 0x7b, 0x11, 0x23, 0x5f, 0x42, 0x45, 0x5e,
- 0x44, 0x8b, 0x8b, 0xfc, 0xb7, 0x33, 0xb2, 0x66, 0x70, 0xb2, 0x68, 0xa0, 0x12, 0xcc, 0x33, 0x42,
- 0xe6, 0x75, 0x97, 0x2b, 0x25, 0x45, 0x91, 0xfb, 0x50, 0x73, 0x3d, 0x4b, 0xb4, 0xd4, 0x95, 0x4c,
- 0x58, 0xac, 0xba, 0x1e, 0xd6, 0xb2, 0xed, 0x57, 0x50, 0x11, 0x2f, 0x21, 0x9d, 0x54, 0xa6, 0x8b,
- 0xfa, 0xcb, 0xdc, 0x1c, 0xa7, 0xc2, 0xc8, 0xc3, 0x29, 0xbd, 0x2e, 0x40, 0xb7, 0xa0, 0x7a, 0xca,
- 0x9b, 0x0f, 0xbc, 0xf4, 0xe3, 0xea, 0x4d, 0x86, 0xda, 0x1f, 0x97, 0x00, 0x0e, 0xe7, 0x4b, 0x0c,
- 0xa4, 0x71, 0x5d, 0x03, 0xe9, 0xe4, 0xf4, 0xf8, 0x7a, 0x99, 0x7f, 0x75, 0x43, 0x59, 0xd2, 0x69,
- 0x17, 0x6f, 0xda, 0x69, 0xdf, 0x87, 0x6a, 0x1c, 0xce, 0xb9, 0xa3, 0x08, 0x63, 0x4a, 0x5b, 0x5a,
- 0x49, 0x25, 0x6f, 0x42, 0x79, 0xe2, 0x87, 0x63, 0x86, 0x8e, 0x95, 0xb2, 0x05, 0xed, 0xc2, 0x65,
- 0x52, 0xed, 0xb2, 0xcb, 0x24, 0xde, 0xa0, 0x45, 0xf2, 0x1e, 0x0d, 0x0b, 0x99, 0x7c, 0x83, 0x96,
- 0x5c, 0xb1, 0xd1, 0x14, 0x44, 0xbe, 0x81, 0xa6, 0x3d, 0x8f, 0x7d, 0xcb, 0xe5, 0x15, 0xda, 0xd4,
- 0x1d, 0x9f, 0x61, 0xd9, 0xdd, 0xcc, 0x7f, 0xaf, 0x4f, 0x0f, 0xaa, 0xd3, 0x9d, 0xc7, 0xbe, 0xe1,
- 0x1c, 0x22, 0x72, 0xa7, 0x2a, 0x93, 0x12, 0x5d, 0xb1, 0x33, 0x64, 0xed, 0xc7, 0xb0, 0x92, 0x85,
- 0xf1, 0x04, 0x24, 0x81, 0xea, 0x1b, 0x3c, 0x3b, 0x8d, 0x78, 0x6a, 0x1b, 0x98, 0x46, 0xb7, 0xaf,
- 0x16, 0xb4, 0x18, 0x1a, 0xb8, 0xbc, 0xf4, 0x8e, 0xeb, 0xba, 0xfd, 0x03, 0x28, 0x61, 0xf8, 0x55,
- 0x2e, 0x7c, 0x0f, 0xc1, 0x98, 0x8b, 0xcc, 0xbc, 0xf9, 0x15, 0xb3, 0xe6, 0xf7, 0xdf, 0x05, 0x58,
- 0x31, 0xfd, 0xf9, 0xf8, 0xe4, 0xa2, 0x01, 0xc2, 0xaf, 0x3b, 0x42, 0x2d, 0x31, 0x1f, 0xe5, 0xa6,
- 0xe6, 0x93, 0x5a, 0x47, 0x71, 0x89, 0x75, 0xdc, 0xf4, 0xcc, 0xb5, 0x2f, 0x60, 0x55, 0x6e, 0x5e,
- 0x6a, 0x3d, 0xd1, 0x66, 0xe1, 0x0a, 0x6d, 0x6a, 0xbf, 0x50, 0x60, 0x55, 0xc4, 0xf7, 0xff, 0xbb,
- 0xd2, 0x2a, 0x37, 0x0c, 0xeb, 0xe5, 0x1b, 0x5d, 0x1e, 0xfd, 0xbf, 0xf4, 0x34, 0x6d, 0x08, 0xcd,
- 0x44, 0x7d, 0x37, 0x50, 0xfb, 0x15, 0x46, 0xfc, 0x8b, 0x02, 0x34, 0x06, 0xec, 0xe5, 0x92, 0x20,
- 0x5a, 0xbe, 0xee, 0x71, 0x7c, 0x98, 0x2b, 0x57, 0x1b, 0xdb, 0xeb, 0x59, 0x19, 0xc4, 0xd5, 0x63,
- 0x52, 0xc1, 0xa6, 0xb7, 0xa8, 0xca, 0xf2, 0x5b, 0xd4, 0xd2, 0x62, 0xb7, 0x9e, 0xb9, 0xc5, 0x2b,
- 0x2e, 0xbb, 0xc5, 0xd3, 0xfe, 0xad, 0x08, 0x0d, 0x6c, 0x90, 0x29, 0x8b, 0xe6, 0xd3, 0x38, 0x27,
- 0x4c, 0xe1, 0x6a, 0x61, 0x3a, 0x50, 0x09, 0x71, 0x92, 0x74, 0xa5, 0x4b, 0x83, 0xbf, 0x40, 0x61,
- 0x6b, 0xfc, 0xdc, 0x0d, 0x02, 0xe6, 0x58, 0x82, 0x92, 0x14, 0x30, 0x4d, 0x49, 0x16, 0x22, 0x44,
- 0xbc, 0xfc, 0x9c, 0xf9, 0x21, 0x4b, 0x51, 0x45, 0xbc, 0x4f, 0x68, 0x70, 0x5a, 0x02, 0xc9, 0xdd,
- 0x37, 0x88, 0xca, 0xe0, 0xfc, 0xbe, 0x21, 0xed, 0x35, 0x91, 0x5b, 0x47, 0xae, 0xe8, 0x35, 0x91,
- 0xcd, 0xbb, 0xa8, 0x99, 0x3d, 0x9d, 0x5a, 0x7e, 0x10, 0xa1, 0xd3, 0xd4, 0x68, 0x0d, 0x09, 0xc3,
- 0x20, 0x22, 0x5f, 0x43, 0x7a, 0x5d, 0x2c, 0x6f, 0xc9, 0xc5, 0x39, 0xb6, 0x2e, 0xbb, 0x58, 0xa0,
- 0xab, 0xe3, 0xdc, 0xfd, 0xcf, 0x92, 0x1b, 0xea, 0xca, 0x4d, 0x6f, 0xa8, 0x1f, 0x42, 0x59, 0xc4,
- 0xa8, 0xda, 0xeb, 0x62, 0x94, 0xc0, 0x65, 0xed, 0xb3, 0x91, 0xb7, 0xcf, 0x5f, 0x16, 0x80, 0x74,
- 0xa7, 0x53, 0x7f, 0x6c, 0xc7, 0xcc, 0x70, 0xa2, 0x8b, 0x66, 0x7a, 0xed, 0xcf, 0x2e, 0x9f, 0x41,
- 0x7d, 0xe6, 0x3b, 0x6c, 0x6a, 0x25, 0xdf, 0x94, 0x2e, 0xad, 0x7e, 0x10, 0xc6, 0x5b, 0x52, 0x02,
- 0x25, 0xbc, 0xc4, 0x51, 0xb0, 0xee, 0xc0, 0x67, 0xde, 0x84, 0xcd, 0xec, 0x97, 0xb2, 0x14, 0xe1,
- 0x8f, 0xa4, 0x03, 0xd5, 0x90, 0x45, 0x2c, 0x3c, 0x65, 0x57, 0x16, 0x55, 0x09, 0x48, 0x7b, 0x06,
- 0x1b, 0xb9, 0x1d, 0x49, 0x47, 0xbe, 0x85, 0x5f, 0x2b, 0xc3, 0x58, 0x7e, 0xb4, 0x12, 0x03, 0xfe,
- 0x3a, 0xe6, 0x25, 0x9f, 0x41, 0xf9, 0x63, 0xea, 0xf0, 0xc5, 0xab, 0xe2, 0xec, 0x1e, 0xa8, 0x59,
- 0x4d, 0xbb, 0x63, 0x0c, 0x36, 0xf2, 0x54, 0x0a, 0xd7, 0x3b, 0x15, 0xed, 0xef, 0x0a, 0xb0, 0xde,
- 0x75, 0x1c, 0xf1, 0x77, 0xc3, 0x25, 0xaa, 0x2f, 0x5e, 0x57, 0xf5, 0x0b, 0x81, 0x58, 0x84, 0x89,
- 0x6b, 0x05, 0xe2, 0x0f, 0xa1, 0x92, 0xd6, 0x5a, 0xc5, 0x05, 0x77, 0x16, 0x72, 0x51, 0x09, 0xd0,
- 0x6e, 0x01, 0xc9, 0x0a, 0x2b, 0xb4, 0xaa, 0xfd, 0x69, 0x11, 0xee, 0xee, 0xb2, 0x63, 0xd7, 0xcb,
- 0xbe, 0xe2, 0x57, 0xdf, 0xc9, 0xc5, 0x4f, 0x65, 0x9f, 0xc1, 0xba, 0x28, 0xe4, 0x93, 0x7f, 0x62,
- 0x59, 0xec, 0x58, 0x7e, 0x9d, 0x94, 0xb1, 0x6a, 0x0d, 0xf9, 0x07, 0x92, 0xad, 0xe3, 0x7f, 0xc5,
- 0x1c, 0x3b, 0xb6, 0x9f, 0xd9, 0x11, 0xb3, 0x5c, 0x47, 0xfe, 0x59, 0x06, 0x12, 0x92, 0xe1, 0x90,
- 0x21, 0x94, 0xb8, 0x0d, 0xa2, 0xeb, 0x36, 0xb7, 0xb7, 0x33, 0x62, 0x5d, 0xb2, 0x95, 0xac, 0x02,
- 0x0f, 0x7c, 0x87, 0xed, 0x54, 0x8f, 0x06, 0x4f, 0x06, 0xc3, 0xef, 0x06, 0x14, 0x17, 0x22, 0x06,
- 0xdc, 0x0a, 0x42, 0x76, 0xea, 0xfa, 0xf3, 0xc8, 0xca, 0x9e, 0x44, 0xf5, 0xca, 0x94, 0xb8, 0x91,
- 0xcc, 0xc9, 0x10, 0xb5, 0x9f, 0xc2, 0xda, 0xc2, 0xcb, 0x78, 0x6d, 0x26, 0x5f, 0xa7, 0xbe, 0x41,
- 0x56, 0xa1, 0x8e, 0x1f, 0xbb, 0x97, 0x7f, 0xfb, 0xd6, 0xfe, 0xb5, 0x80, 0x57, 0x4c, 0x33, 0x37,
- 0xbe, 0x59, 0x06, 0xfb, 0xcd, 0x7c, 0x06, 0x83, 0xed, 0x77, 0xf3, 0xe6, 0x9b, 0x59, 0xb0, 0xf3,
- 0xad, 0x00, 0xa6, 0x41, 0xa4, 0x6d, 0x43, 0x55, 0xd2, 0xc8, 0x6f, 0xc1, 0x5a, 0xe8, 0xfb, 0x71,
- 0xd2, 0x89, 0x8a, 0x0e, 0xe4, 0xf2, 0x3f, 0xdb, 0xac, 0x72, 0xb0, 0x48, 0x06, 0x4f, 0xf2, 0xbd,
- 0x48, 0x59, 0xfc, 0x0d, 0x44, 0x0e, 0x77, 0x1b, 0xbf, 0x5b, 0x4f, 0xff, 0xb7, 0xfb, 0xbf, 0x01,
- 0x00, 0x00, 0xff, 0xff, 0x35, 0x9f, 0x30, 0x98, 0xf2, 0x2b, 0x00, 0x00,
-}
diff --git a/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.proto b/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.proto
deleted file mode 100644
index 497b4d9a9a..0000000000
--- a/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.proto
+++ /dev/null
@@ -1,551 +0,0 @@
-syntax = "proto2";
-option go_package = "datastore";
-
-package appengine;
-
-message Action{}
-
-message PropertyValue {
- optional int64 int64Value = 1;
- optional bool booleanValue = 2;
- optional string stringValue = 3;
- optional double doubleValue = 4;
-
- optional group PointValue = 5 {
- required double x = 6;
- required double y = 7;
- }
-
- optional group UserValue = 8 {
- required string email = 9;
- required string auth_domain = 10;
- optional string nickname = 11;
- optional string federated_identity = 21;
- optional string federated_provider = 22;
- }
-
- optional group ReferenceValue = 12 {
- required string app = 13;
- optional string name_space = 20;
- repeated group PathElement = 14 {
- required string type = 15;
- optional int64 id = 16;
- optional string name = 17;
- }
- }
-}
-
-message Property {
- enum Meaning {
- NO_MEANING = 0;
- BLOB = 14;
- TEXT = 15;
- BYTESTRING = 16;
-
- ATOM_CATEGORY = 1;
- ATOM_LINK = 2;
- ATOM_TITLE = 3;
- ATOM_CONTENT = 4;
- ATOM_SUMMARY = 5;
- ATOM_AUTHOR = 6;
-
- GD_WHEN = 7;
- GD_EMAIL = 8;
- GEORSS_POINT = 9;
- GD_IM = 10;
-
- GD_PHONENUMBER = 11;
- GD_POSTALADDRESS = 12;
-
- GD_RATING = 13;
-
- BLOBKEY = 17;
- ENTITY_PROTO = 19;
-
- INDEX_VALUE = 18;
- };
-
- optional Meaning meaning = 1 [default = NO_MEANING];
- optional string meaning_uri = 2;
-
- required string name = 3;
-
- required PropertyValue value = 5;
-
- required bool multiple = 4;
-
- optional bool searchable = 6 [default=false];
-
- enum FtsTokenizationOption {
- HTML = 1;
- ATOM = 2;
- }
-
- optional FtsTokenizationOption fts_tokenization_option = 8;
-
- optional string locale = 9 [default = "en"];
-}
-
-message Path {
- repeated group Element = 1 {
- required string type = 2;
- optional int64 id = 3;
- optional string name = 4;
- }
-}
-
-message Reference {
- required string app = 13;
- optional string name_space = 20;
- required Path path = 14;
-}
-
-message User {
- required string email = 1;
- required string auth_domain = 2;
- optional string nickname = 3;
- optional string federated_identity = 6;
- optional string federated_provider = 7;
-}
-
-message EntityProto {
- required Reference key = 13;
- required Path entity_group = 16;
- optional User owner = 17;
-
- enum Kind {
- GD_CONTACT = 1;
- GD_EVENT = 2;
- GD_MESSAGE = 3;
- }
- optional Kind kind = 4;
- optional string kind_uri = 5;
-
- repeated Property property = 14;
- repeated Property raw_property = 15;
-
- optional int32 rank = 18;
-}
-
-message CompositeProperty {
- required int64 index_id = 1;
- repeated string value = 2;
-}
-
-message Index {
- required string entity_type = 1;
- required bool ancestor = 5;
- repeated group Property = 2 {
- required string name = 3;
- enum Direction {
- ASCENDING = 1;
- DESCENDING = 2;
- }
- optional Direction direction = 4 [default = ASCENDING];
- }
-}
-
-message CompositeIndex {
- required string app_id = 1;
- required int64 id = 2;
- required Index definition = 3;
-
- enum State {
- WRITE_ONLY = 1;
- READ_WRITE = 2;
- DELETED = 3;
- ERROR = 4;
- }
- required State state = 4;
-
- optional bool only_use_if_required = 6 [default = false];
-}
-
-message IndexPostfix {
- message IndexValue {
- required string property_name = 1;
- required PropertyValue value = 2;
- }
-
- repeated IndexValue index_value = 1;
-
- optional Reference key = 2;
-
- optional bool before = 3 [default=true];
-}
-
-message IndexPosition {
- optional string key = 1;
-
- optional bool before = 2 [default=true];
-}
-
-message Snapshot {
- enum Status {
- INACTIVE = 0;
- ACTIVE = 1;
- }
-
- required int64 ts = 1;
-}
-
-message InternalHeader {
- optional string qos = 1;
-}
-
-message Transaction {
- optional InternalHeader header = 4;
- required fixed64 handle = 1;
- required string app = 2;
- optional bool mark_changes = 3 [default = false];
-}
-
-message Query {
- optional InternalHeader header = 39;
-
- required string app = 1;
- optional string name_space = 29;
-
- optional string kind = 3;
- optional Reference ancestor = 17;
-
- repeated group Filter = 4 {
- enum Operator {
- LESS_THAN = 1;
- LESS_THAN_OR_EQUAL = 2;
- GREATER_THAN = 3;
- GREATER_THAN_OR_EQUAL = 4;
- EQUAL = 5;
- IN = 6;
- EXISTS = 7;
- }
-
- required Operator op = 6;
- repeated Property property = 14;
- }
-
- optional string search_query = 8;
-
- repeated group Order = 9 {
- enum Direction {
- ASCENDING = 1;
- DESCENDING = 2;
- }
-
- required string property = 10;
- optional Direction direction = 11 [default = ASCENDING];
- }
-
- enum Hint {
- ORDER_FIRST = 1;
- ANCESTOR_FIRST = 2;
- FILTER_FIRST = 3;
- }
- optional Hint hint = 18;
-
- optional int32 count = 23;
-
- optional int32 offset = 12 [default = 0];
-
- optional int32 limit = 16;
-
- optional CompiledCursor compiled_cursor = 30;
- optional CompiledCursor end_compiled_cursor = 31;
-
- repeated CompositeIndex composite_index = 19;
-
- optional bool require_perfect_plan = 20 [default = false];
-
- optional bool keys_only = 21 [default = false];
-
- optional Transaction transaction = 22;
-
- optional bool compile = 25 [default = false];
-
- optional int64 failover_ms = 26;
-
- optional bool strong = 32;
-
- repeated string property_name = 33;
-
- repeated string group_by_property_name = 34;
-
- optional bool distinct = 24;
-
- optional int64 min_safe_time_seconds = 35;
-
- repeated string safe_replica_name = 36;
-
- optional bool persist_offset = 37 [default=false];
-}
-
-message CompiledQuery {
- required group PrimaryScan = 1 {
- optional string index_name = 2;
-
- optional string start_key = 3;
- optional bool start_inclusive = 4;
- optional string end_key = 5;
- optional bool end_inclusive = 6;
-
- repeated string start_postfix_value = 22;
- repeated string end_postfix_value = 23;
-
- optional int64 end_unapplied_log_timestamp_us = 19;
- }
-
- repeated group MergeJoinScan = 7 {
- required string index_name = 8;
-
- repeated string prefix_value = 9;
-
- optional bool value_prefix = 20 [default=false];
- }
-
- optional Index index_def = 21;
-
- optional int32 offset = 10 [default = 0];
-
- optional int32 limit = 11;
-
- required bool keys_only = 12;
-
- repeated string property_name = 24;
-
- optional int32 distinct_infix_size = 25;
-
- optional group EntityFilter = 13 {
- optional bool distinct = 14 [default=false];
-
- optional string kind = 17;
- optional Reference ancestor = 18;
- }
-}
-
-message CompiledCursor {
- optional group Position = 2 {
- optional string start_key = 27;
-
- repeated group IndexValue = 29 {
- optional string property = 30;
- required PropertyValue value = 31;
- }
-
- optional Reference key = 32;
-
- optional bool start_inclusive = 28 [default=true];
- }
-}
-
-message Cursor {
- required fixed64 cursor = 1;
-
- optional string app = 2;
-}
-
-message Error {
- enum ErrorCode {
- BAD_REQUEST = 1;
- CONCURRENT_TRANSACTION = 2;
- INTERNAL_ERROR = 3;
- NEED_INDEX = 4;
- TIMEOUT = 5;
- PERMISSION_DENIED = 6;
- BIGTABLE_ERROR = 7;
- COMMITTED_BUT_STILL_APPLYING = 8;
- CAPABILITY_DISABLED = 9;
- TRY_ALTERNATE_BACKEND = 10;
- SAFE_TIME_TOO_OLD = 11;
- }
-}
-
-message Cost {
- optional int32 index_writes = 1;
- optional int32 index_write_bytes = 2;
- optional int32 entity_writes = 3;
- optional int32 entity_write_bytes = 4;
- optional group CommitCost = 5 {
- optional int32 requested_entity_puts = 6;
- optional int32 requested_entity_deletes = 7;
- };
- optional int32 approximate_storage_delta = 8;
- optional int32 id_sequence_updates = 9;
-}
-
-message GetRequest {
- optional InternalHeader header = 6;
-
- repeated Reference key = 1;
- optional Transaction transaction = 2;
-
- optional int64 failover_ms = 3;
-
- optional bool strong = 4;
-
- optional bool allow_deferred = 5 [default=false];
-}
-
-message GetResponse {
- repeated group Entity = 1 {
- optional EntityProto entity = 2;
- optional Reference key = 4;
-
- optional int64 version = 3;
- }
-
- repeated Reference deferred = 5;
-
- optional bool in_order = 6 [default=true];
-}
-
-message PutRequest {
- optional InternalHeader header = 11;
-
- repeated EntityProto entity = 1;
- optional Transaction transaction = 2;
- repeated CompositeIndex composite_index = 3;
-
- optional bool trusted = 4 [default = false];
-
- optional bool force = 7 [default = false];
-
- optional bool mark_changes = 8 [default = false];
- repeated Snapshot snapshot = 9;
-
- enum AutoIdPolicy {
- CURRENT = 0;
- SEQUENTIAL = 1;
- }
- optional AutoIdPolicy auto_id_policy = 10 [default = CURRENT];
-}
-
-message PutResponse {
- repeated Reference key = 1;
- optional Cost cost = 2;
- repeated int64 version = 3;
-}
-
-message TouchRequest {
- optional InternalHeader header = 10;
-
- repeated Reference key = 1;
- repeated CompositeIndex composite_index = 2;
- optional bool force = 3 [default = false];
- repeated Snapshot snapshot = 9;
-}
-
-message TouchResponse {
- optional Cost cost = 1;
-}
-
-message DeleteRequest {
- optional InternalHeader header = 10;
-
- repeated Reference key = 6;
- optional Transaction transaction = 5;
-
- optional bool trusted = 4 [default = false];
-
- optional bool force = 7 [default = false];
-
- optional bool mark_changes = 8 [default = false];
- repeated Snapshot snapshot = 9;
-}
-
-message DeleteResponse {
- optional Cost cost = 1;
- repeated int64 version = 3;
-}
-
-message NextRequest {
- optional InternalHeader header = 5;
-
- required Cursor cursor = 1;
- optional int32 count = 2;
-
- optional int32 offset = 4 [default = 0];
-
- optional bool compile = 3 [default = false];
-}
-
-message QueryResult {
- optional Cursor cursor = 1;
-
- repeated EntityProto result = 2;
-
- optional int32 skipped_results = 7;
-
- required bool more_results = 3;
-
- optional bool keys_only = 4;
-
- optional bool index_only = 9;
-
- optional bool small_ops = 10;
-
- optional CompiledQuery compiled_query = 5;
-
- optional CompiledCursor compiled_cursor = 6;
-
- repeated CompositeIndex index = 8;
-
- repeated int64 version = 11;
-}
-
-message AllocateIdsRequest {
- optional InternalHeader header = 4;
-
- optional Reference model_key = 1;
-
- optional int64 size = 2;
-
- optional int64 max = 3;
-
- repeated Reference reserve = 5;
-}
-
-message AllocateIdsResponse {
- required int64 start = 1;
- required int64 end = 2;
- optional Cost cost = 3;
-}
-
-message CompositeIndices {
- repeated CompositeIndex index = 1;
-}
-
-message AddActionsRequest {
- optional InternalHeader header = 3;
-
- required Transaction transaction = 1;
- repeated Action action = 2;
-}
-
-message AddActionsResponse {
-}
-
-message BeginTransactionRequest {
- optional InternalHeader header = 3;
-
- required string app = 1;
- optional bool allow_multiple_eg = 2 [default = false];
- optional string database_id = 4;
-
- enum TransactionMode {
- UNKNOWN = 0;
- READ_ONLY = 1;
- READ_WRITE = 2;
- }
- optional TransactionMode mode = 5 [default = UNKNOWN];
-
- optional Transaction previous_transaction = 7;
-}
-
-message CommitResponse {
- optional Cost cost = 1;
-
- repeated group Version = 3 {
- required Reference root_entity_key = 4;
- required int64 version = 5;
- }
-}
diff --git a/vendor/google.golang.org/appengine/internal/identity.go b/vendor/google.golang.org/appengine/internal/identity.go
deleted file mode 100644
index 0f95aa91d5..0000000000
--- a/vendor/google.golang.org/appengine/internal/identity.go
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2011 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package internal
-
-import (
- "context"
- "os"
-)
-
-var (
- // This is set to true in identity_classic.go, which is behind the appengine build tag.
- // The appengine build tag is set for the first generation runtimes (<= Go 1.9) but not
- // the second generation runtimes (>= Go 1.11), so this indicates whether we're on a
- // first-gen runtime. See IsStandard below for the second-gen check.
- appengineStandard bool
-
- // This is set to true in identity_flex.go, which is behind the appenginevm build tag.
- appengineFlex bool
-)
-
-// AppID is the implementation of the wrapper function of the same name in
-// ../identity.go. See that file for commentary.
-func AppID(c context.Context) string {
- return appID(FullyQualifiedAppID(c))
-}
-
-// IsStandard is the implementation of the wrapper function of the same name in
-// ../appengine.go. See that file for commentary.
-func IsStandard() bool {
- // appengineStandard will be true for first-gen runtimes (<= Go 1.9) but not
- // second-gen (>= Go 1.11).
- return appengineStandard || IsSecondGen()
-}
-
-// IsSecondGen is the implementation of the wrapper function of the same name in
-// ../appengine.go. See that file for commentary.
-func IsSecondGen() bool {
- // Second-gen runtimes set $GAE_ENV so we use that to check if we're on a second-gen runtime.
- return os.Getenv("GAE_ENV") == "standard"
-}
-
-// IsFlex is the implementation of the wrapper function of the same name in
-// ../appengine.go. See that file for commentary.
-func IsFlex() bool {
- return appengineFlex
-}
-
-// IsAppEngine is the implementation of the wrapper function of the same name in
-// ../appengine.go. See that file for commentary.
-func IsAppEngine() bool {
- return IsStandard() || IsFlex()
-}
diff --git a/vendor/google.golang.org/appengine/internal/identity_classic.go b/vendor/google.golang.org/appengine/internal/identity_classic.go
deleted file mode 100644
index 5ad3548bf7..0000000000
--- a/vendor/google.golang.org/appengine/internal/identity_classic.go
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2015 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-//go:build appengine
-// +build appengine
-
-package internal
-
-import (
- "context"
-
- "appengine"
-)
-
-func init() {
- appengineStandard = true
-}
-
-func DefaultVersionHostname(ctx context.Context) string {
- c := fromContext(ctx)
- if c == nil {
- panic(errNotAppEngineContext)
- }
- return appengine.DefaultVersionHostname(c)
-}
-
-func Datacenter(_ context.Context) string { return appengine.Datacenter() }
-func ServerSoftware() string { return appengine.ServerSoftware() }
-func InstanceID() string { return appengine.InstanceID() }
-func IsDevAppServer() bool { return appengine.IsDevAppServer() }
-
-func RequestID(ctx context.Context) string {
- c := fromContext(ctx)
- if c == nil {
- panic(errNotAppEngineContext)
- }
- return appengine.RequestID(c)
-}
-
-func ModuleName(ctx context.Context) string {
- c := fromContext(ctx)
- if c == nil {
- panic(errNotAppEngineContext)
- }
- return appengine.ModuleName(c)
-}
-func VersionID(ctx context.Context) string {
- c := fromContext(ctx)
- if c == nil {
- panic(errNotAppEngineContext)
- }
- return appengine.VersionID(c)
-}
-
-func fullyQualifiedAppID(ctx context.Context) string {
- c := fromContext(ctx)
- if c == nil {
- panic(errNotAppEngineContext)
- }
- return c.FullyQualifiedAppID()
-}
diff --git a/vendor/google.golang.org/appengine/internal/identity_flex.go b/vendor/google.golang.org/appengine/internal/identity_flex.go
deleted file mode 100644
index 4201b6b585..0000000000
--- a/vendor/google.golang.org/appengine/internal/identity_flex.go
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright 2018 Google LLC. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-//go:build appenginevm
-// +build appenginevm
-
-package internal
-
-func init() {
- appengineFlex = true
-}
diff --git a/vendor/google.golang.org/appengine/internal/identity_vm.go b/vendor/google.golang.org/appengine/internal/identity_vm.go
deleted file mode 100644
index 18ddda3a42..0000000000
--- a/vendor/google.golang.org/appengine/internal/identity_vm.go
+++ /dev/null
@@ -1,134 +0,0 @@
-// Copyright 2011 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-//go:build !appengine
-// +build !appengine
-
-package internal
-
-import (
- "context"
- "log"
- "net/http"
- "os"
- "strings"
-)
-
-// These functions are implementations of the wrapper functions
-// in ../appengine/identity.go. See that file for commentary.
-
-const (
- hDefaultVersionHostname = "X-AppEngine-Default-Version-Hostname"
- hRequestLogId = "X-AppEngine-Request-Log-Id"
- hDatacenter = "X-AppEngine-Datacenter"
-)
-
-func ctxHeaders(ctx context.Context) http.Header {
- c := fromContext(ctx)
- if c == nil {
- return nil
- }
- return c.Request().Header
-}
-
-func DefaultVersionHostname(ctx context.Context) string {
- return ctxHeaders(ctx).Get(hDefaultVersionHostname)
-}
-
-func RequestID(ctx context.Context) string {
- return ctxHeaders(ctx).Get(hRequestLogId)
-}
-
-func Datacenter(ctx context.Context) string {
- if dc := ctxHeaders(ctx).Get(hDatacenter); dc != "" {
- return dc
- }
- // If the header isn't set, read zone from the metadata service.
- // It has the format projects/[NUMERIC_PROJECT_ID]/zones/[ZONE]
- zone, err := getMetadata("instance/zone")
- if err != nil {
- log.Printf("Datacenter: %v", err)
- return ""
- }
- parts := strings.Split(string(zone), "/")
- if len(parts) == 0 {
- return ""
- }
- return parts[len(parts)-1]
-}
-
-func ServerSoftware() string {
- // TODO(dsymonds): Remove fallback when we've verified this.
- if s := os.Getenv("SERVER_SOFTWARE"); s != "" {
- return s
- }
- if s := os.Getenv("GAE_ENV"); s != "" {
- return s
- }
- return "Google App Engine/1.x.x"
-}
-
-// TODO(dsymonds): Remove the metadata fetches.
-
-func ModuleName(_ context.Context) string {
- if s := os.Getenv("GAE_MODULE_NAME"); s != "" {
- return s
- }
- if s := os.Getenv("GAE_SERVICE"); s != "" {
- return s
- }
- return string(mustGetMetadata("instance/attributes/gae_backend_name"))
-}
-
-func VersionID(_ context.Context) string {
- if s1, s2 := os.Getenv("GAE_MODULE_VERSION"), os.Getenv("GAE_MINOR_VERSION"); s1 != "" && s2 != "" {
- return s1 + "." + s2
- }
- if s1, s2 := os.Getenv("GAE_VERSION"), os.Getenv("GAE_DEPLOYMENT_ID"); s1 != "" && s2 != "" {
- return s1 + "." + s2
- }
- return string(mustGetMetadata("instance/attributes/gae_backend_version")) + "." + string(mustGetMetadata("instance/attributes/gae_backend_minor_version"))
-}
-
-func InstanceID() string {
- if s := os.Getenv("GAE_MODULE_INSTANCE"); s != "" {
- return s
- }
- if s := os.Getenv("GAE_INSTANCE"); s != "" {
- return s
- }
- return string(mustGetMetadata("instance/attributes/gae_backend_instance"))
-}
-
-func partitionlessAppID() string {
- // gae_project has everything except the partition prefix.
- if appID := os.Getenv("GAE_LONG_APP_ID"); appID != "" {
- return appID
- }
- if project := os.Getenv("GOOGLE_CLOUD_PROJECT"); project != "" {
- return project
- }
- return string(mustGetMetadata("instance/attributes/gae_project"))
-}
-
-func fullyQualifiedAppID(_ context.Context) string {
- if s := os.Getenv("GAE_APPLICATION"); s != "" {
- return s
- }
- appID := partitionlessAppID()
-
- part := os.Getenv("GAE_PARTITION")
- if part == "" {
- part = string(mustGetMetadata("instance/attributes/gae_partition"))
- }
-
- if part != "" {
- appID = part + "~" + appID
- }
- return appID
-}
-
-func IsDevAppServer() bool {
- return os.Getenv("RUN_WITH_DEVAPPSERVER") != "" || os.Getenv("GAE_ENV") == "localdev"
-}
diff --git a/vendor/google.golang.org/appengine/internal/internal.go b/vendor/google.golang.org/appengine/internal/internal.go
deleted file mode 100644
index 051ea3980a..0000000000
--- a/vendor/google.golang.org/appengine/internal/internal.go
+++ /dev/null
@@ -1,110 +0,0 @@
-// Copyright 2011 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-// Package internal provides support for package appengine.
-//
-// Programs should not use this package directly. Its API is not stable.
-// Use packages appengine and appengine/* instead.
-package internal
-
-import (
- "fmt"
-
- "github.com/golang/protobuf/proto"
-
- remotepb "google.golang.org/appengine/internal/remote_api"
-)
-
-// errorCodeMaps is a map of service name to the error code map for the service.
-var errorCodeMaps = make(map[string]map[int32]string)
-
-// RegisterErrorCodeMap is called from API implementations to register their
-// error code map. This should only be called from init functions.
-func RegisterErrorCodeMap(service string, m map[int32]string) {
- errorCodeMaps[service] = m
-}
-
-type timeoutCodeKey struct {
- service string
- code int32
-}
-
-// timeoutCodes is the set of service+code pairs that represent timeouts.
-var timeoutCodes = make(map[timeoutCodeKey]bool)
-
-func RegisterTimeoutErrorCode(service string, code int32) {
- timeoutCodes[timeoutCodeKey{service, code}] = true
-}
-
-// APIError is the type returned by appengine.Context's Call method
-// when an API call fails in an API-specific way. This may be, for instance,
-// a taskqueue API call failing with TaskQueueServiceError::UNKNOWN_QUEUE.
-type APIError struct {
- Service string
- Detail string
- Code int32 // API-specific error code
-}
-
-func (e *APIError) Error() string {
- if e.Code == 0 {
- if e.Detail == "" {
- return "APIError "
- }
- return e.Detail
- }
- s := fmt.Sprintf("API error %d", e.Code)
- if m, ok := errorCodeMaps[e.Service]; ok {
- s += " (" + e.Service + ": " + m[e.Code] + ")"
- } else {
- // Shouldn't happen, but provide a bit more detail if it does.
- s = e.Service + " " + s
- }
- if e.Detail != "" {
- s += ": " + e.Detail
- }
- return s
-}
-
-func (e *APIError) IsTimeout() bool {
- return timeoutCodes[timeoutCodeKey{e.Service, e.Code}]
-}
-
-// CallError is the type returned by appengine.Context's Call method when an
-// API call fails in a generic way, such as RpcError::CAPABILITY_DISABLED.
-type CallError struct {
- Detail string
- Code int32
- // TODO: Remove this if we get a distinguishable error code.
- Timeout bool
-}
-
-func (e *CallError) Error() string {
- var msg string
- switch remotepb.RpcError_ErrorCode(e.Code) {
- case remotepb.RpcError_UNKNOWN:
- return e.Detail
- case remotepb.RpcError_OVER_QUOTA:
- msg = "Over quota"
- case remotepb.RpcError_CAPABILITY_DISABLED:
- msg = "Capability disabled"
- case remotepb.RpcError_CANCELLED:
- msg = "Canceled"
- default:
- msg = fmt.Sprintf("Call error %d", e.Code)
- }
- s := msg + ": " + e.Detail
- if e.Timeout {
- s += " (timeout)"
- }
- return s
-}
-
-func (e *CallError) IsTimeout() bool {
- return e.Timeout
-}
-
-// NamespaceMods is a map from API service to a function that will mutate an RPC request to attach a namespace.
-// The function should be prepared to be called on the same message more than once; it should only modify the
-// RPC request the first time.
-var NamespaceMods = make(map[string]func(m proto.Message, namespace string))
diff --git a/vendor/google.golang.org/appengine/internal/log/log_service.pb.go b/vendor/google.golang.org/appengine/internal/log/log_service.pb.go
deleted file mode 100644
index 8545ac4ad6..0000000000
--- a/vendor/google.golang.org/appengine/internal/log/log_service.pb.go
+++ /dev/null
@@ -1,1313 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google.golang.org/appengine/internal/log/log_service.proto
-
-package log
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type LogServiceError_ErrorCode int32
-
-const (
- LogServiceError_OK LogServiceError_ErrorCode = 0
- LogServiceError_INVALID_REQUEST LogServiceError_ErrorCode = 1
- LogServiceError_STORAGE_ERROR LogServiceError_ErrorCode = 2
-)
-
-var LogServiceError_ErrorCode_name = map[int32]string{
- 0: "OK",
- 1: "INVALID_REQUEST",
- 2: "STORAGE_ERROR",
-}
-var LogServiceError_ErrorCode_value = map[string]int32{
- "OK": 0,
- "INVALID_REQUEST": 1,
- "STORAGE_ERROR": 2,
-}
-
-func (x LogServiceError_ErrorCode) Enum() *LogServiceError_ErrorCode {
- p := new(LogServiceError_ErrorCode)
- *p = x
- return p
-}
-func (x LogServiceError_ErrorCode) String() string {
- return proto.EnumName(LogServiceError_ErrorCode_name, int32(x))
-}
-func (x *LogServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(LogServiceError_ErrorCode_value, data, "LogServiceError_ErrorCode")
- if err != nil {
- return err
- }
- *x = LogServiceError_ErrorCode(value)
- return nil
-}
-func (LogServiceError_ErrorCode) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_log_service_f054fd4b5012319d, []int{0, 0}
-}
-
-type LogServiceError struct {
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *LogServiceError) Reset() { *m = LogServiceError{} }
-func (m *LogServiceError) String() string { return proto.CompactTextString(m) }
-func (*LogServiceError) ProtoMessage() {}
-func (*LogServiceError) Descriptor() ([]byte, []int) {
- return fileDescriptor_log_service_f054fd4b5012319d, []int{0}
-}
-func (m *LogServiceError) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_LogServiceError.Unmarshal(m, b)
-}
-func (m *LogServiceError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_LogServiceError.Marshal(b, m, deterministic)
-}
-func (dst *LogServiceError) XXX_Merge(src proto.Message) {
- xxx_messageInfo_LogServiceError.Merge(dst, src)
-}
-func (m *LogServiceError) XXX_Size() int {
- return xxx_messageInfo_LogServiceError.Size(m)
-}
-func (m *LogServiceError) XXX_DiscardUnknown() {
- xxx_messageInfo_LogServiceError.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_LogServiceError proto.InternalMessageInfo
-
-type UserAppLogLine struct {
- TimestampUsec *int64 `protobuf:"varint,1,req,name=timestamp_usec,json=timestampUsec" json:"timestamp_usec,omitempty"`
- Level *int64 `protobuf:"varint,2,req,name=level" json:"level,omitempty"`
- Message *string `protobuf:"bytes,3,req,name=message" json:"message,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *UserAppLogLine) Reset() { *m = UserAppLogLine{} }
-func (m *UserAppLogLine) String() string { return proto.CompactTextString(m) }
-func (*UserAppLogLine) ProtoMessage() {}
-func (*UserAppLogLine) Descriptor() ([]byte, []int) {
- return fileDescriptor_log_service_f054fd4b5012319d, []int{1}
-}
-func (m *UserAppLogLine) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_UserAppLogLine.Unmarshal(m, b)
-}
-func (m *UserAppLogLine) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_UserAppLogLine.Marshal(b, m, deterministic)
-}
-func (dst *UserAppLogLine) XXX_Merge(src proto.Message) {
- xxx_messageInfo_UserAppLogLine.Merge(dst, src)
-}
-func (m *UserAppLogLine) XXX_Size() int {
- return xxx_messageInfo_UserAppLogLine.Size(m)
-}
-func (m *UserAppLogLine) XXX_DiscardUnknown() {
- xxx_messageInfo_UserAppLogLine.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_UserAppLogLine proto.InternalMessageInfo
-
-func (m *UserAppLogLine) GetTimestampUsec() int64 {
- if m != nil && m.TimestampUsec != nil {
- return *m.TimestampUsec
- }
- return 0
-}
-
-func (m *UserAppLogLine) GetLevel() int64 {
- if m != nil && m.Level != nil {
- return *m.Level
- }
- return 0
-}
-
-func (m *UserAppLogLine) GetMessage() string {
- if m != nil && m.Message != nil {
- return *m.Message
- }
- return ""
-}
-
-type UserAppLogGroup struct {
- LogLine []*UserAppLogLine `protobuf:"bytes,2,rep,name=log_line,json=logLine" json:"log_line,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *UserAppLogGroup) Reset() { *m = UserAppLogGroup{} }
-func (m *UserAppLogGroup) String() string { return proto.CompactTextString(m) }
-func (*UserAppLogGroup) ProtoMessage() {}
-func (*UserAppLogGroup) Descriptor() ([]byte, []int) {
- return fileDescriptor_log_service_f054fd4b5012319d, []int{2}
-}
-func (m *UserAppLogGroup) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_UserAppLogGroup.Unmarshal(m, b)
-}
-func (m *UserAppLogGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_UserAppLogGroup.Marshal(b, m, deterministic)
-}
-func (dst *UserAppLogGroup) XXX_Merge(src proto.Message) {
- xxx_messageInfo_UserAppLogGroup.Merge(dst, src)
-}
-func (m *UserAppLogGroup) XXX_Size() int {
- return xxx_messageInfo_UserAppLogGroup.Size(m)
-}
-func (m *UserAppLogGroup) XXX_DiscardUnknown() {
- xxx_messageInfo_UserAppLogGroup.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_UserAppLogGroup proto.InternalMessageInfo
-
-func (m *UserAppLogGroup) GetLogLine() []*UserAppLogLine {
- if m != nil {
- return m.LogLine
- }
- return nil
-}
-
-type FlushRequest struct {
- Logs []byte `protobuf:"bytes,1,opt,name=logs" json:"logs,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *FlushRequest) Reset() { *m = FlushRequest{} }
-func (m *FlushRequest) String() string { return proto.CompactTextString(m) }
-func (*FlushRequest) ProtoMessage() {}
-func (*FlushRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_log_service_f054fd4b5012319d, []int{3}
-}
-func (m *FlushRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_FlushRequest.Unmarshal(m, b)
-}
-func (m *FlushRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_FlushRequest.Marshal(b, m, deterministic)
-}
-func (dst *FlushRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_FlushRequest.Merge(dst, src)
-}
-func (m *FlushRequest) XXX_Size() int {
- return xxx_messageInfo_FlushRequest.Size(m)
-}
-func (m *FlushRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_FlushRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FlushRequest proto.InternalMessageInfo
-
-func (m *FlushRequest) GetLogs() []byte {
- if m != nil {
- return m.Logs
- }
- return nil
-}
-
-type SetStatusRequest struct {
- Status *string `protobuf:"bytes,1,req,name=status" json:"status,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *SetStatusRequest) Reset() { *m = SetStatusRequest{} }
-func (m *SetStatusRequest) String() string { return proto.CompactTextString(m) }
-func (*SetStatusRequest) ProtoMessage() {}
-func (*SetStatusRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_log_service_f054fd4b5012319d, []int{4}
-}
-func (m *SetStatusRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_SetStatusRequest.Unmarshal(m, b)
-}
-func (m *SetStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_SetStatusRequest.Marshal(b, m, deterministic)
-}
-func (dst *SetStatusRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_SetStatusRequest.Merge(dst, src)
-}
-func (m *SetStatusRequest) XXX_Size() int {
- return xxx_messageInfo_SetStatusRequest.Size(m)
-}
-func (m *SetStatusRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_SetStatusRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_SetStatusRequest proto.InternalMessageInfo
-
-func (m *SetStatusRequest) GetStatus() string {
- if m != nil && m.Status != nil {
- return *m.Status
- }
- return ""
-}
-
-type LogOffset struct {
- RequestId []byte `protobuf:"bytes,1,opt,name=request_id,json=requestId" json:"request_id,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *LogOffset) Reset() { *m = LogOffset{} }
-func (m *LogOffset) String() string { return proto.CompactTextString(m) }
-func (*LogOffset) ProtoMessage() {}
-func (*LogOffset) Descriptor() ([]byte, []int) {
- return fileDescriptor_log_service_f054fd4b5012319d, []int{5}
-}
-func (m *LogOffset) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_LogOffset.Unmarshal(m, b)
-}
-func (m *LogOffset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_LogOffset.Marshal(b, m, deterministic)
-}
-func (dst *LogOffset) XXX_Merge(src proto.Message) {
- xxx_messageInfo_LogOffset.Merge(dst, src)
-}
-func (m *LogOffset) XXX_Size() int {
- return xxx_messageInfo_LogOffset.Size(m)
-}
-func (m *LogOffset) XXX_DiscardUnknown() {
- xxx_messageInfo_LogOffset.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_LogOffset proto.InternalMessageInfo
-
-func (m *LogOffset) GetRequestId() []byte {
- if m != nil {
- return m.RequestId
- }
- return nil
-}
-
-type LogLine struct {
- Time *int64 `protobuf:"varint,1,req,name=time" json:"time,omitempty"`
- Level *int32 `protobuf:"varint,2,req,name=level" json:"level,omitempty"`
- LogMessage *string `protobuf:"bytes,3,req,name=log_message,json=logMessage" json:"log_message,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *LogLine) Reset() { *m = LogLine{} }
-func (m *LogLine) String() string { return proto.CompactTextString(m) }
-func (*LogLine) ProtoMessage() {}
-func (*LogLine) Descriptor() ([]byte, []int) {
- return fileDescriptor_log_service_f054fd4b5012319d, []int{6}
-}
-func (m *LogLine) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_LogLine.Unmarshal(m, b)
-}
-func (m *LogLine) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_LogLine.Marshal(b, m, deterministic)
-}
-func (dst *LogLine) XXX_Merge(src proto.Message) {
- xxx_messageInfo_LogLine.Merge(dst, src)
-}
-func (m *LogLine) XXX_Size() int {
- return xxx_messageInfo_LogLine.Size(m)
-}
-func (m *LogLine) XXX_DiscardUnknown() {
- xxx_messageInfo_LogLine.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_LogLine proto.InternalMessageInfo
-
-func (m *LogLine) GetTime() int64 {
- if m != nil && m.Time != nil {
- return *m.Time
- }
- return 0
-}
-
-func (m *LogLine) GetLevel() int32 {
- if m != nil && m.Level != nil {
- return *m.Level
- }
- return 0
-}
-
-func (m *LogLine) GetLogMessage() string {
- if m != nil && m.LogMessage != nil {
- return *m.LogMessage
- }
- return ""
-}
-
-type RequestLog struct {
- AppId *string `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
- ModuleId *string `protobuf:"bytes,37,opt,name=module_id,json=moduleId,def=default" json:"module_id,omitempty"`
- VersionId *string `protobuf:"bytes,2,req,name=version_id,json=versionId" json:"version_id,omitempty"`
- RequestId []byte `protobuf:"bytes,3,req,name=request_id,json=requestId" json:"request_id,omitempty"`
- Offset *LogOffset `protobuf:"bytes,35,opt,name=offset" json:"offset,omitempty"`
- Ip *string `protobuf:"bytes,4,req,name=ip" json:"ip,omitempty"`
- Nickname *string `protobuf:"bytes,5,opt,name=nickname" json:"nickname,omitempty"`
- StartTime *int64 `protobuf:"varint,6,req,name=start_time,json=startTime" json:"start_time,omitempty"`
- EndTime *int64 `protobuf:"varint,7,req,name=end_time,json=endTime" json:"end_time,omitempty"`
- Latency *int64 `protobuf:"varint,8,req,name=latency" json:"latency,omitempty"`
- Mcycles *int64 `protobuf:"varint,9,req,name=mcycles" json:"mcycles,omitempty"`
- Method *string `protobuf:"bytes,10,req,name=method" json:"method,omitempty"`
- Resource *string `protobuf:"bytes,11,req,name=resource" json:"resource,omitempty"`
- HttpVersion *string `protobuf:"bytes,12,req,name=http_version,json=httpVersion" json:"http_version,omitempty"`
- Status *int32 `protobuf:"varint,13,req,name=status" json:"status,omitempty"`
- ResponseSize *int64 `protobuf:"varint,14,req,name=response_size,json=responseSize" json:"response_size,omitempty"`
- Referrer *string `protobuf:"bytes,15,opt,name=referrer" json:"referrer,omitempty"`
- UserAgent *string `protobuf:"bytes,16,opt,name=user_agent,json=userAgent" json:"user_agent,omitempty"`
- UrlMapEntry *string `protobuf:"bytes,17,req,name=url_map_entry,json=urlMapEntry" json:"url_map_entry,omitempty"`
- Combined *string `protobuf:"bytes,18,req,name=combined" json:"combined,omitempty"`
- ApiMcycles *int64 `protobuf:"varint,19,opt,name=api_mcycles,json=apiMcycles" json:"api_mcycles,omitempty"`
- Host *string `protobuf:"bytes,20,opt,name=host" json:"host,omitempty"`
- Cost *float64 `protobuf:"fixed64,21,opt,name=cost" json:"cost,omitempty"`
- TaskQueueName *string `protobuf:"bytes,22,opt,name=task_queue_name,json=taskQueueName" json:"task_queue_name,omitempty"`
- TaskName *string `protobuf:"bytes,23,opt,name=task_name,json=taskName" json:"task_name,omitempty"`
- WasLoadingRequest *bool `protobuf:"varint,24,opt,name=was_loading_request,json=wasLoadingRequest" json:"was_loading_request,omitempty"`
- PendingTime *int64 `protobuf:"varint,25,opt,name=pending_time,json=pendingTime" json:"pending_time,omitempty"`
- ReplicaIndex *int32 `protobuf:"varint,26,opt,name=replica_index,json=replicaIndex,def=-1" json:"replica_index,omitempty"`
- Finished *bool `protobuf:"varint,27,opt,name=finished,def=1" json:"finished,omitempty"`
- CloneKey []byte `protobuf:"bytes,28,opt,name=clone_key,json=cloneKey" json:"clone_key,omitempty"`
- Line []*LogLine `protobuf:"bytes,29,rep,name=line" json:"line,omitempty"`
- LinesIncomplete *bool `protobuf:"varint,36,opt,name=lines_incomplete,json=linesIncomplete" json:"lines_incomplete,omitempty"`
- AppEngineRelease []byte `protobuf:"bytes,38,opt,name=app_engine_release,json=appEngineRelease" json:"app_engine_release,omitempty"`
- ExitReason *int32 `protobuf:"varint,30,opt,name=exit_reason,json=exitReason" json:"exit_reason,omitempty"`
- WasThrottledForTime *bool `protobuf:"varint,31,opt,name=was_throttled_for_time,json=wasThrottledForTime" json:"was_throttled_for_time,omitempty"`
- WasThrottledForRequests *bool `protobuf:"varint,32,opt,name=was_throttled_for_requests,json=wasThrottledForRequests" json:"was_throttled_for_requests,omitempty"`
- ThrottledTime *int64 `protobuf:"varint,33,opt,name=throttled_time,json=throttledTime" json:"throttled_time,omitempty"`
- ServerName []byte `protobuf:"bytes,34,opt,name=server_name,json=serverName" json:"server_name,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *RequestLog) Reset() { *m = RequestLog{} }
-func (m *RequestLog) String() string { return proto.CompactTextString(m) }
-func (*RequestLog) ProtoMessage() {}
-func (*RequestLog) Descriptor() ([]byte, []int) {
- return fileDescriptor_log_service_f054fd4b5012319d, []int{7}
-}
-func (m *RequestLog) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_RequestLog.Unmarshal(m, b)
-}
-func (m *RequestLog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_RequestLog.Marshal(b, m, deterministic)
-}
-func (dst *RequestLog) XXX_Merge(src proto.Message) {
- xxx_messageInfo_RequestLog.Merge(dst, src)
-}
-func (m *RequestLog) XXX_Size() int {
- return xxx_messageInfo_RequestLog.Size(m)
-}
-func (m *RequestLog) XXX_DiscardUnknown() {
- xxx_messageInfo_RequestLog.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_RequestLog proto.InternalMessageInfo
-
-const Default_RequestLog_ModuleId string = "default"
-const Default_RequestLog_ReplicaIndex int32 = -1
-const Default_RequestLog_Finished bool = true
-
-func (m *RequestLog) GetAppId() string {
- if m != nil && m.AppId != nil {
- return *m.AppId
- }
- return ""
-}
-
-func (m *RequestLog) GetModuleId() string {
- if m != nil && m.ModuleId != nil {
- return *m.ModuleId
- }
- return Default_RequestLog_ModuleId
-}
-
-func (m *RequestLog) GetVersionId() string {
- if m != nil && m.VersionId != nil {
- return *m.VersionId
- }
- return ""
-}
-
-func (m *RequestLog) GetRequestId() []byte {
- if m != nil {
- return m.RequestId
- }
- return nil
-}
-
-func (m *RequestLog) GetOffset() *LogOffset {
- if m != nil {
- return m.Offset
- }
- return nil
-}
-
-func (m *RequestLog) GetIp() string {
- if m != nil && m.Ip != nil {
- return *m.Ip
- }
- return ""
-}
-
-func (m *RequestLog) GetNickname() string {
- if m != nil && m.Nickname != nil {
- return *m.Nickname
- }
- return ""
-}
-
-func (m *RequestLog) GetStartTime() int64 {
- if m != nil && m.StartTime != nil {
- return *m.StartTime
- }
- return 0
-}
-
-func (m *RequestLog) GetEndTime() int64 {
- if m != nil && m.EndTime != nil {
- return *m.EndTime
- }
- return 0
-}
-
-func (m *RequestLog) GetLatency() int64 {
- if m != nil && m.Latency != nil {
- return *m.Latency
- }
- return 0
-}
-
-func (m *RequestLog) GetMcycles() int64 {
- if m != nil && m.Mcycles != nil {
- return *m.Mcycles
- }
- return 0
-}
-
-func (m *RequestLog) GetMethod() string {
- if m != nil && m.Method != nil {
- return *m.Method
- }
- return ""
-}
-
-func (m *RequestLog) GetResource() string {
- if m != nil && m.Resource != nil {
- return *m.Resource
- }
- return ""
-}
-
-func (m *RequestLog) GetHttpVersion() string {
- if m != nil && m.HttpVersion != nil {
- return *m.HttpVersion
- }
- return ""
-}
-
-func (m *RequestLog) GetStatus() int32 {
- if m != nil && m.Status != nil {
- return *m.Status
- }
- return 0
-}
-
-func (m *RequestLog) GetResponseSize() int64 {
- if m != nil && m.ResponseSize != nil {
- return *m.ResponseSize
- }
- return 0
-}
-
-func (m *RequestLog) GetReferrer() string {
- if m != nil && m.Referrer != nil {
- return *m.Referrer
- }
- return ""
-}
-
-func (m *RequestLog) GetUserAgent() string {
- if m != nil && m.UserAgent != nil {
- return *m.UserAgent
- }
- return ""
-}
-
-func (m *RequestLog) GetUrlMapEntry() string {
- if m != nil && m.UrlMapEntry != nil {
- return *m.UrlMapEntry
- }
- return ""
-}
-
-func (m *RequestLog) GetCombined() string {
- if m != nil && m.Combined != nil {
- return *m.Combined
- }
- return ""
-}
-
-func (m *RequestLog) GetApiMcycles() int64 {
- if m != nil && m.ApiMcycles != nil {
- return *m.ApiMcycles
- }
- return 0
-}
-
-func (m *RequestLog) GetHost() string {
- if m != nil && m.Host != nil {
- return *m.Host
- }
- return ""
-}
-
-func (m *RequestLog) GetCost() float64 {
- if m != nil && m.Cost != nil {
- return *m.Cost
- }
- return 0
-}
-
-func (m *RequestLog) GetTaskQueueName() string {
- if m != nil && m.TaskQueueName != nil {
- return *m.TaskQueueName
- }
- return ""
-}
-
-func (m *RequestLog) GetTaskName() string {
- if m != nil && m.TaskName != nil {
- return *m.TaskName
- }
- return ""
-}
-
-func (m *RequestLog) GetWasLoadingRequest() bool {
- if m != nil && m.WasLoadingRequest != nil {
- return *m.WasLoadingRequest
- }
- return false
-}
-
-func (m *RequestLog) GetPendingTime() int64 {
- if m != nil && m.PendingTime != nil {
- return *m.PendingTime
- }
- return 0
-}
-
-func (m *RequestLog) GetReplicaIndex() int32 {
- if m != nil && m.ReplicaIndex != nil {
- return *m.ReplicaIndex
- }
- return Default_RequestLog_ReplicaIndex
-}
-
-func (m *RequestLog) GetFinished() bool {
- if m != nil && m.Finished != nil {
- return *m.Finished
- }
- return Default_RequestLog_Finished
-}
-
-func (m *RequestLog) GetCloneKey() []byte {
- if m != nil {
- return m.CloneKey
- }
- return nil
-}
-
-func (m *RequestLog) GetLine() []*LogLine {
- if m != nil {
- return m.Line
- }
- return nil
-}
-
-func (m *RequestLog) GetLinesIncomplete() bool {
- if m != nil && m.LinesIncomplete != nil {
- return *m.LinesIncomplete
- }
- return false
-}
-
-func (m *RequestLog) GetAppEngineRelease() []byte {
- if m != nil {
- return m.AppEngineRelease
- }
- return nil
-}
-
-func (m *RequestLog) GetExitReason() int32 {
- if m != nil && m.ExitReason != nil {
- return *m.ExitReason
- }
- return 0
-}
-
-func (m *RequestLog) GetWasThrottledForTime() bool {
- if m != nil && m.WasThrottledForTime != nil {
- return *m.WasThrottledForTime
- }
- return false
-}
-
-func (m *RequestLog) GetWasThrottledForRequests() bool {
- if m != nil && m.WasThrottledForRequests != nil {
- return *m.WasThrottledForRequests
- }
- return false
-}
-
-func (m *RequestLog) GetThrottledTime() int64 {
- if m != nil && m.ThrottledTime != nil {
- return *m.ThrottledTime
- }
- return 0
-}
-
-func (m *RequestLog) GetServerName() []byte {
- if m != nil {
- return m.ServerName
- }
- return nil
-}
-
-type LogModuleVersion struct {
- ModuleId *string `protobuf:"bytes,1,opt,name=module_id,json=moduleId,def=default" json:"module_id,omitempty"`
- VersionId *string `protobuf:"bytes,2,opt,name=version_id,json=versionId" json:"version_id,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *LogModuleVersion) Reset() { *m = LogModuleVersion{} }
-func (m *LogModuleVersion) String() string { return proto.CompactTextString(m) }
-func (*LogModuleVersion) ProtoMessage() {}
-func (*LogModuleVersion) Descriptor() ([]byte, []int) {
- return fileDescriptor_log_service_f054fd4b5012319d, []int{8}
-}
-func (m *LogModuleVersion) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_LogModuleVersion.Unmarshal(m, b)
-}
-func (m *LogModuleVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_LogModuleVersion.Marshal(b, m, deterministic)
-}
-func (dst *LogModuleVersion) XXX_Merge(src proto.Message) {
- xxx_messageInfo_LogModuleVersion.Merge(dst, src)
-}
-func (m *LogModuleVersion) XXX_Size() int {
- return xxx_messageInfo_LogModuleVersion.Size(m)
-}
-func (m *LogModuleVersion) XXX_DiscardUnknown() {
- xxx_messageInfo_LogModuleVersion.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_LogModuleVersion proto.InternalMessageInfo
-
-const Default_LogModuleVersion_ModuleId string = "default"
-
-func (m *LogModuleVersion) GetModuleId() string {
- if m != nil && m.ModuleId != nil {
- return *m.ModuleId
- }
- return Default_LogModuleVersion_ModuleId
-}
-
-func (m *LogModuleVersion) GetVersionId() string {
- if m != nil && m.VersionId != nil {
- return *m.VersionId
- }
- return ""
-}
-
-type LogReadRequest struct {
- AppId *string `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
- VersionId []string `protobuf:"bytes,2,rep,name=version_id,json=versionId" json:"version_id,omitempty"`
- ModuleVersion []*LogModuleVersion `protobuf:"bytes,19,rep,name=module_version,json=moduleVersion" json:"module_version,omitempty"`
- StartTime *int64 `protobuf:"varint,3,opt,name=start_time,json=startTime" json:"start_time,omitempty"`
- EndTime *int64 `protobuf:"varint,4,opt,name=end_time,json=endTime" json:"end_time,omitempty"`
- Offset *LogOffset `protobuf:"bytes,5,opt,name=offset" json:"offset,omitempty"`
- RequestId [][]byte `protobuf:"bytes,6,rep,name=request_id,json=requestId" json:"request_id,omitempty"`
- MinimumLogLevel *int32 `protobuf:"varint,7,opt,name=minimum_log_level,json=minimumLogLevel" json:"minimum_log_level,omitempty"`
- IncludeIncomplete *bool `protobuf:"varint,8,opt,name=include_incomplete,json=includeIncomplete" json:"include_incomplete,omitempty"`
- Count *int64 `protobuf:"varint,9,opt,name=count" json:"count,omitempty"`
- CombinedLogRegex *string `protobuf:"bytes,14,opt,name=combined_log_regex,json=combinedLogRegex" json:"combined_log_regex,omitempty"`
- HostRegex *string `protobuf:"bytes,15,opt,name=host_regex,json=hostRegex" json:"host_regex,omitempty"`
- ReplicaIndex *int32 `protobuf:"varint,16,opt,name=replica_index,json=replicaIndex" json:"replica_index,omitempty"`
- IncludeAppLogs *bool `protobuf:"varint,10,opt,name=include_app_logs,json=includeAppLogs" json:"include_app_logs,omitempty"`
- AppLogsPerRequest *int32 `protobuf:"varint,17,opt,name=app_logs_per_request,json=appLogsPerRequest" json:"app_logs_per_request,omitempty"`
- IncludeHost *bool `protobuf:"varint,11,opt,name=include_host,json=includeHost" json:"include_host,omitempty"`
- IncludeAll *bool `protobuf:"varint,12,opt,name=include_all,json=includeAll" json:"include_all,omitempty"`
- CacheIterator *bool `protobuf:"varint,13,opt,name=cache_iterator,json=cacheIterator" json:"cache_iterator,omitempty"`
- NumShards *int32 `protobuf:"varint,18,opt,name=num_shards,json=numShards" json:"num_shards,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *LogReadRequest) Reset() { *m = LogReadRequest{} }
-func (m *LogReadRequest) String() string { return proto.CompactTextString(m) }
-func (*LogReadRequest) ProtoMessage() {}
-func (*LogReadRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_log_service_f054fd4b5012319d, []int{9}
-}
-func (m *LogReadRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_LogReadRequest.Unmarshal(m, b)
-}
-func (m *LogReadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_LogReadRequest.Marshal(b, m, deterministic)
-}
-func (dst *LogReadRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_LogReadRequest.Merge(dst, src)
-}
-func (m *LogReadRequest) XXX_Size() int {
- return xxx_messageInfo_LogReadRequest.Size(m)
-}
-func (m *LogReadRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_LogReadRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_LogReadRequest proto.InternalMessageInfo
-
-func (m *LogReadRequest) GetAppId() string {
- if m != nil && m.AppId != nil {
- return *m.AppId
- }
- return ""
-}
-
-func (m *LogReadRequest) GetVersionId() []string {
- if m != nil {
- return m.VersionId
- }
- return nil
-}
-
-func (m *LogReadRequest) GetModuleVersion() []*LogModuleVersion {
- if m != nil {
- return m.ModuleVersion
- }
- return nil
-}
-
-func (m *LogReadRequest) GetStartTime() int64 {
- if m != nil && m.StartTime != nil {
- return *m.StartTime
- }
- return 0
-}
-
-func (m *LogReadRequest) GetEndTime() int64 {
- if m != nil && m.EndTime != nil {
- return *m.EndTime
- }
- return 0
-}
-
-func (m *LogReadRequest) GetOffset() *LogOffset {
- if m != nil {
- return m.Offset
- }
- return nil
-}
-
-func (m *LogReadRequest) GetRequestId() [][]byte {
- if m != nil {
- return m.RequestId
- }
- return nil
-}
-
-func (m *LogReadRequest) GetMinimumLogLevel() int32 {
- if m != nil && m.MinimumLogLevel != nil {
- return *m.MinimumLogLevel
- }
- return 0
-}
-
-func (m *LogReadRequest) GetIncludeIncomplete() bool {
- if m != nil && m.IncludeIncomplete != nil {
- return *m.IncludeIncomplete
- }
- return false
-}
-
-func (m *LogReadRequest) GetCount() int64 {
- if m != nil && m.Count != nil {
- return *m.Count
- }
- return 0
-}
-
-func (m *LogReadRequest) GetCombinedLogRegex() string {
- if m != nil && m.CombinedLogRegex != nil {
- return *m.CombinedLogRegex
- }
- return ""
-}
-
-func (m *LogReadRequest) GetHostRegex() string {
- if m != nil && m.HostRegex != nil {
- return *m.HostRegex
- }
- return ""
-}
-
-func (m *LogReadRequest) GetReplicaIndex() int32 {
- if m != nil && m.ReplicaIndex != nil {
- return *m.ReplicaIndex
- }
- return 0
-}
-
-func (m *LogReadRequest) GetIncludeAppLogs() bool {
- if m != nil && m.IncludeAppLogs != nil {
- return *m.IncludeAppLogs
- }
- return false
-}
-
-func (m *LogReadRequest) GetAppLogsPerRequest() int32 {
- if m != nil && m.AppLogsPerRequest != nil {
- return *m.AppLogsPerRequest
- }
- return 0
-}
-
-func (m *LogReadRequest) GetIncludeHost() bool {
- if m != nil && m.IncludeHost != nil {
- return *m.IncludeHost
- }
- return false
-}
-
-func (m *LogReadRequest) GetIncludeAll() bool {
- if m != nil && m.IncludeAll != nil {
- return *m.IncludeAll
- }
- return false
-}
-
-func (m *LogReadRequest) GetCacheIterator() bool {
- if m != nil && m.CacheIterator != nil {
- return *m.CacheIterator
- }
- return false
-}
-
-func (m *LogReadRequest) GetNumShards() int32 {
- if m != nil && m.NumShards != nil {
- return *m.NumShards
- }
- return 0
-}
-
-type LogReadResponse struct {
- Log []*RequestLog `protobuf:"bytes,1,rep,name=log" json:"log,omitempty"`
- Offset *LogOffset `protobuf:"bytes,2,opt,name=offset" json:"offset,omitempty"`
- LastEndTime *int64 `protobuf:"varint,3,opt,name=last_end_time,json=lastEndTime" json:"last_end_time,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *LogReadResponse) Reset() { *m = LogReadResponse{} }
-func (m *LogReadResponse) String() string { return proto.CompactTextString(m) }
-func (*LogReadResponse) ProtoMessage() {}
-func (*LogReadResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_log_service_f054fd4b5012319d, []int{10}
-}
-func (m *LogReadResponse) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_LogReadResponse.Unmarshal(m, b)
-}
-func (m *LogReadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_LogReadResponse.Marshal(b, m, deterministic)
-}
-func (dst *LogReadResponse) XXX_Merge(src proto.Message) {
- xxx_messageInfo_LogReadResponse.Merge(dst, src)
-}
-func (m *LogReadResponse) XXX_Size() int {
- return xxx_messageInfo_LogReadResponse.Size(m)
-}
-func (m *LogReadResponse) XXX_DiscardUnknown() {
- xxx_messageInfo_LogReadResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_LogReadResponse proto.InternalMessageInfo
-
-func (m *LogReadResponse) GetLog() []*RequestLog {
- if m != nil {
- return m.Log
- }
- return nil
-}
-
-func (m *LogReadResponse) GetOffset() *LogOffset {
- if m != nil {
- return m.Offset
- }
- return nil
-}
-
-func (m *LogReadResponse) GetLastEndTime() int64 {
- if m != nil && m.LastEndTime != nil {
- return *m.LastEndTime
- }
- return 0
-}
-
-type LogUsageRecord struct {
- VersionId *string `protobuf:"bytes,1,opt,name=version_id,json=versionId" json:"version_id,omitempty"`
- StartTime *int32 `protobuf:"varint,2,opt,name=start_time,json=startTime" json:"start_time,omitempty"`
- EndTime *int32 `protobuf:"varint,3,opt,name=end_time,json=endTime" json:"end_time,omitempty"`
- Count *int64 `protobuf:"varint,4,opt,name=count" json:"count,omitempty"`
- TotalSize *int64 `protobuf:"varint,5,opt,name=total_size,json=totalSize" json:"total_size,omitempty"`
- Records *int32 `protobuf:"varint,6,opt,name=records" json:"records,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *LogUsageRecord) Reset() { *m = LogUsageRecord{} }
-func (m *LogUsageRecord) String() string { return proto.CompactTextString(m) }
-func (*LogUsageRecord) ProtoMessage() {}
-func (*LogUsageRecord) Descriptor() ([]byte, []int) {
- return fileDescriptor_log_service_f054fd4b5012319d, []int{11}
-}
-func (m *LogUsageRecord) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_LogUsageRecord.Unmarshal(m, b)
-}
-func (m *LogUsageRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_LogUsageRecord.Marshal(b, m, deterministic)
-}
-func (dst *LogUsageRecord) XXX_Merge(src proto.Message) {
- xxx_messageInfo_LogUsageRecord.Merge(dst, src)
-}
-func (m *LogUsageRecord) XXX_Size() int {
- return xxx_messageInfo_LogUsageRecord.Size(m)
-}
-func (m *LogUsageRecord) XXX_DiscardUnknown() {
- xxx_messageInfo_LogUsageRecord.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_LogUsageRecord proto.InternalMessageInfo
-
-func (m *LogUsageRecord) GetVersionId() string {
- if m != nil && m.VersionId != nil {
- return *m.VersionId
- }
- return ""
-}
-
-func (m *LogUsageRecord) GetStartTime() int32 {
- if m != nil && m.StartTime != nil {
- return *m.StartTime
- }
- return 0
-}
-
-func (m *LogUsageRecord) GetEndTime() int32 {
- if m != nil && m.EndTime != nil {
- return *m.EndTime
- }
- return 0
-}
-
-func (m *LogUsageRecord) GetCount() int64 {
- if m != nil && m.Count != nil {
- return *m.Count
- }
- return 0
-}
-
-func (m *LogUsageRecord) GetTotalSize() int64 {
- if m != nil && m.TotalSize != nil {
- return *m.TotalSize
- }
- return 0
-}
-
-func (m *LogUsageRecord) GetRecords() int32 {
- if m != nil && m.Records != nil {
- return *m.Records
- }
- return 0
-}
-
-type LogUsageRequest struct {
- AppId *string `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
- VersionId []string `protobuf:"bytes,2,rep,name=version_id,json=versionId" json:"version_id,omitempty"`
- StartTime *int32 `protobuf:"varint,3,opt,name=start_time,json=startTime" json:"start_time,omitempty"`
- EndTime *int32 `protobuf:"varint,4,opt,name=end_time,json=endTime" json:"end_time,omitempty"`
- ResolutionHours *uint32 `protobuf:"varint,5,opt,name=resolution_hours,json=resolutionHours,def=1" json:"resolution_hours,omitempty"`
- CombineVersions *bool `protobuf:"varint,6,opt,name=combine_versions,json=combineVersions" json:"combine_versions,omitempty"`
- UsageVersion *int32 `protobuf:"varint,7,opt,name=usage_version,json=usageVersion" json:"usage_version,omitempty"`
- VersionsOnly *bool `protobuf:"varint,8,opt,name=versions_only,json=versionsOnly" json:"versions_only,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *LogUsageRequest) Reset() { *m = LogUsageRequest{} }
-func (m *LogUsageRequest) String() string { return proto.CompactTextString(m) }
-func (*LogUsageRequest) ProtoMessage() {}
-func (*LogUsageRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_log_service_f054fd4b5012319d, []int{12}
-}
-func (m *LogUsageRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_LogUsageRequest.Unmarshal(m, b)
-}
-func (m *LogUsageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_LogUsageRequest.Marshal(b, m, deterministic)
-}
-func (dst *LogUsageRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_LogUsageRequest.Merge(dst, src)
-}
-func (m *LogUsageRequest) XXX_Size() int {
- return xxx_messageInfo_LogUsageRequest.Size(m)
-}
-func (m *LogUsageRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_LogUsageRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_LogUsageRequest proto.InternalMessageInfo
-
-const Default_LogUsageRequest_ResolutionHours uint32 = 1
-
-func (m *LogUsageRequest) GetAppId() string {
- if m != nil && m.AppId != nil {
- return *m.AppId
- }
- return ""
-}
-
-func (m *LogUsageRequest) GetVersionId() []string {
- if m != nil {
- return m.VersionId
- }
- return nil
-}
-
-func (m *LogUsageRequest) GetStartTime() int32 {
- if m != nil && m.StartTime != nil {
- return *m.StartTime
- }
- return 0
-}
-
-func (m *LogUsageRequest) GetEndTime() int32 {
- if m != nil && m.EndTime != nil {
- return *m.EndTime
- }
- return 0
-}
-
-func (m *LogUsageRequest) GetResolutionHours() uint32 {
- if m != nil && m.ResolutionHours != nil {
- return *m.ResolutionHours
- }
- return Default_LogUsageRequest_ResolutionHours
-}
-
-func (m *LogUsageRequest) GetCombineVersions() bool {
- if m != nil && m.CombineVersions != nil {
- return *m.CombineVersions
- }
- return false
-}
-
-func (m *LogUsageRequest) GetUsageVersion() int32 {
- if m != nil && m.UsageVersion != nil {
- return *m.UsageVersion
- }
- return 0
-}
-
-func (m *LogUsageRequest) GetVersionsOnly() bool {
- if m != nil && m.VersionsOnly != nil {
- return *m.VersionsOnly
- }
- return false
-}
-
-type LogUsageResponse struct {
- Usage []*LogUsageRecord `protobuf:"bytes,1,rep,name=usage" json:"usage,omitempty"`
- Summary *LogUsageRecord `protobuf:"bytes,2,opt,name=summary" json:"summary,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *LogUsageResponse) Reset() { *m = LogUsageResponse{} }
-func (m *LogUsageResponse) String() string { return proto.CompactTextString(m) }
-func (*LogUsageResponse) ProtoMessage() {}
-func (*LogUsageResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_log_service_f054fd4b5012319d, []int{13}
-}
-func (m *LogUsageResponse) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_LogUsageResponse.Unmarshal(m, b)
-}
-func (m *LogUsageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_LogUsageResponse.Marshal(b, m, deterministic)
-}
-func (dst *LogUsageResponse) XXX_Merge(src proto.Message) {
- xxx_messageInfo_LogUsageResponse.Merge(dst, src)
-}
-func (m *LogUsageResponse) XXX_Size() int {
- return xxx_messageInfo_LogUsageResponse.Size(m)
-}
-func (m *LogUsageResponse) XXX_DiscardUnknown() {
- xxx_messageInfo_LogUsageResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_LogUsageResponse proto.InternalMessageInfo
-
-func (m *LogUsageResponse) GetUsage() []*LogUsageRecord {
- if m != nil {
- return m.Usage
- }
- return nil
-}
-
-func (m *LogUsageResponse) GetSummary() *LogUsageRecord {
- if m != nil {
- return m.Summary
- }
- return nil
-}
-
-func init() {
- proto.RegisterType((*LogServiceError)(nil), "appengine.LogServiceError")
- proto.RegisterType((*UserAppLogLine)(nil), "appengine.UserAppLogLine")
- proto.RegisterType((*UserAppLogGroup)(nil), "appengine.UserAppLogGroup")
- proto.RegisterType((*FlushRequest)(nil), "appengine.FlushRequest")
- proto.RegisterType((*SetStatusRequest)(nil), "appengine.SetStatusRequest")
- proto.RegisterType((*LogOffset)(nil), "appengine.LogOffset")
- proto.RegisterType((*LogLine)(nil), "appengine.LogLine")
- proto.RegisterType((*RequestLog)(nil), "appengine.RequestLog")
- proto.RegisterType((*LogModuleVersion)(nil), "appengine.LogModuleVersion")
- proto.RegisterType((*LogReadRequest)(nil), "appengine.LogReadRequest")
- proto.RegisterType((*LogReadResponse)(nil), "appengine.LogReadResponse")
- proto.RegisterType((*LogUsageRecord)(nil), "appengine.LogUsageRecord")
- proto.RegisterType((*LogUsageRequest)(nil), "appengine.LogUsageRequest")
- proto.RegisterType((*LogUsageResponse)(nil), "appengine.LogUsageResponse")
-}
-
-func init() {
- proto.RegisterFile("google.golang.org/appengine/internal/log/log_service.proto", fileDescriptor_log_service_f054fd4b5012319d)
-}
-
-var fileDescriptor_log_service_f054fd4b5012319d = []byte{
- // 1553 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xdd, 0x72, 0xdb, 0xc6,
- 0x15, 0x2e, 0x48, 0x51, 0x24, 0x0f, 0x49, 0x91, 0x5a, 0xcb, 0xce, 0xda, 0xae, 0x6b, 0x1a, 0x4e,
- 0x1c, 0xd6, 0x93, 0x48, 0x93, 0xa4, 0x57, 0xca, 0x95, 0xd3, 0x2a, 0x8e, 0x26, 0xb4, 0xd5, 0x40,
- 0x72, 0x3a, 0xd3, 0x1b, 0x0c, 0x0a, 0x1c, 0x81, 0x18, 0x2f, 0xb1, 0xc8, 0xee, 0xc2, 0x91, 0x72,
- 0xdb, 0xdb, 0x3e, 0x46, 0x1f, 0xa2, 0xaf, 0xd2, 0xb7, 0xe9, 0xec, 0xd9, 0x05, 0x44, 0x2a, 0x4d,
- 0xc6, 0x33, 0xb9, 0xe0, 0x10, 0xfb, 0x9d, 0x83, 0xdd, 0xf3, 0xf3, 0x9d, 0x6f, 0x01, 0xc7, 0xb9,
- 0x94, 0xb9, 0xc0, 0xc3, 0x5c, 0x8a, 0xa4, 0xcc, 0x0f, 0xa5, 0xca, 0x8f, 0x92, 0xaa, 0xc2, 0x32,
- 0x2f, 0x4a, 0x3c, 0x2a, 0x4a, 0x83, 0xaa, 0x4c, 0xc4, 0x91, 0x90, 0xb9, 0xfd, 0xc5, 0x1a, 0xd5,
- 0xbb, 0x22, 0xc5, 0xc3, 0x4a, 0x49, 0x23, 0xd9, 0xb0, 0xf5, 0x0c, 0x5f, 0xc3, 0x74, 0x29, 0xf3,
- 0x73, 0x67, 0x3e, 0x51, 0x4a, 0xaa, 0xf0, 0x4b, 0x18, 0xd2, 0xc3, 0x9f, 0x65, 0x86, 0x6c, 0x17,
- 0x3a, 0x67, 0xdf, 0xce, 0x7e, 0xc7, 0xee, 0xc0, 0xf4, 0xf4, 0xf5, 0xf7, 0x2f, 0x96, 0xa7, 0x7f,
- 0x89, 0xa3, 0x93, 0xef, 0xde, 0x9c, 0x9c, 0x5f, 0xcc, 0x02, 0xb6, 0x0f, 0x93, 0xf3, 0x8b, 0xb3,
- 0xe8, 0xc5, 0xcb, 0x93, 0xf8, 0x24, 0x8a, 0xce, 0xa2, 0x59, 0x27, 0xcc, 0x61, 0xef, 0x8d, 0x46,
- 0xf5, 0xa2, 0xaa, 0x96, 0x32, 0x5f, 0x16, 0x25, 0xb2, 0x8f, 0x60, 0xcf, 0x14, 0x6b, 0xd4, 0x26,
- 0x59, 0x57, 0x71, 0xad, 0x31, 0xe5, 0xc1, 0xbc, 0xb3, 0xe8, 0x46, 0x93, 0x16, 0x7d, 0xa3, 0x31,
- 0x65, 0x07, 0xd0, 0x13, 0xf8, 0x0e, 0x05, 0xef, 0x90, 0xd5, 0x2d, 0x18, 0x87, 0xfe, 0x1a, 0xb5,
- 0x4e, 0x72, 0xe4, 0xdd, 0x79, 0x67, 0x31, 0x8c, 0x9a, 0x65, 0xf8, 0x12, 0xa6, 0x37, 0x07, 0xbd,
- 0x54, 0xb2, 0xae, 0xd8, 0x9f, 0x60, 0x60, 0x73, 0x15, 0x45, 0x89, 0xbc, 0x33, 0xef, 0x2e, 0x46,
- 0x9f, 0xdf, 0x3f, 0x6c, 0x33, 0x3d, 0xdc, 0x0e, 0x2b, 0xea, 0x0b, 0xf7, 0x10, 0x86, 0x30, 0xfe,
- 0x5a, 0xd4, 0x7a, 0x15, 0xe1, 0x0f, 0x35, 0x6a, 0xc3, 0x18, 0xec, 0x08, 0x99, 0x6b, 0x1e, 0xcc,
- 0x83, 0xc5, 0x38, 0xa2, 0xe7, 0xf0, 0x39, 0xcc, 0xce, 0xd1, 0x9c, 0x9b, 0xc4, 0xd4, 0xba, 0xf1,
- 0xbb, 0x07, 0xbb, 0x9a, 0x00, 0xca, 0x67, 0x18, 0xf9, 0x55, 0xf8, 0x1c, 0x86, 0x4b, 0x99, 0x9f,
- 0x5d, 0x5e, 0x6a, 0x34, 0xec, 0x11, 0x80, 0x72, 0xfe, 0x71, 0x91, 0xf9, 0x2d, 0x87, 0x1e, 0x39,
- 0xcd, 0xc2, 0x0b, 0xe8, 0x37, 0x65, 0x62, 0xb0, 0x63, 0x0b, 0xe2, 0x8b, 0x43, 0xcf, 0xdb, 0x35,
- 0xe9, 0x35, 0x35, 0x79, 0x0c, 0x23, 0x9b, 0xe6, 0x76, 0x5d, 0x40, 0xc8, 0xfc, 0x95, 0x2f, 0xcd,
- 0x3f, 0x01, 0xc0, 0x47, 0xb9, 0x94, 0x39, 0xbb, 0x0b, 0xbb, 0x49, 0x55, 0xb9, 0xf3, 0xad, 0x6b,
- 0x2f, 0xa9, 0xaa, 0xd3, 0x8c, 0x7d, 0x08, 0xc3, 0xb5, 0xcc, 0x6a, 0x81, 0xd6, 0xf2, 0xd1, 0x3c,
- 0x58, 0x0c, 0x8f, 0xfb, 0x19, 0x5e, 0x26, 0xb5, 0x30, 0xd1, 0xc0, 0x59, 0x4e, 0x33, 0x9b, 0xc0,
- 0x3b, 0x54, 0xba, 0x90, 0xa5, 0x75, 0xeb, 0xd0, 0x06, 0x43, 0x8f, 0x38, 0xf3, 0x46, 0x7e, 0x36,
- 0x94, 0xcd, 0xfc, 0xd8, 0x27, 0xb0, 0x2b, 0xa9, 0x10, 0xfc, 0xe9, 0x3c, 0x58, 0x8c, 0x3e, 0x3f,
- 0xd8, 0xe8, 0x47, 0x5b, 0xa4, 0xc8, 0xfb, 0xb0, 0x3d, 0xe8, 0x14, 0x15, 0xdf, 0xa1, 0x33, 0x3a,
- 0x45, 0xc5, 0x1e, 0xc0, 0xa0, 0x2c, 0xd2, 0xb7, 0x65, 0xb2, 0x46, 0xde, 0xb3, 0x01, 0x46, 0xed,
- 0xda, 0x1e, 0xac, 0x4d, 0xa2, 0x4c, 0x4c, 0x45, 0xdb, 0xa5, 0xa2, 0x0d, 0x09, 0xb9, 0xb0, 0x95,
- 0xbb, 0x0f, 0x03, 0x2c, 0x33, 0x67, 0xec, 0x93, 0xb1, 0x8f, 0x65, 0x46, 0x26, 0x0e, 0x7d, 0x91,
- 0x18, 0x2c, 0xd3, 0x6b, 0x3e, 0x70, 0x16, 0xbf, 0x24, 0xb2, 0xa5, 0xd7, 0xa9, 0x40, 0xcd, 0x87,
- 0xce, 0xe2, 0x97, 0xb6, 0xd7, 0x6b, 0x34, 0x2b, 0x99, 0x71, 0x70, 0xbd, 0x76, 0x2b, 0x1b, 0xa1,
- 0x42, 0x2d, 0x6b, 0x95, 0x22, 0x1f, 0x91, 0xa5, 0x5d, 0xb3, 0x27, 0x30, 0x5e, 0x19, 0x53, 0xc5,
- 0xbe, 0x58, 0x7c, 0x4c, 0xf6, 0x91, 0xc5, 0xbe, 0x77, 0xd0, 0x06, 0x85, 0x26, 0xd4, 0x60, 0xbf,
- 0x62, 0x4f, 0x61, 0xa2, 0x50, 0x57, 0xb2, 0xd4, 0x18, 0xeb, 0xe2, 0x27, 0xe4, 0x7b, 0x14, 0xce,
- 0xb8, 0x01, 0xcf, 0x8b, 0x9f, 0xd0, 0x9d, 0x7d, 0x89, 0x4a, 0xa1, 0xe2, 0x53, 0x57, 0x9d, 0x66,
- 0x6d, 0xab, 0x53, 0x6b, 0x54, 0x71, 0x92, 0x63, 0x69, 0xf8, 0x8c, 0xac, 0x43, 0x8b, 0xbc, 0xb0,
- 0x00, 0x0b, 0x61, 0x52, 0x2b, 0x11, 0xaf, 0x93, 0x2a, 0xc6, 0xd2, 0xa8, 0x6b, 0xbe, 0xef, 0x62,
- 0xab, 0x95, 0x78, 0x95, 0x54, 0x27, 0x16, 0xb2, 0xdb, 0xa7, 0x72, 0xfd, 0x8f, 0xa2, 0xc4, 0x8c,
- 0x33, 0x97, 0x5a, 0xb3, 0xb6, 0x0c, 0x4c, 0xaa, 0x22, 0x6e, 0x8a, 0x75, 0x67, 0x1e, 0x2c, 0xba,
- 0x11, 0x24, 0x55, 0xf1, 0xca, 0xd7, 0x8b, 0xc1, 0xce, 0x4a, 0x6a, 0xc3, 0x0f, 0xe8, 0x64, 0x7a,
- 0xb6, 0x58, 0x6a, 0xb1, 0xbb, 0xf3, 0x60, 0x11, 0x44, 0xf4, 0xcc, 0x9e, 0xc1, 0xd4, 0x24, 0xfa,
- 0x6d, 0xfc, 0x43, 0x8d, 0x35, 0xc6, 0xd4, 0xe8, 0x7b, 0xf4, 0xca, 0xc4, 0xc2, 0xdf, 0x59, 0xf4,
- 0xb5, 0xed, 0xf6, 0x43, 0x18, 0x92, 0x1f, 0x79, 0x7c, 0xe0, 0x92, 0xb5, 0x00, 0x19, 0x0f, 0xe1,
- 0xce, 0x8f, 0x89, 0x8e, 0x85, 0x4c, 0xb2, 0xa2, 0xcc, 0x63, 0xcf, 0x3e, 0xce, 0xe7, 0xc1, 0x62,
- 0x10, 0xed, 0xff, 0x98, 0xe8, 0xa5, 0xb3, 0x34, 0x83, 0xfb, 0x04, 0xc6, 0x15, 0x96, 0xe4, 0x4b,
- 0xfc, 0xb8, 0x4f, 0xe1, 0x8f, 0x3c, 0x46, 0x1c, 0xf9, 0xd8, 0x36, 0xa0, 0x12, 0x45, 0x9a, 0xc4,
- 0x45, 0x99, 0xe1, 0x15, 0x7f, 0x30, 0x0f, 0x16, 0xbd, 0xe3, 0xce, 0xa7, 0x9f, 0xd9, 0x26, 0x90,
- 0xe1, 0xd4, 0xe2, 0x6c, 0x0e, 0x83, 0xcb, 0xa2, 0x2c, 0xf4, 0x0a, 0x33, 0xfe, 0xd0, 0x1e, 0x78,
- 0xbc, 0x63, 0x54, 0x8d, 0x51, 0x8b, 0xda, 0xd0, 0x53, 0x21, 0x4b, 0x8c, 0xdf, 0xe2, 0x35, 0xff,
- 0x3d, 0x09, 0xc0, 0x80, 0x80, 0x6f, 0xf1, 0x9a, 0x3d, 0x83, 0x1d, 0x52, 0xab, 0x47, 0xa4, 0x56,
- 0x6c, 0x7b, 0x3a, 0x48, 0xa6, 0xc8, 0xce, 0xfe, 0x08, 0x33, 0xfb, 0xaf, 0xe3, 0xa2, 0x4c, 0xe5,
- 0xba, 0x12, 0x68, 0x90, 0x7f, 0x48, 0xf9, 0x4d, 0x09, 0x3f, 0x6d, 0x61, 0xf6, 0x09, 0x30, 0x3b,
- 0xed, 0x6e, 0x9b, 0x58, 0xa1, 0xc0, 0x44, 0x23, 0x7f, 0x46, 0x07, 0xcf, 0x92, 0xaa, 0x3a, 0x21,
- 0x43, 0xe4, 0x70, 0xdb, 0x49, 0xbc, 0x2a, 0x4c, 0xac, 0x30, 0xd1, 0xb2, 0xe4, 0x7f, 0xb0, 0x69,
- 0x46, 0x60, 0xa1, 0x88, 0x10, 0xf6, 0x05, 0xdc, 0xb3, 0xc5, 0x35, 0x2b, 0x25, 0x8d, 0x11, 0x98,
- 0xc5, 0x97, 0x52, 0xb9, 0xb2, 0x3d, 0xa6, 0xf3, 0x6d, 0xe9, 0x2f, 0x1a, 0xe3, 0xd7, 0x52, 0x51,
- 0xf9, 0xbe, 0x84, 0x07, 0x3f, 0x7f, 0xc9, 0xf7, 0x45, 0xf3, 0x39, 0xbd, 0xf8, 0xc1, 0xad, 0x17,
- 0x7d, 0x77, 0x34, 0xdd, 0x17, 0xed, 0x8b, 0x74, 0xd2, 0x13, 0x6a, 0xd0, 0xa4, 0x45, 0xe9, 0x8c,
- 0xc7, 0x30, 0xb2, 0x97, 0x1a, 0x2a, 0x47, 0x8a, 0x90, 0x12, 0x04, 0x07, 0x59, 0x5a, 0x84, 0x7f,
- 0x83, 0xd9, 0x52, 0xe6, 0xaf, 0x48, 0xc8, 0x9a, 0x81, 0xdb, 0xd2, 0xbc, 0xe0, 0x7d, 0x35, 0x2f,
- 0xd8, 0xd2, 0xbc, 0xf0, 0xbf, 0x3d, 0xd8, 0x5b, 0xca, 0x3c, 0xc2, 0x24, 0x6b, 0x28, 0xf5, 0x0b,
- 0x12, 0x7b, 0x7b, 0xa3, 0xee, 0xb6, 0x78, 0x7e, 0x05, 0x7b, 0x3e, 0x9a, 0x46, 0x23, 0xee, 0x10,
- 0x0f, 0x1e, 0x6e, 0xf3, 0x60, 0x2b, 0x85, 0x68, 0xb2, 0xde, 0xca, 0x68, 0x5b, 0x07, 0xbb, 0x54,
- 0xa9, 0x5f, 0xd0, 0xc1, 0x1d, 0x32, 0xb6, 0x3a, 0x78, 0xa3, 0xcd, 0xbd, 0xf7, 0xd0, 0xe6, 0x6d,
- 0xa1, 0xdf, 0x9d, 0x77, 0xb7, 0x85, 0xfe, 0x39, 0xec, 0xaf, 0x8b, 0xb2, 0x58, 0xd7, 0xeb, 0x98,
- 0xae, 0x60, 0xba, 0xb5, 0xfa, 0xc4, 0xa6, 0xa9, 0x37, 0x58, 0x46, 0xd3, 0xfd, 0xf5, 0x29, 0xb0,
- 0xa2, 0x4c, 0x45, 0x9d, 0xe1, 0x26, 0x9d, 0x07, 0x6e, 0x5c, 0xbd, 0x65, 0x83, 0xd0, 0x07, 0xd0,
- 0x4b, 0x65, 0x5d, 0x1a, 0x3e, 0xa4, 0xf8, 0xdd, 0xc2, 0xd2, 0xbc, 0x91, 0x23, 0x3a, 0x51, 0x61,
- 0x8e, 0x57, 0x7c, 0x8f, 0x7a, 0x35, 0x6b, 0x2c, 0xd4, 0xa5, 0x1c, 0xaf, 0x6c, 0xf4, 0x56, 0x83,
- 0xbc, 0x97, 0x53, 0xcb, 0xa1, 0x45, 0x9c, 0xf9, 0xe9, 0xed, 0x71, 0x9f, 0x51, 0xe4, 0xdb, 0xa3,
- 0xbe, 0x80, 0x59, 0x13, 0xb6, 0xed, 0x35, 0x7d, 0x23, 0x00, 0x05, 0xbd, 0xe7, 0x71, 0xf7, 0x75,
- 0xa1, 0xd9, 0x11, 0x1c, 0x34, 0x1e, 0x71, 0x85, 0x2d, 0xf3, 0xf9, 0x3e, 0xed, 0xba, 0x9f, 0x38,
- 0xb7, 0xbf, 0xa2, 0xda, 0x50, 0xa4, 0x66, 0x6b, 0x92, 0xcd, 0x11, 0x6d, 0x3b, 0xf2, 0xd8, 0x37,
- 0x56, 0x29, 0x1f, 0xc3, 0xa8, 0x3d, 0x5d, 0x08, 0x3e, 0x26, 0x0f, 0x68, 0x0e, 0x16, 0xc2, 0x8e,
- 0x4d, 0x9a, 0xa4, 0x2b, 0x8c, 0x0b, 0x83, 0x2a, 0x31, 0x52, 0xf1, 0x09, 0xf9, 0x4c, 0x08, 0x3d,
- 0xf5, 0xa0, 0xad, 0x44, 0x59, 0xaf, 0x63, 0xbd, 0x4a, 0x54, 0xa6, 0x39, 0xa3, 0x88, 0x86, 0x65,
- 0xbd, 0x3e, 0x27, 0x20, 0xfc, 0x57, 0x40, 0xdf, 0x83, 0x8e, 0xdb, 0xee, 0xb2, 0x61, 0x1f, 0x43,
- 0x57, 0xc8, 0x9c, 0x07, 0xc4, 0xcd, 0xbb, 0x1b, 0x2c, 0xb9, 0xf9, 0xc6, 0x88, 0xac, 0xc7, 0x06,
- 0xa3, 0x3a, 0xef, 0xc1, 0xa8, 0x10, 0x26, 0x22, 0xd1, 0x26, 0x6e, 0xf9, 0xe9, 0xc8, 0x3b, 0xb2,
- 0xe0, 0x89, 0xe3, 0x68, 0xf8, 0x9f, 0x80, 0x46, 0xed, 0x8d, 0xfd, 0xac, 0x89, 0x30, 0x95, 0xea,
- 0xf6, 0x4c, 0x05, 0xb7, 0x86, 0xf3, 0xd6, 0x3c, 0x74, 0x5c, 0x7e, 0xff, 0x7f, 0x1e, 0xba, 0x64,
- 0x6c, 0xe7, 0xa1, 0xe5, 0xd9, 0xce, 0x26, 0xcf, 0x1e, 0x01, 0x18, 0x69, 0x12, 0xe1, 0xee, 0xe1,
- 0x9e, 0x9b, 0x2f, 0x42, 0xe8, 0x12, 0xe6, 0xd0, 0x57, 0x14, 0x97, 0xe6, 0xbb, 0x6e, 0x3b, 0xbf,
- 0x0c, 0xff, 0xdd, 0xa1, 0x4a, 0xfa, 0xd0, 0x7f, 0x8b, 0x4c, 0xfc, 0x7c, 0xc4, 0x7b, 0xbf, 0x36,
- 0xe2, 0xbd, 0xcd, 0x11, 0x9f, 0xd9, 0xcf, 0x11, 0x51, 0x1b, 0xbb, 0xf7, 0x4a, 0xd6, 0x4a, 0x53,
- 0x0a, 0x93, 0xe3, 0xe0, 0xb3, 0x68, 0x7a, 0x63, 0xfa, 0xc6, 0x5a, 0xec, 0x25, 0xe3, 0x07, 0xa7,
- 0xd1, 0x23, 0x97, 0xd4, 0x20, 0x9a, 0x7a, 0xdc, 0x8b, 0x0e, 0x7d, 0xa0, 0xd4, 0x36, 0xb1, 0x56,
- 0xb8, 0xdc, 0xa8, 0x8f, 0x09, 0x6c, 0xa4, 0xe9, 0x29, 0x4c, 0x9a, 0x7d, 0x62, 0x59, 0x8a, 0x6b,
- 0x3f, 0xe2, 0xe3, 0x06, 0x3c, 0x2b, 0xc5, 0x75, 0x78, 0x45, 0x2a, 0xed, 0xab, 0xe4, 0x09, 0x77,
- 0x04, 0x3d, 0xda, 0xc8, 0x53, 0xee, 0xfe, 0x36, 0x8d, 0x36, 0xc8, 0x10, 0x39, 0x3f, 0xf6, 0x05,
- 0xf4, 0x75, 0xbd, 0x5e, 0x27, 0xea, 0xda, 0x33, 0xef, 0x57, 0x5e, 0x69, 0x3c, 0xbf, 0xea, 0xfd,
- 0xdd, 0x92, 0xf6, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x70, 0xd9, 0xa0, 0xf8, 0x48, 0x0d, 0x00,
- 0x00,
-}
diff --git a/vendor/google.golang.org/appengine/internal/log/log_service.proto b/vendor/google.golang.org/appengine/internal/log/log_service.proto
deleted file mode 100644
index 8981dc4757..0000000000
--- a/vendor/google.golang.org/appengine/internal/log/log_service.proto
+++ /dev/null
@@ -1,150 +0,0 @@
-syntax = "proto2";
-option go_package = "log";
-
-package appengine;
-
-message LogServiceError {
- enum ErrorCode {
- OK = 0;
- INVALID_REQUEST = 1;
- STORAGE_ERROR = 2;
- }
-}
-
-message UserAppLogLine {
- required int64 timestamp_usec = 1;
- required int64 level = 2;
- required string message = 3;
-}
-
-message UserAppLogGroup {
- repeated UserAppLogLine log_line = 2;
-}
-
-message FlushRequest {
- optional bytes logs = 1;
-}
-
-message SetStatusRequest {
- required string status = 1;
-}
-
-
-message LogOffset {
- optional bytes request_id = 1;
-}
-
-message LogLine {
- required int64 time = 1;
- required int32 level = 2;
- required string log_message = 3;
-}
-
-message RequestLog {
- required string app_id = 1;
- optional string module_id = 37 [default="default"];
- required string version_id = 2;
- required bytes request_id = 3;
- optional LogOffset offset = 35;
- required string ip = 4;
- optional string nickname = 5;
- required int64 start_time = 6;
- required int64 end_time = 7;
- required int64 latency = 8;
- required int64 mcycles = 9;
- required string method = 10;
- required string resource = 11;
- required string http_version = 12;
- required int32 status = 13;
- required int64 response_size = 14;
- optional string referrer = 15;
- optional string user_agent = 16;
- required string url_map_entry = 17;
- required string combined = 18;
- optional int64 api_mcycles = 19;
- optional string host = 20;
- optional double cost = 21;
-
- optional string task_queue_name = 22;
- optional string task_name = 23;
-
- optional bool was_loading_request = 24;
- optional int64 pending_time = 25;
- optional int32 replica_index = 26 [default = -1];
- optional bool finished = 27 [default = true];
- optional bytes clone_key = 28;
-
- repeated LogLine line = 29;
-
- optional bool lines_incomplete = 36;
- optional bytes app_engine_release = 38;
-
- optional int32 exit_reason = 30;
- optional bool was_throttled_for_time = 31;
- optional bool was_throttled_for_requests = 32;
- optional int64 throttled_time = 33;
-
- optional bytes server_name = 34;
-}
-
-message LogModuleVersion {
- optional string module_id = 1 [default="default"];
- optional string version_id = 2;
-}
-
-message LogReadRequest {
- required string app_id = 1;
- repeated string version_id = 2;
- repeated LogModuleVersion module_version = 19;
-
- optional int64 start_time = 3;
- optional int64 end_time = 4;
- optional LogOffset offset = 5;
- repeated bytes request_id = 6;
-
- optional int32 minimum_log_level = 7;
- optional bool include_incomplete = 8;
- optional int64 count = 9;
-
- optional string combined_log_regex = 14;
- optional string host_regex = 15;
- optional int32 replica_index = 16;
-
- optional bool include_app_logs = 10;
- optional int32 app_logs_per_request = 17;
- optional bool include_host = 11;
- optional bool include_all = 12;
- optional bool cache_iterator = 13;
- optional int32 num_shards = 18;
-}
-
-message LogReadResponse {
- repeated RequestLog log = 1;
- optional LogOffset offset = 2;
- optional int64 last_end_time = 3;
-}
-
-message LogUsageRecord {
- optional string version_id = 1;
- optional int32 start_time = 2;
- optional int32 end_time = 3;
- optional int64 count = 4;
- optional int64 total_size = 5;
- optional int32 records = 6;
-}
-
-message LogUsageRequest {
- required string app_id = 1;
- repeated string version_id = 2;
- optional int32 start_time = 3;
- optional int32 end_time = 4;
- optional uint32 resolution_hours = 5 [default = 1];
- optional bool combine_versions = 6;
- optional int32 usage_version = 7;
- optional bool versions_only = 8;
-}
-
-message LogUsageResponse {
- repeated LogUsageRecord usage = 1;
- optional LogUsageRecord summary = 2;
-}
diff --git a/vendor/google.golang.org/appengine/internal/main.go b/vendor/google.golang.org/appengine/internal/main.go
deleted file mode 100644
index afd0ae84fd..0000000000
--- a/vendor/google.golang.org/appengine/internal/main.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2011 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-//go:build appengine
-// +build appengine
-
-package internal
-
-import (
- "appengine_internal"
-)
-
-func Main() {
- MainPath = ""
- appengine_internal.Main()
-}
diff --git a/vendor/google.golang.org/appengine/internal/main_common.go b/vendor/google.golang.org/appengine/internal/main_common.go
deleted file mode 100644
index 357dce4dd0..0000000000
--- a/vendor/google.golang.org/appengine/internal/main_common.go
+++ /dev/null
@@ -1,7 +0,0 @@
-package internal
-
-// MainPath stores the file path of the main package. On App Engine Standard
-// using Go version 1.9 and below, this will be unset. On App Engine Flex and
-// App Engine Standard second-gen (Go 1.11 and above), this will be the
-// filepath to package main.
-var MainPath string
diff --git a/vendor/google.golang.org/appengine/internal/main_vm.go b/vendor/google.golang.org/appengine/internal/main_vm.go
deleted file mode 100644
index 86a8caf06f..0000000000
--- a/vendor/google.golang.org/appengine/internal/main_vm.go
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright 2011 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-//go:build !appengine
-// +build !appengine
-
-package internal
-
-import (
- "io"
- "log"
- "net/http"
- "net/url"
- "os"
- "path/filepath"
- "runtime"
-)
-
-func Main() {
- MainPath = filepath.Dir(findMainPath())
- installHealthChecker(http.DefaultServeMux)
-
- port := "8080"
- if s := os.Getenv("PORT"); s != "" {
- port = s
- }
-
- host := ""
- if IsDevAppServer() {
- host = "127.0.0.1"
- }
- if err := http.ListenAndServe(host+":"+port, Middleware(http.DefaultServeMux)); err != nil {
- log.Fatalf("http.ListenAndServe: %v", err)
- }
-}
-
-// Find the path to package main by looking at the root Caller.
-func findMainPath() string {
- pc := make([]uintptr, 100)
- n := runtime.Callers(2, pc)
- frames := runtime.CallersFrames(pc[:n])
- for {
- frame, more := frames.Next()
- // Tests won't have package main, instead they have testing.tRunner
- if frame.Function == "main.main" || frame.Function == "testing.tRunner" {
- return frame.File
- }
- if !more {
- break
- }
- }
- return ""
-}
-
-func installHealthChecker(mux *http.ServeMux) {
- // If no health check handler has been installed by this point, add a trivial one.
- const healthPath = "/_ah/health"
- hreq := &http.Request{
- Method: "GET",
- URL: &url.URL{
- Path: healthPath,
- },
- }
- if _, pat := mux.Handler(hreq); pat != healthPath {
- mux.HandleFunc(healthPath, func(w http.ResponseWriter, r *http.Request) {
- io.WriteString(w, "ok")
- })
- }
-}
diff --git a/vendor/google.golang.org/appengine/internal/metadata.go b/vendor/google.golang.org/appengine/internal/metadata.go
deleted file mode 100644
index c4ba63bb48..0000000000
--- a/vendor/google.golang.org/appengine/internal/metadata.go
+++ /dev/null
@@ -1,60 +0,0 @@
-// Copyright 2014 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package internal
-
-// This file has code for accessing metadata.
-//
-// References:
-// https://cloud.google.com/compute/docs/metadata
-
-import (
- "fmt"
- "io/ioutil"
- "net/http"
- "net/url"
-)
-
-const (
- metadataHost = "metadata"
- metadataPath = "/computeMetadata/v1/"
-)
-
-var (
- metadataRequestHeaders = http.Header{
- "Metadata-Flavor": []string{"Google"},
- }
-)
-
-// TODO(dsymonds): Do we need to support default values, like Python?
-func mustGetMetadata(key string) []byte {
- b, err := getMetadata(key)
- if err != nil {
- panic(fmt.Sprintf("Metadata fetch failed for '%s': %v", key, err))
- }
- return b
-}
-
-func getMetadata(key string) ([]byte, error) {
- // TODO(dsymonds): May need to use url.Parse to support keys with query args.
- req := &http.Request{
- Method: "GET",
- URL: &url.URL{
- Scheme: "http",
- Host: metadataHost,
- Path: metadataPath + key,
- },
- Header: metadataRequestHeaders,
- Host: metadataHost,
- }
- resp, err := http.DefaultClient.Do(req)
- if err != nil {
- return nil, err
- }
- defer resp.Body.Close()
- if resp.StatusCode != 200 {
- return nil, fmt.Errorf("metadata server returned HTTP %d", resp.StatusCode)
- }
- return ioutil.ReadAll(resp.Body)
-}
diff --git a/vendor/google.golang.org/appengine/internal/net.go b/vendor/google.golang.org/appengine/internal/net.go
deleted file mode 100644
index fe429720e1..0000000000
--- a/vendor/google.golang.org/appengine/internal/net.go
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2014 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package internal
-
-// This file implements a network dialer that limits the number of concurrent connections.
-// It is only used for API calls.
-
-import (
- "log"
- "net"
- "runtime"
- "sync"
- "time"
-)
-
-var limitSem = make(chan int, 100) // TODO(dsymonds): Use environment variable.
-
-func limitRelease() {
- // non-blocking
- select {
- case <-limitSem:
- default:
- // This should not normally happen.
- log.Print("appengine: unbalanced limitSem release!")
- }
-}
-
-func limitDial(network, addr string) (net.Conn, error) {
- limitSem <- 1
-
- // Dial with a timeout in case the API host is MIA.
- // The connection should normally be very fast.
- conn, err := net.DialTimeout(network, addr, 10*time.Second)
- if err != nil {
- limitRelease()
- return nil, err
- }
- lc := &limitConn{Conn: conn}
- runtime.SetFinalizer(lc, (*limitConn).Close) // shouldn't usually be required
- return lc, nil
-}
-
-type limitConn struct {
- close sync.Once
- net.Conn
-}
-
-func (lc *limitConn) Close() error {
- defer lc.close.Do(func() {
- limitRelease()
- runtime.SetFinalizer(lc, nil)
- })
- return lc.Conn.Close()
-}
diff --git a/vendor/google.golang.org/appengine/internal/regen.sh b/vendor/google.golang.org/appengine/internal/regen.sh
deleted file mode 100644
index 2fdb546a63..0000000000
--- a/vendor/google.golang.org/appengine/internal/regen.sh
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/bin/bash -e
-#
-# This script rebuilds the generated code for the protocol buffers.
-# To run this you will need protoc and goprotobuf installed;
-# see https://github.com/golang/protobuf for instructions.
-
-PKG=google.golang.org/appengine
-
-function die() {
- echo 1>&2 $*
- exit 1
-}
-
-# Sanity check that the right tools are accessible.
-for tool in go protoc protoc-gen-go; do
- q=$(which $tool) || die "didn't find $tool"
- echo 1>&2 "$tool: $q"
-done
-
-echo -n 1>&2 "finding package dir... "
-pkgdir=$(go list -f '{{.Dir}}' $PKG)
-echo 1>&2 $pkgdir
-base=$(echo $pkgdir | sed "s,/$PKG\$,,")
-echo 1>&2 "base: $base"
-cd $base
-
-# Run protoc once per package.
-for dir in $(find $PKG/internal -name '*.proto' | xargs dirname | sort | uniq); do
- echo 1>&2 "* $dir"
- protoc --go_out=. $dir/*.proto
-done
-
-for f in $(find $PKG/internal -name '*.pb.go'); do
- # Remove proto.RegisterEnum calls.
- # These cause duplicate registration panics when these packages
- # are used on classic App Engine. proto.RegisterEnum only affects
- # parsing the text format; we don't care about that.
- # https://code.google.com/p/googleappengine/issues/detail?id=11670#c17
- sed -i '/proto.RegisterEnum/d' $f
-done
diff --git a/vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go b/vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go
deleted file mode 100644
index 8d782a38e1..0000000000
--- a/vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go
+++ /dev/null
@@ -1,361 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google.golang.org/appengine/internal/remote_api/remote_api.proto
-
-package remote_api
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type RpcError_ErrorCode int32
-
-const (
- RpcError_UNKNOWN RpcError_ErrorCode = 0
- RpcError_CALL_NOT_FOUND RpcError_ErrorCode = 1
- RpcError_PARSE_ERROR RpcError_ErrorCode = 2
- RpcError_SECURITY_VIOLATION RpcError_ErrorCode = 3
- RpcError_OVER_QUOTA RpcError_ErrorCode = 4
- RpcError_REQUEST_TOO_LARGE RpcError_ErrorCode = 5
- RpcError_CAPABILITY_DISABLED RpcError_ErrorCode = 6
- RpcError_FEATURE_DISABLED RpcError_ErrorCode = 7
- RpcError_BAD_REQUEST RpcError_ErrorCode = 8
- RpcError_RESPONSE_TOO_LARGE RpcError_ErrorCode = 9
- RpcError_CANCELLED RpcError_ErrorCode = 10
- RpcError_REPLAY_ERROR RpcError_ErrorCode = 11
- RpcError_DEADLINE_EXCEEDED RpcError_ErrorCode = 12
-)
-
-var RpcError_ErrorCode_name = map[int32]string{
- 0: "UNKNOWN",
- 1: "CALL_NOT_FOUND",
- 2: "PARSE_ERROR",
- 3: "SECURITY_VIOLATION",
- 4: "OVER_QUOTA",
- 5: "REQUEST_TOO_LARGE",
- 6: "CAPABILITY_DISABLED",
- 7: "FEATURE_DISABLED",
- 8: "BAD_REQUEST",
- 9: "RESPONSE_TOO_LARGE",
- 10: "CANCELLED",
- 11: "REPLAY_ERROR",
- 12: "DEADLINE_EXCEEDED",
-}
-var RpcError_ErrorCode_value = map[string]int32{
- "UNKNOWN": 0,
- "CALL_NOT_FOUND": 1,
- "PARSE_ERROR": 2,
- "SECURITY_VIOLATION": 3,
- "OVER_QUOTA": 4,
- "REQUEST_TOO_LARGE": 5,
- "CAPABILITY_DISABLED": 6,
- "FEATURE_DISABLED": 7,
- "BAD_REQUEST": 8,
- "RESPONSE_TOO_LARGE": 9,
- "CANCELLED": 10,
- "REPLAY_ERROR": 11,
- "DEADLINE_EXCEEDED": 12,
-}
-
-func (x RpcError_ErrorCode) Enum() *RpcError_ErrorCode {
- p := new(RpcError_ErrorCode)
- *p = x
- return p
-}
-func (x RpcError_ErrorCode) String() string {
- return proto.EnumName(RpcError_ErrorCode_name, int32(x))
-}
-func (x *RpcError_ErrorCode) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(RpcError_ErrorCode_value, data, "RpcError_ErrorCode")
- if err != nil {
- return err
- }
- *x = RpcError_ErrorCode(value)
- return nil
-}
-func (RpcError_ErrorCode) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_remote_api_1978114ec33a273d, []int{2, 0}
-}
-
-type Request struct {
- ServiceName *string `protobuf:"bytes,2,req,name=service_name,json=serviceName" json:"service_name,omitempty"`
- Method *string `protobuf:"bytes,3,req,name=method" json:"method,omitempty"`
- Request []byte `protobuf:"bytes,4,req,name=request" json:"request,omitempty"`
- RequestId *string `protobuf:"bytes,5,opt,name=request_id,json=requestId" json:"request_id,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Request) Reset() { *m = Request{} }
-func (m *Request) String() string { return proto.CompactTextString(m) }
-func (*Request) ProtoMessage() {}
-func (*Request) Descriptor() ([]byte, []int) {
- return fileDescriptor_remote_api_1978114ec33a273d, []int{0}
-}
-func (m *Request) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Request.Unmarshal(m, b)
-}
-func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Request.Marshal(b, m, deterministic)
-}
-func (dst *Request) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Request.Merge(dst, src)
-}
-func (m *Request) XXX_Size() int {
- return xxx_messageInfo_Request.Size(m)
-}
-func (m *Request) XXX_DiscardUnknown() {
- xxx_messageInfo_Request.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Request proto.InternalMessageInfo
-
-func (m *Request) GetServiceName() string {
- if m != nil && m.ServiceName != nil {
- return *m.ServiceName
- }
- return ""
-}
-
-func (m *Request) GetMethod() string {
- if m != nil && m.Method != nil {
- return *m.Method
- }
- return ""
-}
-
-func (m *Request) GetRequest() []byte {
- if m != nil {
- return m.Request
- }
- return nil
-}
-
-func (m *Request) GetRequestId() string {
- if m != nil && m.RequestId != nil {
- return *m.RequestId
- }
- return ""
-}
-
-type ApplicationError struct {
- Code *int32 `protobuf:"varint,1,req,name=code" json:"code,omitempty"`
- Detail *string `protobuf:"bytes,2,req,name=detail" json:"detail,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *ApplicationError) Reset() { *m = ApplicationError{} }
-func (m *ApplicationError) String() string { return proto.CompactTextString(m) }
-func (*ApplicationError) ProtoMessage() {}
-func (*ApplicationError) Descriptor() ([]byte, []int) {
- return fileDescriptor_remote_api_1978114ec33a273d, []int{1}
-}
-func (m *ApplicationError) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_ApplicationError.Unmarshal(m, b)
-}
-func (m *ApplicationError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_ApplicationError.Marshal(b, m, deterministic)
-}
-func (dst *ApplicationError) XXX_Merge(src proto.Message) {
- xxx_messageInfo_ApplicationError.Merge(dst, src)
-}
-func (m *ApplicationError) XXX_Size() int {
- return xxx_messageInfo_ApplicationError.Size(m)
-}
-func (m *ApplicationError) XXX_DiscardUnknown() {
- xxx_messageInfo_ApplicationError.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ApplicationError proto.InternalMessageInfo
-
-func (m *ApplicationError) GetCode() int32 {
- if m != nil && m.Code != nil {
- return *m.Code
- }
- return 0
-}
-
-func (m *ApplicationError) GetDetail() string {
- if m != nil && m.Detail != nil {
- return *m.Detail
- }
- return ""
-}
-
-type RpcError struct {
- Code *int32 `protobuf:"varint,1,req,name=code" json:"code,omitempty"`
- Detail *string `protobuf:"bytes,2,opt,name=detail" json:"detail,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *RpcError) Reset() { *m = RpcError{} }
-func (m *RpcError) String() string { return proto.CompactTextString(m) }
-func (*RpcError) ProtoMessage() {}
-func (*RpcError) Descriptor() ([]byte, []int) {
- return fileDescriptor_remote_api_1978114ec33a273d, []int{2}
-}
-func (m *RpcError) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_RpcError.Unmarshal(m, b)
-}
-func (m *RpcError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_RpcError.Marshal(b, m, deterministic)
-}
-func (dst *RpcError) XXX_Merge(src proto.Message) {
- xxx_messageInfo_RpcError.Merge(dst, src)
-}
-func (m *RpcError) XXX_Size() int {
- return xxx_messageInfo_RpcError.Size(m)
-}
-func (m *RpcError) XXX_DiscardUnknown() {
- xxx_messageInfo_RpcError.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_RpcError proto.InternalMessageInfo
-
-func (m *RpcError) GetCode() int32 {
- if m != nil && m.Code != nil {
- return *m.Code
- }
- return 0
-}
-
-func (m *RpcError) GetDetail() string {
- if m != nil && m.Detail != nil {
- return *m.Detail
- }
- return ""
-}
-
-type Response struct {
- Response []byte `protobuf:"bytes,1,opt,name=response" json:"response,omitempty"`
- Exception []byte `protobuf:"bytes,2,opt,name=exception" json:"exception,omitempty"`
- ApplicationError *ApplicationError `protobuf:"bytes,3,opt,name=application_error,json=applicationError" json:"application_error,omitempty"`
- JavaException []byte `protobuf:"bytes,4,opt,name=java_exception,json=javaException" json:"java_exception,omitempty"`
- RpcError *RpcError `protobuf:"bytes,5,opt,name=rpc_error,json=rpcError" json:"rpc_error,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Response) Reset() { *m = Response{} }
-func (m *Response) String() string { return proto.CompactTextString(m) }
-func (*Response) ProtoMessage() {}
-func (*Response) Descriptor() ([]byte, []int) {
- return fileDescriptor_remote_api_1978114ec33a273d, []int{3}
-}
-func (m *Response) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Response.Unmarshal(m, b)
-}
-func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Response.Marshal(b, m, deterministic)
-}
-func (dst *Response) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Response.Merge(dst, src)
-}
-func (m *Response) XXX_Size() int {
- return xxx_messageInfo_Response.Size(m)
-}
-func (m *Response) XXX_DiscardUnknown() {
- xxx_messageInfo_Response.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Response proto.InternalMessageInfo
-
-func (m *Response) GetResponse() []byte {
- if m != nil {
- return m.Response
- }
- return nil
-}
-
-func (m *Response) GetException() []byte {
- if m != nil {
- return m.Exception
- }
- return nil
-}
-
-func (m *Response) GetApplicationError() *ApplicationError {
- if m != nil {
- return m.ApplicationError
- }
- return nil
-}
-
-func (m *Response) GetJavaException() []byte {
- if m != nil {
- return m.JavaException
- }
- return nil
-}
-
-func (m *Response) GetRpcError() *RpcError {
- if m != nil {
- return m.RpcError
- }
- return nil
-}
-
-func init() {
- proto.RegisterType((*Request)(nil), "remote_api.Request")
- proto.RegisterType((*ApplicationError)(nil), "remote_api.ApplicationError")
- proto.RegisterType((*RpcError)(nil), "remote_api.RpcError")
- proto.RegisterType((*Response)(nil), "remote_api.Response")
-}
-
-func init() {
- proto.RegisterFile("google.golang.org/appengine/internal/remote_api/remote_api.proto", fileDescriptor_remote_api_1978114ec33a273d)
-}
-
-var fileDescriptor_remote_api_1978114ec33a273d = []byte{
- // 531 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0x51, 0x6e, 0xd3, 0x40,
- 0x10, 0x86, 0xb1, 0x9b, 0x34, 0xf1, 0xc4, 0x2d, 0xdb, 0xa5, 0x14, 0x0b, 0x15, 0x29, 0x44, 0x42,
- 0xca, 0x53, 0x2a, 0x38, 0x00, 0x62, 0x63, 0x6f, 0x91, 0x85, 0x65, 0xa7, 0x6b, 0xbb, 0x50, 0x5e,
- 0x56, 0x2b, 0x67, 0x65, 0x8c, 0x12, 0xaf, 0xd9, 0x98, 0x8a, 0x17, 0x6e, 0xc0, 0xb5, 0x38, 0x0c,
- 0xb7, 0x40, 0x36, 0x6e, 0x63, 0xf5, 0x89, 0xb7, 0x7f, 0x7e, 0x7b, 0xe6, 0x1b, 0xcd, 0xcc, 0xc2,
- 0xbb, 0x5c, 0xa9, 0x7c, 0x23, 0x17, 0xb9, 0xda, 0x88, 0x32, 0x5f, 0x28, 0x9d, 0x5f, 0x88, 0xaa,
- 0x92, 0x65, 0x5e, 0x94, 0xf2, 0xa2, 0x28, 0x6b, 0xa9, 0x4b, 0xb1, 0xb9, 0xd0, 0x72, 0xab, 0x6a,
- 0xc9, 0x45, 0x55, 0xf4, 0xe4, 0xa2, 0xd2, 0xaa, 0x56, 0x18, 0xf6, 0xce, 0xec, 0x27, 0x8c, 0x98,
- 0xfc, 0xf6, 0x5d, 0xee, 0x6a, 0xfc, 0x12, 0xec, 0x9d, 0xd4, 0xb7, 0x45, 0x26, 0x79, 0x29, 0xb6,
- 0xd2, 0x31, 0xa7, 0xe6, 0xdc, 0x62, 0x93, 0xce, 0x0b, 0xc5, 0x56, 0xe2, 0x33, 0x38, 0xdc, 0xca,
- 0xfa, 0x8b, 0x5a, 0x3b, 0x07, 0xed, 0xc7, 0x2e, 0xc2, 0x0e, 0x8c, 0xf4, 0xbf, 0x2a, 0xce, 0x60,
- 0x6a, 0xce, 0x6d, 0x76, 0x17, 0xe2, 0x17, 0x00, 0x9d, 0xe4, 0xc5, 0xda, 0x19, 0x4e, 0x8d, 0xb9,
- 0xc5, 0xac, 0xce, 0xf1, 0xd7, 0xb3, 0xb7, 0x80, 0x48, 0x55, 0x6d, 0x8a, 0x4c, 0xd4, 0x85, 0x2a,
- 0xa9, 0xd6, 0x4a, 0x63, 0x0c, 0x83, 0x4c, 0xad, 0xa5, 0x63, 0x4c, 0xcd, 0xf9, 0x90, 0xb5, 0xba,
- 0x01, 0xaf, 0x65, 0x2d, 0x8a, 0x4d, 0xd7, 0x55, 0x17, 0xcd, 0x7e, 0x9b, 0x30, 0x66, 0x55, 0xf6,
- 0x7f, 0x89, 0x46, 0x2f, 0xf1, 0x97, 0x09, 0x56, 0x9b, 0xe5, 0x36, 0x7f, 0x4d, 0x60, 0x94, 0x86,
- 0x1f, 0xc2, 0xe8, 0x63, 0x88, 0x1e, 0x61, 0x0c, 0xc7, 0x2e, 0x09, 0x02, 0x1e, 0x46, 0x09, 0xbf,
- 0x8c, 0xd2, 0xd0, 0x43, 0x06, 0x7e, 0x0c, 0x93, 0x15, 0x61, 0x31, 0xe5, 0x94, 0xb1, 0x88, 0x21,
- 0x13, 0x9f, 0x01, 0x8e, 0xa9, 0x9b, 0x32, 0x3f, 0xb9, 0xe1, 0xd7, 0x7e, 0x14, 0x90, 0xc4, 0x8f,
- 0x42, 0x74, 0x80, 0x8f, 0x01, 0xa2, 0x6b, 0xca, 0xf8, 0x55, 0x1a, 0x25, 0x04, 0x0d, 0xf0, 0x53,
- 0x38, 0x61, 0xf4, 0x2a, 0xa5, 0x71, 0xc2, 0x93, 0x28, 0xe2, 0x01, 0x61, 0xef, 0x29, 0x1a, 0xe2,
- 0x67, 0xf0, 0xc4, 0x25, 0x2b, 0xb2, 0xf4, 0x83, 0xa6, 0x80, 0xe7, 0xc7, 0x64, 0x19, 0x50, 0x0f,
- 0x1d, 0xe2, 0x53, 0x40, 0x97, 0x94, 0x24, 0x29, 0xa3, 0x7b, 0x77, 0xd4, 0xe0, 0x97, 0xc4, 0xe3,
- 0x5d, 0x25, 0x34, 0x6e, 0xf0, 0x8c, 0xc6, 0xab, 0x28, 0x8c, 0x69, 0xaf, 0xae, 0x85, 0x8f, 0xc0,
- 0x72, 0x49, 0xe8, 0xd2, 0xa0, 0xc9, 0x03, 0x8c, 0xc0, 0x66, 0x74, 0x15, 0x90, 0x9b, 0xae, 0xef,
- 0x49, 0xd3, 0x8f, 0x47, 0x89, 0x17, 0xf8, 0x21, 0xe5, 0xf4, 0x93, 0x4b, 0xa9, 0x47, 0x3d, 0x64,
- 0xcf, 0xfe, 0x18, 0x30, 0x66, 0x72, 0x57, 0xa9, 0x72, 0x27, 0xf1, 0x73, 0x18, 0xeb, 0x4e, 0x3b,
- 0xc6, 0xd4, 0x98, 0xdb, 0xec, 0x3e, 0xc6, 0xe7, 0x60, 0xc9, 0x1f, 0x99, 0xac, 0x9a, 0x75, 0xb5,
- 0x23, 0xb5, 0xd9, 0xde, 0xc0, 0x3e, 0x9c, 0x88, 0xfd, 0x3a, 0xb9, 0x6c, 0x06, 0xec, 0x1c, 0x4c,
- 0x8d, 0xf9, 0xe4, 0xcd, 0xf9, 0xa2, 0x77, 0x87, 0x0f, 0x77, 0xce, 0x90, 0x78, 0x78, 0x05, 0xaf,
- 0xe0, 0xf8, 0xab, 0xb8, 0x15, 0x7c, 0x4f, 0x1b, 0xb4, 0xb4, 0xa3, 0xc6, 0xa5, 0xf7, 0xc4, 0xd7,
- 0x60, 0xe9, 0x2a, 0xeb, 0x48, 0xc3, 0x96, 0x74, 0xda, 0x27, 0xdd, 0x1d, 0x07, 0x1b, 0xeb, 0x4e,
- 0x2d, 0xed, 0xcf, 0xbd, 0x07, 0xf0, 0x37, 0x00, 0x00, 0xff, 0xff, 0x38, 0xd1, 0x0f, 0x22, 0x4f,
- 0x03, 0x00, 0x00,
-}
diff --git a/vendor/google.golang.org/appengine/internal/remote_api/remote_api.proto b/vendor/google.golang.org/appengine/internal/remote_api/remote_api.proto
deleted file mode 100644
index f21763a4e2..0000000000
--- a/vendor/google.golang.org/appengine/internal/remote_api/remote_api.proto
+++ /dev/null
@@ -1,44 +0,0 @@
-syntax = "proto2";
-option go_package = "remote_api";
-
-package remote_api;
-
-message Request {
- required string service_name = 2;
- required string method = 3;
- required bytes request = 4;
- optional string request_id = 5;
-}
-
-message ApplicationError {
- required int32 code = 1;
- required string detail = 2;
-}
-
-message RpcError {
- enum ErrorCode {
- UNKNOWN = 0;
- CALL_NOT_FOUND = 1;
- PARSE_ERROR = 2;
- SECURITY_VIOLATION = 3;
- OVER_QUOTA = 4;
- REQUEST_TOO_LARGE = 5;
- CAPABILITY_DISABLED = 6;
- FEATURE_DISABLED = 7;
- BAD_REQUEST = 8;
- RESPONSE_TOO_LARGE = 9;
- CANCELLED = 10;
- REPLAY_ERROR = 11;
- DEADLINE_EXCEEDED = 12;
- }
- required int32 code = 1;
- optional string detail = 2;
-}
-
-message Response {
- optional bytes response = 1;
- optional bytes exception = 2;
- optional ApplicationError application_error = 3;
- optional bytes java_exception = 4;
- optional RpcError rpc_error = 5;
-}
diff --git a/vendor/google.golang.org/appengine/internal/transaction.go b/vendor/google.golang.org/appengine/internal/transaction.go
deleted file mode 100644
index 2ae8ab9fa4..0000000000
--- a/vendor/google.golang.org/appengine/internal/transaction.go
+++ /dev/null
@@ -1,115 +0,0 @@
-// Copyright 2014 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package internal
-
-// This file implements hooks for applying datastore transactions.
-
-import (
- "context"
- "errors"
- "reflect"
-
- "github.com/golang/protobuf/proto"
-
- basepb "google.golang.org/appengine/internal/base"
- pb "google.golang.org/appengine/internal/datastore"
-)
-
-var transactionSetters = make(map[reflect.Type]reflect.Value)
-
-// RegisterTransactionSetter registers a function that sets transaction information
-// in a protocol buffer message. f should be a function with two arguments,
-// the first being a protocol buffer type, and the second being *datastore.Transaction.
-func RegisterTransactionSetter(f interface{}) {
- v := reflect.ValueOf(f)
- transactionSetters[v.Type().In(0)] = v
-}
-
-// applyTransaction applies the transaction t to message pb
-// by using the relevant setter passed to RegisterTransactionSetter.
-func applyTransaction(pb proto.Message, t *pb.Transaction) {
- v := reflect.ValueOf(pb)
- if f, ok := transactionSetters[v.Type()]; ok {
- f.Call([]reflect.Value{v, reflect.ValueOf(t)})
- }
-}
-
-var transactionKey = "used for *Transaction"
-
-func transactionFromContext(ctx context.Context) *transaction {
- t, _ := ctx.Value(&transactionKey).(*transaction)
- return t
-}
-
-func withTransaction(ctx context.Context, t *transaction) context.Context {
- return context.WithValue(ctx, &transactionKey, t)
-}
-
-type transaction struct {
- transaction pb.Transaction
- finished bool
-}
-
-var ErrConcurrentTransaction = errors.New("internal: concurrent transaction")
-
-func RunTransactionOnce(c context.Context, f func(context.Context) error, xg bool, readOnly bool, previousTransaction *pb.Transaction) (*pb.Transaction, error) {
- if transactionFromContext(c) != nil {
- return nil, errors.New("nested transactions are not supported")
- }
-
- // Begin the transaction.
- t := &transaction{}
- req := &pb.BeginTransactionRequest{
- App: proto.String(FullyQualifiedAppID(c)),
- }
- if xg {
- req.AllowMultipleEg = proto.Bool(true)
- }
- if previousTransaction != nil {
- req.PreviousTransaction = previousTransaction
- }
- if readOnly {
- req.Mode = pb.BeginTransactionRequest_READ_ONLY.Enum()
- } else {
- req.Mode = pb.BeginTransactionRequest_READ_WRITE.Enum()
- }
- if err := Call(c, "datastore_v3", "BeginTransaction", req, &t.transaction); err != nil {
- return nil, err
- }
-
- // Call f, rolling back the transaction if f returns a non-nil error, or panics.
- // The panic is not recovered.
- defer func() {
- if t.finished {
- return
- }
- t.finished = true
- // Ignore the error return value, since we are already returning a non-nil
- // error (or we're panicking).
- Call(c, "datastore_v3", "Rollback", &t.transaction, &basepb.VoidProto{})
- }()
- if err := f(withTransaction(c, t)); err != nil {
- return &t.transaction, err
- }
- t.finished = true
-
- // Commit the transaction.
- res := &pb.CommitResponse{}
- err := Call(c, "datastore_v3", "Commit", &t.transaction, res)
- if ae, ok := err.(*APIError); ok {
- /* TODO: restore this conditional
- if appengine.IsDevAppServer() {
- */
- // The Python Dev AppServer raises an ApplicationError with error code 2 (which is
- // Error.CONCURRENT_TRANSACTION) and message "Concurrency exception.".
- if ae.Code == int32(pb.Error_BAD_REQUEST) && ae.Detail == "ApplicationError: 2 Concurrency exception." {
- return &t.transaction, ErrConcurrentTransaction
- }
- if ae.Code == int32(pb.Error_CONCURRENT_TRANSACTION) {
- return &t.transaction, ErrConcurrentTransaction
- }
- }
- return &t.transaction, err
-}
diff --git a/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.pb.go b/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.pb.go
deleted file mode 100644
index 5f727750ad..0000000000
--- a/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.pb.go
+++ /dev/null
@@ -1,527 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto
-
-package urlfetch
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type URLFetchServiceError_ErrorCode int32
-
-const (
- URLFetchServiceError_OK URLFetchServiceError_ErrorCode = 0
- URLFetchServiceError_INVALID_URL URLFetchServiceError_ErrorCode = 1
- URLFetchServiceError_FETCH_ERROR URLFetchServiceError_ErrorCode = 2
- URLFetchServiceError_UNSPECIFIED_ERROR URLFetchServiceError_ErrorCode = 3
- URLFetchServiceError_RESPONSE_TOO_LARGE URLFetchServiceError_ErrorCode = 4
- URLFetchServiceError_DEADLINE_EXCEEDED URLFetchServiceError_ErrorCode = 5
- URLFetchServiceError_SSL_CERTIFICATE_ERROR URLFetchServiceError_ErrorCode = 6
- URLFetchServiceError_DNS_ERROR URLFetchServiceError_ErrorCode = 7
- URLFetchServiceError_CLOSED URLFetchServiceError_ErrorCode = 8
- URLFetchServiceError_INTERNAL_TRANSIENT_ERROR URLFetchServiceError_ErrorCode = 9
- URLFetchServiceError_TOO_MANY_REDIRECTS URLFetchServiceError_ErrorCode = 10
- URLFetchServiceError_MALFORMED_REPLY URLFetchServiceError_ErrorCode = 11
- URLFetchServiceError_CONNECTION_ERROR URLFetchServiceError_ErrorCode = 12
-)
-
-var URLFetchServiceError_ErrorCode_name = map[int32]string{
- 0: "OK",
- 1: "INVALID_URL",
- 2: "FETCH_ERROR",
- 3: "UNSPECIFIED_ERROR",
- 4: "RESPONSE_TOO_LARGE",
- 5: "DEADLINE_EXCEEDED",
- 6: "SSL_CERTIFICATE_ERROR",
- 7: "DNS_ERROR",
- 8: "CLOSED",
- 9: "INTERNAL_TRANSIENT_ERROR",
- 10: "TOO_MANY_REDIRECTS",
- 11: "MALFORMED_REPLY",
- 12: "CONNECTION_ERROR",
-}
-var URLFetchServiceError_ErrorCode_value = map[string]int32{
- "OK": 0,
- "INVALID_URL": 1,
- "FETCH_ERROR": 2,
- "UNSPECIFIED_ERROR": 3,
- "RESPONSE_TOO_LARGE": 4,
- "DEADLINE_EXCEEDED": 5,
- "SSL_CERTIFICATE_ERROR": 6,
- "DNS_ERROR": 7,
- "CLOSED": 8,
- "INTERNAL_TRANSIENT_ERROR": 9,
- "TOO_MANY_REDIRECTS": 10,
- "MALFORMED_REPLY": 11,
- "CONNECTION_ERROR": 12,
-}
-
-func (x URLFetchServiceError_ErrorCode) Enum() *URLFetchServiceError_ErrorCode {
- p := new(URLFetchServiceError_ErrorCode)
- *p = x
- return p
-}
-func (x URLFetchServiceError_ErrorCode) String() string {
- return proto.EnumName(URLFetchServiceError_ErrorCode_name, int32(x))
-}
-func (x *URLFetchServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(URLFetchServiceError_ErrorCode_value, data, "URLFetchServiceError_ErrorCode")
- if err != nil {
- return err
- }
- *x = URLFetchServiceError_ErrorCode(value)
- return nil
-}
-func (URLFetchServiceError_ErrorCode) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{0, 0}
-}
-
-type URLFetchRequest_RequestMethod int32
-
-const (
- URLFetchRequest_GET URLFetchRequest_RequestMethod = 1
- URLFetchRequest_POST URLFetchRequest_RequestMethod = 2
- URLFetchRequest_HEAD URLFetchRequest_RequestMethod = 3
- URLFetchRequest_PUT URLFetchRequest_RequestMethod = 4
- URLFetchRequest_DELETE URLFetchRequest_RequestMethod = 5
- URLFetchRequest_PATCH URLFetchRequest_RequestMethod = 6
-)
-
-var URLFetchRequest_RequestMethod_name = map[int32]string{
- 1: "GET",
- 2: "POST",
- 3: "HEAD",
- 4: "PUT",
- 5: "DELETE",
- 6: "PATCH",
-}
-var URLFetchRequest_RequestMethod_value = map[string]int32{
- "GET": 1,
- "POST": 2,
- "HEAD": 3,
- "PUT": 4,
- "DELETE": 5,
- "PATCH": 6,
-}
-
-func (x URLFetchRequest_RequestMethod) Enum() *URLFetchRequest_RequestMethod {
- p := new(URLFetchRequest_RequestMethod)
- *p = x
- return p
-}
-func (x URLFetchRequest_RequestMethod) String() string {
- return proto.EnumName(URLFetchRequest_RequestMethod_name, int32(x))
-}
-func (x *URLFetchRequest_RequestMethod) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(URLFetchRequest_RequestMethod_value, data, "URLFetchRequest_RequestMethod")
- if err != nil {
- return err
- }
- *x = URLFetchRequest_RequestMethod(value)
- return nil
-}
-func (URLFetchRequest_RequestMethod) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{1, 0}
-}
-
-type URLFetchServiceError struct {
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *URLFetchServiceError) Reset() { *m = URLFetchServiceError{} }
-func (m *URLFetchServiceError) String() string { return proto.CompactTextString(m) }
-func (*URLFetchServiceError) ProtoMessage() {}
-func (*URLFetchServiceError) Descriptor() ([]byte, []int) {
- return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{0}
-}
-func (m *URLFetchServiceError) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_URLFetchServiceError.Unmarshal(m, b)
-}
-func (m *URLFetchServiceError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_URLFetchServiceError.Marshal(b, m, deterministic)
-}
-func (dst *URLFetchServiceError) XXX_Merge(src proto.Message) {
- xxx_messageInfo_URLFetchServiceError.Merge(dst, src)
-}
-func (m *URLFetchServiceError) XXX_Size() int {
- return xxx_messageInfo_URLFetchServiceError.Size(m)
-}
-func (m *URLFetchServiceError) XXX_DiscardUnknown() {
- xxx_messageInfo_URLFetchServiceError.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_URLFetchServiceError proto.InternalMessageInfo
-
-type URLFetchRequest struct {
- Method *URLFetchRequest_RequestMethod `protobuf:"varint,1,req,name=Method,enum=appengine.URLFetchRequest_RequestMethod" json:"Method,omitempty"`
- Url *string `protobuf:"bytes,2,req,name=Url" json:"Url,omitempty"`
- Header []*URLFetchRequest_Header `protobuf:"group,3,rep,name=Header,json=header" json:"header,omitempty"`
- Payload []byte `protobuf:"bytes,6,opt,name=Payload" json:"Payload,omitempty"`
- FollowRedirects *bool `protobuf:"varint,7,opt,name=FollowRedirects,def=1" json:"FollowRedirects,omitempty"`
- Deadline *float64 `protobuf:"fixed64,8,opt,name=Deadline" json:"Deadline,omitempty"`
- MustValidateServerCertificate *bool `protobuf:"varint,9,opt,name=MustValidateServerCertificate,def=1" json:"MustValidateServerCertificate,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *URLFetchRequest) Reset() { *m = URLFetchRequest{} }
-func (m *URLFetchRequest) String() string { return proto.CompactTextString(m) }
-func (*URLFetchRequest) ProtoMessage() {}
-func (*URLFetchRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{1}
-}
-func (m *URLFetchRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_URLFetchRequest.Unmarshal(m, b)
-}
-func (m *URLFetchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_URLFetchRequest.Marshal(b, m, deterministic)
-}
-func (dst *URLFetchRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_URLFetchRequest.Merge(dst, src)
-}
-func (m *URLFetchRequest) XXX_Size() int {
- return xxx_messageInfo_URLFetchRequest.Size(m)
-}
-func (m *URLFetchRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_URLFetchRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_URLFetchRequest proto.InternalMessageInfo
-
-const Default_URLFetchRequest_FollowRedirects bool = true
-const Default_URLFetchRequest_MustValidateServerCertificate bool = true
-
-func (m *URLFetchRequest) GetMethod() URLFetchRequest_RequestMethod {
- if m != nil && m.Method != nil {
- return *m.Method
- }
- return URLFetchRequest_GET
-}
-
-func (m *URLFetchRequest) GetUrl() string {
- if m != nil && m.Url != nil {
- return *m.Url
- }
- return ""
-}
-
-func (m *URLFetchRequest) GetHeader() []*URLFetchRequest_Header {
- if m != nil {
- return m.Header
- }
- return nil
-}
-
-func (m *URLFetchRequest) GetPayload() []byte {
- if m != nil {
- return m.Payload
- }
- return nil
-}
-
-func (m *URLFetchRequest) GetFollowRedirects() bool {
- if m != nil && m.FollowRedirects != nil {
- return *m.FollowRedirects
- }
- return Default_URLFetchRequest_FollowRedirects
-}
-
-func (m *URLFetchRequest) GetDeadline() float64 {
- if m != nil && m.Deadline != nil {
- return *m.Deadline
- }
- return 0
-}
-
-func (m *URLFetchRequest) GetMustValidateServerCertificate() bool {
- if m != nil && m.MustValidateServerCertificate != nil {
- return *m.MustValidateServerCertificate
- }
- return Default_URLFetchRequest_MustValidateServerCertificate
-}
-
-type URLFetchRequest_Header struct {
- Key *string `protobuf:"bytes,4,req,name=Key" json:"Key,omitempty"`
- Value *string `protobuf:"bytes,5,req,name=Value" json:"Value,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *URLFetchRequest_Header) Reset() { *m = URLFetchRequest_Header{} }
-func (m *URLFetchRequest_Header) String() string { return proto.CompactTextString(m) }
-func (*URLFetchRequest_Header) ProtoMessage() {}
-func (*URLFetchRequest_Header) Descriptor() ([]byte, []int) {
- return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{1, 0}
-}
-func (m *URLFetchRequest_Header) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_URLFetchRequest_Header.Unmarshal(m, b)
-}
-func (m *URLFetchRequest_Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_URLFetchRequest_Header.Marshal(b, m, deterministic)
-}
-func (dst *URLFetchRequest_Header) XXX_Merge(src proto.Message) {
- xxx_messageInfo_URLFetchRequest_Header.Merge(dst, src)
-}
-func (m *URLFetchRequest_Header) XXX_Size() int {
- return xxx_messageInfo_URLFetchRequest_Header.Size(m)
-}
-func (m *URLFetchRequest_Header) XXX_DiscardUnknown() {
- xxx_messageInfo_URLFetchRequest_Header.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_URLFetchRequest_Header proto.InternalMessageInfo
-
-func (m *URLFetchRequest_Header) GetKey() string {
- if m != nil && m.Key != nil {
- return *m.Key
- }
- return ""
-}
-
-func (m *URLFetchRequest_Header) GetValue() string {
- if m != nil && m.Value != nil {
- return *m.Value
- }
- return ""
-}
-
-type URLFetchResponse struct {
- Content []byte `protobuf:"bytes,1,opt,name=Content" json:"Content,omitempty"`
- StatusCode *int32 `protobuf:"varint,2,req,name=StatusCode" json:"StatusCode,omitempty"`
- Header []*URLFetchResponse_Header `protobuf:"group,3,rep,name=Header,json=header" json:"header,omitempty"`
- ContentWasTruncated *bool `protobuf:"varint,6,opt,name=ContentWasTruncated,def=0" json:"ContentWasTruncated,omitempty"`
- ExternalBytesSent *int64 `protobuf:"varint,7,opt,name=ExternalBytesSent" json:"ExternalBytesSent,omitempty"`
- ExternalBytesReceived *int64 `protobuf:"varint,8,opt,name=ExternalBytesReceived" json:"ExternalBytesReceived,omitempty"`
- FinalUrl *string `protobuf:"bytes,9,opt,name=FinalUrl" json:"FinalUrl,omitempty"`
- ApiCpuMilliseconds *int64 `protobuf:"varint,10,opt,name=ApiCpuMilliseconds,def=0" json:"ApiCpuMilliseconds,omitempty"`
- ApiBytesSent *int64 `protobuf:"varint,11,opt,name=ApiBytesSent,def=0" json:"ApiBytesSent,omitempty"`
- ApiBytesReceived *int64 `protobuf:"varint,12,opt,name=ApiBytesReceived,def=0" json:"ApiBytesReceived,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *URLFetchResponse) Reset() { *m = URLFetchResponse{} }
-func (m *URLFetchResponse) String() string { return proto.CompactTextString(m) }
-func (*URLFetchResponse) ProtoMessage() {}
-func (*URLFetchResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{2}
-}
-func (m *URLFetchResponse) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_URLFetchResponse.Unmarshal(m, b)
-}
-func (m *URLFetchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_URLFetchResponse.Marshal(b, m, deterministic)
-}
-func (dst *URLFetchResponse) XXX_Merge(src proto.Message) {
- xxx_messageInfo_URLFetchResponse.Merge(dst, src)
-}
-func (m *URLFetchResponse) XXX_Size() int {
- return xxx_messageInfo_URLFetchResponse.Size(m)
-}
-func (m *URLFetchResponse) XXX_DiscardUnknown() {
- xxx_messageInfo_URLFetchResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_URLFetchResponse proto.InternalMessageInfo
-
-const Default_URLFetchResponse_ContentWasTruncated bool = false
-const Default_URLFetchResponse_ApiCpuMilliseconds int64 = 0
-const Default_URLFetchResponse_ApiBytesSent int64 = 0
-const Default_URLFetchResponse_ApiBytesReceived int64 = 0
-
-func (m *URLFetchResponse) GetContent() []byte {
- if m != nil {
- return m.Content
- }
- return nil
-}
-
-func (m *URLFetchResponse) GetStatusCode() int32 {
- if m != nil && m.StatusCode != nil {
- return *m.StatusCode
- }
- return 0
-}
-
-func (m *URLFetchResponse) GetHeader() []*URLFetchResponse_Header {
- if m != nil {
- return m.Header
- }
- return nil
-}
-
-func (m *URLFetchResponse) GetContentWasTruncated() bool {
- if m != nil && m.ContentWasTruncated != nil {
- return *m.ContentWasTruncated
- }
- return Default_URLFetchResponse_ContentWasTruncated
-}
-
-func (m *URLFetchResponse) GetExternalBytesSent() int64 {
- if m != nil && m.ExternalBytesSent != nil {
- return *m.ExternalBytesSent
- }
- return 0
-}
-
-func (m *URLFetchResponse) GetExternalBytesReceived() int64 {
- if m != nil && m.ExternalBytesReceived != nil {
- return *m.ExternalBytesReceived
- }
- return 0
-}
-
-func (m *URLFetchResponse) GetFinalUrl() string {
- if m != nil && m.FinalUrl != nil {
- return *m.FinalUrl
- }
- return ""
-}
-
-func (m *URLFetchResponse) GetApiCpuMilliseconds() int64 {
- if m != nil && m.ApiCpuMilliseconds != nil {
- return *m.ApiCpuMilliseconds
- }
- return Default_URLFetchResponse_ApiCpuMilliseconds
-}
-
-func (m *URLFetchResponse) GetApiBytesSent() int64 {
- if m != nil && m.ApiBytesSent != nil {
- return *m.ApiBytesSent
- }
- return Default_URLFetchResponse_ApiBytesSent
-}
-
-func (m *URLFetchResponse) GetApiBytesReceived() int64 {
- if m != nil && m.ApiBytesReceived != nil {
- return *m.ApiBytesReceived
- }
- return Default_URLFetchResponse_ApiBytesReceived
-}
-
-type URLFetchResponse_Header struct {
- Key *string `protobuf:"bytes,4,req,name=Key" json:"Key,omitempty"`
- Value *string `protobuf:"bytes,5,req,name=Value" json:"Value,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *URLFetchResponse_Header) Reset() { *m = URLFetchResponse_Header{} }
-func (m *URLFetchResponse_Header) String() string { return proto.CompactTextString(m) }
-func (*URLFetchResponse_Header) ProtoMessage() {}
-func (*URLFetchResponse_Header) Descriptor() ([]byte, []int) {
- return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{2, 0}
-}
-func (m *URLFetchResponse_Header) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_URLFetchResponse_Header.Unmarshal(m, b)
-}
-func (m *URLFetchResponse_Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_URLFetchResponse_Header.Marshal(b, m, deterministic)
-}
-func (dst *URLFetchResponse_Header) XXX_Merge(src proto.Message) {
- xxx_messageInfo_URLFetchResponse_Header.Merge(dst, src)
-}
-func (m *URLFetchResponse_Header) XXX_Size() int {
- return xxx_messageInfo_URLFetchResponse_Header.Size(m)
-}
-func (m *URLFetchResponse_Header) XXX_DiscardUnknown() {
- xxx_messageInfo_URLFetchResponse_Header.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_URLFetchResponse_Header proto.InternalMessageInfo
-
-func (m *URLFetchResponse_Header) GetKey() string {
- if m != nil && m.Key != nil {
- return *m.Key
- }
- return ""
-}
-
-func (m *URLFetchResponse_Header) GetValue() string {
- if m != nil && m.Value != nil {
- return *m.Value
- }
- return ""
-}
-
-func init() {
- proto.RegisterType((*URLFetchServiceError)(nil), "appengine.URLFetchServiceError")
- proto.RegisterType((*URLFetchRequest)(nil), "appengine.URLFetchRequest")
- proto.RegisterType((*URLFetchRequest_Header)(nil), "appengine.URLFetchRequest.Header")
- proto.RegisterType((*URLFetchResponse)(nil), "appengine.URLFetchResponse")
- proto.RegisterType((*URLFetchResponse_Header)(nil), "appengine.URLFetchResponse.Header")
-}
-
-func init() {
- proto.RegisterFile("google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto", fileDescriptor_urlfetch_service_b245a7065f33bced)
-}
-
-var fileDescriptor_urlfetch_service_b245a7065f33bced = []byte{
- // 770 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xdd, 0x6e, 0xe3, 0x54,
- 0x10, 0xc6, 0x76, 0x7e, 0xa7, 0x5d, 0x7a, 0x76, 0xb6, 0x45, 0x66, 0xb5, 0xa0, 0x10, 0x09, 0x29,
- 0x17, 0x90, 0x2e, 0x2b, 0x24, 0x44, 0xaf, 0x70, 0xed, 0x93, 0xad, 0xa9, 0x63, 0x47, 0xc7, 0x4e,
- 0x61, 0xb9, 0xb1, 0xac, 0x78, 0x9a, 0x5a, 0xb2, 0xec, 0x60, 0x9f, 0x2c, 0xf4, 0x35, 0x78, 0x0d,
- 0xde, 0x87, 0xa7, 0xe1, 0x02, 0x9d, 0xc4, 0xc9, 0x6e, 0xbb, 0xd1, 0x4a, 0x5c, 0x65, 0xe6, 0x9b,
- 0xef, 0xcc, 0x99, 0x7c, 0xdf, 0xf8, 0x80, 0xb3, 0x2c, 0xcb, 0x65, 0x4e, 0xe3, 0x65, 0x99, 0x27,
- 0xc5, 0x72, 0x5c, 0x56, 0xcb, 0xf3, 0x64, 0xb5, 0xa2, 0x62, 0x99, 0x15, 0x74, 0x9e, 0x15, 0x92,
- 0xaa, 0x22, 0xc9, 0xcf, 0xd7, 0x55, 0x7e, 0x4b, 0x72, 0x71, 0xb7, 0x0f, 0xe2, 0x9a, 0xaa, 0xb7,
- 0xd9, 0x82, 0xc6, 0xab, 0xaa, 0x94, 0x25, 0xf6, 0xf7, 0x67, 0x86, 0x7f, 0xeb, 0x70, 0x3a, 0x17,
- 0xde, 0x44, 0xb1, 0xc2, 0x2d, 0x89, 0x57, 0x55, 0x59, 0x0d, 0xff, 0xd2, 0xa1, 0xbf, 0x89, 0xec,
- 0x32, 0x25, 0xec, 0x80, 0x1e, 0x5c, 0xb3, 0x4f, 0xf0, 0x04, 0x8e, 0x5c, 0xff, 0xc6, 0xf2, 0x5c,
- 0x27, 0x9e, 0x0b, 0x8f, 0x69, 0x0a, 0x98, 0xf0, 0xc8, 0xbe, 0x8a, 0xb9, 0x10, 0x81, 0x60, 0x3a,
- 0x9e, 0xc1, 0xd3, 0xb9, 0x1f, 0xce, 0xb8, 0xed, 0x4e, 0x5c, 0xee, 0x34, 0xb0, 0x81, 0x9f, 0x01,
- 0x0a, 0x1e, 0xce, 0x02, 0x3f, 0xe4, 0x71, 0x14, 0x04, 0xb1, 0x67, 0x89, 0xd7, 0x9c, 0xb5, 0x14,
- 0xdd, 0xe1, 0x96, 0xe3, 0xb9, 0x3e, 0x8f, 0xf9, 0xaf, 0x36, 0xe7, 0x0e, 0x77, 0x58, 0x1b, 0x3f,
- 0x87, 0xb3, 0x30, 0xf4, 0x62, 0x9b, 0x8b, 0xc8, 0x9d, 0xb8, 0xb6, 0x15, 0xf1, 0xa6, 0x53, 0x07,
- 0x9f, 0x40, 0xdf, 0xf1, 0xc3, 0x26, 0xed, 0x22, 0x40, 0xc7, 0xf6, 0x82, 0x90, 0x3b, 0xac, 0x87,
- 0x2f, 0xc0, 0x74, 0xfd, 0x88, 0x0b, 0xdf, 0xf2, 0xe2, 0x48, 0x58, 0x7e, 0xe8, 0x72, 0x3f, 0x6a,
- 0x98, 0x7d, 0x35, 0x82, 0xba, 0x79, 0x6a, 0xf9, 0x6f, 0x62, 0xc1, 0x1d, 0x57, 0x70, 0x3b, 0x0a,
- 0x19, 0xe0, 0x33, 0x38, 0x99, 0x5a, 0xde, 0x24, 0x10, 0x53, 0xee, 0xc4, 0x82, 0xcf, 0xbc, 0x37,
- 0xec, 0x08, 0x4f, 0x81, 0xd9, 0x81, 0xef, 0x73, 0x3b, 0x72, 0x03, 0xbf, 0x69, 0x71, 0x3c, 0xfc,
- 0xc7, 0x80, 0x93, 0x9d, 0x5a, 0x82, 0x7e, 0x5f, 0x53, 0x2d, 0xf1, 0x27, 0xe8, 0x4c, 0x49, 0xde,
- 0x95, 0xa9, 0xa9, 0x0d, 0xf4, 0xd1, 0xa7, 0xaf, 0x46, 0xe3, 0xbd, 0xba, 0xe3, 0x47, 0xdc, 0x71,
- 0xf3, 0xbb, 0xe5, 0x8b, 0xe6, 0x1c, 0x32, 0x30, 0xe6, 0x55, 0x6e, 0xea, 0x03, 0x7d, 0xd4, 0x17,
- 0x2a, 0xc4, 0x1f, 0xa1, 0x73, 0x47, 0x49, 0x4a, 0x95, 0x69, 0x0c, 0x8c, 0x11, 0xbc, 0xfa, 0xea,
- 0x23, 0x3d, 0xaf, 0x36, 0x44, 0xd1, 0x1c, 0xc0, 0x17, 0xd0, 0x9d, 0x25, 0xf7, 0x79, 0x99, 0xa4,
- 0x66, 0x67, 0xa0, 0x8d, 0x8e, 0x2f, 0xf5, 0x9e, 0x26, 0x76, 0x10, 0x8e, 0xe1, 0x64, 0x52, 0xe6,
- 0x79, 0xf9, 0x87, 0xa0, 0x34, 0xab, 0x68, 0x21, 0x6b, 0xb3, 0x3b, 0xd0, 0x46, 0xbd, 0x8b, 0x96,
- 0xac, 0xd6, 0x24, 0x1e, 0x17, 0xf1, 0x39, 0xf4, 0x1c, 0x4a, 0xd2, 0x3c, 0x2b, 0xc8, 0xec, 0x0d,
- 0xb4, 0x91, 0x26, 0xf6, 0x39, 0xfe, 0x0c, 0x5f, 0x4c, 0xd7, 0xb5, 0xbc, 0x49, 0xf2, 0x2c, 0x4d,
- 0x24, 0xa9, 0xed, 0xa1, 0xca, 0xa6, 0x4a, 0x66, 0xb7, 0xd9, 0x22, 0x91, 0x64, 0xf6, 0xdf, 0xeb,
- 0xfc, 0x71, 0xea, 0xf3, 0x97, 0xd0, 0xd9, 0xfe, 0x0f, 0x25, 0xc6, 0x35, 0xdd, 0x9b, 0xad, 0xad,
- 0x18, 0xd7, 0x74, 0x8f, 0xa7, 0xd0, 0xbe, 0x49, 0xf2, 0x35, 0x99, 0xed, 0x0d, 0xb6, 0x4d, 0x86,
- 0x1e, 0x3c, 0x79, 0xa0, 0x26, 0x76, 0xc1, 0x78, 0xcd, 0x23, 0xa6, 0x61, 0x0f, 0x5a, 0xb3, 0x20,
- 0x8c, 0x98, 0xae, 0xa2, 0x2b, 0x6e, 0x39, 0xcc, 0x50, 0xc5, 0xd9, 0x3c, 0x62, 0x2d, 0xb5, 0x2e,
- 0x0e, 0xf7, 0x78, 0xc4, 0x59, 0x1b, 0xfb, 0xd0, 0x9e, 0x59, 0x91, 0x7d, 0xc5, 0x3a, 0xc3, 0x7f,
- 0x0d, 0x60, 0xef, 0x84, 0xad, 0x57, 0x65, 0x51, 0x13, 0x9a, 0xd0, 0xb5, 0xcb, 0x42, 0x52, 0x21,
- 0x4d, 0x4d, 0x49, 0x29, 0x76, 0x29, 0x7e, 0x09, 0x10, 0xca, 0x44, 0xae, 0x6b, 0xf5, 0x71, 0x6c,
- 0x8c, 0x6b, 0x8b, 0xf7, 0x10, 0xbc, 0x78, 0xe4, 0xdf, 0xf0, 0xa0, 0x7f, 0xdb, 0x6b, 0x1e, 0x1b,
- 0xf8, 0x03, 0x3c, 0x6b, 0xae, 0xf9, 0x25, 0xa9, 0xa3, 0x6a, 0x5d, 0x28, 0x81, 0xb6, 0x66, 0xf6,
- 0x2e, 0xda, 0xb7, 0x49, 0x5e, 0x93, 0x38, 0xc4, 0xc0, 0x6f, 0xe0, 0x29, 0xff, 0x73, 0xfb, 0x02,
- 0x5c, 0xde, 0x4b, 0xaa, 0x43, 0x35, 0xb8, 0x72, 0xd7, 0x10, 0x1f, 0x16, 0xf0, 0x7b, 0x38, 0x7b,
- 0x00, 0x0a, 0x5a, 0x50, 0xf6, 0x96, 0xd2, 0x8d, 0xcd, 0x86, 0x38, 0x5c, 0x54, 0xfb, 0x30, 0xc9,
- 0x8a, 0x24, 0x57, 0xfb, 0xaa, 0xec, 0xed, 0x8b, 0x7d, 0x8e, 0xdf, 0x01, 0x5a, 0xab, 0xcc, 0x5e,
- 0xad, 0xa7, 0x59, 0x9e, 0x67, 0x35, 0x2d, 0xca, 0x22, 0xad, 0x4d, 0x50, 0xed, 0x2e, 0xb4, 0x97,
- 0xe2, 0x40, 0x11, 0xbf, 0x86, 0x63, 0x6b, 0x95, 0xbd, 0x9b, 0xf6, 0x68, 0x47, 0x7e, 0x00, 0xe3,
- 0xb7, 0xc0, 0x76, 0xf9, 0x7e, 0xcc, 0xe3, 0x1d, 0xf5, 0x83, 0xd2, 0xff, 0x5f, 0xa6, 0x4b, 0xf8,
- 0xad, 0xb7, 0x7b, 0x2a, 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x1d, 0x9f, 0x6d, 0x24, 0x63, 0x05,
- 0x00, 0x00,
-}
diff --git a/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto b/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto
deleted file mode 100644
index f695edf6a9..0000000000
--- a/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto
+++ /dev/null
@@ -1,64 +0,0 @@
-syntax = "proto2";
-option go_package = "urlfetch";
-
-package appengine;
-
-message URLFetchServiceError {
- enum ErrorCode {
- OK = 0;
- INVALID_URL = 1;
- FETCH_ERROR = 2;
- UNSPECIFIED_ERROR = 3;
- RESPONSE_TOO_LARGE = 4;
- DEADLINE_EXCEEDED = 5;
- SSL_CERTIFICATE_ERROR = 6;
- DNS_ERROR = 7;
- CLOSED = 8;
- INTERNAL_TRANSIENT_ERROR = 9;
- TOO_MANY_REDIRECTS = 10;
- MALFORMED_REPLY = 11;
- CONNECTION_ERROR = 12;
- }
-}
-
-message URLFetchRequest {
- enum RequestMethod {
- GET = 1;
- POST = 2;
- HEAD = 3;
- PUT = 4;
- DELETE = 5;
- PATCH = 6;
- }
- required RequestMethod Method = 1;
- required string Url = 2;
- repeated group Header = 3 {
- required string Key = 4;
- required string Value = 5;
- }
- optional bytes Payload = 6 [ctype=CORD];
-
- optional bool FollowRedirects = 7 [default=true];
-
- optional double Deadline = 8;
-
- optional bool MustValidateServerCertificate = 9 [default=true];
-}
-
-message URLFetchResponse {
- optional bytes Content = 1;
- required int32 StatusCode = 2;
- repeated group Header = 3 {
- required string Key = 4;
- required string Value = 5;
- }
- optional bool ContentWasTruncated = 6 [default=false];
- optional int64 ExternalBytesSent = 7;
- optional int64 ExternalBytesReceived = 8;
-
- optional string FinalUrl = 9;
-
- optional int64 ApiCpuMilliseconds = 10 [default=0];
- optional int64 ApiBytesSent = 11 [default=0];
- optional int64 ApiBytesReceived = 12 [default=0];
-}
diff --git a/vendor/google.golang.org/appengine/urlfetch/urlfetch.go b/vendor/google.golang.org/appengine/urlfetch/urlfetch.go
deleted file mode 100644
index 6c0d72418d..0000000000
--- a/vendor/google.golang.org/appengine/urlfetch/urlfetch.go
+++ /dev/null
@@ -1,209 +0,0 @@
-// Copyright 2011 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-// Package urlfetch provides an http.RoundTripper implementation
-// for fetching URLs via App Engine's urlfetch service.
-package urlfetch // import "google.golang.org/appengine/urlfetch"
-
-import (
- "context"
- "errors"
- "fmt"
- "io"
- "io/ioutil"
- "net/http"
- "net/url"
- "strconv"
- "strings"
- "time"
-
- "github.com/golang/protobuf/proto"
-
- "google.golang.org/appengine/internal"
- pb "google.golang.org/appengine/internal/urlfetch"
-)
-
-// Transport is an implementation of http.RoundTripper for
-// App Engine. Users should generally create an http.Client using
-// this transport and use the Client rather than using this transport
-// directly.
-type Transport struct {
- Context context.Context
-
- // Controls whether the application checks the validity of SSL certificates
- // over HTTPS connections. A value of false (the default) instructs the
- // application to send a request to the server only if the certificate is
- // valid and signed by a trusted certificate authority (CA), and also
- // includes a hostname that matches the certificate. A value of true
- // instructs the application to perform no certificate validation.
- AllowInvalidServerCertificate bool
-}
-
-// Verify statically that *Transport implements http.RoundTripper.
-var _ http.RoundTripper = (*Transport)(nil)
-
-// Client returns an *http.Client using a default urlfetch Transport. This
-// client will check the validity of SSL certificates.
-//
-// Any deadline of the provided context will be used for requests through this client.
-// If the client does not have a deadline, then an App Engine default of 60 second is used.
-func Client(ctx context.Context) *http.Client {
- return &http.Client{
- Transport: &Transport{
- Context: ctx,
- },
- }
-}
-
-type bodyReader struct {
- content []byte
- truncated bool
- closed bool
-}
-
-// ErrTruncatedBody is the error returned after the final Read() from a
-// response's Body if the body has been truncated by App Engine's proxy.
-var ErrTruncatedBody = errors.New("urlfetch: truncated body")
-
-func statusCodeToText(code int) string {
- if t := http.StatusText(code); t != "" {
- return t
- }
- return strconv.Itoa(code)
-}
-
-func (br *bodyReader) Read(p []byte) (n int, err error) {
- if br.closed {
- if br.truncated {
- return 0, ErrTruncatedBody
- }
- return 0, io.EOF
- }
- n = copy(p, br.content)
- if n > 0 {
- br.content = br.content[n:]
- return
- }
- if br.truncated {
- br.closed = true
- return 0, ErrTruncatedBody
- }
- return 0, io.EOF
-}
-
-func (br *bodyReader) Close() error {
- br.closed = true
- br.content = nil
- return nil
-}
-
-// A map of the URL Fetch-accepted methods that take a request body.
-var methodAcceptsRequestBody = map[string]bool{
- "POST": true,
- "PUT": true,
- "PATCH": true,
-}
-
-// urlString returns a valid string given a URL. This function is necessary because
-// the String method of URL doesn't correctly handle URLs with non-empty Opaque values.
-// See http://code.google.com/p/go/issues/detail?id=4860.
-func urlString(u *url.URL) string {
- if u.Opaque == "" || strings.HasPrefix(u.Opaque, "//") {
- return u.String()
- }
- aux := *u
- aux.Opaque = "//" + aux.Host + aux.Opaque
- return aux.String()
-}
-
-// RoundTrip issues a single HTTP request and returns its response. Per the
-// http.RoundTripper interface, RoundTrip only returns an error if there
-// was an unsupported request or the URL Fetch proxy fails.
-// Note that HTTP response codes such as 5xx, 403, 404, etc are not
-// errors as far as the transport is concerned and will be returned
-// with err set to nil.
-func (t *Transport) RoundTrip(req *http.Request) (res *http.Response, err error) {
- methNum, ok := pb.URLFetchRequest_RequestMethod_value[req.Method]
- if !ok {
- return nil, fmt.Errorf("urlfetch: unsupported HTTP method %q", req.Method)
- }
-
- method := pb.URLFetchRequest_RequestMethod(methNum)
-
- freq := &pb.URLFetchRequest{
- Method: &method,
- Url: proto.String(urlString(req.URL)),
- FollowRedirects: proto.Bool(false), // http.Client's responsibility
- MustValidateServerCertificate: proto.Bool(!t.AllowInvalidServerCertificate),
- }
- if deadline, ok := t.Context.Deadline(); ok {
- freq.Deadline = proto.Float64(deadline.Sub(time.Now()).Seconds())
- }
-
- for k, vals := range req.Header {
- for _, val := range vals {
- freq.Header = append(freq.Header, &pb.URLFetchRequest_Header{
- Key: proto.String(k),
- Value: proto.String(val),
- })
- }
- }
- if methodAcceptsRequestBody[req.Method] && req.Body != nil {
- // Avoid a []byte copy if req.Body has a Bytes method.
- switch b := req.Body.(type) {
- case interface {
- Bytes() []byte
- }:
- freq.Payload = b.Bytes()
- default:
- freq.Payload, err = ioutil.ReadAll(req.Body)
- if err != nil {
- return nil, err
- }
- }
- }
-
- fres := &pb.URLFetchResponse{}
- if err := internal.Call(t.Context, "urlfetch", "Fetch", freq, fres); err != nil {
- return nil, err
- }
-
- res = &http.Response{}
- res.StatusCode = int(*fres.StatusCode)
- res.Status = fmt.Sprintf("%d %s", res.StatusCode, statusCodeToText(res.StatusCode))
- res.Header = make(http.Header)
- res.Request = req
-
- // Faked:
- res.ProtoMajor = 1
- res.ProtoMinor = 1
- res.Proto = "HTTP/1.1"
- res.Close = true
-
- for _, h := range fres.Header {
- hkey := http.CanonicalHeaderKey(*h.Key)
- hval := *h.Value
- if hkey == "Content-Length" {
- // Will get filled in below for all but HEAD requests.
- if req.Method == "HEAD" {
- res.ContentLength, _ = strconv.ParseInt(hval, 10, 64)
- }
- continue
- }
- res.Header.Add(hkey, hval)
- }
-
- if req.Method != "HEAD" {
- res.ContentLength = int64(len(fres.Content))
- }
-
- truncated := fres.GetContentWasTruncated()
- res.Body = &bodyReader{content: fres.Content, truncated: truncated}
- return
-}
-
-func init() {
- internal.RegisterErrorCodeMap("urlfetch", pb.URLFetchServiceError_ErrorCode_name)
- internal.RegisterTimeoutErrorCode("urlfetch", int32(pb.URLFetchServiceError_DEADLINE_EXCEEDED))
-}
diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/annotations.pb.go b/vendor/google.golang.org/genproto/googleapis/api/annotations/annotations.pb.go
index 191bea48c8..8b462f3dfe 100644
--- a/vendor/google.golang.org/genproto/googleapis/api/annotations/annotations.pb.go
+++ b/vendor/google.golang.org/genproto/googleapis/api/annotations/annotations.pb.go
@@ -1,4 +1,4 @@
-// Copyright 2015 Google LLC
+// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -15,7 +15,7 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.26.0
-// protoc v3.12.2
+// protoc v4.24.4
// source: google/api/annotations.proto
package annotations
diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/client.pb.go b/vendor/google.golang.org/genproto/googleapis/api/annotations/client.pb.go
index 10f35d10e5..aa69fb4d50 100644
--- a/vendor/google.golang.org/genproto/googleapis/api/annotations/client.pb.go
+++ b/vendor/google.golang.org/genproto/googleapis/api/annotations/client.pb.go
@@ -1,4 +1,4 @@
-// Copyright 2023 Google LLC
+// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -719,6 +719,8 @@ type PythonSettings struct {
// Some settings.
Common *CommonLanguageSettings `protobuf:"bytes,1,opt,name=common,proto3" json:"common,omitempty"`
+ // Experimental features to be included during client library generation.
+ ExperimentalFeatures *PythonSettings_ExperimentalFeatures `protobuf:"bytes,2,opt,name=experimental_features,json=experimentalFeatures,proto3" json:"experimental_features,omitempty"`
}
func (x *PythonSettings) Reset() {
@@ -760,6 +762,13 @@ func (x *PythonSettings) GetCommon() *CommonLanguageSettings {
return nil
}
+func (x *PythonSettings) GetExperimentalFeatures() *PythonSettings_ExperimentalFeatures {
+ if x != nil {
+ return x.ExperimentalFeatures
+ }
+ return nil
+}
+
// Settings for Node client libraries.
type NodeSettings struct {
state protoimpl.MessageState
@@ -1024,6 +1033,13 @@ type MethodSettings struct {
// The fully qualified name of the method, for which the options below apply.
// This is used to find the method to apply the options.
+ //
+ // Example:
+ //
+ // publishing:
+ // method_settings:
+ // - selector: google.storage.control.v2.StorageControl.CreateFolder
+ // # method settings for CreateFolder...
Selector string `protobuf:"bytes,1,opt,name=selector,proto3" json:"selector,omitempty"`
// Describes settings to use for long-running operations when generating
// API methods for RPCs. Complements RPCs that use the annotations in
@@ -1033,15 +1049,12 @@ type MethodSettings struct {
//
// publishing:
// method_settings:
- // - selector: google.cloud.speech.v2.Speech.BatchRecognize
- // long_running:
- // initial_poll_delay:
- // seconds: 60 # 1 minute
- // poll_delay_multiplier: 1.5
- // max_poll_delay:
- // seconds: 360 # 6 minutes
- // total_poll_timeout:
- // seconds: 54000 # 90 minutes
+ // - selector: google.cloud.speech.v2.Speech.BatchRecognize
+ // long_running:
+ // initial_poll_delay: 60s # 1 minute
+ // poll_delay_multiplier: 1.5
+ // max_poll_delay: 360s # 6 minutes
+ // total_poll_timeout: 54000s # 90 minutes
LongRunning *MethodSettings_LongRunning `protobuf:"bytes,2,opt,name=long_running,json=longRunning,proto3" json:"long_running,omitempty"`
// List of top-level fields of the request message, that should be
// automatically populated by the client libraries based on their
@@ -1051,9 +1064,9 @@ type MethodSettings struct {
//
// publishing:
// method_settings:
- // - selector: google.example.v1.ExampleService.CreateExample
- // auto_populated_fields:
- // - request_id
+ // - selector: google.example.v1.ExampleService.CreateExample
+ // auto_populated_fields:
+ // - request_id
AutoPopulatedFields []string `protobuf:"bytes,3,rep,name=auto_populated_fields,json=autoPopulatedFields,proto3" json:"auto_populated_fields,omitempty"`
}
@@ -1110,6 +1123,60 @@ func (x *MethodSettings) GetAutoPopulatedFields() []string {
return nil
}
+// Experimental features to be included during client library generation.
+// These fields will be deprecated once the feature graduates and is enabled
+// by default.
+type PythonSettings_ExperimentalFeatures struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // Enables generation of asynchronous REST clients if `rest` transport is
+ // enabled. By default, asynchronous REST clients will not be generated.
+ // This feature will be enabled by default 1 month after launching the
+ // feature in preview packages.
+ RestAsyncIoEnabled bool `protobuf:"varint,1,opt,name=rest_async_io_enabled,json=restAsyncIoEnabled,proto3" json:"rest_async_io_enabled,omitempty"`
+}
+
+func (x *PythonSettings_ExperimentalFeatures) Reset() {
+ *x = PythonSettings_ExperimentalFeatures{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_google_api_client_proto_msgTypes[13]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *PythonSettings_ExperimentalFeatures) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PythonSettings_ExperimentalFeatures) ProtoMessage() {}
+
+func (x *PythonSettings_ExperimentalFeatures) ProtoReflect() protoreflect.Message {
+ mi := &file_google_api_client_proto_msgTypes[13]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use PythonSettings_ExperimentalFeatures.ProtoReflect.Descriptor instead.
+func (*PythonSettings_ExperimentalFeatures) Descriptor() ([]byte, []int) {
+ return file_google_api_client_proto_rawDescGZIP(), []int{6, 0}
+}
+
+func (x *PythonSettings_ExperimentalFeatures) GetRestAsyncIoEnabled() bool {
+ if x != nil {
+ return x.RestAsyncIoEnabled
+ }
+ return false
+}
+
// Describes settings to use when generating API methods that use the
// long-running operation pattern.
// All default values below are from those used in the client library
@@ -1138,7 +1205,7 @@ type MethodSettings_LongRunning struct {
func (x *MethodSettings_LongRunning) Reset() {
*x = MethodSettings_LongRunning{}
if protoimpl.UnsafeEnabled {
- mi := &file_google_api_client_proto_msgTypes[15]
+ mi := &file_google_api_client_proto_msgTypes[16]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1151,7 +1218,7 @@ func (x *MethodSettings_LongRunning) String() string {
func (*MethodSettings_LongRunning) ProtoMessage() {}
func (x *MethodSettings_LongRunning) ProtoReflect() protoreflect.Message {
- mi := &file_google_api_client_proto_msgTypes[15]
+ mi := &file_google_api_client_proto_msgTypes[16]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1456,132 +1523,143 @@ var file_google_api_client_proto_rawDesc = []byte{
0x73, 0x12, 0x3a, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28,
0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x43,
0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x4c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74,
- 0x74, 0x69, 0x6e, 0x67, 0x73, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x22, 0x4c, 0x0a,
- 0x0e, 0x50, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x12,
- 0x3a, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
- 0x22, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x43, 0x6f, 0x6d,
- 0x6d, 0x6f, 0x6e, 0x4c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x74, 0x69,
- 0x6e, 0x67, 0x73, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x22, 0x4a, 0x0a, 0x0c, 0x4e,
- 0x6f, 0x64, 0x65, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x3a, 0x0a, 0x06, 0x63,
- 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f,
- 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x4c,
- 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x52,
- 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x22, 0xae, 0x04, 0x0a, 0x0e, 0x44, 0x6f, 0x74, 0x6e,
- 0x65, 0x74, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x3a, 0x0a, 0x06, 0x63, 0x6f,
+ 0x74, 0x69, 0x6e, 0x67, 0x73, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x22, 0xfd, 0x01,
+ 0x0a, 0x0e, 0x50, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73,
+ 0x12, 0x3a, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
+ 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x43, 0x6f,
+ 0x6d, 0x6d, 0x6f, 0x6e, 0x4c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x74,
+ 0x69, 0x6e, 0x67, 0x73, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x12, 0x64, 0x0a, 0x15,
+ 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x5f, 0x66, 0x65, 0x61,
+ 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x67, 0x6f,
+ 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x50, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x53,
+ 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x2e, 0x45, 0x78, 0x70, 0x65, 0x72, 0x69, 0x6d, 0x65,
+ 0x6e, 0x74, 0x61, 0x6c, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x52, 0x14, 0x65, 0x78,
+ 0x70, 0x65, 0x72, 0x69, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72,
+ 0x65, 0x73, 0x1a, 0x49, 0x0a, 0x14, 0x45, 0x78, 0x70, 0x65, 0x72, 0x69, 0x6d, 0x65, 0x6e, 0x74,
+ 0x61, 0x6c, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x31, 0x0a, 0x15, 0x72, 0x65,
+ 0x73, 0x74, 0x5f, 0x61, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x69, 0x6f, 0x5f, 0x65, 0x6e, 0x61, 0x62,
+ 0x6c, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x72, 0x65, 0x73, 0x74, 0x41,
+ 0x73, 0x79, 0x6e, 0x63, 0x49, 0x6f, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x22, 0x4a, 0x0a,
+ 0x0c, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x3a, 0x0a,
+ 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e,
+ 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f,
+ 0x6e, 0x4c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67,
+ 0x73, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x22, 0xae, 0x04, 0x0a, 0x0e, 0x44, 0x6f,
+ 0x74, 0x6e, 0x65, 0x74, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x3a, 0x0a, 0x06,
+ 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67,
+ 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e,
+ 0x4c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73,
+ 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x12, 0x5a, 0x0a, 0x10, 0x72, 0x65, 0x6e, 0x61,
+ 0x6d, 0x65, 0x64, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03,
+ 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e,
+ 0x44, 0x6f, 0x74, 0x6e, 0x65, 0x74, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x2e, 0x52,
+ 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x45, 0x6e,
+ 0x74, 0x72, 0x79, 0x52, 0x0f, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x53, 0x65, 0x72, 0x76,
+ 0x69, 0x63, 0x65, 0x73, 0x12, 0x5d, 0x0a, 0x11, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x5f,
+ 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32,
+ 0x30, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x44, 0x6f, 0x74,
+ 0x6e, 0x65, 0x74, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x2e, 0x52, 0x65, 0x6e, 0x61,
+ 0x6d, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72,
+ 0x79, 0x52, 0x10, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72,
+ 0x63, 0x65, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x64, 0x5f, 0x72,
+ 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x10,
+ 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73,
+ 0x12, 0x38, 0x0a, 0x18, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73,
+ 0x70, 0x61, 0x63, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03,
+ 0x28, 0x09, 0x52, 0x16, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70,
+ 0x61, 0x63, 0x65, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x73, 0x12, 0x35, 0x0a, 0x16, 0x68, 0x61,
+ 0x6e, 0x64, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74,
+ 0x75, 0x72, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x15, 0x68, 0x61, 0x6e, 0x64,
+ 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65,
+ 0x73, 0x1a, 0x42, 0x0a, 0x14, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x53, 0x65, 0x72, 0x76,
+ 0x69, 0x63, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
+ 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76,
+ 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
+ 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x43, 0x0a, 0x15, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x64,
+ 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10,
+ 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79,
+ 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+ 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x4a, 0x0a, 0x0c, 0x52, 0x75,
+ 0x62, 0x79, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x3a, 0x0a, 0x06, 0x63, 0x6f,
0x6d, 0x6d, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x6f,
0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x4c, 0x61,
0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x52, 0x06,
- 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x12, 0x5a, 0x0a, 0x10, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65,
- 0x64, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b,
- 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x44, 0x6f,
- 0x74, 0x6e, 0x65, 0x74, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x2e, 0x52, 0x65, 0x6e,
- 0x61, 0x6d, 0x65, 0x64, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72,
- 0x79, 0x52, 0x0f, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63,
- 0x65, 0x73, 0x12, 0x5d, 0x0a, 0x11, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x5f, 0x72, 0x65,
- 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x30, 0x2e,
- 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x44, 0x6f, 0x74, 0x6e, 0x65,
- 0x74, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x2e, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65,
- 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52,
- 0x10, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65,
- 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x73,
- 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x10, 0x69, 0x67,
- 0x6e, 0x6f, 0x72, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x12, 0x38,
- 0x0a, 0x18, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61,
- 0x63, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09,
- 0x52, 0x16, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63,
- 0x65, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x73, 0x12, 0x35, 0x0a, 0x16, 0x68, 0x61, 0x6e, 0x64,
- 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72,
- 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x15, 0x68, 0x61, 0x6e, 0x64, 0x77, 0x72,
- 0x69, 0x74, 0x74, 0x65, 0x6e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x1a,
- 0x42, 0x0a, 0x14, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63,
- 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
- 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
- 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
- 0x02, 0x38, 0x01, 0x1a, 0x43, 0x0a, 0x15, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x52, 0x65,
- 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
- 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14,
- 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76,
- 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x4a, 0x0a, 0x0c, 0x52, 0x75, 0x62, 0x79,
- 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x3a, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d,
- 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
- 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x4c, 0x61, 0x6e, 0x67,
- 0x75, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x52, 0x06, 0x63, 0x6f,
- 0x6d, 0x6d, 0x6f, 0x6e, 0x22, 0x48, 0x0a, 0x0a, 0x47, 0x6f, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e,
- 0x67, 0x73, 0x12, 0x3a, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01,
- 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e,
- 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x4c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x53, 0x65,
- 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x22, 0xc2,
- 0x03, 0x0a, 0x0e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67,
- 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20,
- 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x49, 0x0a,
- 0x0c, 0x6c, 0x6f, 0x6e, 0x67, 0x5f, 0x72, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x18, 0x02, 0x20,
- 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69,
- 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x2e,
- 0x4c, 0x6f, 0x6e, 0x67, 0x52, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x0b, 0x6c, 0x6f, 0x6e,
- 0x67, 0x52, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x12, 0x32, 0x0a, 0x15, 0x61, 0x75, 0x74, 0x6f,
- 0x5f, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64,
- 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x13, 0x61, 0x75, 0x74, 0x6f, 0x50, 0x6f, 0x70,
- 0x75, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x1a, 0x94, 0x02, 0x0a,
- 0x0b, 0x4c, 0x6f, 0x6e, 0x67, 0x52, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x12, 0x47, 0x0a, 0x12,
- 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x70, 0x6f, 0x6c, 0x6c, 0x5f, 0x64, 0x65, 0x6c,
- 0x61, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+ 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x22, 0x48, 0x0a, 0x0a, 0x47, 0x6f, 0x53, 0x65, 0x74, 0x74,
+ 0x69, 0x6e, 0x67, 0x73, 0x12, 0x3a, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x18, 0x01,
+ 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70,
+ 0x69, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x4c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65,
+ 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e,
+ 0x22, 0xc2, 0x03, 0x0a, 0x0e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x53, 0x65, 0x74, 0x74, 0x69,
+ 0x6e, 0x67, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18,
+ 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12,
+ 0x49, 0x0a, 0x0c, 0x6c, 0x6f, 0x6e, 0x67, 0x5f, 0x72, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x18,
+ 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61,
+ 0x70, 0x69, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67,
+ 0x73, 0x2e, 0x4c, 0x6f, 0x6e, 0x67, 0x52, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x0b, 0x6c,
+ 0x6f, 0x6e, 0x67, 0x52, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x12, 0x32, 0x0a, 0x15, 0x61, 0x75,
+ 0x74, 0x6f, 0x5f, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x65,
+ 0x6c, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x13, 0x61, 0x75, 0x74, 0x6f, 0x50,
+ 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x1a, 0x94,
+ 0x02, 0x0a, 0x0b, 0x4c, 0x6f, 0x6e, 0x67, 0x52, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x12, 0x47,
+ 0x0a, 0x12, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x70, 0x6f, 0x6c, 0x6c, 0x5f, 0x64,
+ 0x65, 0x6c, 0x61, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f,
+ 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72,
+ 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x10, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x50, 0x6f,
+ 0x6c, 0x6c, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x12, 0x32, 0x0a, 0x15, 0x70, 0x6f, 0x6c, 0x6c, 0x5f,
+ 0x64, 0x65, 0x6c, 0x61, 0x79, 0x5f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x69, 0x65, 0x72,
+ 0x18, 0x02, 0x20, 0x01, 0x28, 0x02, 0x52, 0x13, 0x70, 0x6f, 0x6c, 0x6c, 0x44, 0x65, 0x6c, 0x61,
+ 0x79, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x69, 0x65, 0x72, 0x12, 0x3f, 0x0a, 0x0e, 0x6d,
+ 0x61, 0x78, 0x5f, 0x70, 0x6f, 0x6c, 0x6c, 0x5f, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x18, 0x03, 0x20,
+ 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
+ 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0c,
+ 0x6d, 0x61, 0x78, 0x50, 0x6f, 0x6c, 0x6c, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x12, 0x47, 0x0a, 0x12,
+ 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x70, 0x6f, 0x6c, 0x6c, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f,
+ 0x75, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74,
- 0x69, 0x6f, 0x6e, 0x52, 0x10, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x50, 0x6f, 0x6c, 0x6c,
- 0x44, 0x65, 0x6c, 0x61, 0x79, 0x12, 0x32, 0x0a, 0x15, 0x70, 0x6f, 0x6c, 0x6c, 0x5f, 0x64, 0x65,
- 0x6c, 0x61, 0x79, 0x5f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x69, 0x65, 0x72, 0x18, 0x02,
- 0x20, 0x01, 0x28, 0x02, 0x52, 0x13, 0x70, 0x6f, 0x6c, 0x6c, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x4d,
- 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x69, 0x65, 0x72, 0x12, 0x3f, 0x0a, 0x0e, 0x6d, 0x61, 0x78,
- 0x5f, 0x70, 0x6f, 0x6c, 0x6c, 0x5f, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28,
- 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
- 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0c, 0x6d, 0x61,
- 0x78, 0x50, 0x6f, 0x6c, 0x6c, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x12, 0x47, 0x0a, 0x12, 0x74, 0x6f,
- 0x74, 0x61, 0x6c, 0x5f, 0x70, 0x6f, 0x6c, 0x6c, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74,
- 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
- 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f,
- 0x6e, 0x52, 0x10, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x50, 0x6f, 0x6c, 0x6c, 0x54, 0x69, 0x6d, 0x65,
- 0x6f, 0x75, 0x74, 0x2a, 0xa3, 0x01, 0x0a, 0x19, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x4c, 0x69,
- 0x62, 0x72, 0x61, 0x72, 0x79, 0x4f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f,
- 0x6e, 0x12, 0x2b, 0x0a, 0x27, 0x43, 0x4c, 0x49, 0x45, 0x4e, 0x54, 0x5f, 0x4c, 0x49, 0x42, 0x52,
- 0x41, 0x52, 0x59, 0x5f, 0x4f, 0x52, 0x47, 0x41, 0x4e, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e,
- 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x09,
- 0x0a, 0x05, 0x43, 0x4c, 0x4f, 0x55, 0x44, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x41, 0x44, 0x53,
- 0x10, 0x02, 0x12, 0x0a, 0x0a, 0x06, 0x50, 0x48, 0x4f, 0x54, 0x4f, 0x53, 0x10, 0x03, 0x12, 0x0f,
- 0x0a, 0x0b, 0x53, 0x54, 0x52, 0x45, 0x45, 0x54, 0x5f, 0x56, 0x49, 0x45, 0x57, 0x10, 0x04, 0x12,
- 0x0c, 0x0a, 0x08, 0x53, 0x48, 0x4f, 0x50, 0x50, 0x49, 0x4e, 0x47, 0x10, 0x05, 0x12, 0x07, 0x0a,
- 0x03, 0x47, 0x45, 0x4f, 0x10, 0x06, 0x12, 0x11, 0x0a, 0x0d, 0x47, 0x45, 0x4e, 0x45, 0x52, 0x41,
- 0x54, 0x49, 0x56, 0x45, 0x5f, 0x41, 0x49, 0x10, 0x07, 0x2a, 0x67, 0x0a, 0x18, 0x43, 0x6c, 0x69,
- 0x65, 0x6e, 0x74, 0x4c, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e,
- 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2a, 0x0a, 0x26, 0x43, 0x4c, 0x49, 0x45, 0x4e, 0x54, 0x5f,
- 0x4c, 0x49, 0x42, 0x52, 0x41, 0x52, 0x59, 0x5f, 0x44, 0x45, 0x53, 0x54, 0x49, 0x4e, 0x41, 0x54,
- 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10,
- 0x00, 0x12, 0x0a, 0x0a, 0x06, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x10, 0x0a, 0x12, 0x13, 0x0a,
- 0x0f, 0x50, 0x41, 0x43, 0x4b, 0x41, 0x47, 0x45, 0x5f, 0x4d, 0x41, 0x4e, 0x41, 0x47, 0x45, 0x52,
- 0x10, 0x14, 0x3a, 0x4a, 0x0a, 0x10, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x5f, 0x73, 0x69, 0x67,
- 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
- 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f,
- 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x9b, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0f, 0x6d,
- 0x65, 0x74, 0x68, 0x6f, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x3a, 0x43,
- 0x0a, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x68, 0x6f, 0x73, 0x74, 0x12, 0x1f,
- 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
- 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18,
- 0x99, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x48,
- 0x6f, 0x73, 0x74, 0x3a, 0x43, 0x0a, 0x0c, 0x6f, 0x61, 0x75, 0x74, 0x68, 0x5f, 0x73, 0x63, 0x6f,
- 0x70, 0x65, 0x73, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
- 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4f, 0x70, 0x74,
- 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x9a, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6f, 0x61, 0x75,
- 0x74, 0x68, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x73, 0x3a, 0x44, 0x0a, 0x0b, 0x61, 0x70, 0x69, 0x5f,
- 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
- 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63,
- 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xc1, 0xba, 0xab, 0xfa, 0x01, 0x20, 0x01,
- 0x28, 0x09, 0x52, 0x0a, 0x61, 0x70, 0x69, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x69,
- 0x0a, 0x0e, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69,
- 0x42, 0x0b, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a,
- 0x41, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f,
- 0x72, 0x67, 0x2f, 0x67, 0x65, 0x6e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x6f, 0x67,
- 0x6c, 0x65, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74,
- 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f,
- 0x6e, 0x73, 0xa2, 0x02, 0x04, 0x47, 0x41, 0x50, 0x49, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
- 0x33,
+ 0x69, 0x6f, 0x6e, 0x52, 0x10, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x50, 0x6f, 0x6c, 0x6c, 0x54, 0x69,
+ 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x2a, 0xa3, 0x01, 0x0a, 0x19, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74,
+ 0x4c, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x4f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74,
+ 0x69, 0x6f, 0x6e, 0x12, 0x2b, 0x0a, 0x27, 0x43, 0x4c, 0x49, 0x45, 0x4e, 0x54, 0x5f, 0x4c, 0x49,
+ 0x42, 0x52, 0x41, 0x52, 0x59, 0x5f, 0x4f, 0x52, 0x47, 0x41, 0x4e, 0x49, 0x5a, 0x41, 0x54, 0x49,
+ 0x4f, 0x4e, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00,
+ 0x12, 0x09, 0x0a, 0x05, 0x43, 0x4c, 0x4f, 0x55, 0x44, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x41,
+ 0x44, 0x53, 0x10, 0x02, 0x12, 0x0a, 0x0a, 0x06, 0x50, 0x48, 0x4f, 0x54, 0x4f, 0x53, 0x10, 0x03,
+ 0x12, 0x0f, 0x0a, 0x0b, 0x53, 0x54, 0x52, 0x45, 0x45, 0x54, 0x5f, 0x56, 0x49, 0x45, 0x57, 0x10,
+ 0x04, 0x12, 0x0c, 0x0a, 0x08, 0x53, 0x48, 0x4f, 0x50, 0x50, 0x49, 0x4e, 0x47, 0x10, 0x05, 0x12,
+ 0x07, 0x0a, 0x03, 0x47, 0x45, 0x4f, 0x10, 0x06, 0x12, 0x11, 0x0a, 0x0d, 0x47, 0x45, 0x4e, 0x45,
+ 0x52, 0x41, 0x54, 0x49, 0x56, 0x45, 0x5f, 0x41, 0x49, 0x10, 0x07, 0x2a, 0x67, 0x0a, 0x18, 0x43,
+ 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x4c, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x44, 0x65, 0x73, 0x74,
+ 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2a, 0x0a, 0x26, 0x43, 0x4c, 0x49, 0x45, 0x4e,
+ 0x54, 0x5f, 0x4c, 0x49, 0x42, 0x52, 0x41, 0x52, 0x59, 0x5f, 0x44, 0x45, 0x53, 0x54, 0x49, 0x4e,
+ 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45,
+ 0x44, 0x10, 0x00, 0x12, 0x0a, 0x0a, 0x06, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x10, 0x0a, 0x12,
+ 0x13, 0x0a, 0x0f, 0x50, 0x41, 0x43, 0x4b, 0x41, 0x47, 0x45, 0x5f, 0x4d, 0x41, 0x4e, 0x41, 0x47,
+ 0x45, 0x52, 0x10, 0x14, 0x3a, 0x4a, 0x0a, 0x10, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x5f, 0x73,
+ 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+ 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f,
+ 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x9b, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52,
+ 0x0f, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65,
+ 0x3a, 0x43, 0x0a, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x68, 0x6f, 0x73, 0x74,
+ 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+ 0x75, 0x66, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+ 0x73, 0x18, 0x99, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c,
+ 0x74, 0x48, 0x6f, 0x73, 0x74, 0x3a, 0x43, 0x0a, 0x0c, 0x6f, 0x61, 0x75, 0x74, 0x68, 0x5f, 0x73,
+ 0x63, 0x6f, 0x70, 0x65, 0x73, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
+ 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4f,
+ 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x9a, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6f,
+ 0x61, 0x75, 0x74, 0x68, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x73, 0x3a, 0x44, 0x0a, 0x0b, 0x61, 0x70,
+ 0x69, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+ 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x65, 0x72, 0x76,
+ 0x69, 0x63, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xc1, 0xba, 0xab, 0xfa, 0x01,
+ 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x70, 0x69, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
+ 0x42, 0x69, 0x0a, 0x0e, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61,
+ 0x70, 0x69, 0x42, 0x0b, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50,
+ 0x01, 0x5a, 0x41, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67,
+ 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x67, 0x65, 0x6e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f,
+ 0x6f, 0x67, 0x6c, 0x65, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e,
+ 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74,
+ 0x69, 0x6f, 0x6e, 0x73, 0xa2, 0x02, 0x04, 0x47, 0x41, 0x50, 0x49, 0x62, 0x06, 0x70, 0x72, 0x6f,
+ 0x74, 0x6f, 0x33,
}
var (
@@ -1597,34 +1675,35 @@ func file_google_api_client_proto_rawDescGZIP() []byte {
}
var file_google_api_client_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
-var file_google_api_client_proto_msgTypes = make([]protoimpl.MessageInfo, 16)
+var file_google_api_client_proto_msgTypes = make([]protoimpl.MessageInfo, 17)
var file_google_api_client_proto_goTypes = []interface{}{
- (ClientLibraryOrganization)(0), // 0: google.api.ClientLibraryOrganization
- (ClientLibraryDestination)(0), // 1: google.api.ClientLibraryDestination
- (*CommonLanguageSettings)(nil), // 2: google.api.CommonLanguageSettings
- (*ClientLibrarySettings)(nil), // 3: google.api.ClientLibrarySettings
- (*Publishing)(nil), // 4: google.api.Publishing
- (*JavaSettings)(nil), // 5: google.api.JavaSettings
- (*CppSettings)(nil), // 6: google.api.CppSettings
- (*PhpSettings)(nil), // 7: google.api.PhpSettings
- (*PythonSettings)(nil), // 8: google.api.PythonSettings
- (*NodeSettings)(nil), // 9: google.api.NodeSettings
- (*DotnetSettings)(nil), // 10: google.api.DotnetSettings
- (*RubySettings)(nil), // 11: google.api.RubySettings
- (*GoSettings)(nil), // 12: google.api.GoSettings
- (*MethodSettings)(nil), // 13: google.api.MethodSettings
- nil, // 14: google.api.JavaSettings.ServiceClassNamesEntry
- nil, // 15: google.api.DotnetSettings.RenamedServicesEntry
- nil, // 16: google.api.DotnetSettings.RenamedResourcesEntry
- (*MethodSettings_LongRunning)(nil), // 17: google.api.MethodSettings.LongRunning
- (api.LaunchStage)(0), // 18: google.api.LaunchStage
- (*durationpb.Duration)(nil), // 19: google.protobuf.Duration
- (*descriptorpb.MethodOptions)(nil), // 20: google.protobuf.MethodOptions
- (*descriptorpb.ServiceOptions)(nil), // 21: google.protobuf.ServiceOptions
+ (ClientLibraryOrganization)(0), // 0: google.api.ClientLibraryOrganization
+ (ClientLibraryDestination)(0), // 1: google.api.ClientLibraryDestination
+ (*CommonLanguageSettings)(nil), // 2: google.api.CommonLanguageSettings
+ (*ClientLibrarySettings)(nil), // 3: google.api.ClientLibrarySettings
+ (*Publishing)(nil), // 4: google.api.Publishing
+ (*JavaSettings)(nil), // 5: google.api.JavaSettings
+ (*CppSettings)(nil), // 6: google.api.CppSettings
+ (*PhpSettings)(nil), // 7: google.api.PhpSettings
+ (*PythonSettings)(nil), // 8: google.api.PythonSettings
+ (*NodeSettings)(nil), // 9: google.api.NodeSettings
+ (*DotnetSettings)(nil), // 10: google.api.DotnetSettings
+ (*RubySettings)(nil), // 11: google.api.RubySettings
+ (*GoSettings)(nil), // 12: google.api.GoSettings
+ (*MethodSettings)(nil), // 13: google.api.MethodSettings
+ nil, // 14: google.api.JavaSettings.ServiceClassNamesEntry
+ (*PythonSettings_ExperimentalFeatures)(nil), // 15: google.api.PythonSettings.ExperimentalFeatures
+ nil, // 16: google.api.DotnetSettings.RenamedServicesEntry
+ nil, // 17: google.api.DotnetSettings.RenamedResourcesEntry
+ (*MethodSettings_LongRunning)(nil), // 18: google.api.MethodSettings.LongRunning
+ (api.LaunchStage)(0), // 19: google.api.LaunchStage
+ (*durationpb.Duration)(nil), // 20: google.protobuf.Duration
+ (*descriptorpb.MethodOptions)(nil), // 21: google.protobuf.MethodOptions
+ (*descriptorpb.ServiceOptions)(nil), // 22: google.protobuf.ServiceOptions
}
var file_google_api_client_proto_depIdxs = []int32{
1, // 0: google.api.CommonLanguageSettings.destinations:type_name -> google.api.ClientLibraryDestination
- 18, // 1: google.api.ClientLibrarySettings.launch_stage:type_name -> google.api.LaunchStage
+ 19, // 1: google.api.ClientLibrarySettings.launch_stage:type_name -> google.api.LaunchStage
5, // 2: google.api.ClientLibrarySettings.java_settings:type_name -> google.api.JavaSettings
6, // 3: google.api.ClientLibrarySettings.cpp_settings:type_name -> google.api.CppSettings
7, // 4: google.api.ClientLibrarySettings.php_settings:type_name -> google.api.PhpSettings
@@ -1641,25 +1720,26 @@ var file_google_api_client_proto_depIdxs = []int32{
2, // 15: google.api.CppSettings.common:type_name -> google.api.CommonLanguageSettings
2, // 16: google.api.PhpSettings.common:type_name -> google.api.CommonLanguageSettings
2, // 17: google.api.PythonSettings.common:type_name -> google.api.CommonLanguageSettings
- 2, // 18: google.api.NodeSettings.common:type_name -> google.api.CommonLanguageSettings
- 2, // 19: google.api.DotnetSettings.common:type_name -> google.api.CommonLanguageSettings
- 15, // 20: google.api.DotnetSettings.renamed_services:type_name -> google.api.DotnetSettings.RenamedServicesEntry
- 16, // 21: google.api.DotnetSettings.renamed_resources:type_name -> google.api.DotnetSettings.RenamedResourcesEntry
- 2, // 22: google.api.RubySettings.common:type_name -> google.api.CommonLanguageSettings
- 2, // 23: google.api.GoSettings.common:type_name -> google.api.CommonLanguageSettings
- 17, // 24: google.api.MethodSettings.long_running:type_name -> google.api.MethodSettings.LongRunning
- 19, // 25: google.api.MethodSettings.LongRunning.initial_poll_delay:type_name -> google.protobuf.Duration
- 19, // 26: google.api.MethodSettings.LongRunning.max_poll_delay:type_name -> google.protobuf.Duration
- 19, // 27: google.api.MethodSettings.LongRunning.total_poll_timeout:type_name -> google.protobuf.Duration
- 20, // 28: google.api.method_signature:extendee -> google.protobuf.MethodOptions
- 21, // 29: google.api.default_host:extendee -> google.protobuf.ServiceOptions
- 21, // 30: google.api.oauth_scopes:extendee -> google.protobuf.ServiceOptions
- 21, // 31: google.api.api_version:extendee -> google.protobuf.ServiceOptions
- 32, // [32:32] is the sub-list for method output_type
- 32, // [32:32] is the sub-list for method input_type
- 32, // [32:32] is the sub-list for extension type_name
- 28, // [28:32] is the sub-list for extension extendee
- 0, // [0:28] is the sub-list for field type_name
+ 15, // 18: google.api.PythonSettings.experimental_features:type_name -> google.api.PythonSettings.ExperimentalFeatures
+ 2, // 19: google.api.NodeSettings.common:type_name -> google.api.CommonLanguageSettings
+ 2, // 20: google.api.DotnetSettings.common:type_name -> google.api.CommonLanguageSettings
+ 16, // 21: google.api.DotnetSettings.renamed_services:type_name -> google.api.DotnetSettings.RenamedServicesEntry
+ 17, // 22: google.api.DotnetSettings.renamed_resources:type_name -> google.api.DotnetSettings.RenamedResourcesEntry
+ 2, // 23: google.api.RubySettings.common:type_name -> google.api.CommonLanguageSettings
+ 2, // 24: google.api.GoSettings.common:type_name -> google.api.CommonLanguageSettings
+ 18, // 25: google.api.MethodSettings.long_running:type_name -> google.api.MethodSettings.LongRunning
+ 20, // 26: google.api.MethodSettings.LongRunning.initial_poll_delay:type_name -> google.protobuf.Duration
+ 20, // 27: google.api.MethodSettings.LongRunning.max_poll_delay:type_name -> google.protobuf.Duration
+ 20, // 28: google.api.MethodSettings.LongRunning.total_poll_timeout:type_name -> google.protobuf.Duration
+ 21, // 29: google.api.method_signature:extendee -> google.protobuf.MethodOptions
+ 22, // 30: google.api.default_host:extendee -> google.protobuf.ServiceOptions
+ 22, // 31: google.api.oauth_scopes:extendee -> google.protobuf.ServiceOptions
+ 22, // 32: google.api.api_version:extendee -> google.protobuf.ServiceOptions
+ 33, // [33:33] is the sub-list for method output_type
+ 33, // [33:33] is the sub-list for method input_type
+ 33, // [33:33] is the sub-list for extension type_name
+ 29, // [29:33] is the sub-list for extension extendee
+ 0, // [0:29] is the sub-list for field type_name
}
func init() { file_google_api_client_proto_init() }
@@ -1812,7 +1892,19 @@ func file_google_api_client_proto_init() {
return nil
}
}
- file_google_api_client_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+ file_google_api_client_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*PythonSettings_ExperimentalFeatures); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_google_api_client_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*MethodSettings_LongRunning); i {
case 0:
return &v.state
@@ -1831,7 +1923,7 @@ func file_google_api_client_proto_init() {
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_google_api_client_proto_rawDesc,
NumEnums: 2,
- NumMessages: 16,
+ NumMessages: 17,
NumExtensions: 4,
NumServices: 0,
},
diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/field_behavior.pb.go b/vendor/google.golang.org/genproto/googleapis/api/annotations/field_behavior.pb.go
index 312d7eb49a..08505ba3fe 100644
--- a/vendor/google.golang.org/genproto/googleapis/api/annotations/field_behavior.pb.go
+++ b/vendor/google.golang.org/genproto/googleapis/api/annotations/field_behavior.pb.go
@@ -1,4 +1,4 @@
-// Copyright 2023 Google LLC
+// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/field_info.pb.go b/vendor/google.golang.org/genproto/googleapis/api/annotations/field_info.pb.go
index 6ff36206da..a462e7d013 100644
--- a/vendor/google.golang.org/genproto/googleapis/api/annotations/field_info.pb.go
+++ b/vendor/google.golang.org/genproto/googleapis/api/annotations/field_info.pb.go
@@ -1,4 +1,4 @@
-// Copyright 2023 Google LLC
+// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -121,6 +121,11 @@ type FieldInfo struct {
// any API consumer, just documents the API's format for the field it is
// applied to.
Format FieldInfo_Format `protobuf:"varint,1,opt,name=format,proto3,enum=google.api.FieldInfo_Format" json:"format,omitempty"`
+ // The type(s) that the annotated, generic field may represent.
+ //
+ // Currently, this must only be used on fields of type `google.protobuf.Any`.
+ // Supporting other generic types may be considered in the future.
+ ReferencedTypes []*TypeReference `protobuf:"bytes,2,rep,name=referenced_types,json=referencedTypes,proto3" json:"referenced_types,omitempty"`
}
func (x *FieldInfo) Reset() {
@@ -162,6 +167,70 @@ func (x *FieldInfo) GetFormat() FieldInfo_Format {
return FieldInfo_FORMAT_UNSPECIFIED
}
+func (x *FieldInfo) GetReferencedTypes() []*TypeReference {
+ if x != nil {
+ return x.ReferencedTypes
+ }
+ return nil
+}
+
+// A reference to a message type, for use in [FieldInfo][google.api.FieldInfo].
+type TypeReference struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // The name of the type that the annotated, generic field may represent.
+ // If the type is in the same protobuf package, the value can be the simple
+ // message name e.g., `"MyMessage"`. Otherwise, the value must be the
+ // fully-qualified message name e.g., `"google.library.v1.Book"`.
+ //
+ // If the type(s) are unknown to the service (e.g. the field accepts generic
+ // user input), use the wildcard `"*"` to denote this behavior.
+ //
+ // See [AIP-202](https://google.aip.dev/202#type-references) for more details.
+ TypeName string `protobuf:"bytes,1,opt,name=type_name,json=typeName,proto3" json:"type_name,omitempty"`
+}
+
+func (x *TypeReference) Reset() {
+ *x = TypeReference{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_google_api_field_info_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *TypeReference) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TypeReference) ProtoMessage() {}
+
+func (x *TypeReference) ProtoReflect() protoreflect.Message {
+ mi := &file_google_api_field_info_proto_msgTypes[1]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use TypeReference.ProtoReflect.Descriptor instead.
+func (*TypeReference) Descriptor() ([]byte, []int) {
+ return file_google_api_field_info_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *TypeReference) GetTypeName() string {
+ if x != nil {
+ return x.TypeName
+ }
+ return ""
+}
+
var file_google_api_field_info_proto_extTypes = []protoimpl.ExtensionInfo{
{
ExtendedType: (*descriptorpb.FieldOptions)(nil),
@@ -185,6 +254,13 @@ var (
// string actual_ip_address = 4 [
// (google.api.field_info).format = IPV4_OR_IPV6
// ];
+ // google.protobuf.Any generic_field = 5 [
+ // (google.api.field_info).referenced_types = {type_name: "ActualType"},
+ // (google.api.field_info).referenced_types = {type_name: "OtherType"},
+ // ];
+ // google.protobuf.Any generic_user_input = 5 [
+ // (google.api.field_info).referenced_types = {type_name: "*"},
+ // ];
//
// optional google.api.FieldInfo field_info = 291403980;
E_FieldInfo = &file_google_api_field_info_proto_extTypes[0]
@@ -197,30 +273,37 @@ var file_google_api_field_info_proto_rawDesc = []byte{
0x6c, 0x64, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0a, 0x67,
0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72,
- 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x94, 0x01, 0x0a, 0x09,
+ 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xda, 0x01, 0x0a, 0x09,
0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x34, 0x0a, 0x06, 0x66, 0x6f, 0x72,
0x6d, 0x61, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x66, 0x6f,
- 0x2e, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x22,
- 0x51, 0x0a, 0x06, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x16, 0x0a, 0x12, 0x46, 0x4f, 0x52,
- 0x4d, 0x41, 0x54, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10,
- 0x00, 0x12, 0x09, 0x0a, 0x05, 0x55, 0x55, 0x49, 0x44, 0x34, 0x10, 0x01, 0x12, 0x08, 0x0a, 0x04,
- 0x49, 0x50, 0x56, 0x34, 0x10, 0x02, 0x12, 0x08, 0x0a, 0x04, 0x49, 0x50, 0x56, 0x36, 0x10, 0x03,
- 0x12, 0x10, 0x0a, 0x0c, 0x49, 0x50, 0x56, 0x34, 0x5f, 0x4f, 0x52, 0x5f, 0x49, 0x50, 0x56, 0x36,
- 0x10, 0x04, 0x3a, 0x57, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x69, 0x6e, 0x66, 0x6f,
- 0x12, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
- 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18,
- 0xcc, 0xf1, 0xf9, 0x8a, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
- 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x66, 0x6f,
- 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x42, 0x6c, 0x0a, 0x0e, 0x63,
- 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x42, 0x0e, 0x46,
- 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a,
- 0x41, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f,
- 0x72, 0x67, 0x2f, 0x67, 0x65, 0x6e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x6f, 0x67,
- 0x6c, 0x65, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74,
- 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f,
- 0x6e, 0x73, 0xa2, 0x02, 0x04, 0x47, 0x41, 0x50, 0x49, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
- 0x33,
+ 0x2e, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12,
+ 0x44, 0x0a, 0x10, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x64, 0x5f, 0x74, 0x79,
+ 0x70, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+ 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x66, 0x65, 0x72,
+ 0x65, 0x6e, 0x63, 0x65, 0x52, 0x0f, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x64,
+ 0x54, 0x79, 0x70, 0x65, 0x73, 0x22, 0x51, 0x0a, 0x06, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12,
+ 0x16, 0x0a, 0x12, 0x46, 0x4f, 0x52, 0x4d, 0x41, 0x54, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43,
+ 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x55, 0x55, 0x49, 0x44, 0x34,
+ 0x10, 0x01, 0x12, 0x08, 0x0a, 0x04, 0x49, 0x50, 0x56, 0x34, 0x10, 0x02, 0x12, 0x08, 0x0a, 0x04,
+ 0x49, 0x50, 0x56, 0x36, 0x10, 0x03, 0x12, 0x10, 0x0a, 0x0c, 0x49, 0x50, 0x56, 0x34, 0x5f, 0x4f,
+ 0x52, 0x5f, 0x49, 0x50, 0x56, 0x36, 0x10, 0x04, 0x22, 0x2c, 0x0a, 0x0d, 0x54, 0x79, 0x70, 0x65,
+ 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x79, 0x70,
+ 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x74, 0x79,
+ 0x70, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x3a, 0x57, 0x0a, 0x0a, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f,
+ 0x69, 0x6e, 0x66, 0x6f, 0x12, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+ 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69,
+ 0x6f, 0x6e, 0x73, 0x18, 0xcc, 0xf1, 0xf9, 0x8a, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e,
+ 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64,
+ 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x42,
+ 0x6c, 0x0a, 0x0e, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70,
+ 0x69, 0x42, 0x0e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x50, 0x72, 0x6f, 0x74,
+ 0x6f, 0x50, 0x01, 0x5a, 0x41, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61,
+ 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x67, 0x65, 0x6e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f,
+ 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61,
+ 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x61, 0x6e, 0x6e, 0x6f, 0x74,
+ 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0xa2, 0x02, 0x04, 0x47, 0x41, 0x50, 0x49, 0x62, 0x06, 0x70,
+ 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
@@ -236,21 +319,23 @@ func file_google_api_field_info_proto_rawDescGZIP() []byte {
}
var file_google_api_field_info_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
-var file_google_api_field_info_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_google_api_field_info_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_google_api_field_info_proto_goTypes = []interface{}{
(FieldInfo_Format)(0), // 0: google.api.FieldInfo.Format
(*FieldInfo)(nil), // 1: google.api.FieldInfo
- (*descriptorpb.FieldOptions)(nil), // 2: google.protobuf.FieldOptions
+ (*TypeReference)(nil), // 2: google.api.TypeReference
+ (*descriptorpb.FieldOptions)(nil), // 3: google.protobuf.FieldOptions
}
var file_google_api_field_info_proto_depIdxs = []int32{
0, // 0: google.api.FieldInfo.format:type_name -> google.api.FieldInfo.Format
- 2, // 1: google.api.field_info:extendee -> google.protobuf.FieldOptions
- 1, // 2: google.api.field_info:type_name -> google.api.FieldInfo
- 3, // [3:3] is the sub-list for method output_type
- 3, // [3:3] is the sub-list for method input_type
- 2, // [2:3] is the sub-list for extension type_name
- 1, // [1:2] is the sub-list for extension extendee
- 0, // [0:1] is the sub-list for field type_name
+ 2, // 1: google.api.FieldInfo.referenced_types:type_name -> google.api.TypeReference
+ 3, // 2: google.api.field_info:extendee -> google.protobuf.FieldOptions
+ 1, // 3: google.api.field_info:type_name -> google.api.FieldInfo
+ 4, // [4:4] is the sub-list for method output_type
+ 4, // [4:4] is the sub-list for method input_type
+ 3, // [3:4] is the sub-list for extension type_name
+ 2, // [2:3] is the sub-list for extension extendee
+ 0, // [0:2] is the sub-list for field type_name
}
func init() { file_google_api_field_info_proto_init() }
@@ -271,6 +356,18 @@ func file_google_api_field_info_proto_init() {
return nil
}
}
+ file_google_api_field_info_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*TypeReference); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
}
type x struct{}
out := protoimpl.TypeBuilder{
@@ -278,7 +375,7 @@ func file_google_api_field_info_proto_init() {
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_google_api_field_info_proto_rawDesc,
NumEnums: 1,
- NumMessages: 1,
+ NumMessages: 2,
NumExtensions: 1,
NumServices: 0,
},
diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/http.pb.go b/vendor/google.golang.org/genproto/googleapis/api/annotations/http.pb.go
index 8a0e1c345b..ffb5838cb1 100644
--- a/vendor/google.golang.org/genproto/googleapis/api/annotations/http.pb.go
+++ b/vendor/google.golang.org/genproto/googleapis/api/annotations/http.pb.go
@@ -1,4 +1,4 @@
-// Copyright 2023 Google LLC
+// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -15,7 +15,7 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.26.0
-// protoc v3.21.9
+// protoc v4.24.4
// source: google/api/http.proto
package annotations
@@ -102,7 +102,7 @@ func (x *Http) GetFullyDecodeReservedExpansion() bool {
return false
}
-// # gRPC Transcoding
+// gRPC Transcoding
//
// gRPC Transcoding is a feature for mapping between a gRPC method and one or
// more HTTP REST endpoints. It allows developers to build a single API service
@@ -143,9 +143,8 @@ func (x *Http) GetFullyDecodeReservedExpansion() bool {
//
// This enables an HTTP REST to gRPC mapping as below:
//
-// HTTP | gRPC
-// -----|-----
-// `GET /v1/messages/123456` | `GetMessage(name: "messages/123456")`
+// - HTTP: `GET /v1/messages/123456`
+// - gRPC: `GetMessage(name: "messages/123456")`
//
// Any fields in the request message which are not bound by the path template
// automatically become HTTP query parameters if there is no HTTP request body.
@@ -169,11 +168,9 @@ func (x *Http) GetFullyDecodeReservedExpansion() bool {
//
// This enables a HTTP JSON to RPC mapping as below:
//
-// HTTP | gRPC
-// -----|-----
-// `GET /v1/messages/123456?revision=2&sub.subfield=foo` |
-// `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield:
-// "foo"))`
+// - HTTP: `GET /v1/messages/123456?revision=2&sub.subfield=foo`
+// - gRPC: `GetMessage(message_id: "123456" revision: 2 sub:
+// SubMessage(subfield: "foo"))`
//
// Note that fields which are mapped to URL query parameters must have a
// primitive type or a repeated primitive type or a non-repeated message type.
@@ -203,10 +200,8 @@ func (x *Http) GetFullyDecodeReservedExpansion() bool {
// representation of the JSON in the request body is determined by
// protos JSON encoding:
//
-// HTTP | gRPC
-// -----|-----
-// `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id:
-// "123456" message { text: "Hi!" })`
+// - HTTP: `PATCH /v1/messages/123456 { "text": "Hi!" }`
+// - gRPC: `UpdateMessage(message_id: "123456" message { text: "Hi!" })`
//
// The special name `*` can be used in the body mapping to define that
// every field not bound by the path template should be mapped to the
@@ -228,10 +223,8 @@ func (x *Http) GetFullyDecodeReservedExpansion() bool {
//
// The following HTTP JSON to RPC mapping is enabled:
//
-// HTTP | gRPC
-// -----|-----
-// `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id:
-// "123456" text: "Hi!")`
+// - HTTP: `PATCH /v1/messages/123456 { "text": "Hi!" }`
+// - gRPC: `UpdateMessage(message_id: "123456" text: "Hi!")`
//
// Note that when using `*` in the body mapping, it is not possible to
// have HTTP parameters, as all fields not bound by the path end in
@@ -259,13 +252,13 @@ func (x *Http) GetFullyDecodeReservedExpansion() bool {
//
// This enables the following two alternative HTTP JSON to RPC mappings:
//
-// HTTP | gRPC
-// -----|-----
-// `GET /v1/messages/123456` | `GetMessage(message_id: "123456")`
-// `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id:
-// "123456")`
+// - HTTP: `GET /v1/messages/123456`
+// - gRPC: `GetMessage(message_id: "123456")`
//
-// ## Rules for HTTP mapping
+// - HTTP: `GET /v1/users/me/messages/123456`
+// - gRPC: `GetMessage(user_id: "me" message_id: "123456")`
+//
+// # Rules for HTTP mapping
//
// 1. Leaf request fields (recursive expansion nested messages in the request
// message) are classified into three categories:
@@ -284,7 +277,7 @@ func (x *Http) GetFullyDecodeReservedExpansion() bool {
// request body, all
// fields are passed via URL path and URL query parameters.
//
-// ### Path template syntax
+// Path template syntax
//
// Template = "/" Segments [ Verb ] ;
// Segments = Segment { "/" Segment } ;
@@ -323,7 +316,7 @@ func (x *Http) GetFullyDecodeReservedExpansion() bool {
// Document](https://developers.google.com/discovery/v1/reference/apis) as
// `{+var}`.
//
-// ## Using gRPC API Service Configuration
+// # Using gRPC API Service Configuration
//
// gRPC API Service Configuration (service config) is a configuration language
// for configuring a gRPC service to become a user-facing product. The
@@ -338,15 +331,14 @@ func (x *Http) GetFullyDecodeReservedExpansion() bool {
// specified in the service config will override any matching transcoding
// configuration in the proto.
//
-// Example:
+// The following example selects a gRPC method and applies an `HttpRule` to it:
//
// http:
// rules:
-// # Selects a gRPC method and applies HttpRule to it.
// - selector: example.v1.Messaging.GetMessage
// get: /v1/messages/{message_id}/{sub.subfield}
//
-// ## Special notes
+// # Special notes
//
// When gRPC Transcoding is used to map a gRPC to JSON REST endpoints, the
// proto to JSON conversion must follow the [proto3
diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/resource.pb.go b/vendor/google.golang.org/genproto/googleapis/api/annotations/resource.pb.go
index bbcc12d29c..b5db279aeb 100644
--- a/vendor/google.golang.org/genproto/googleapis/api/annotations/resource.pb.go
+++ b/vendor/google.golang.org/genproto/googleapis/api/annotations/resource.pb.go
@@ -1,4 +1,4 @@
-// Copyright 2023 Google LLC
+// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -15,7 +15,7 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.26.0
-// protoc v3.21.9
+// protoc v4.24.4
// source: google/api/resource.proto
package annotations
@@ -253,8 +253,13 @@ type ResourceDescriptor struct {
History ResourceDescriptor_History `protobuf:"varint,4,opt,name=history,proto3,enum=google.api.ResourceDescriptor_History" json:"history,omitempty"`
// The plural name used in the resource name and permission names, such as
// 'projects' for the resource name of 'projects/{project}' and the permission
- // name of 'cloudresourcemanager.googleapis.com/projects.get'. It is the same
- // concept of the `plural` field in k8s CRD spec
+ // name of 'cloudresourcemanager.googleapis.com/projects.get'. One exception
+ // to this is for Nested Collections that have stuttering names, as defined
+ // in [AIP-122](https://google.aip.dev/122#nested-collections), where the
+ // collection ID in the resource name pattern does not necessarily directly
+ // match the `plural` value.
+ //
+ // It is the same concept of the `plural` field in k8s CRD spec
// https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions/
//
// Note: The plural form is required even for singleton resources. See
diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/routing.pb.go b/vendor/google.golang.org/genproto/googleapis/api/annotations/routing.pb.go
index 9a9ae04c29..1d8397b02b 100644
--- a/vendor/google.golang.org/genproto/googleapis/api/annotations/routing.pb.go
+++ b/vendor/google.golang.org/genproto/googleapis/api/annotations/routing.pb.go
@@ -1,4 +1,4 @@
-// Copyright 2023 Google LLC
+// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -15,7 +15,7 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.26.0
-// protoc v3.21.9
+// protoc v4.24.4
// source: google/api/routing.proto
package annotations
diff --git a/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/checked.pb.go b/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/checked.pb.go
index 137ff5b1e9..9f81dbcd86 100644
--- a/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/checked.pb.go
+++ b/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/checked.pb.go
@@ -1,4 +1,4 @@
-// Copyright 2023 Google LLC
+// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
diff --git a/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/eval.pb.go b/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/eval.pb.go
index ca4415956f..0a2ffb5955 100644
--- a/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/eval.pb.go
+++ b/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/eval.pb.go
@@ -1,4 +1,4 @@
-// Copyright 2023 Google LLC
+// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
diff --git a/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/explain.pb.go b/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/explain.pb.go
index 3f994b4e3e..57aaa2c9f5 100644
--- a/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/explain.pb.go
+++ b/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/explain.pb.go
@@ -1,4 +1,4 @@
-// Copyright 2023 Google LLC
+// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
diff --git a/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/syntax.pb.go b/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/syntax.pb.go
index 0d718fc36d..c90c6015d2 100644
--- a/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/syntax.pb.go
+++ b/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/syntax.pb.go
@@ -1,4 +1,4 @@
-// Copyright 2023 Google LLC
+// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -1105,25 +1105,66 @@ func (x *Expr_CreateStruct) GetEntries() []*Expr_CreateStruct_Entry {
// messages `has(m.x)` is defined as 'defined, but not set`. For proto3, the
// macro tests whether the property is set to its default. For map and struct
// types, the macro tests whether the property `x` is defined on `m`.
+//
+// Comprehensions for the standard environment macros evaluation can be best
+// visualized as the following pseudocode:
+//
+// ```
+// let `accu_var` = `accu_init`
+//
+// for (let `iter_var` in `iter_range`) {
+// if (!`loop_condition`) {
+// break
+// }
+// `accu_var` = `loop_step`
+// }
+//
+// return `result`
+// ```
+//
+// Comprehensions for the optional V2 macros which support map-to-map
+// translation differ slightly from the standard environment macros in that
+// they expose both the key or index in addition to the value for each list
+// or map entry:
+//
+// ```
+// let `accu_var` = `accu_init`
+//
+// for (let `iter_var`, `iter_var2` in `iter_range`) {
+// if (!`loop_condition`) {
+// break
+// }
+// `accu_var` = `loop_step`
+// }
+//
+// return `result`
+// ```
type Expr_Comprehension struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
- // The name of the iteration variable.
+ // The name of the first iteration variable.
+ // When the iter_range is a list, this variable is the list element.
+ // When the iter_range is a map, this variable is the map entry key.
IterVar string `protobuf:"bytes,1,opt,name=iter_var,json=iterVar,proto3" json:"iter_var,omitempty"`
- // The range over which var iterates.
+ // The name of the second iteration variable, empty if not set.
+ // When the iter_range is a list, this variable is the integer index.
+ // When the iter_range is a map, this variable is the map entry value.
+ // This field is only set for comprehension v2 macros.
+ IterVar2 string `protobuf:"bytes,8,opt,name=iter_var2,json=iterVar2,proto3" json:"iter_var2,omitempty"`
+ // The range over which the comprehension iterates.
IterRange *Expr `protobuf:"bytes,2,opt,name=iter_range,json=iterRange,proto3" json:"iter_range,omitempty"`
// The name of the variable used for accumulation of the result.
AccuVar string `protobuf:"bytes,3,opt,name=accu_var,json=accuVar,proto3" json:"accu_var,omitempty"`
// The initial value of the accumulator.
AccuInit *Expr `protobuf:"bytes,4,opt,name=accu_init,json=accuInit,proto3" json:"accu_init,omitempty"`
- // An expression which can contain iter_var and accu_var.
+ // An expression which can contain iter_var, iter_var2, and accu_var.
//
// Returns false when the result has been computed and may be used as
// a hint to short-circuit the remainder of the comprehension.
LoopCondition *Expr `protobuf:"bytes,5,opt,name=loop_condition,json=loopCondition,proto3" json:"loop_condition,omitempty"`
- // An expression which can contain iter_var and accu_var.
+ // An expression which can contain iter_var, iter_var2, and accu_var.
//
// Computes the next value of accu_var.
LoopStep *Expr `protobuf:"bytes,6,opt,name=loop_step,json=loopStep,proto3" json:"loop_step,omitempty"`
@@ -1172,6 +1213,13 @@ func (x *Expr_Comprehension) GetIterVar() string {
return ""
}
+func (x *Expr_Comprehension) GetIterVar2() string {
+ if x != nil {
+ return x.IterVar2
+ }
+ return ""
+}
+
func (x *Expr_Comprehension) GetIterRange() *Expr {
if x != nil {
return x.IterRange
@@ -1485,7 +1533,7 @@ var file_google_api_expr_v1alpha1_syntax_proto_rawDesc = []byte{
0x66, 0x6f, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x65, 0x78, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70,
0x68, 0x61, 0x31, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0a,
- 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0xae, 0x0d, 0x0a, 0x04, 0x45,
+ 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0xcb, 0x0d, 0x0a, 0x04, 0x45,
0x78, 0x70, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52,
0x02, 0x69, 0x64, 0x12, 0x43, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x5f, 0x65, 0x78, 0x70,
0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
@@ -1567,132 +1615,134 @@ var file_google_api_expr_v1alpha1_syntax_proto_rawDesc = []byte{
0x45, 0x78, 0x70, 0x72, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x6f,
0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x18, 0x05, 0x20,
0x01, 0x28, 0x08, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x45, 0x6e, 0x74,
- 0x72, 0x79, 0x42, 0x0a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x1a, 0xfd,
- 0x02, 0x0a, 0x0d, 0x43, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x68, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+ 0x72, 0x79, 0x42, 0x0a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x1a, 0x9a,
+ 0x03, 0x0a, 0x0d, 0x43, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x68, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
0x12, 0x19, 0x0a, 0x08, 0x69, 0x74, 0x65, 0x72, 0x5f, 0x76, 0x61, 0x72, 0x18, 0x01, 0x20, 0x01,
- 0x28, 0x09, 0x52, 0x07, 0x69, 0x74, 0x65, 0x72, 0x56, 0x61, 0x72, 0x12, 0x3d, 0x0a, 0x0a, 0x69,
- 0x74, 0x65, 0x72, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
- 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x65, 0x78, 0x70,
- 0x72, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x72, 0x52,
- 0x09, 0x69, 0x74, 0x65, 0x72, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x61, 0x63,
- 0x63, 0x75, 0x5f, 0x76, 0x61, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x63,
- 0x63, 0x75, 0x56, 0x61, 0x72, 0x12, 0x3b, 0x0a, 0x09, 0x61, 0x63, 0x63, 0x75, 0x5f, 0x69, 0x6e,
- 0x69, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
- 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x65, 0x78, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70,
- 0x68, 0x61, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x72, 0x52, 0x08, 0x61, 0x63, 0x63, 0x75, 0x49, 0x6e,
- 0x69, 0x74, 0x12, 0x45, 0x0a, 0x0e, 0x6c, 0x6f, 0x6f, 0x70, 0x5f, 0x63, 0x6f, 0x6e, 0x64, 0x69,
- 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x6f,
- 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x65, 0x78, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x61,
- 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x72, 0x52, 0x0d, 0x6c, 0x6f, 0x6f, 0x70,
- 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3b, 0x0a, 0x09, 0x6c, 0x6f, 0x6f,
- 0x70, 0x5f, 0x73, 0x74, 0x65, 0x70, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67,
+ 0x28, 0x09, 0x52, 0x07, 0x69, 0x74, 0x65, 0x72, 0x56, 0x61, 0x72, 0x12, 0x1b, 0x0a, 0x09, 0x69,
+ 0x74, 0x65, 0x72, 0x5f, 0x76, 0x61, 0x72, 0x32, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08,
+ 0x69, 0x74, 0x65, 0x72, 0x56, 0x61, 0x72, 0x32, 0x12, 0x3d, 0x0a, 0x0a, 0x69, 0x74, 0x65, 0x72,
+ 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67,
0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x65, 0x78, 0x70, 0x72, 0x2e, 0x76,
- 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x72, 0x52, 0x08, 0x6c, 0x6f,
- 0x6f, 0x70, 0x53, 0x74, 0x65, 0x70, 0x12, 0x36, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74,
- 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
- 0x61, 0x70, 0x69, 0x2e, 0x65, 0x78, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
- 0x31, 0x2e, 0x45, 0x78, 0x70, 0x72, 0x52, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x42, 0x0b,
- 0x0a, 0x09, 0x65, 0x78, 0x70, 0x72, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x22, 0xc1, 0x03, 0x0a, 0x08,
- 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x12, 0x3b, 0x0a, 0x0a, 0x6e, 0x75, 0x6c, 0x6c,
- 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x67,
- 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4e,
- 0x75, 0x6c, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x09, 0x6e, 0x75, 0x6c, 0x6c,
- 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1f, 0x0a, 0x0a, 0x62, 0x6f, 0x6f, 0x6c, 0x5f, 0x76, 0x61,
- 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x09, 0x62, 0x6f, 0x6f,
- 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0b, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x5f,
- 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x0a, 0x69,
- 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x75, 0x69, 0x6e,
- 0x74, 0x36, 0x34, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x48,
- 0x00, 0x52, 0x0b, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23,
- 0x0a, 0x0c, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05,
- 0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, 0x0b, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x56, 0x61,
- 0x6c, 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x76, 0x61,
- 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x73, 0x74, 0x72,
- 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0b, 0x62, 0x79, 0x74, 0x65,
- 0x73, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52,
- 0x0a, 0x62, 0x79, 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x46, 0x0a, 0x0e, 0x64,
- 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20,
- 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
- 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x02,
- 0x18, 0x01, 0x48, 0x00, 0x52, 0x0d, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x61,
- 0x6c, 0x75, 0x65, 0x12, 0x49, 0x0a, 0x0f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
- 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67,
- 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54,
- 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x02, 0x18, 0x01, 0x48, 0x00, 0x52, 0x0e,
- 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x0f,
- 0x0a, 0x0d, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x22,
- 0x8c, 0x07, 0x0a, 0x0a, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x25,
- 0x0a, 0x0e, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
- 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x56, 0x65,
- 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f,
- 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f,
- 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74,
- 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0b, 0x6c, 0x69, 0x6e, 0x65, 0x4f, 0x66, 0x66,
- 0x73, 0x65, 0x74, 0x73, 0x12, 0x51, 0x0a, 0x09, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
- 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+ 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x72, 0x52, 0x09, 0x69, 0x74,
+ 0x65, 0x72, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x61, 0x63, 0x63, 0x75, 0x5f,
+ 0x76, 0x61, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x63, 0x63, 0x75, 0x56,
+ 0x61, 0x72, 0x12, 0x3b, 0x0a, 0x09, 0x61, 0x63, 0x63, 0x75, 0x5f, 0x69, 0x6e, 0x69, 0x74, 0x18,
+ 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61,
+ 0x70, 0x69, 0x2e, 0x65, 0x78, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31,
+ 0x2e, 0x45, 0x78, 0x70, 0x72, 0x52, 0x08, 0x61, 0x63, 0x63, 0x75, 0x49, 0x6e, 0x69, 0x74, 0x12,
+ 0x45, 0x0a, 0x0e, 0x6c, 0x6f, 0x6f, 0x70, 0x5f, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f,
+ 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
0x2e, 0x61, 0x70, 0x69, 0x2e, 0x65, 0x78, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68,
- 0x61, 0x31, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x50, 0x6f,
- 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x09, 0x70, 0x6f,
- 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x55, 0x0a, 0x0b, 0x6d, 0x61, 0x63, 0x72, 0x6f,
- 0x5f, 0x63, 0x61, 0x6c, 0x6c, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x67,
- 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x65, 0x78, 0x70, 0x72, 0x2e, 0x76,
- 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e,
- 0x66, 0x6f, 0x2e, 0x4d, 0x61, 0x63, 0x72, 0x6f, 0x43, 0x61, 0x6c, 0x6c, 0x73, 0x45, 0x6e, 0x74,
- 0x72, 0x79, 0x52, 0x0a, 0x6d, 0x61, 0x63, 0x72, 0x6f, 0x43, 0x61, 0x6c, 0x6c, 0x73, 0x12, 0x4e,
- 0x0a, 0x0a, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x06, 0x20, 0x03,
- 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e,
- 0x65, 0x78, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x6f,
- 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
- 0x6f, 0x6e, 0x52, 0x0a, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x80,
- 0x03, 0x0a, 0x09, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x0e, 0x0a, 0x02,
- 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x69, 0x0a, 0x13,
- 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65,
- 0x6e, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x38, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+ 0x61, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x72, 0x52, 0x0d, 0x6c, 0x6f, 0x6f, 0x70, 0x43, 0x6f, 0x6e,
+ 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3b, 0x0a, 0x09, 0x6c, 0x6f, 0x6f, 0x70, 0x5f, 0x73,
+ 0x74, 0x65, 0x70, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x65, 0x78, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x61, 0x6c,
- 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x2e,
- 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
- 0x65, 0x6e, 0x74, 0x52, 0x12, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x6d,
- 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x50, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69,
- 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
- 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x65, 0x78, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70,
- 0x68, 0x61, 0x31, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x45,
- 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
- 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x1a, 0x35, 0x0a, 0x07, 0x56, 0x65, 0x72,
- 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x18, 0x01, 0x20,
- 0x01, 0x28, 0x03, 0x52, 0x05, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x69,
- 0x6e, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x6d, 0x69, 0x6e, 0x6f, 0x72,
- 0x22, 0x6f, 0x0a, 0x09, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x12, 0x19, 0x0a,
- 0x15, 0x43, 0x4f, 0x4d, 0x50, 0x4f, 0x4e, 0x45, 0x4e, 0x54, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45,
- 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, 0x43, 0x4f, 0x4d, 0x50,
- 0x4f, 0x4e, 0x45, 0x4e, 0x54, 0x5f, 0x50, 0x41, 0x52, 0x53, 0x45, 0x52, 0x10, 0x01, 0x12, 0x1a,
- 0x0a, 0x16, 0x43, 0x4f, 0x4d, 0x50, 0x4f, 0x4e, 0x45, 0x4e, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45,
- 0x5f, 0x43, 0x48, 0x45, 0x43, 0x4b, 0x45, 0x52, 0x10, 0x02, 0x12, 0x15, 0x0a, 0x11, 0x43, 0x4f,
- 0x4d, 0x50, 0x4f, 0x4e, 0x45, 0x4e, 0x54, 0x5f, 0x52, 0x55, 0x4e, 0x54, 0x49, 0x4d, 0x45, 0x10,
- 0x03, 0x1a, 0x3c, 0x0a, 0x0e, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e,
- 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03,
- 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02,
- 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a,
- 0x5d, 0x0a, 0x0f, 0x4d, 0x61, 0x63, 0x72, 0x6f, 0x43, 0x61, 0x6c, 0x6c, 0x73, 0x45, 0x6e, 0x74,
- 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52,
- 0x03, 0x6b, 0x65, 0x79, 0x12, 0x34, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20,
+ 0x70, 0x68, 0x61, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x72, 0x52, 0x08, 0x6c, 0x6f, 0x6f, 0x70, 0x53,
+ 0x74, 0x65, 0x70, 0x12, 0x36, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x07, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69,
0x2e, 0x65, 0x78, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x45,
- 0x78, 0x70, 0x72, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x70,
- 0x0a, 0x0e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
- 0x12, 0x1a, 0x0a, 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01,
- 0x28, 0x09, 0x52, 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06,
- 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x6f, 0x66,
- 0x66, 0x73, 0x65, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x03, 0x20, 0x01,
- 0x28, 0x05, 0x52, 0x04, 0x6c, 0x69, 0x6e, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6c, 0x75,
- 0x6d, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e,
- 0x42, 0x6e, 0x0a, 0x1c, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61,
+ 0x78, 0x70, 0x72, 0x52, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x42, 0x0b, 0x0a, 0x09, 0x65,
+ 0x78, 0x70, 0x72, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x22, 0xc1, 0x03, 0x0a, 0x08, 0x43, 0x6f, 0x6e,
+ 0x73, 0x74, 0x61, 0x6e, 0x74, 0x12, 0x3b, 0x0a, 0x0a, 0x6e, 0x75, 0x6c, 0x6c, 0x5f, 0x76, 0x61,
+ 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+ 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4e, 0x75, 0x6c, 0x6c,
+ 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x09, 0x6e, 0x75, 0x6c, 0x6c, 0x56, 0x61, 0x6c,
+ 0x75, 0x65, 0x12, 0x1f, 0x0a, 0x0a, 0x62, 0x6f, 0x6f, 0x6c, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65,
+ 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x09, 0x62, 0x6f, 0x6f, 0x6c, 0x56, 0x61,
+ 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0b, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x5f, 0x76, 0x61, 0x6c,
+ 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x0a, 0x69, 0x6e, 0x74, 0x36,
+ 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34,
+ 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x48, 0x00, 0x52, 0x0b,
+ 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x64,
+ 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28,
+ 0x01, 0x48, 0x00, 0x52, 0x0b, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
+ 0x12, 0x23, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65,
+ 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+ 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0b, 0x62, 0x79, 0x74, 0x65, 0x73, 0x5f, 0x76,
+ 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0a, 0x62, 0x79,
+ 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x46, 0x0a, 0x0e, 0x64, 0x75, 0x72, 0x61,
+ 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b,
+ 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+ 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x02, 0x18, 0x01, 0x48,
+ 0x00, 0x52, 0x0d, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x61, 0x6c, 0x75, 0x65,
+ 0x12, 0x49, 0x0a, 0x0f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x76, 0x61,
+ 0x6c, 0x75, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+ 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65,
+ 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x02, 0x18, 0x01, 0x48, 0x00, 0x52, 0x0e, 0x74, 0x69, 0x6d,
+ 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x0f, 0x0a, 0x0d, 0x63,
+ 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x22, 0x8c, 0x07, 0x0a,
+ 0x0a, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x25, 0x0a, 0x0e, 0x73,
+ 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20,
+ 0x01, 0x28, 0x09, 0x52, 0x0d, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x56, 0x65, 0x72, 0x73, 0x69,
+ 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02,
+ 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x21,
+ 0x0a, 0x0c, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x73, 0x18, 0x03,
+ 0x20, 0x03, 0x28, 0x05, 0x52, 0x0b, 0x6c, 0x69, 0x6e, 0x65, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74,
+ 0x73, 0x12, 0x51, 0x0a, 0x09, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x04,
+ 0x20, 0x03, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70,
+ 0x69, 0x2e, 0x65, 0x78, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e,
+ 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x50, 0x6f, 0x73, 0x69, 0x74,
+ 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x09, 0x70, 0x6f, 0x73, 0x69, 0x74,
+ 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x55, 0x0a, 0x0b, 0x6d, 0x61, 0x63, 0x72, 0x6f, 0x5f, 0x63, 0x61,
+ 0x6c, 0x6c, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+ 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x65, 0x78, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x61, 0x6c,
+ 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x2e,
+ 0x4d, 0x61, 0x63, 0x72, 0x6f, 0x43, 0x61, 0x6c, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52,
+ 0x0a, 0x6d, 0x61, 0x63, 0x72, 0x6f, 0x43, 0x61, 0x6c, 0x6c, 0x73, 0x12, 0x4e, 0x0a, 0x0a, 0x65,
+ 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32,
+ 0x2e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x65, 0x78, 0x70,
+ 0x72, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63,
+ 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52,
+ 0x0a, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x80, 0x03, 0x0a, 0x09,
+ 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18,
+ 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x69, 0x0a, 0x13, 0x61, 0x66, 0x66,
+ 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73,
+ 0x18, 0x02, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x38, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+ 0x61, 0x70, 0x69, 0x2e, 0x65, 0x78, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
+ 0x31, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x45, 0x78, 0x74,
+ 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
+ 0x52, 0x12, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
+ 0x65, 0x6e, 0x74, 0x73, 0x12, 0x50, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18,
+ 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61,
0x70, 0x69, 0x2e, 0x65, 0x78, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31,
- 0x42, 0x0b, 0x53, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a,
- 0x3c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f,
- 0x72, 0x67, 0x2f, 0x67, 0x65, 0x6e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x6f, 0x67,
- 0x6c, 0x65, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x65, 0x78, 0x70, 0x72, 0x2f,
- 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x3b, 0x65, 0x78, 0x70, 0x72, 0xf8, 0x01, 0x01,
- 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+ 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x45, 0x78, 0x74, 0x65,
+ 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x76,
+ 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x1a, 0x35, 0x0a, 0x07, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f,
+ 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03,
+ 0x52, 0x05, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x69, 0x6e, 0x6f, 0x72,
+ 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x6d, 0x69, 0x6e, 0x6f, 0x72, 0x22, 0x6f, 0x0a,
+ 0x09, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x12, 0x19, 0x0a, 0x15, 0x43, 0x4f,
+ 0x4d, 0x50, 0x4f, 0x4e, 0x45, 0x4e, 0x54, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46,
+ 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, 0x43, 0x4f, 0x4d, 0x50, 0x4f, 0x4e, 0x45,
+ 0x4e, 0x54, 0x5f, 0x50, 0x41, 0x52, 0x53, 0x45, 0x52, 0x10, 0x01, 0x12, 0x1a, 0x0a, 0x16, 0x43,
+ 0x4f, 0x4d, 0x50, 0x4f, 0x4e, 0x45, 0x4e, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, 0x48,
+ 0x45, 0x43, 0x4b, 0x45, 0x52, 0x10, 0x02, 0x12, 0x15, 0x0a, 0x11, 0x43, 0x4f, 0x4d, 0x50, 0x4f,
+ 0x4e, 0x45, 0x4e, 0x54, 0x5f, 0x52, 0x55, 0x4e, 0x54, 0x49, 0x4d, 0x45, 0x10, 0x03, 0x1a, 0x3c,
+ 0x0a, 0x0e, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79,
+ 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b,
+ 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
+ 0x05, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x5d, 0x0a, 0x0f,
+ 0x4d, 0x61, 0x63, 0x72, 0x6f, 0x43, 0x61, 0x6c, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12,
+ 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65,
+ 0x79, 0x12, 0x34, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
+ 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x65, 0x78,
+ 0x70, 0x72, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x72,
+ 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x70, 0x0a, 0x0e, 0x53,
+ 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a,
+ 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+ 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x66, 0x66,
+ 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65,
+ 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52,
+ 0x04, 0x6c, 0x69, 0x6e, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x18,
+ 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x42, 0x6e, 0x0a,
+ 0x1c, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e,
+ 0x65, 0x78, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x42, 0x0b, 0x53,
+ 0x79, 0x6e, 0x74, 0x61, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3c, 0x67, 0x6f,
+ 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f,
+ 0x67, 0x65, 0x6e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x61,
+ 0x70, 0x69, 0x73, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x65, 0x78, 0x70, 0x72, 0x2f, 0x76, 0x31, 0x61,
+ 0x6c, 0x70, 0x68, 0x61, 0x31, 0x3b, 0x65, 0x78, 0x70, 0x72, 0xf8, 0x01, 0x01, 0x62, 0x06, 0x70,
+ 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
diff --git a/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/value.pb.go b/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/value.pb.go
index 033f238684..0a5ca6a1b9 100644
--- a/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/value.pb.go
+++ b/vendor/google.golang.org/genproto/googleapis/api/expr/v1alpha1/value.pb.go
@@ -1,4 +1,4 @@
-// Copyright 2023 Google LLC
+// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
diff --git a/vendor/google.golang.org/genproto/googleapis/api/httpbody/httpbody.pb.go b/vendor/google.golang.org/genproto/googleapis/api/httpbody/httpbody.pb.go
index 3543268f84..e7d3805e36 100644
--- a/vendor/google.golang.org/genproto/googleapis/api/httpbody/httpbody.pb.go
+++ b/vendor/google.golang.org/genproto/googleapis/api/httpbody/httpbody.pb.go
@@ -1,4 +1,4 @@
-// Copyright 2023 Google LLC
+// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -15,7 +15,7 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.26.0
-// protoc v3.21.9
+// protoc v4.24.4
// source: google/api/httpbody.proto
package httpbody
diff --git a/vendor/google.golang.org/genproto/googleapis/api/launch_stage.pb.go b/vendor/google.golang.org/genproto/googleapis/api/launch_stage.pb.go
index 454948669d..498020e33c 100644
--- a/vendor/google.golang.org/genproto/googleapis/api/launch_stage.pb.go
+++ b/vendor/google.golang.org/genproto/googleapis/api/launch_stage.pb.go
@@ -1,4 +1,4 @@
-// Copyright 2023 Google LLC
+// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -15,7 +15,7 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.26.0
-// protoc v3.21.9
+// protoc v4.24.4
// source: google/api/launch_stage.proto
package api
diff --git a/vendor/google.golang.org/genproto/googleapis/rpc/errdetails/error_details.pb.go b/vendor/google.golang.org/genproto/googleapis/rpc/errdetails/error_details.pb.go
index 7bd161e48a..3e56218279 100644
--- a/vendor/google.golang.org/genproto/googleapis/rpc/errdetails/error_details.pb.go
+++ b/vendor/google.golang.org/genproto/googleapis/rpc/errdetails/error_details.pb.go
@@ -1,4 +1,4 @@
-// Copyright 2022 Google LLC
+// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -15,7 +15,7 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.26.0
-// protoc v3.21.9
+// protoc v4.24.4
// source: google/rpc/error_details.proto
package errdetails
diff --git a/vendor/google.golang.org/genproto/googleapis/rpc/status/status.pb.go b/vendor/google.golang.org/genproto/googleapis/rpc/status/status.pb.go
index a6b5081888..6ad1b1c1df 100644
--- a/vendor/google.golang.org/genproto/googleapis/rpc/status/status.pb.go
+++ b/vendor/google.golang.org/genproto/googleapis/rpc/status/status.pb.go
@@ -1,4 +1,4 @@
-// Copyright 2022 Google LLC
+// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -15,7 +15,7 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.26.0
-// protoc v3.21.9
+// protoc v4.24.4
// source: google/rpc/status.proto
package status
diff --git a/vendor/google.golang.org/grpc/CONTRIBUTING.md b/vendor/google.golang.org/grpc/CONTRIBUTING.md
index 0854d298e4..d9bfa6e1e7 100644
--- a/vendor/google.golang.org/grpc/CONTRIBUTING.md
+++ b/vendor/google.golang.org/grpc/CONTRIBUTING.md
@@ -4,7 +4,7 @@ We definitely welcome your patches and contributions to gRPC! Please read the gR
organization's [governance rules](https://github.com/grpc/grpc-community/blob/master/governance.md)
and [contribution guidelines](https://github.com/grpc/grpc-community/blob/master/CONTRIBUTING.md) before proceeding.
-If you are new to github, please start by reading [Pull Request howto](https://help.github.com/articles/about-pull-requests/)
+If you are new to GitHub, please start by reading [Pull Request howto](https://help.github.com/articles/about-pull-requests/)
## Legal requirements
@@ -25,8 +25,8 @@ How to get your contributions merged smoothly and quickly.
is a great place to start. These issues are well-documented and usually can be
resolved with a single pull request.
-- If you are adding a new file, make sure it has the copyright message template
- at the top as a comment. You can copy over the message from an existing file
+- If you are adding a new file, make sure it has the copyright message template
+ at the top as a comment. You can copy over the message from an existing file
and update the year.
- The grpc package should only depend on standard Go packages and a small number
@@ -39,12 +39,12 @@ How to get your contributions merged smoothly and quickly.
proposal](https://github.com/grpc/proposal).
- Provide a good **PR description** as a record of **what** change is being made
- and **why** it was made. Link to a github issue if it exists.
+ and **why** it was made. Link to a GitHub issue if it exists.
-- If you want to fix formatting or style, consider whether your changes are an
- obvious improvement or might be considered a personal preference. If a style
- change is based on preference, it likely will not be accepted. If it corrects
- widely agreed-upon anti-patterns, then please do create a PR and explain the
+- If you want to fix formatting or style, consider whether your changes are an
+ obvious improvement or might be considered a personal preference. If a style
+ change is based on preference, it likely will not be accepted. If it corrects
+ widely agreed-upon anti-patterns, then please do create a PR and explain the
benefits of the change.
- Unless your PR is trivial, you should expect there will be reviewer comments
diff --git a/vendor/google.golang.org/grpc/MAINTAINERS.md b/vendor/google.golang.org/grpc/MAINTAINERS.md
index 6a8a07781a..5d4096d46a 100644
--- a/vendor/google.golang.org/grpc/MAINTAINERS.md
+++ b/vendor/google.golang.org/grpc/MAINTAINERS.md
@@ -9,21 +9,28 @@ for general contribution guidelines.
## Maintainers (in alphabetical order)
+- [aranjans](https://github.com/aranjans), Google LLC
+- [arjan-bal](https://github.com/arjan-bal), Google LLC
+- [arvindbr8](https://github.com/arvindbr8), Google LLC
- [atollena](https://github.com/atollena), Datadog, Inc.
-- [cesarghali](https://github.com/cesarghali), Google LLC
- [dfawley](https://github.com/dfawley), Google LLC
- [easwars](https://github.com/easwars), Google LLC
-- [menghanl](https://github.com/menghanl), Google LLC
-- [srini100](https://github.com/srini100), Google LLC
+- [erm-g](https://github.com/erm-g), Google LLC
+- [gtcooke94](https://github.com/gtcooke94), Google LLC
+- [purnesh42h](https://github.com/purnesh42h), Google LLC
+- [zasweq](https://github.com/zasweq), Google LLC
## Emeritus Maintainers (in alphabetical order)
-- [adelez](https://github.com/adelez), Google LLC
-- [canguler](https://github.com/canguler), Google LLC
-- [iamqizhao](https://github.com/iamqizhao), Google LLC
-- [jadekler](https://github.com/jadekler), Google LLC
-- [jtattermusch](https://github.com/jtattermusch), Google LLC
-- [lyuxuan](https://github.com/lyuxuan), Google LLC
-- [makmukhi](https://github.com/makmukhi), Google LLC
-- [matt-kwong](https://github.com/matt-kwong), Google LLC
-- [nicolasnoble](https://github.com/nicolasnoble), Google LLC
-- [yongni](https://github.com/yongni), Google LLC
+- [adelez](https://github.com/adelez)
+- [canguler](https://github.com/canguler)
+- [cesarghali](https://github.com/cesarghali)
+- [iamqizhao](https://github.com/iamqizhao)
+- [jeanbza](https://github.com/jeanbza)
+- [jtattermusch](https://github.com/jtattermusch)
+- [lyuxuan](https://github.com/lyuxuan)
+- [makmukhi](https://github.com/makmukhi)
+- [matt-kwong](https://github.com/matt-kwong)
+- [menghanl](https://github.com/menghanl)
+- [nicolasnoble](https://github.com/nicolasnoble)
+- [srini100](https://github.com/srini100)
+- [yongni](https://github.com/yongni)
diff --git a/vendor/google.golang.org/grpc/README.md b/vendor/google.golang.org/grpc/README.md
index ab0fbb79b8..b572707c62 100644
--- a/vendor/google.golang.org/grpc/README.md
+++ b/vendor/google.golang.org/grpc/README.md
@@ -10,7 +10,7 @@ RPC framework that puts mobile and HTTP/2 first. For more information see the
## Prerequisites
-- **[Go][]**: any one of the **three latest major** [releases][go-releases].
+- **[Go][]**: any one of the **two latest major** [releases][go-releases].
## Installation
diff --git a/vendor/google.golang.org/grpc/SECURITY.md b/vendor/google.golang.org/grpc/SECURITY.md
index be6e108705..abab279379 100644
--- a/vendor/google.golang.org/grpc/SECURITY.md
+++ b/vendor/google.golang.org/grpc/SECURITY.md
@@ -1,3 +1,3 @@
# Security Policy
-For information on gRPC Security Policy and reporting potentional security issues, please see [gRPC CVE Process](https://github.com/grpc/proposal/blob/master/P4-grpc-cve-process.md).
+For information on gRPC Security Policy and reporting potential security issues, please see [gRPC CVE Process](https://github.com/grpc/proposal/blob/master/P4-grpc-cve-process.md).
diff --git a/vendor/google.golang.org/grpc/backoff/backoff.go b/vendor/google.golang.org/grpc/backoff/backoff.go
index 0787d0b50c..d7b40b7cb6 100644
--- a/vendor/google.golang.org/grpc/backoff/backoff.go
+++ b/vendor/google.golang.org/grpc/backoff/backoff.go
@@ -39,7 +39,7 @@ type Config struct {
MaxDelay time.Duration
}
-// DefaultConfig is a backoff configuration with the default values specfied
+// DefaultConfig is a backoff configuration with the default values specified
// at https://github.com/grpc/grpc/blob/master/doc/connection-backoff.md.
//
// This should be useful for callers who want to configure backoff with
diff --git a/vendor/google.golang.org/grpc/balancer/balancer.go b/vendor/google.golang.org/grpc/balancer/balancer.go
index f391744f72..3a2092f105 100644
--- a/vendor/google.golang.org/grpc/balancer/balancer.go
+++ b/vendor/google.golang.org/grpc/balancer/balancer.go
@@ -30,6 +30,7 @@ import (
"google.golang.org/grpc/channelz"
"google.golang.org/grpc/connectivity"
"google.golang.org/grpc/credentials"
+ estats "google.golang.org/grpc/experimental/stats"
"google.golang.org/grpc/grpclog"
"google.golang.org/grpc/internal"
"google.golang.org/grpc/metadata"
@@ -72,8 +73,21 @@ func unregisterForTesting(name string) {
delete(m, name)
}
+// connectedAddress returns the connected address for a SubConnState. The
+// address is only valid if the state is READY.
+func connectedAddress(scs SubConnState) resolver.Address {
+ return scs.connectedAddress
+}
+
+// setConnectedAddress sets the connected address for a SubConnState.
+func setConnectedAddress(scs *SubConnState, addr resolver.Address) {
+ scs.connectedAddress = addr
+}
+
func init() {
internal.BalancerUnregister = unregisterForTesting
+ internal.ConnectedAddress = connectedAddress
+ internal.SetConnectedAddress = setConnectedAddress
}
// Get returns the resolver builder registered with the given name.
@@ -116,7 +130,7 @@ type SubConn interface {
// UpdateAddresses updates the addresses used in this SubConn.
// gRPC checks if currently-connected address is still in the new list.
// If it's in the list, the connection will be kept.
- // If it's not in the list, the connection will gracefully closed, and
+ // If it's not in the list, the connection will gracefully close, and
// a new connection will be created.
//
// This will trigger a state transition for the SubConn.
@@ -128,8 +142,11 @@ type SubConn interface {
Connect()
// GetOrBuildProducer returns a reference to the existing Producer for this
// ProducerBuilder in this SubConn, or, if one does not currently exist,
- // creates a new one and returns it. Returns a close function which must
- // be called when the Producer is no longer needed.
+ // creates a new one and returns it. Returns a close function which may be
+ // called when the Producer is no longer needed. Otherwise the producer
+ // will automatically be closed upon connection loss or subchannel close.
+ // Should only be called on a SubConn in state Ready. Otherwise the
+ // producer will be unable to create streams.
GetOrBuildProducer(ProducerBuilder) (p Producer, close func())
// Shutdown shuts down the SubConn gracefully. Any started RPCs will be
// allowed to complete. No future calls should be made on the SubConn.
@@ -243,6 +260,10 @@ type BuildOptions struct {
// same resolver.Target as passed to the resolver. See the documentation for
// the resolver.Target type for details about what it contains.
Target resolver.Target
+ // MetricsRecorder is the metrics recorder that balancers can use to record
+ // metrics. Balancer implementations which do not register metrics on
+ // metrics registry and record on them can ignore this field.
+ MetricsRecorder estats.MetricsRecorder
}
// Builder creates a balancer.
@@ -410,6 +431,9 @@ type SubConnState struct {
// ConnectionError is set if the ConnectivityState is TransientFailure,
// describing the reason the SubConn failed. Otherwise, it is nil.
ConnectionError error
+ // connectedAddr contains the connected address when ConnectivityState is
+ // Ready. Otherwise, it is indeterminate.
+ connectedAddress resolver.Address
}
// ClientConnState describes the state of a ClientConn relevant to the
@@ -431,8 +455,10 @@ type ProducerBuilder interface {
// Build creates a Producer. The first parameter is always a
// grpc.ClientConnInterface (a type to allow creating RPCs/streams on the
// associated SubConn), but is declared as `any` to avoid a dependency
- // cycle. Should also return a close function that will be called when all
- // references to the Producer have been given up.
+ // cycle. Build also returns a close function that will be called when all
+ // references to the Producer have been given up for a SubConn, or when a
+ // connectivity state change occurs on the SubConn. The close function
+ // should always block until all asynchronous cleanup work is completed.
Build(grpcClientConnInterface any) (p Producer, close func())
}
diff --git a/vendor/google.golang.org/grpc/balancer/base/balancer.go b/vendor/google.golang.org/grpc/balancer/base/balancer.go
index a7f1eeec8e..d5ed172ae6 100644
--- a/vendor/google.golang.org/grpc/balancer/base/balancer.go
+++ b/vendor/google.golang.org/grpc/balancer/base/balancer.go
@@ -36,7 +36,7 @@ type baseBuilder struct {
config Config
}
-func (bb *baseBuilder) Build(cc balancer.ClientConn, opt balancer.BuildOptions) balancer.Balancer {
+func (bb *baseBuilder) Build(cc balancer.ClientConn, _ balancer.BuildOptions) balancer.Balancer {
bal := &baseBalancer{
cc: cc,
pickerBuilder: bb.pickerBuilder,
@@ -133,7 +133,7 @@ func (b *baseBalancer) UpdateClientConnState(s balancer.ClientConnState) error {
}
}
// If resolver state contains no addresses, return an error so ClientConn
- // will trigger re-resolve. Also records this as an resolver error, so when
+ // will trigger re-resolve. Also records this as a resolver error, so when
// the overall state turns transient failure, the error message will have
// the zero address information.
if len(s.ResolverState.Addresses) == 0 {
@@ -259,6 +259,6 @@ type errPicker struct {
err error // Pick() always returns this err.
}
-func (p *errPicker) Pick(info balancer.PickInfo) (balancer.PickResult, error) {
+func (p *errPicker) Pick(balancer.PickInfo) (balancer.PickResult, error) {
return balancer.PickResult{}, p.err
}
diff --git a/vendor/google.golang.org/grpc/balancer/pickfirst/internal/internal.go b/vendor/google.golang.org/grpc/balancer/pickfirst/internal/internal.go
new file mode 100644
index 0000000000..c519789458
--- /dev/null
+++ b/vendor/google.golang.org/grpc/balancer/pickfirst/internal/internal.go
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2024 gRPC 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 internal contains code internal to the pickfirst package.
+package internal
+
+import "math/rand"
+
+// RandShuffle pseudo-randomizes the order of addresses.
+var RandShuffle = rand.Shuffle
diff --git a/vendor/google.golang.org/grpc/pickfirst.go b/vendor/google.golang.org/grpc/balancer/pickfirst/pickfirst.go
similarity index 85%
rename from vendor/google.golang.org/grpc/pickfirst.go
rename to vendor/google.golang.org/grpc/balancer/pickfirst/pickfirst.go
index 8853626614..e069346a75 100644
--- a/vendor/google.golang.org/grpc/pickfirst.go
+++ b/vendor/google.golang.org/grpc/balancer/pickfirst/pickfirst.go
@@ -16,38 +16,53 @@
*
*/
-package grpc
+// Package pickfirst contains the pick_first load balancing policy.
+package pickfirst
import (
"encoding/json"
"errors"
"fmt"
+ "math/rand"
"google.golang.org/grpc/balancer"
+ "google.golang.org/grpc/balancer/pickfirst/internal"
"google.golang.org/grpc/connectivity"
+ "google.golang.org/grpc/grpclog"
+ "google.golang.org/grpc/internal/envconfig"
internalgrpclog "google.golang.org/grpc/internal/grpclog"
- "google.golang.org/grpc/internal/grpcrand"
"google.golang.org/grpc/internal/pretty"
"google.golang.org/grpc/resolver"
"google.golang.org/grpc/serviceconfig"
+
+ _ "google.golang.org/grpc/balancer/pickfirst/pickfirstleaf" // For automatically registering the new pickfirst if required.
)
+func init() {
+ if envconfig.NewPickFirstEnabled {
+ return
+ }
+ balancer.Register(pickfirstBuilder{})
+}
+
+var logger = grpclog.Component("pick-first-lb")
+
const (
- // PickFirstBalancerName is the name of the pick_first balancer.
- PickFirstBalancerName = "pick_first"
- logPrefix = "[pick-first-lb %p] "
+ // Name is the name of the pick_first balancer.
+ Name = "pick_first"
+ logPrefix = "[pick-first-lb %p] "
)
type pickfirstBuilder struct{}
-func (pickfirstBuilder) Build(cc balancer.ClientConn, opt balancer.BuildOptions) balancer.Balancer {
+func (pickfirstBuilder) Build(cc balancer.ClientConn, _ balancer.BuildOptions) balancer.Balancer {
b := &pickfirstBalancer{cc: cc}
b.logger = internalgrpclog.NewPrefixLogger(logger, fmt.Sprintf(logPrefix, b))
return b
}
func (pickfirstBuilder) Name() string {
- return PickFirstBalancerName
+ return Name
}
type pfConfig struct {
@@ -93,6 +108,15 @@ func (b *pickfirstBalancer) ResolverError(err error) {
})
}
+// Shuffler is an interface for shuffling an address list.
+type Shuffler interface {
+ ShuffleAddressListForTesting(n int, swap func(i, j int))
+}
+
+// ShuffleAddressListForTesting pseudo-randomizes the order of addresses. n
+// is the number of elements. swap swaps the elements with indexes i and j.
+func ShuffleAddressListForTesting(n int, swap func(i, j int)) { rand.Shuffle(n, swap) }
+
func (b *pickfirstBalancer) UpdateClientConnState(state balancer.ClientConnState) error {
if len(state.ResolverState.Addresses) == 0 && len(state.ResolverState.Endpoints) == 0 {
// The resolver reported an empty address list. Treat it like an error by
@@ -124,7 +148,7 @@ func (b *pickfirstBalancer) UpdateClientConnState(state balancer.ClientConnState
// within each endpoint. - A61
if cfg.ShuffleAddressList {
endpoints = append([]resolver.Endpoint{}, endpoints...)
- grpcrand.Shuffle(len(endpoints), func(i, j int) { endpoints[i], endpoints[j] = endpoints[j], endpoints[i] })
+ internal.RandShuffle(len(endpoints), func(i, j int) { endpoints[i], endpoints[j] = endpoints[j], endpoints[i] })
}
// "Flatten the list by concatenating the ordered list of addresses for each
@@ -139,13 +163,13 @@ func (b *pickfirstBalancer) UpdateClientConnState(state balancer.ClientConnState
// Endpoints not set, process addresses until we migrate resolver
// emissions fully to Endpoints. The top channel does wrap emitted
// addresses with endpoints, however some balancers such as weighted
- // target do not forwarrd the corresponding correct endpoints down/split
+ // target do not forward the corresponding correct endpoints down/split
// endpoints properly. Once all balancers correctly forward endpoints
// down, can delete this else conditional.
addrs = state.ResolverState.Addresses
if cfg.ShuffleAddressList {
addrs = append([]resolver.Address{}, addrs...)
- grpcrand.Shuffle(len(addrs), func(i, j int) { addrs[i], addrs[j] = addrs[j], addrs[i] })
+ rand.Shuffle(len(addrs), func(i, j int) { addrs[i], addrs[j] = addrs[j], addrs[i] })
}
}
diff --git a/vendor/google.golang.org/grpc/balancer/pickfirst/pickfirstleaf/pickfirstleaf.go b/vendor/google.golang.org/grpc/balancer/pickfirst/pickfirstleaf/pickfirstleaf.go
new file mode 100644
index 0000000000..985b6edc7f
--- /dev/null
+++ b/vendor/google.golang.org/grpc/balancer/pickfirst/pickfirstleaf/pickfirstleaf.go
@@ -0,0 +1,625 @@
+/*
+ *
+ * Copyright 2024 gRPC 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 pickfirstleaf contains the pick_first load balancing policy which
+// will be the universal leaf policy after dualstack changes are implemented.
+//
+// # Experimental
+//
+// Notice: This package is EXPERIMENTAL and may be changed or removed in a
+// later release.
+package pickfirstleaf
+
+import (
+ "encoding/json"
+ "errors"
+ "fmt"
+ "sync"
+
+ "google.golang.org/grpc/balancer"
+ "google.golang.org/grpc/balancer/pickfirst/internal"
+ "google.golang.org/grpc/connectivity"
+ "google.golang.org/grpc/grpclog"
+ "google.golang.org/grpc/internal/envconfig"
+ internalgrpclog "google.golang.org/grpc/internal/grpclog"
+ "google.golang.org/grpc/internal/pretty"
+ "google.golang.org/grpc/resolver"
+ "google.golang.org/grpc/serviceconfig"
+)
+
+func init() {
+ if envconfig.NewPickFirstEnabled {
+ // Register as the default pick_first balancer.
+ Name = "pick_first"
+ }
+ balancer.Register(pickfirstBuilder{})
+}
+
+var (
+ logger = grpclog.Component("pick-first-leaf-lb")
+ // Name is the name of the pick_first_leaf balancer.
+ // It is changed to "pick_first" in init() if this balancer is to be
+ // registered as the default pickfirst.
+ Name = "pick_first_leaf"
+)
+
+// TODO: change to pick-first when this becomes the default pick_first policy.
+const logPrefix = "[pick-first-leaf-lb %p] "
+
+type pickfirstBuilder struct{}
+
+func (pickfirstBuilder) Build(cc balancer.ClientConn, _ balancer.BuildOptions) balancer.Balancer {
+ b := &pickfirstBalancer{
+ cc: cc,
+ addressList: addressList{},
+ subConns: resolver.NewAddressMap(),
+ state: connectivity.Connecting,
+ mu: sync.Mutex{},
+ }
+ b.logger = internalgrpclog.NewPrefixLogger(logger, fmt.Sprintf(logPrefix, b))
+ return b
+}
+
+func (b pickfirstBuilder) Name() string {
+ return Name
+}
+
+func (pickfirstBuilder) ParseConfig(js json.RawMessage) (serviceconfig.LoadBalancingConfig, error) {
+ var cfg pfConfig
+ if err := json.Unmarshal(js, &cfg); err != nil {
+ return nil, fmt.Errorf("pickfirst: unable to unmarshal LB policy config: %s, error: %v", string(js), err)
+ }
+ return cfg, nil
+}
+
+type pfConfig struct {
+ serviceconfig.LoadBalancingConfig `json:"-"`
+
+ // If set to true, instructs the LB policy to shuffle the order of the list
+ // of endpoints received from the name resolver before attempting to
+ // connect to them.
+ ShuffleAddressList bool `json:"shuffleAddressList"`
+}
+
+// scData keeps track of the current state of the subConn.
+// It is not safe for concurrent access.
+type scData struct {
+ // The following fields are initialized at build time and read-only after
+ // that.
+ subConn balancer.SubConn
+ addr resolver.Address
+
+ state connectivity.State
+ lastErr error
+}
+
+func (b *pickfirstBalancer) newSCData(addr resolver.Address) (*scData, error) {
+ sd := &scData{
+ state: connectivity.Idle,
+ addr: addr,
+ }
+ sc, err := b.cc.NewSubConn([]resolver.Address{addr}, balancer.NewSubConnOptions{
+ StateListener: func(state balancer.SubConnState) {
+ b.updateSubConnState(sd, state)
+ },
+ })
+ if err != nil {
+ return nil, err
+ }
+ sd.subConn = sc
+ return sd, nil
+}
+
+type pickfirstBalancer struct {
+ // The following fields are initialized at build time and read-only after
+ // that and therefore do not need to be guarded by a mutex.
+ logger *internalgrpclog.PrefixLogger
+ cc balancer.ClientConn
+
+ // The mutex is used to ensure synchronization of updates triggered
+ // from the idle picker and the already serialized resolver,
+ // SubConn state updates.
+ mu sync.Mutex
+ state connectivity.State
+ // scData for active subonns mapped by address.
+ subConns *resolver.AddressMap
+ addressList addressList
+ firstPass bool
+ numTF int
+}
+
+// ResolverError is called by the ClientConn when the name resolver produces
+// an error or when pickfirst determined the resolver update to be invalid.
+func (b *pickfirstBalancer) ResolverError(err error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+ b.resolverErrorLocked(err)
+}
+
+func (b *pickfirstBalancer) resolverErrorLocked(err error) {
+ if b.logger.V(2) {
+ b.logger.Infof("Received error from the name resolver: %v", err)
+ }
+
+ // The picker will not change since the balancer does not currently
+ // report an error. If the balancer hasn't received a single good resolver
+ // update yet, transition to TRANSIENT_FAILURE.
+ if b.state != connectivity.TransientFailure && b.addressList.size() > 0 {
+ if b.logger.V(2) {
+ b.logger.Infof("Ignoring resolver error because balancer is using a previous good update.")
+ }
+ return
+ }
+
+ b.cc.UpdateState(balancer.State{
+ ConnectivityState: connectivity.TransientFailure,
+ Picker: &picker{err: fmt.Errorf("name resolver error: %v", err)},
+ })
+}
+
+func (b *pickfirstBalancer) UpdateClientConnState(state balancer.ClientConnState) error {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+ if len(state.ResolverState.Addresses) == 0 && len(state.ResolverState.Endpoints) == 0 {
+ // Cleanup state pertaining to the previous resolver state.
+ // Treat an empty address list like an error by calling b.ResolverError.
+ b.state = connectivity.TransientFailure
+ b.closeSubConnsLocked()
+ b.addressList.updateAddrs(nil)
+ b.resolverErrorLocked(errors.New("produced zero addresses"))
+ return balancer.ErrBadResolverState
+ }
+ cfg, ok := state.BalancerConfig.(pfConfig)
+ if state.BalancerConfig != nil && !ok {
+ return fmt.Errorf("pickfirst: received illegal BalancerConfig (type %T): %v: %w", state.BalancerConfig, state.BalancerConfig, balancer.ErrBadResolverState)
+ }
+
+ if b.logger.V(2) {
+ b.logger.Infof("Received new config %s, resolver state %s", pretty.ToJSON(cfg), pretty.ToJSON(state.ResolverState))
+ }
+
+ var newAddrs []resolver.Address
+ if endpoints := state.ResolverState.Endpoints; len(endpoints) != 0 {
+ // Perform the optional shuffling described in gRFC A62. The shuffling
+ // will change the order of endpoints but not touch the order of the
+ // addresses within each endpoint. - A61
+ if cfg.ShuffleAddressList {
+ endpoints = append([]resolver.Endpoint{}, endpoints...)
+ internal.RandShuffle(len(endpoints), func(i, j int) { endpoints[i], endpoints[j] = endpoints[j], endpoints[i] })
+ }
+
+ // "Flatten the list by concatenating the ordered list of addresses for
+ // each of the endpoints, in order." - A61
+ for _, endpoint := range endpoints {
+ // "In the flattened list, interleave addresses from the two address
+ // families, as per RFC-8305 section 4." - A61
+ // TODO: support the above language.
+ newAddrs = append(newAddrs, endpoint.Addresses...)
+ }
+ } else {
+ // Endpoints not set, process addresses until we migrate resolver
+ // emissions fully to Endpoints. The top channel does wrap emitted
+ // addresses with endpoints, however some balancers such as weighted
+ // target do not forward the corresponding correct endpoints down/split
+ // endpoints properly. Once all balancers correctly forward endpoints
+ // down, can delete this else conditional.
+ newAddrs = state.ResolverState.Addresses
+ if cfg.ShuffleAddressList {
+ newAddrs = append([]resolver.Address{}, newAddrs...)
+ internal.RandShuffle(len(endpoints), func(i, j int) { endpoints[i], endpoints[j] = endpoints[j], endpoints[i] })
+ }
+ }
+
+ // If an address appears in multiple endpoints or in the same endpoint
+ // multiple times, we keep it only once. We will create only one SubConn
+ // for the address because an AddressMap is used to store SubConns.
+ // Not de-duplicating would result in attempting to connect to the same
+ // SubConn multiple times in the same pass. We don't want this.
+ newAddrs = deDupAddresses(newAddrs)
+
+ // Since we have a new set of addresses, we are again at first pass.
+ b.firstPass = true
+
+ // If the previous ready SubConn exists in new address list,
+ // keep this connection and don't create new SubConns.
+ prevAddr := b.addressList.currentAddress()
+ prevAddrsCount := b.addressList.size()
+ b.addressList.updateAddrs(newAddrs)
+ if b.state == connectivity.Ready && b.addressList.seekTo(prevAddr) {
+ return nil
+ }
+
+ b.reconcileSubConnsLocked(newAddrs)
+ // If it's the first resolver update or the balancer was already READY
+ // (but the new address list does not contain the ready SubConn) or
+ // CONNECTING, enter CONNECTING.
+ // We may be in TRANSIENT_FAILURE due to a previous empty address list,
+ // we should still enter CONNECTING because the sticky TF behaviour
+ // mentioned in A62 applies only when the TRANSIENT_FAILURE is reported
+ // due to connectivity failures.
+ if b.state == connectivity.Ready || b.state == connectivity.Connecting || prevAddrsCount == 0 {
+ // Start connection attempt at first address.
+ b.state = connectivity.Connecting
+ b.cc.UpdateState(balancer.State{
+ ConnectivityState: connectivity.Connecting,
+ Picker: &picker{err: balancer.ErrNoSubConnAvailable},
+ })
+ b.requestConnectionLocked()
+ } else if b.state == connectivity.TransientFailure {
+ // If we're in TRANSIENT_FAILURE, we stay in TRANSIENT_FAILURE until
+ // we're READY. See A62.
+ b.requestConnectionLocked()
+ }
+ return nil
+}
+
+// UpdateSubConnState is unused as a StateListener is always registered when
+// creating SubConns.
+func (b *pickfirstBalancer) UpdateSubConnState(subConn balancer.SubConn, state balancer.SubConnState) {
+ b.logger.Errorf("UpdateSubConnState(%v, %+v) called unexpectedly", subConn, state)
+}
+
+func (b *pickfirstBalancer) Close() {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+ b.closeSubConnsLocked()
+ b.state = connectivity.Shutdown
+}
+
+// ExitIdle moves the balancer out of idle state. It can be called concurrently
+// by the idlePicker and clientConn so access to variables should be
+// synchronized.
+func (b *pickfirstBalancer) ExitIdle() {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+ if b.state == connectivity.Idle && b.addressList.currentAddress() == b.addressList.first() {
+ b.firstPass = true
+ b.requestConnectionLocked()
+ }
+}
+
+func (b *pickfirstBalancer) closeSubConnsLocked() {
+ for _, sd := range b.subConns.Values() {
+ sd.(*scData).subConn.Shutdown()
+ }
+ b.subConns = resolver.NewAddressMap()
+}
+
+// deDupAddresses ensures that each address appears only once in the slice.
+func deDupAddresses(addrs []resolver.Address) []resolver.Address {
+ seenAddrs := resolver.NewAddressMap()
+ retAddrs := []resolver.Address{}
+
+ for _, addr := range addrs {
+ if _, ok := seenAddrs.Get(addr); ok {
+ continue
+ }
+ retAddrs = append(retAddrs, addr)
+ }
+ return retAddrs
+}
+
+// reconcileSubConnsLocked updates the active subchannels based on a new address
+// list from the resolver. It does this by:
+// - closing subchannels: any existing subchannels associated with addresses
+// that are no longer in the updated list are shut down.
+// - removing subchannels: entries for these closed subchannels are removed
+// from the subchannel map.
+//
+// This ensures that the subchannel map accurately reflects the current set of
+// addresses received from the name resolver.
+func (b *pickfirstBalancer) reconcileSubConnsLocked(newAddrs []resolver.Address) {
+ newAddrsMap := resolver.NewAddressMap()
+ for _, addr := range newAddrs {
+ newAddrsMap.Set(addr, true)
+ }
+
+ for _, oldAddr := range b.subConns.Keys() {
+ if _, ok := newAddrsMap.Get(oldAddr); ok {
+ continue
+ }
+ val, _ := b.subConns.Get(oldAddr)
+ val.(*scData).subConn.Shutdown()
+ b.subConns.Delete(oldAddr)
+ }
+}
+
+// shutdownRemainingLocked shuts down remaining subConns. Called when a subConn
+// becomes ready, which means that all other subConn must be shutdown.
+func (b *pickfirstBalancer) shutdownRemainingLocked(selected *scData) {
+ for _, v := range b.subConns.Values() {
+ sd := v.(*scData)
+ if sd.subConn != selected.subConn {
+ sd.subConn.Shutdown()
+ }
+ }
+ b.subConns = resolver.NewAddressMap()
+ b.subConns.Set(selected.addr, selected)
+}
+
+// requestConnectionLocked starts connecting on the subchannel corresponding to
+// the current address. If no subchannel exists, one is created. If the current
+// subchannel is in TransientFailure, a connection to the next address is
+// attempted until a subchannel is found.
+func (b *pickfirstBalancer) requestConnectionLocked() {
+ if !b.addressList.isValid() {
+ return
+ }
+ var lastErr error
+ for valid := true; valid; valid = b.addressList.increment() {
+ curAddr := b.addressList.currentAddress()
+ sd, ok := b.subConns.Get(curAddr)
+ if !ok {
+ var err error
+ // We want to assign the new scData to sd from the outer scope,
+ // hence we can't use := below.
+ sd, err = b.newSCData(curAddr)
+ if err != nil {
+ // This should never happen, unless the clientConn is being shut
+ // down.
+ if b.logger.V(2) {
+ b.logger.Infof("Failed to create a subConn for address %v: %v", curAddr.String(), err)
+ }
+ // Do nothing, the LB policy will be closed soon.
+ return
+ }
+ b.subConns.Set(curAddr, sd)
+ }
+
+ scd := sd.(*scData)
+ switch scd.state {
+ case connectivity.Idle:
+ scd.subConn.Connect()
+ case connectivity.TransientFailure:
+ // Try the next address.
+ lastErr = scd.lastErr
+ continue
+ case connectivity.Ready:
+ // Should never happen.
+ b.logger.Errorf("Requesting a connection even though we have a READY SubConn")
+ case connectivity.Shutdown:
+ // Should never happen.
+ b.logger.Errorf("SubConn with state SHUTDOWN present in SubConns map")
+ case connectivity.Connecting:
+ // Wait for the SubConn to report success or failure.
+ }
+ return
+ }
+ // All the remaining addresses in the list are in TRANSIENT_FAILURE, end the
+ // first pass.
+ b.endFirstPassLocked(lastErr)
+}
+
+func (b *pickfirstBalancer) updateSubConnState(sd *scData, newState balancer.SubConnState) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+ oldState := sd.state
+ sd.state = newState.ConnectivityState
+ // Previously relevant SubConns can still callback with state updates.
+ // To prevent pickers from returning these obsolete SubConns, this logic
+ // is included to check if the current list of active SubConns includes this
+ // SubConn.
+ if activeSD, found := b.subConns.Get(sd.addr); !found || activeSD != sd {
+ return
+ }
+ if newState.ConnectivityState == connectivity.Shutdown {
+ return
+ }
+
+ if newState.ConnectivityState == connectivity.Ready {
+ b.shutdownRemainingLocked(sd)
+ if !b.addressList.seekTo(sd.addr) {
+ // This should not fail as we should have only one SubConn after
+ // entering READY. The SubConn should be present in the addressList.
+ b.logger.Errorf("Address %q not found address list in %v", sd.addr, b.addressList.addresses)
+ return
+ }
+ b.state = connectivity.Ready
+ b.cc.UpdateState(balancer.State{
+ ConnectivityState: connectivity.Ready,
+ Picker: &picker{result: balancer.PickResult{SubConn: sd.subConn}},
+ })
+ return
+ }
+
+ // If the LB policy is READY, and it receives a subchannel state change,
+ // it means that the READY subchannel has failed.
+ // A SubConn can also transition from CONNECTING directly to IDLE when
+ // a transport is successfully created, but the connection fails
+ // before the SubConn can send the notification for READY. We treat
+ // this as a successful connection and transition to IDLE.
+ if (b.state == connectivity.Ready && newState.ConnectivityState != connectivity.Ready) || (oldState == connectivity.Connecting && newState.ConnectivityState == connectivity.Idle) {
+ // Once a transport fails, the balancer enters IDLE and starts from
+ // the first address when the picker is used.
+ b.shutdownRemainingLocked(sd)
+ b.state = connectivity.Idle
+ b.addressList.reset()
+ b.cc.UpdateState(balancer.State{
+ ConnectivityState: connectivity.Idle,
+ Picker: &idlePicker{exitIdle: sync.OnceFunc(b.ExitIdle)},
+ })
+ return
+ }
+
+ if b.firstPass {
+ switch newState.ConnectivityState {
+ case connectivity.Connecting:
+ // The balancer can be in either IDLE, CONNECTING or
+ // TRANSIENT_FAILURE. If it's in TRANSIENT_FAILURE, stay in
+ // TRANSIENT_FAILURE until it's READY. See A62.
+ // If the balancer is already in CONNECTING, no update is needed.
+ if b.state == connectivity.Idle {
+ b.state = connectivity.Connecting
+ b.cc.UpdateState(balancer.State{
+ ConnectivityState: connectivity.Connecting,
+ Picker: &picker{err: balancer.ErrNoSubConnAvailable},
+ })
+ }
+ case connectivity.TransientFailure:
+ sd.lastErr = newState.ConnectionError
+ // Since we're re-using common SubConns while handling resolver
+ // updates, we could receive an out of turn TRANSIENT_FAILURE from
+ // a pass over the previous address list. We ignore such updates.
+
+ if curAddr := b.addressList.currentAddress(); !equalAddressIgnoringBalAttributes(&curAddr, &sd.addr) {
+ return
+ }
+ if b.addressList.increment() {
+ b.requestConnectionLocked()
+ return
+ }
+ // End of the first pass.
+ b.endFirstPassLocked(newState.ConnectionError)
+ }
+ return
+ }
+
+ // We have finished the first pass, keep re-connecting failing SubConns.
+ switch newState.ConnectivityState {
+ case connectivity.TransientFailure:
+ b.numTF = (b.numTF + 1) % b.subConns.Len()
+ sd.lastErr = newState.ConnectionError
+ if b.numTF%b.subConns.Len() == 0 {
+ b.cc.UpdateState(balancer.State{
+ ConnectivityState: connectivity.TransientFailure,
+ Picker: &picker{err: newState.ConnectionError},
+ })
+ }
+ // We don't need to request re-resolution since the SubConn already
+ // does that before reporting TRANSIENT_FAILURE.
+ // TODO: #7534 - Move re-resolution requests from SubConn into
+ // pick_first.
+ case connectivity.Idle:
+ sd.subConn.Connect()
+ }
+}
+
+func (b *pickfirstBalancer) endFirstPassLocked(lastErr error) {
+ b.firstPass = false
+ b.numTF = 0
+ b.state = connectivity.TransientFailure
+
+ b.cc.UpdateState(balancer.State{
+ ConnectivityState: connectivity.TransientFailure,
+ Picker: &picker{err: lastErr},
+ })
+ // Start re-connecting all the SubConns that are already in IDLE.
+ for _, v := range b.subConns.Values() {
+ sd := v.(*scData)
+ if sd.state == connectivity.Idle {
+ sd.subConn.Connect()
+ }
+ }
+}
+
+type picker struct {
+ result balancer.PickResult
+ err error
+}
+
+func (p *picker) Pick(balancer.PickInfo) (balancer.PickResult, error) {
+ return p.result, p.err
+}
+
+// idlePicker is used when the SubConn is IDLE and kicks the SubConn into
+// CONNECTING when Pick is called.
+type idlePicker struct {
+ exitIdle func()
+}
+
+func (i *idlePicker) Pick(balancer.PickInfo) (balancer.PickResult, error) {
+ i.exitIdle()
+ return balancer.PickResult{}, balancer.ErrNoSubConnAvailable
+}
+
+// addressList manages sequentially iterating over addresses present in a list
+// of endpoints. It provides a 1 dimensional view of the addresses present in
+// the endpoints.
+// This type is not safe for concurrent access.
+type addressList struct {
+ addresses []resolver.Address
+ idx int
+}
+
+func (al *addressList) isValid() bool {
+ return al.idx < len(al.addresses)
+}
+
+func (al *addressList) size() int {
+ return len(al.addresses)
+}
+
+// increment moves to the next index in the address list.
+// This method returns false if it went off the list, true otherwise.
+func (al *addressList) increment() bool {
+ if !al.isValid() {
+ return false
+ }
+ al.idx++
+ return al.idx < len(al.addresses)
+}
+
+// currentAddress returns the current address pointed to in the addressList.
+// If the list is in an invalid state, it returns an empty address instead.
+func (al *addressList) currentAddress() resolver.Address {
+ if !al.isValid() {
+ return resolver.Address{}
+ }
+ return al.addresses[al.idx]
+}
+
+// first returns the first address in the list. If the list is empty, it returns
+// an empty address instead.
+func (al *addressList) first() resolver.Address {
+ if len(al.addresses) == 0 {
+ return resolver.Address{}
+ }
+ return al.addresses[0]
+}
+
+func (al *addressList) reset() {
+ al.idx = 0
+}
+
+func (al *addressList) updateAddrs(addrs []resolver.Address) {
+ al.addresses = addrs
+ al.reset()
+}
+
+// seekTo returns false if the needle was not found and the current index was
+// left unchanged.
+func (al *addressList) seekTo(needle resolver.Address) bool {
+ for ai, addr := range al.addresses {
+ if !equalAddressIgnoringBalAttributes(&addr, &needle) {
+ continue
+ }
+ al.idx = ai
+ return true
+ }
+ return false
+}
+
+// equalAddressIgnoringBalAttributes returns true is a and b are considered
+// equal. This is different from the Equal method on the resolver.Address type
+// which considers all fields to determine equality. Here, we only consider
+// fields that are meaningful to the SubConn.
+func equalAddressIgnoringBalAttributes(a, b *resolver.Address) bool {
+ return a.Addr == b.Addr && a.ServerName == b.ServerName &&
+ a.Attributes.Equal(b.Attributes) &&
+ a.Metadata == b.Metadata
+}
diff --git a/vendor/google.golang.org/grpc/balancer/roundrobin/roundrobin.go b/vendor/google.golang.org/grpc/balancer/roundrobin/roundrobin.go
index f7031ad225..260255d31b 100644
--- a/vendor/google.golang.org/grpc/balancer/roundrobin/roundrobin.go
+++ b/vendor/google.golang.org/grpc/balancer/roundrobin/roundrobin.go
@@ -22,12 +22,12 @@
package roundrobin
import (
+ "math/rand"
"sync/atomic"
"google.golang.org/grpc/balancer"
"google.golang.org/grpc/balancer/base"
"google.golang.org/grpc/grpclog"
- "google.golang.org/grpc/internal/grpcrand"
)
// Name is the name of round_robin balancer.
@@ -60,7 +60,7 @@ func (*rrPickerBuilder) Build(info base.PickerBuildInfo) balancer.Picker {
// Start at a random index, as the same RR balancer rebuilds a new
// picker when SubConn states change, and we don't want to apply excess
// load to the first server in the list.
- next: uint32(grpcrand.Intn(len(scs))),
+ next: uint32(rand.Intn(len(scs))),
}
}
diff --git a/vendor/google.golang.org/grpc/balancer_wrapper.go b/vendor/google.golang.org/grpc/balancer_wrapper.go
index af39b8a4c7..2a4f2878ae 100644
--- a/vendor/google.golang.org/grpc/balancer_wrapper.go
+++ b/vendor/google.golang.org/grpc/balancer_wrapper.go
@@ -24,13 +24,18 @@ import (
"sync"
"google.golang.org/grpc/balancer"
+ "google.golang.org/grpc/codes"
"google.golang.org/grpc/connectivity"
+ "google.golang.org/grpc/internal"
"google.golang.org/grpc/internal/balancer/gracefulswitch"
"google.golang.org/grpc/internal/channelz"
"google.golang.org/grpc/internal/grpcsync"
"google.golang.org/grpc/resolver"
+ "google.golang.org/grpc/status"
)
+var setConnectedAddress = internal.SetConnectedAddress.(func(*balancer.SubConnState, resolver.Address))
+
// ccBalancerWrapper sits between the ClientConn and the Balancer.
//
// ccBalancerWrapper implements methods corresponding to the ones on the
@@ -79,6 +84,7 @@ func newCCBalancerWrapper(cc *ClientConn) *ccBalancerWrapper {
CustomUserAgent: cc.dopts.copts.UserAgent,
ChannelzParent: cc.channelz,
Target: cc.parsedTarget,
+ MetricsRecorder: cc.metricsRecorderList,
},
serializer: grpcsync.NewCallbackSerializer(ctx),
serializerCancel: cancel,
@@ -92,7 +98,7 @@ func newCCBalancerWrapper(cc *ClientConn) *ccBalancerWrapper {
// it is safe to call into the balancer here.
func (ccb *ccBalancerWrapper) updateClientConnState(ccs *balancer.ClientConnState) error {
errCh := make(chan error)
- ok := ccb.serializer.Schedule(func(ctx context.Context) {
+ uccs := func(ctx context.Context) {
defer close(errCh)
if ctx.Err() != nil || ccb.balancer == nil {
return
@@ -107,17 +113,23 @@ func (ccb *ccBalancerWrapper) updateClientConnState(ccs *balancer.ClientConnStat
logger.Infof("error from balancer.UpdateClientConnState: %v", err)
}
errCh <- err
- })
- if !ok {
- return nil
}
+ onFailure := func() { close(errCh) }
+
+ // UpdateClientConnState can race with Close, and when the latter wins, the
+ // serializer is closed, and the attempt to schedule the callback will fail.
+ // It is acceptable to ignore this failure. But since we want to handle the
+ // state update in a blocking fashion (when we successfully schedule the
+ // callback), we have to use the ScheduleOr method and not the MaybeSchedule
+ // method on the serializer.
+ ccb.serializer.ScheduleOr(uccs, onFailure)
return <-errCh
}
// resolverError is invoked by grpc to push a resolver error to the underlying
// balancer. The call to the balancer is executed from the serializer.
func (ccb *ccBalancerWrapper) resolverError(err error) {
- ccb.serializer.Schedule(func(ctx context.Context) {
+ ccb.serializer.TrySchedule(func(ctx context.Context) {
if ctx.Err() != nil || ccb.balancer == nil {
return
}
@@ -133,7 +145,7 @@ func (ccb *ccBalancerWrapper) close() {
ccb.closed = true
ccb.mu.Unlock()
channelz.Info(logger, ccb.cc.channelz, "ccBalancerWrapper: closing")
- ccb.serializer.Schedule(func(context.Context) {
+ ccb.serializer.TrySchedule(func(context.Context) {
if ccb.balancer == nil {
return
}
@@ -145,7 +157,7 @@ func (ccb *ccBalancerWrapper) close() {
// exitIdle invokes the balancer's exitIdle method in the serializer.
func (ccb *ccBalancerWrapper) exitIdle() {
- ccb.serializer.Schedule(func(ctx context.Context) {
+ ccb.serializer.TrySchedule(func(ctx context.Context) {
if ctx.Err() != nil || ccb.balancer == nil {
return
}
@@ -182,7 +194,7 @@ func (ccb *ccBalancerWrapper) NewSubConn(addrs []resolver.Address, opts balancer
return acbw, nil
}
-func (ccb *ccBalancerWrapper) RemoveSubConn(sc balancer.SubConn) {
+func (ccb *ccBalancerWrapper) RemoveSubConn(balancer.SubConn) {
// The graceful switch balancer will never call this.
logger.Errorf("ccb RemoveSubConn(%v) called unexpectedly, sc")
}
@@ -198,6 +210,10 @@ func (ccb *ccBalancerWrapper) UpdateAddresses(sc balancer.SubConn, addrs []resol
func (ccb *ccBalancerWrapper) UpdateState(s balancer.State) {
ccb.cc.mu.Lock()
defer ccb.cc.mu.Unlock()
+ if ccb.cc.conns == nil {
+ // The CC has been closed; ignore this update.
+ return
+ }
ccb.mu.Lock()
if ccb.closed {
@@ -242,21 +258,28 @@ type acBalancerWrapper struct {
ccb *ccBalancerWrapper // read-only
stateListener func(balancer.SubConnState)
- mu sync.Mutex
- producers map[balancer.ProducerBuilder]*refCountedProducer
+ producersMu sync.Mutex
+ producers map[balancer.ProducerBuilder]*refCountedProducer
}
// updateState is invoked by grpc to push a subConn state update to the
// underlying balancer.
-func (acbw *acBalancerWrapper) updateState(s connectivity.State, err error) {
- acbw.ccb.serializer.Schedule(func(ctx context.Context) {
+func (acbw *acBalancerWrapper) updateState(s connectivity.State, curAddr resolver.Address, err error) {
+ acbw.ccb.serializer.TrySchedule(func(ctx context.Context) {
if ctx.Err() != nil || acbw.ccb.balancer == nil {
return
}
+ // Invalidate all producers on any state change.
+ acbw.closeProducers()
+
// Even though it is optional for balancers, gracefulswitch ensures
// opts.StateListener is set, so this cannot ever be nil.
// TODO: delete this comment when UpdateSubConnState is removed.
- acbw.stateListener(balancer.SubConnState{ConnectivityState: s, ConnectionError: err})
+ scs := balancer.SubConnState{ConnectivityState: s, ConnectionError: err}
+ if s == connectivity.Ready {
+ setConnectedAddress(&scs, curAddr)
+ }
+ acbw.stateListener(scs)
})
}
@@ -273,6 +296,7 @@ func (acbw *acBalancerWrapper) Connect() {
}
func (acbw *acBalancerWrapper) Shutdown() {
+ acbw.closeProducers()
acbw.ccb.cc.removeAddrConn(acbw.ac, errConnDrain)
}
@@ -280,9 +304,10 @@ func (acbw *acBalancerWrapper) Shutdown() {
// ready, blocks until it is or ctx expires. Returns an error when the context
// expires or the addrConn is shut down.
func (acbw *acBalancerWrapper) NewStream(ctx context.Context, desc *StreamDesc, method string, opts ...CallOption) (ClientStream, error) {
- transport, err := acbw.ac.getTransport(ctx)
- if err != nil {
- return nil, err
+ transport := acbw.ac.getReadyTransport()
+ if transport == nil {
+ return nil, status.Errorf(codes.Unavailable, "SubConn state is not Ready")
+
}
return newNonRetryClientStream(ctx, desc, method, transport, acbw.ac, opts...)
}
@@ -307,15 +332,15 @@ type refCountedProducer struct {
}
func (acbw *acBalancerWrapper) GetOrBuildProducer(pb balancer.ProducerBuilder) (balancer.Producer, func()) {
- acbw.mu.Lock()
- defer acbw.mu.Unlock()
+ acbw.producersMu.Lock()
+ defer acbw.producersMu.Unlock()
// Look up existing producer from this builder.
pData := acbw.producers[pb]
if pData == nil {
// Not found; create a new one and add it to the producers map.
- p, close := pb.Build(acbw)
- pData = &refCountedProducer{producer: p, close: close}
+ p, closeFn := pb.Build(acbw)
+ pData = &refCountedProducer{producer: p, close: closeFn}
acbw.producers[pb] = pData
}
// Account for this new reference.
@@ -325,13 +350,26 @@ func (acbw *acBalancerWrapper) GetOrBuildProducer(pb balancer.ProducerBuilder) (
// and delete the refCountedProducer from the map if the total reference
// count goes to zero.
unref := func() {
- acbw.mu.Lock()
+ acbw.producersMu.Lock()
+ // If closeProducers has already closed this producer instance, refs is
+ // set to 0, so the check after decrementing will never pass, and the
+ // producer will not be double-closed.
pData.refs--
if pData.refs == 0 {
defer pData.close() // Run outside the acbw mutex
delete(acbw.producers, pb)
}
- acbw.mu.Unlock()
+ acbw.producersMu.Unlock()
}
return pData.producer, grpcsync.OnceFunc(unref)
}
+
+func (acbw *acBalancerWrapper) closeProducers() {
+ acbw.producersMu.Lock()
+ defer acbw.producersMu.Unlock()
+ for pb, pData := range acbw.producers {
+ pData.refs = 0
+ pData.close()
+ delete(acbw.producers, pb)
+ }
+}
diff --git a/vendor/google.golang.org/grpc/binarylog/grpc_binarylog_v1/binarylog.pb.go b/vendor/google.golang.org/grpc/binarylog/grpc_binarylog_v1/binarylog.pb.go
index 1afb1e84ac..55bffaa77e 100644
--- a/vendor/google.golang.org/grpc/binarylog/grpc_binarylog_v1/binarylog.pb.go
+++ b/vendor/google.golang.org/grpc/binarylog/grpc_binarylog_v1/binarylog.pb.go
@@ -18,8 +18,8 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
-// protoc-gen-go v1.33.0
-// protoc v4.25.2
+// protoc-gen-go v1.34.2
+// protoc v5.27.1
// source: grpc/binlog/v1/binarylog.proto
package grpc_binarylog_v1
@@ -1015,7 +1015,7 @@ func file_grpc_binlog_v1_binarylog_proto_rawDescGZIP() []byte {
var file_grpc_binlog_v1_binarylog_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
var file_grpc_binlog_v1_binarylog_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
-var file_grpc_binlog_v1_binarylog_proto_goTypes = []interface{}{
+var file_grpc_binlog_v1_binarylog_proto_goTypes = []any{
(GrpcLogEntry_EventType)(0), // 0: grpc.binarylog.v1.GrpcLogEntry.EventType
(GrpcLogEntry_Logger)(0), // 1: grpc.binarylog.v1.GrpcLogEntry.Logger
(Address_Type)(0), // 2: grpc.binarylog.v1.Address.Type
@@ -1058,7 +1058,7 @@ func file_grpc_binlog_v1_binarylog_proto_init() {
return
}
if !protoimpl.UnsafeEnabled {
- file_grpc_binlog_v1_binarylog_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ file_grpc_binlog_v1_binarylog_proto_msgTypes[0].Exporter = func(v any, i int) any {
switch v := v.(*GrpcLogEntry); i {
case 0:
return &v.state
@@ -1070,7 +1070,7 @@ func file_grpc_binlog_v1_binarylog_proto_init() {
return nil
}
}
- file_grpc_binlog_v1_binarylog_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ file_grpc_binlog_v1_binarylog_proto_msgTypes[1].Exporter = func(v any, i int) any {
switch v := v.(*ClientHeader); i {
case 0:
return &v.state
@@ -1082,7 +1082,7 @@ func file_grpc_binlog_v1_binarylog_proto_init() {
return nil
}
}
- file_grpc_binlog_v1_binarylog_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+ file_grpc_binlog_v1_binarylog_proto_msgTypes[2].Exporter = func(v any, i int) any {
switch v := v.(*ServerHeader); i {
case 0:
return &v.state
@@ -1094,7 +1094,7 @@ func file_grpc_binlog_v1_binarylog_proto_init() {
return nil
}
}
- file_grpc_binlog_v1_binarylog_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+ file_grpc_binlog_v1_binarylog_proto_msgTypes[3].Exporter = func(v any, i int) any {
switch v := v.(*Trailer); i {
case 0:
return &v.state
@@ -1106,7 +1106,7 @@ func file_grpc_binlog_v1_binarylog_proto_init() {
return nil
}
}
- file_grpc_binlog_v1_binarylog_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+ file_grpc_binlog_v1_binarylog_proto_msgTypes[4].Exporter = func(v any, i int) any {
switch v := v.(*Message); i {
case 0:
return &v.state
@@ -1118,7 +1118,7 @@ func file_grpc_binlog_v1_binarylog_proto_init() {
return nil
}
}
- file_grpc_binlog_v1_binarylog_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+ file_grpc_binlog_v1_binarylog_proto_msgTypes[5].Exporter = func(v any, i int) any {
switch v := v.(*Metadata); i {
case 0:
return &v.state
@@ -1130,7 +1130,7 @@ func file_grpc_binlog_v1_binarylog_proto_init() {
return nil
}
}
- file_grpc_binlog_v1_binarylog_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+ file_grpc_binlog_v1_binarylog_proto_msgTypes[6].Exporter = func(v any, i int) any {
switch v := v.(*MetadataEntry); i {
case 0:
return &v.state
@@ -1142,7 +1142,7 @@ func file_grpc_binlog_v1_binarylog_proto_init() {
return nil
}
}
- file_grpc_binlog_v1_binarylog_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+ file_grpc_binlog_v1_binarylog_proto_msgTypes[7].Exporter = func(v any, i int) any {
switch v := v.(*Address); i {
case 0:
return &v.state
@@ -1155,7 +1155,7 @@ func file_grpc_binlog_v1_binarylog_proto_init() {
}
}
}
- file_grpc_binlog_v1_binarylog_proto_msgTypes[0].OneofWrappers = []interface{}{
+ file_grpc_binlog_v1_binarylog_proto_msgTypes[0].OneofWrappers = []any{
(*GrpcLogEntry_ClientHeader)(nil),
(*GrpcLogEntry_ServerHeader)(nil),
(*GrpcLogEntry_Message)(nil),
diff --git a/vendor/google.golang.org/grpc/clientconn.go b/vendor/google.golang.org/grpc/clientconn.go
index 2359f94b8a..19763f8edd 100644
--- a/vendor/google.golang.org/grpc/clientconn.go
+++ b/vendor/google.golang.org/grpc/clientconn.go
@@ -24,6 +24,7 @@ import (
"fmt"
"math"
"net/url"
+ "slices"
"strings"
"sync"
"sync/atomic"
@@ -31,6 +32,7 @@ import (
"google.golang.org/grpc/balancer"
"google.golang.org/grpc/balancer/base"
+ "google.golang.org/grpc/balancer/pickfirst"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/connectivity"
"google.golang.org/grpc/internal"
@@ -38,6 +40,7 @@ import (
"google.golang.org/grpc/internal/grpcsync"
"google.golang.org/grpc/internal/idle"
iresolver "google.golang.org/grpc/internal/resolver"
+ "google.golang.org/grpc/internal/stats"
"google.golang.org/grpc/internal/transport"
"google.golang.org/grpc/keepalive"
"google.golang.org/grpc/resolver"
@@ -72,6 +75,8 @@ var (
// invalidDefaultServiceConfigErrPrefix is used to prefix the json parsing error for the default
// service config.
invalidDefaultServiceConfigErrPrefix = "grpc: the provided default service config is invalid"
+ // PickFirstBalancerName is the name of the pick_first balancer.
+ PickFirstBalancerName = pickfirst.Name
)
// The following errors are returned from Dial and DialContext
@@ -152,6 +157,16 @@ func NewClient(target string, opts ...DialOption) (conn *ClientConn, err error)
for _, opt := range opts {
opt.apply(&cc.dopts)
}
+
+ // Determine the resolver to use.
+ if err := cc.initParsedTargetAndResolverBuilder(); err != nil {
+ return nil, err
+ }
+
+ for _, opt := range globalPerTargetDialOptions {
+ opt.DialOptionForTarget(cc.parsedTarget.URL).apply(&cc.dopts)
+ }
+
chainUnaryClientInterceptors(cc)
chainStreamClientInterceptors(cc)
@@ -160,7 +175,7 @@ func NewClient(target string, opts ...DialOption) (conn *ClientConn, err error)
}
if cc.dopts.defaultServiceConfigRawJSON != nil {
- scpr := parseServiceConfig(*cc.dopts.defaultServiceConfigRawJSON)
+ scpr := parseServiceConfig(*cc.dopts.defaultServiceConfigRawJSON, cc.dopts.maxCallAttempts)
if scpr.Err != nil {
return nil, fmt.Errorf("%s: %v", invalidDefaultServiceConfigErrPrefix, scpr.Err)
}
@@ -168,30 +183,24 @@ func NewClient(target string, opts ...DialOption) (conn *ClientConn, err error)
}
cc.mkp = cc.dopts.copts.KeepaliveParams
- // Register ClientConn with channelz.
- cc.channelzRegistration(target)
-
- // TODO: Ideally it should be impossible to error from this function after
- // channelz registration. This will require removing some channelz logs
- // from the following functions that can error. Errors can be returned to
- // the user, and successful logs can be emitted here, after the checks have
- // passed and channelz is subsequently registered.
-
- // Determine the resolver to use.
- if err := cc.parseTargetAndFindResolver(); err != nil {
- channelz.RemoveEntry(cc.channelz.ID)
- return nil, err
- }
- if err = cc.determineAuthority(); err != nil {
- channelz.RemoveEntry(cc.channelz.ID)
+ if err = cc.initAuthority(); err != nil {
return nil, err
}
+ // Register ClientConn with channelz. Note that this is only done after
+ // channel creation cannot fail.
+ cc.channelzRegistration(target)
+ channelz.Infof(logger, cc.channelz, "parsed dial target is: %#v", cc.parsedTarget)
+ channelz.Infof(logger, cc.channelz, "Channel authority set to %q", cc.authority)
+
cc.csMgr = newConnectivityStateManager(cc.ctx, cc.channelz)
cc.pickerWrapper = newPickerWrapper(cc.dopts.copts.StatsHandlers)
+ cc.metricsRecorderList = stats.NewMetricsRecorderList(cc.dopts.copts.StatsHandlers)
+
cc.initIdleStateLocked() // Safe to call without the lock, since nothing else has a reference to cc.
cc.idlenessMgr = idle.NewManager((*idler)(cc), cc.dopts.idleTimeout)
+
return cc, nil
}
@@ -586,13 +595,14 @@ type ClientConn struct {
cancel context.CancelFunc // Cancelled on close.
// The following are initialized at dial time, and are read-only after that.
- target string // User's dial target.
- parsedTarget resolver.Target // See parseTargetAndFindResolver().
- authority string // See determineAuthority().
- dopts dialOptions // Default and user specified dial options.
- channelz *channelz.Channel // Channelz object.
- resolverBuilder resolver.Builder // See parseTargetAndFindResolver().
- idlenessMgr *idle.Manager
+ target string // User's dial target.
+ parsedTarget resolver.Target // See initParsedTargetAndResolverBuilder().
+ authority string // See initAuthority().
+ dopts dialOptions // Default and user specified dial options.
+ channelz *channelz.Channel // Channelz object.
+ resolverBuilder resolver.Builder // See initParsedTargetAndResolverBuilder().
+ idlenessMgr *idle.Manager
+ metricsRecorderList *stats.MetricsRecorderList
// The following provide their own synchronization, and therefore don't
// require cc.mu to be held to access them.
@@ -622,11 +632,6 @@ type ClientConn struct {
// WaitForStateChange waits until the connectivity.State of ClientConn changes from sourceState or
// ctx expires. A true value is returned in former case and false in latter.
-//
-// # Experimental
-//
-// Notice: This API is EXPERIMENTAL and may be changed or removed in a
-// later release.
func (cc *ClientConn) WaitForStateChange(ctx context.Context, sourceState connectivity.State) bool {
ch := cc.csMgr.getNotifyChan()
if cc.csMgr.getState() != sourceState {
@@ -641,11 +646,6 @@ func (cc *ClientConn) WaitForStateChange(ctx context.Context, sourceState connec
}
// GetState returns the connectivity.State of ClientConn.
-//
-// # Experimental
-//
-// Notice: This API is EXPERIMENTAL and may be changed or removed in a later
-// release.
func (cc *ClientConn) GetState() connectivity.State {
return cc.csMgr.getState()
}
@@ -692,8 +692,7 @@ func (cc *ClientConn) waitForResolvedAddrs(ctx context.Context) error {
var emptyServiceConfig *ServiceConfig
func init() {
- balancer.Register(pickfirstBuilder{})
- cfg := parseServiceConfig("{}")
+ cfg := parseServiceConfig("{}", defaultMaxCallAttempts)
if cfg.Err != nil {
panic(fmt.Sprintf("impossible error parsing empty service config: %v", cfg.Err))
}
@@ -809,17 +808,11 @@ func (cc *ClientConn) applyFailingLBLocked(sc *serviceconfig.ParseResult) {
cc.csMgr.updateState(connectivity.TransientFailure)
}
-// Makes a copy of the input addresses slice and clears out the balancer
-// attributes field. Addresses are passed during subconn creation and address
-// update operations. In both cases, we will clear the balancer attributes by
-// calling this function, and therefore we will be able to use the Equal method
-// provided by the resolver.Address type for comparison.
-func copyAddressesWithoutBalancerAttributes(in []resolver.Address) []resolver.Address {
+// Makes a copy of the input addresses slice. Addresses are passed during
+// subconn creation and address update operations.
+func copyAddresses(in []resolver.Address) []resolver.Address {
out := make([]resolver.Address, len(in))
- for i := range in {
- out[i] = in[i]
- out[i].BalancerAttributes = nil
- }
+ copy(out, in)
return out
}
@@ -834,12 +827,11 @@ func (cc *ClientConn) newAddrConnLocked(addrs []resolver.Address, opts balancer.
ac := &addrConn{
state: connectivity.Idle,
cc: cc,
- addrs: copyAddressesWithoutBalancerAttributes(addrs),
+ addrs: copyAddresses(addrs),
scopts: opts,
dopts: cc.dopts,
channelz: channelz.RegisterSubChannel(cc.channelz, ""),
resetBackoff: make(chan struct{}),
- stateChan: make(chan struct{}),
}
ac.ctx, ac.cancel = context.WithCancel(cc.ctx)
// Start with our address set to the first address; this may be updated if
@@ -915,28 +907,29 @@ func (ac *addrConn) connect() error {
ac.mu.Unlock()
return nil
}
- ac.mu.Unlock()
- ac.resetTransport()
+ ac.resetTransportAndUnlock()
return nil
}
-func equalAddresses(a, b []resolver.Address) bool {
- if len(a) != len(b) {
- return false
- }
- for i, v := range a {
- if !v.Equal(b[i]) {
- return false
- }
- }
- return true
+// equalAddressIgnoringBalAttributes returns true is a and b are considered equal.
+// This is different from the Equal method on the resolver.Address type which
+// considers all fields to determine equality. Here, we only consider fields
+// that are meaningful to the subConn.
+func equalAddressIgnoringBalAttributes(a, b *resolver.Address) bool {
+ return a.Addr == b.Addr && a.ServerName == b.ServerName &&
+ a.Attributes.Equal(b.Attributes) &&
+ a.Metadata == b.Metadata
+}
+
+func equalAddressesIgnoringBalAttributes(a, b []resolver.Address) bool {
+ return slices.EqualFunc(a, b, func(a, b resolver.Address) bool { return equalAddressIgnoringBalAttributes(&a, &b) })
}
// updateAddrs updates ac.addrs with the new addresses list and handles active
// connections or connection attempts.
func (ac *addrConn) updateAddrs(addrs []resolver.Address) {
- addrs = copyAddressesWithoutBalancerAttributes(addrs)
+ addrs = copyAddresses(addrs)
limit := len(addrs)
if limit > 5 {
limit = 5
@@ -944,7 +937,7 @@ func (ac *addrConn) updateAddrs(addrs []resolver.Address) {
channelz.Infof(logger, ac.channelz, "addrConn: updateAddrs addrs (%d of %d): %v", limit, len(addrs), addrs[:limit])
ac.mu.Lock()
- if equalAddresses(ac.addrs, addrs) {
+ if equalAddressesIgnoringBalAttributes(ac.addrs, addrs) {
ac.mu.Unlock()
return
}
@@ -963,7 +956,7 @@ func (ac *addrConn) updateAddrs(addrs []resolver.Address) {
// Try to find the connected address.
for _, a := range addrs {
a.ServerName = ac.cc.getServerName(a)
- if a.Equal(ac.curAddr) {
+ if equalAddressIgnoringBalAttributes(&a, &ac.curAddr) {
// We are connected to a valid address, so do nothing but
// update the addresses.
ac.mu.Unlock()
@@ -989,11 +982,9 @@ func (ac *addrConn) updateAddrs(addrs []resolver.Address) {
ac.updateConnectivityState(connectivity.Idle, nil)
}
- ac.mu.Unlock()
-
// Since we were connecting/connected, we should start a new connection
// attempt.
- go ac.resetTransport()
+ go ac.resetTransportAndUnlock()
}
// getServerName determines the serverName to be used in the connection
@@ -1149,10 +1140,15 @@ func (cc *ClientConn) Close() error {
<-cc.resolverWrapper.serializer.Done()
<-cc.balancerWrapper.serializer.Done()
-
+ var wg sync.WaitGroup
for ac := range conns {
- ac.tearDown(ErrClientConnClosing)
+ wg.Add(1)
+ go func(ac *addrConn) {
+ defer wg.Done()
+ ac.tearDown(ErrClientConnClosing)
+ }(ac)
}
+ wg.Wait()
cc.addTraceEvent("deleted")
// TraceEvent needs to be called before RemoveEntry, as TraceEvent may add
// trace reference to the entity being deleted, and thus prevent it from being
@@ -1187,8 +1183,7 @@ type addrConn struct {
addrs []resolver.Address // All addresses that the resolver resolved to.
// Use updateConnectivityState for updating addrConn's connectivity state.
- state connectivity.State
- stateChan chan struct{} // closed and recreated on every state change.
+ state connectivity.State
backoffIdx int // Needs to be stateful for resetConnectBackoff.
resetBackoff chan struct{}
@@ -1201,9 +1196,6 @@ func (ac *addrConn) updateConnectivityState(s connectivity.State, lastErr error)
if ac.state == s {
return
}
- // When changing states, reset the state change channel.
- close(ac.stateChan)
- ac.stateChan = make(chan struct{})
ac.state = s
ac.channelz.ChannelMetrics.State.Store(&s)
if lastErr == nil {
@@ -1211,7 +1203,7 @@ func (ac *addrConn) updateConnectivityState(s connectivity.State, lastErr error)
} else {
channelz.Infof(logger, ac.channelz, "Subchannel Connectivity change to %v, last error: %s", s, lastErr)
}
- ac.acbw.updateState(s, lastErr)
+ ac.acbw.updateState(s, ac.curAddr, lastErr)
}
// adjustParams updates parameters used to create transports upon
@@ -1228,8 +1220,10 @@ func (ac *addrConn) adjustParams(r transport.GoAwayReason) {
}
}
-func (ac *addrConn) resetTransport() {
- ac.mu.Lock()
+// resetTransportAndUnlock unconditionally connects the addrConn.
+//
+// ac.mu must be held by the caller, and this function will guarantee it is released.
+func (ac *addrConn) resetTransportAndUnlock() {
acCtx := ac.ctx
if acCtx.Err() != nil {
ac.mu.Unlock()
@@ -1260,6 +1254,8 @@ func (ac *addrConn) resetTransport() {
ac.mu.Unlock()
if err := ac.tryAllAddrs(acCtx, addrs, connectDeadline); err != nil {
+ // TODO: #7534 - Move re-resolution requests into the pick_first LB policy
+ // to ensure one resolution request per pass instead of per subconn failure.
ac.cc.resolveNow(resolver.ResolveNowOptions{})
ac.mu.Lock()
if acCtx.Err() != nil {
@@ -1301,7 +1297,7 @@ func (ac *addrConn) resetTransport() {
ac.mu.Unlock()
}
-// tryAllAddrs tries to creates a connection to the addresses, and stop when at
+// tryAllAddrs tries to create a connection to the addresses, and stop when at
// the first successful one. It returns an error if no address was successfully
// connected, or updates ac appropriately with the new transport.
func (ac *addrConn) tryAllAddrs(ctx context.Context, addrs []resolver.Address, connectDeadline time.Time) error {
@@ -1513,29 +1509,6 @@ func (ac *addrConn) getReadyTransport() transport.ClientTransport {
return nil
}
-// getTransport waits until the addrconn is ready and returns the transport.
-// If the context expires first, returns an appropriate status. If the
-// addrConn is stopped first, returns an Unavailable status error.
-func (ac *addrConn) getTransport(ctx context.Context) (transport.ClientTransport, error) {
- for ctx.Err() == nil {
- ac.mu.Lock()
- t, state, sc := ac.transport, ac.state, ac.stateChan
- ac.mu.Unlock()
- if state == connectivity.Ready {
- return t, nil
- }
- if state == connectivity.Shutdown {
- return nil, status.Errorf(codes.Unavailable, "SubConn shutting down")
- }
-
- select {
- case <-ctx.Done():
- case <-sc:
- }
- }
- return nil, status.FromContextError(ctx.Err()).Err()
-}
-
// tearDown starts to tear down the addrConn.
//
// Note that tearDown doesn't remove ac from ac.cc.conns, so the addrConn struct
@@ -1582,7 +1555,7 @@ func (ac *addrConn) tearDown(err error) {
} else {
// Hard close the transport when the channel is entering idle or is
// being shutdown. In the case where the channel is being shutdown,
- // closing of transports is also taken care of by cancelation of cc.ctx.
+ // closing of transports is also taken care of by cancellation of cc.ctx.
// But in the case where the channel is entering idle, we need to
// explicitly close the transports here. Instead of distinguishing
// between these two cases, it is simpler to close the transport
@@ -1673,22 +1646,19 @@ func (cc *ClientConn) connectionError() error {
return cc.lastConnectionError
}
-// parseTargetAndFindResolver parses the user's dial target and stores the
-// parsed target in `cc.parsedTarget`.
+// initParsedTargetAndResolverBuilder parses the user's dial target and stores
+// the parsed target in `cc.parsedTarget`.
//
// The resolver to use is determined based on the scheme in the parsed target
// and the same is stored in `cc.resolverBuilder`.
//
// Doesn't grab cc.mu as this method is expected to be called only at Dial time.
-func (cc *ClientConn) parseTargetAndFindResolver() error {
- channelz.Infof(logger, cc.channelz, "original dial target is: %q", cc.target)
+func (cc *ClientConn) initParsedTargetAndResolverBuilder() error {
+ logger.Infof("original dial target is: %q", cc.target)
var rb resolver.Builder
parsedTarget, err := parseTarget(cc.target)
- if err != nil {
- channelz.Infof(logger, cc.channelz, "dial target %q parse failed: %v", cc.target, err)
- } else {
- channelz.Infof(logger, cc.channelz, "parsed dial target is: %#v", parsedTarget)
+ if err == nil {
rb = cc.getResolver(parsedTarget.URL.Scheme)
if rb != nil {
cc.parsedTarget = parsedTarget
@@ -1707,15 +1677,12 @@ func (cc *ClientConn) parseTargetAndFindResolver() error {
defScheme = resolver.GetDefaultScheme()
}
- channelz.Infof(logger, cc.channelz, "fallback to scheme %q", defScheme)
canonicalTarget := defScheme + ":///" + cc.target
parsedTarget, err = parseTarget(canonicalTarget)
if err != nil {
- channelz.Infof(logger, cc.channelz, "dial target %q parse failed: %v", canonicalTarget, err)
return err
}
- channelz.Infof(logger, cc.channelz, "parsed dial target is: %+v", parsedTarget)
rb = cc.getResolver(parsedTarget.URL.Scheme)
if rb == nil {
return fmt.Errorf("could not get resolver for default scheme: %q", parsedTarget.URL.Scheme)
@@ -1805,7 +1772,7 @@ func encodeAuthority(authority string) string {
// credentials do not match the authority configured through the dial option.
//
// Doesn't grab cc.mu as this method is expected to be called only at Dial time.
-func (cc *ClientConn) determineAuthority() error {
+func (cc *ClientConn) initAuthority() error {
dopts := cc.dopts
// Historically, we had two options for users to specify the serverName or
// authority for a channel. One was through the transport credentials
@@ -1838,6 +1805,5 @@ func (cc *ClientConn) determineAuthority() error {
} else {
cc.authority = encodeAuthority(endpoint)
}
- channelz.Infof(logger, cc.channelz, "Channel authority set to %q", cc.authority)
return nil
}
diff --git a/vendor/google.golang.org/grpc/codec.go b/vendor/google.golang.org/grpc/codec.go
index 411e3dfd47..e840858b77 100644
--- a/vendor/google.golang.org/grpc/codec.go
+++ b/vendor/google.golang.org/grpc/codec.go
@@ -21,18 +21,73 @@ package grpc
import (
"google.golang.org/grpc/encoding"
_ "google.golang.org/grpc/encoding/proto" // to register the Codec for "proto"
+ "google.golang.org/grpc/mem"
)
-// baseCodec contains the functionality of both Codec and encoding.Codec, but
-// omits the name/string, which vary between the two and are not needed for
-// anything besides the registry in the encoding package.
+// baseCodec captures the new encoding.CodecV2 interface without the Name
+// function, allowing it to be implemented by older Codec and encoding.Codec
+// implementations. The omitted Name function is only needed for the register in
+// the encoding package and is not part of the core functionality.
type baseCodec interface {
- Marshal(v any) ([]byte, error)
- Unmarshal(data []byte, v any) error
+ Marshal(v any) (mem.BufferSlice, error)
+ Unmarshal(data mem.BufferSlice, v any) error
+}
+
+// getCodec returns an encoding.CodecV2 for the codec of the given name (if
+// registered). Initially checks the V2 registry with encoding.GetCodecV2 and
+// returns the V2 codec if it is registered. Otherwise, it checks the V1 registry
+// with encoding.GetCodec and if it is registered wraps it with newCodecV1Bridge
+// to turn it into an encoding.CodecV2. Returns nil otherwise.
+func getCodec(name string) encoding.CodecV2 {
+ if codecV1 := encoding.GetCodec(name); codecV1 != nil {
+ return newCodecV1Bridge(codecV1)
+ }
+
+ return encoding.GetCodecV2(name)
+}
+
+func newCodecV0Bridge(c Codec) baseCodec {
+ return codecV0Bridge{codec: c}
+}
+
+func newCodecV1Bridge(c encoding.Codec) encoding.CodecV2 {
+ return codecV1Bridge{
+ codecV0Bridge: codecV0Bridge{codec: c},
+ name: c.Name(),
+ }
+}
+
+var _ baseCodec = codecV0Bridge{}
+
+type codecV0Bridge struct {
+ codec interface {
+ Marshal(v any) ([]byte, error)
+ Unmarshal(data []byte, v any) error
+ }
+}
+
+func (c codecV0Bridge) Marshal(v any) (mem.BufferSlice, error) {
+ data, err := c.codec.Marshal(v)
+ if err != nil {
+ return nil, err
+ }
+ return mem.BufferSlice{mem.NewBuffer(&data, nil)}, nil
+}
+
+func (c codecV0Bridge) Unmarshal(data mem.BufferSlice, v any) (err error) {
+ return c.codec.Unmarshal(data.Materialize(), v)
}
-var _ baseCodec = Codec(nil)
-var _ baseCodec = encoding.Codec(nil)
+var _ encoding.CodecV2 = codecV1Bridge{}
+
+type codecV1Bridge struct {
+ codecV0Bridge
+ name string
+}
+
+func (c codecV1Bridge) Name() string {
+ return c.name
+}
// Codec defines the interface gRPC uses to encode and decode messages.
// Note that implementations of this interface must be thread safe;
diff --git a/vendor/google.golang.org/grpc/credentials/insecure/insecure.go b/vendor/google.golang.org/grpc/credentials/insecure/insecure.go
index 82bee1443b..4c805c6446 100644
--- a/vendor/google.golang.org/grpc/credentials/insecure/insecure.go
+++ b/vendor/google.golang.org/grpc/credentials/insecure/insecure.go
@@ -40,7 +40,7 @@ func NewCredentials() credentials.TransportCredentials {
// NoSecurity.
type insecureTC struct{}
-func (insecureTC) ClientHandshake(ctx context.Context, _ string, conn net.Conn) (net.Conn, credentials.AuthInfo, error) {
+func (insecureTC) ClientHandshake(_ context.Context, _ string, conn net.Conn) (net.Conn, credentials.AuthInfo, error) {
return conn, info{credentials.CommonAuthInfo{SecurityLevel: credentials.NoSecurity}}, nil
}
diff --git a/vendor/google.golang.org/grpc/credentials/tls.go b/vendor/google.golang.org/grpc/credentials/tls.go
index 5dafd34edf..e163a473df 100644
--- a/vendor/google.golang.org/grpc/credentials/tls.go
+++ b/vendor/google.golang.org/grpc/credentials/tls.go
@@ -27,9 +27,13 @@ import (
"net/url"
"os"
+ "google.golang.org/grpc/grpclog"
credinternal "google.golang.org/grpc/internal/credentials"
+ "google.golang.org/grpc/internal/envconfig"
)
+var logger = grpclog.Component("credentials")
+
// TLSInfo contains the auth information for a TLS authenticated connection.
// It implements the AuthInfo interface.
type TLSInfo struct {
@@ -112,6 +116,22 @@ func (c *tlsCreds) ClientHandshake(ctx context.Context, authority string, rawCon
conn.Close()
return nil, nil, ctx.Err()
}
+
+ // The negotiated protocol can be either of the following:
+ // 1. h2: When the server supports ALPN. Only HTTP/2 can be negotiated since
+ // it is the only protocol advertised by the client during the handshake.
+ // The tls library ensures that the server chooses a protocol advertised
+ // by the client.
+ // 2. "" (empty string): If the server doesn't support ALPN. ALPN is a requirement
+ // for using HTTP/2 over TLS. We can terminate the connection immediately.
+ np := conn.ConnectionState().NegotiatedProtocol
+ if np == "" {
+ if envconfig.EnforceALPNEnabled {
+ conn.Close()
+ return nil, nil, fmt.Errorf("credentials: cannot check peer: missing selected ALPN property")
+ }
+ logger.Warningf("Allowing TLS connection to server %q with ALPN disabled. TLS connections to servers with ALPN disabled will be disallowed in future grpc-go releases", cfg.ServerName)
+ }
tlsInfo := TLSInfo{
State: conn.ConnectionState(),
CommonAuthInfo: CommonAuthInfo{
@@ -131,8 +151,20 @@ func (c *tlsCreds) ServerHandshake(rawConn net.Conn) (net.Conn, AuthInfo, error)
conn.Close()
return nil, nil, err
}
+ cs := conn.ConnectionState()
+ // The negotiated application protocol can be empty only if the client doesn't
+ // support ALPN. In such cases, we can close the connection since ALPN is required
+ // for using HTTP/2 over TLS.
+ if cs.NegotiatedProtocol == "" {
+ if envconfig.EnforceALPNEnabled {
+ conn.Close()
+ return nil, nil, fmt.Errorf("credentials: cannot check peer: missing selected ALPN property")
+ } else if logger.V(2) {
+ logger.Info("Allowing TLS connection from client with ALPN disabled. TLS connections with ALPN disabled will be disallowed in future grpc-go releases")
+ }
+ }
tlsInfo := TLSInfo{
- State: conn.ConnectionState(),
+ State: cs,
CommonAuthInfo: CommonAuthInfo{
SecurityLevel: PrivacyAndIntegrity,
},
@@ -168,25 +200,40 @@ var tls12ForbiddenCipherSuites = map[uint16]struct{}{
// NewTLS uses c to construct a TransportCredentials based on TLS.
func NewTLS(c *tls.Config) TransportCredentials {
- tc := &tlsCreds{credinternal.CloneTLSConfig(c)}
- tc.config.NextProtos = credinternal.AppendH2ToNextProtos(tc.config.NextProtos)
+ config := applyDefaults(c)
+ if config.GetConfigForClient != nil {
+ oldFn := config.GetConfigForClient
+ config.GetConfigForClient = func(hello *tls.ClientHelloInfo) (*tls.Config, error) {
+ cfgForClient, err := oldFn(hello)
+ if err != nil || cfgForClient == nil {
+ return cfgForClient, err
+ }
+ return applyDefaults(cfgForClient), nil
+ }
+ }
+ return &tlsCreds{config: config}
+}
+
+func applyDefaults(c *tls.Config) *tls.Config {
+ config := credinternal.CloneTLSConfig(c)
+ config.NextProtos = credinternal.AppendH2ToNextProtos(config.NextProtos)
// If the user did not configure a MinVersion and did not configure a
// MaxVersion < 1.2, use MinVersion=1.2, which is required by
// https://datatracker.ietf.org/doc/html/rfc7540#section-9.2
- if tc.config.MinVersion == 0 && (tc.config.MaxVersion == 0 || tc.config.MaxVersion >= tls.VersionTLS12) {
- tc.config.MinVersion = tls.VersionTLS12
+ if config.MinVersion == 0 && (config.MaxVersion == 0 || config.MaxVersion >= tls.VersionTLS12) {
+ config.MinVersion = tls.VersionTLS12
}
// If the user did not configure CipherSuites, use all "secure" cipher
// suites reported by the TLS package, but remove some explicitly forbidden
// by https://datatracker.ietf.org/doc/html/rfc7540#appendix-A
- if tc.config.CipherSuites == nil {
+ if config.CipherSuites == nil {
for _, cs := range tls.CipherSuites() {
if _, ok := tls12ForbiddenCipherSuites[cs.ID]; !ok {
- tc.config.CipherSuites = append(tc.config.CipherSuites, cs.ID)
+ config.CipherSuites = append(config.CipherSuites, cs.ID)
}
}
}
- return tc
+ return config
}
// NewClientTLSFromCert constructs TLS credentials from the provided root
diff --git a/vendor/google.golang.org/grpc/dialoptions.go b/vendor/google.golang.org/grpc/dialoptions.go
index 00273702b6..518692c3af 100644
--- a/vendor/google.golang.org/grpc/dialoptions.go
+++ b/vendor/google.golang.org/grpc/dialoptions.go
@@ -21,6 +21,7 @@ package grpc
import (
"context"
"net"
+ "net/url"
"time"
"google.golang.org/grpc/backoff"
@@ -32,10 +33,16 @@ import (
"google.golang.org/grpc/internal/binarylog"
"google.golang.org/grpc/internal/transport"
"google.golang.org/grpc/keepalive"
+ "google.golang.org/grpc/mem"
"google.golang.org/grpc/resolver"
"google.golang.org/grpc/stats"
)
+const (
+ // https://github.com/grpc/proposal/blob/master/A6-client-retries.md#limits-on-retries-and-hedges
+ defaultMaxCallAttempts = 5
+)
+
func init() {
internal.AddGlobalDialOptions = func(opt ...DialOption) {
globalDialOptions = append(globalDialOptions, opt...)
@@ -43,10 +50,18 @@ func init() {
internal.ClearGlobalDialOptions = func() {
globalDialOptions = nil
}
+ internal.AddGlobalPerTargetDialOptions = func(opt any) {
+ if ptdo, ok := opt.(perTargetDialOption); ok {
+ globalPerTargetDialOptions = append(globalPerTargetDialOptions, ptdo)
+ }
+ }
+ internal.ClearGlobalPerTargetDialOptions = func() {
+ globalPerTargetDialOptions = nil
+ }
internal.WithBinaryLogger = withBinaryLogger
internal.JoinDialOptions = newJoinDialOption
internal.DisableGlobalDialOptions = newDisableGlobalDialOptions
- internal.WithRecvBufferPool = withRecvBufferPool
+ internal.WithBufferPool = withBufferPool
}
// dialOptions configure a Dial call. dialOptions are set by the DialOption
@@ -78,8 +93,8 @@ type dialOptions struct {
defaultServiceConfigRawJSON *string
resolvers []resolver.Builder
idleTimeout time.Duration
- recvBufferPool SharedBufferPool
defaultScheme string
+ maxCallAttempts int
}
// DialOption configures how we set up the connection.
@@ -89,6 +104,19 @@ type DialOption interface {
var globalDialOptions []DialOption
+// perTargetDialOption takes a parsed target and returns a dial option to apply.
+//
+// This gets called after NewClient() parses the target, and allows per target
+// configuration set through a returned DialOption. The DialOption will not take
+// effect if specifies a resolver builder, as that Dial Option is factored in
+// while parsing target.
+type perTargetDialOption interface {
+ // DialOption returns a Dial Option to apply.
+ DialOptionForTarget(parsedTarget url.URL) DialOption
+}
+
+var globalPerTargetDialOptions []perTargetDialOption
+
// EmptyDialOption does not alter the dial configuration. It can be embedded in
// another structure to build custom dial options.
//
@@ -408,7 +436,7 @@ func WithTimeout(d time.Duration) DialOption {
// option to true from the Control field. For a concrete example of how to do
// this, see internal.NetDialerWithTCPKeepalive().
//
-// For more information, please see [issue 23459] in the Go github repo.
+// For more information, please see [issue 23459] in the Go GitHub repo.
//
// [issue 23459]: https://github.com/golang/go/issues/23459
func WithContextDialer(f func(context.Context, string) (net.Conn, error)) DialOption {
@@ -490,6 +518,8 @@ func WithUserAgent(s string) DialOption {
// WithKeepaliveParams returns a DialOption that specifies keepalive parameters
// for the client transport.
+//
+// Keepalive is disabled by default.
func WithKeepaliveParams(kp keepalive.ClientParameters) DialOption {
if kp.Time < internal.KeepaliveMinPingTime {
logger.Warningf("Adjusting keepalive ping interval to minimum period of %v", internal.KeepaliveMinPingTime)
@@ -649,12 +679,13 @@ func defaultDialOptions() dialOptions {
WriteBufferSize: defaultWriteBufSize,
UseProxy: true,
UserAgent: grpcUA,
+ BufferPool: mem.DefaultBufferPool(),
},
bs: internalbackoff.DefaultExponential,
healthCheckFunc: internal.HealthCheckFunc,
idleTimeout: 30 * time.Minute,
- recvBufferPool: nopBufferPool{},
defaultScheme: "dns",
+ maxCallAttempts: defaultMaxCallAttempts,
}
}
@@ -712,25 +743,25 @@ func WithIdleTimeout(d time.Duration) DialOption {
})
}
-// WithRecvBufferPool returns a DialOption that configures the ClientConn
-// to use the provided shared buffer pool for parsing incoming messages. Depending
-// on the application's workload, this could result in reduced memory allocation.
-//
-// If you are unsure about how to implement a memory pool but want to utilize one,
-// begin with grpc.NewSharedBufferPool.
-//
-// Note: The shared buffer pool feature will not be active if any of the following
-// options are used: WithStatsHandler, EnableTracing, or binary logging. In such
-// cases, the shared buffer pool will be ignored.
+// WithMaxCallAttempts returns a DialOption that configures the maximum number
+// of attempts per call (including retries and hedging) using the channel.
+// Service owners may specify a higher value for these parameters, but higher
+// values will be treated as equal to the maximum value by the client
+// implementation. This mitigates security concerns related to the service
+// config being transferred to the client via DNS.
//
-// Deprecated: use experimental.WithRecvBufferPool instead. Will be deleted in
-// v1.60.0 or later.
-func WithRecvBufferPool(bufferPool SharedBufferPool) DialOption {
- return withRecvBufferPool(bufferPool)
+// A value of 5 will be used if this dial option is not set or n < 2.
+func WithMaxCallAttempts(n int) DialOption {
+ return newFuncDialOption(func(o *dialOptions) {
+ if n < 2 {
+ n = defaultMaxCallAttempts
+ }
+ o.maxCallAttempts = n
+ })
}
-func withRecvBufferPool(bufferPool SharedBufferPool) DialOption {
+func withBufferPool(bufferPool mem.BufferPool) DialOption {
return newFuncDialOption(func(o *dialOptions) {
- o.recvBufferPool = bufferPool
+ o.copts.BufferPool = bufferPool
})
}
diff --git a/vendor/google.golang.org/grpc/doc.go b/vendor/google.golang.org/grpc/doc.go
index 0022859ad7..e7b532b6f8 100644
--- a/vendor/google.golang.org/grpc/doc.go
+++ b/vendor/google.golang.org/grpc/doc.go
@@ -16,7 +16,7 @@
*
*/
-//go:generate ./regenerate.sh
+//go:generate ./scripts/regenerate.sh
/*
Package grpc implements an RPC system called gRPC.
diff --git a/vendor/google.golang.org/grpc/encoding/encoding.go b/vendor/google.golang.org/grpc/encoding/encoding.go
index 5ebf88d714..11d0ae142c 100644
--- a/vendor/google.golang.org/grpc/encoding/encoding.go
+++ b/vendor/google.golang.org/grpc/encoding/encoding.go
@@ -94,7 +94,7 @@ type Codec interface {
Name() string
}
-var registeredCodecs = make(map[string]Codec)
+var registeredCodecs = make(map[string]any)
// RegisterCodec registers the provided Codec for use with all gRPC clients and
// servers.
@@ -126,5 +126,6 @@ func RegisterCodec(codec Codec) {
//
// The content-subtype is expected to be lowercase.
func GetCodec(contentSubtype string) Codec {
- return registeredCodecs[contentSubtype]
+ c, _ := registeredCodecs[contentSubtype].(Codec)
+ return c
}
diff --git a/vendor/google.golang.org/grpc/encoding/encoding_v2.go b/vendor/google.golang.org/grpc/encoding/encoding_v2.go
new file mode 100644
index 0000000000..074c5e234a
--- /dev/null
+++ b/vendor/google.golang.org/grpc/encoding/encoding_v2.go
@@ -0,0 +1,81 @@
+/*
+ *
+ * Copyright 2024 gRPC 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 encoding
+
+import (
+ "strings"
+
+ "google.golang.org/grpc/mem"
+)
+
+// CodecV2 defines the interface gRPC uses to encode and decode messages. Note
+// that implementations of this interface must be thread safe; a CodecV2's
+// methods can be called from concurrent goroutines.
+type CodecV2 interface {
+ // Marshal returns the wire format of v. The buffers in the returned
+ // [mem.BufferSlice] must have at least one reference each, which will be freed
+ // by gRPC when they are no longer needed.
+ Marshal(v any) (out mem.BufferSlice, err error)
+ // Unmarshal parses the wire format into v. Note that data will be freed as soon
+ // as this function returns. If the codec wishes to guarantee access to the data
+ // after this function, it must take its own reference that it frees when it is
+ // no longer needed.
+ Unmarshal(data mem.BufferSlice, v any) error
+ // Name returns the name of the Codec implementation. The returned string
+ // will be used as part of content type in transmission. The result must be
+ // static; the result cannot change between calls.
+ Name() string
+}
+
+// RegisterCodecV2 registers the provided CodecV2 for use with all gRPC clients and
+// servers.
+//
+// The CodecV2 will be stored and looked up by result of its Name() method, which
+// should match the content-subtype of the encoding handled by the CodecV2. This
+// is case-insensitive, and is stored and looked up as lowercase. If the
+// result of calling Name() is an empty string, RegisterCodecV2 will panic. See
+// Content-Type on
+// https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#requests for
+// more details.
+//
+// If both a Codec and CodecV2 are registered with the same name, the CodecV2
+// will be used.
+//
+// NOTE: this function must only be called during initialization time (i.e. in
+// an init() function), and is not thread-safe. If multiple Codecs are
+// registered with the same name, the one registered last will take effect.
+func RegisterCodecV2(codec CodecV2) {
+ if codec == nil {
+ panic("cannot register a nil CodecV2")
+ }
+ if codec.Name() == "" {
+ panic("cannot register CodecV2 with empty string result for Name()")
+ }
+ contentSubtype := strings.ToLower(codec.Name())
+ registeredCodecs[contentSubtype] = codec
+}
+
+// GetCodecV2 gets a registered CodecV2 by content-subtype, or nil if no CodecV2 is
+// registered for the content-subtype.
+//
+// The content-subtype is expected to be lowercase.
+func GetCodecV2(contentSubtype string) CodecV2 {
+ c, _ := registeredCodecs[contentSubtype].(CodecV2)
+ return c
+}
diff --git a/vendor/google.golang.org/grpc/encoding/proto/proto.go b/vendor/google.golang.org/grpc/encoding/proto/proto.go
index 66d5cdf03e..ceec319dd2 100644
--- a/vendor/google.golang.org/grpc/encoding/proto/proto.go
+++ b/vendor/google.golang.org/grpc/encoding/proto/proto.go
@@ -1,6 +1,6 @@
/*
*
- * Copyright 2018 gRPC authors.
+ * Copyright 2024 gRPC authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -24,6 +24,7 @@ import (
"fmt"
"google.golang.org/grpc/encoding"
+ "google.golang.org/grpc/mem"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/protoadapt"
)
@@ -32,28 +33,51 @@ import (
const Name = "proto"
func init() {
- encoding.RegisterCodec(codec{})
+ encoding.RegisterCodecV2(&codecV2{})
}
-// codec is a Codec implementation with protobuf. It is the default codec for gRPC.
-type codec struct{}
+// codec is a CodecV2 implementation with protobuf. It is the default codec for
+// gRPC.
+type codecV2 struct{}
-func (codec) Marshal(v any) ([]byte, error) {
+func (c *codecV2) Marshal(v any) (data mem.BufferSlice, err error) {
vv := messageV2Of(v)
if vv == nil {
- return nil, fmt.Errorf("failed to marshal, message is %T, want proto.Message", v)
+ return nil, fmt.Errorf("proto: failed to marshal, message is %T, want proto.Message", v)
}
- return proto.Marshal(vv)
+ size := proto.Size(vv)
+ if mem.IsBelowBufferPoolingThreshold(size) {
+ buf, err := proto.Marshal(vv)
+ if err != nil {
+ return nil, err
+ }
+ data = append(data, mem.SliceBuffer(buf))
+ } else {
+ pool := mem.DefaultBufferPool()
+ buf := pool.Get(size)
+ if _, err := (proto.MarshalOptions{}).MarshalAppend((*buf)[:0], vv); err != nil {
+ pool.Put(buf)
+ return nil, err
+ }
+ data = append(data, mem.NewBuffer(buf, pool))
+ }
+
+ return data, nil
}
-func (codec) Unmarshal(data []byte, v any) error {
+func (c *codecV2) Unmarshal(data mem.BufferSlice, v any) (err error) {
vv := messageV2Of(v)
if vv == nil {
return fmt.Errorf("failed to unmarshal, message is %T, want proto.Message", v)
}
- return proto.Unmarshal(data, vv)
+ buf := data.MaterializeToBuffer(mem.DefaultBufferPool())
+ defer buf.Free()
+ // TODO: Upgrade proto.Unmarshal to support mem.BufferSlice. Right now, it's not
+ // really possible without a major overhaul of the proto package, but the
+ // vtprotobuf library may be able to support this.
+ return proto.Unmarshal(buf.ReadOnlyData(), vv)
}
func messageV2Of(v any) proto.Message {
@@ -67,6 +91,6 @@ func messageV2Of(v any) proto.Message {
return nil
}
-func (codec) Name() string {
+func (c *codecV2) Name() string {
return Name
}
diff --git a/vendor/google.golang.org/grpc/experimental/stats/metricregistry.go b/vendor/google.golang.org/grpc/experimental/stats/metricregistry.go
new file mode 100644
index 0000000000..1d827dd5d9
--- /dev/null
+++ b/vendor/google.golang.org/grpc/experimental/stats/metricregistry.go
@@ -0,0 +1,269 @@
+/*
+ *
+ * Copyright 2024 gRPC 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 stats
+
+import (
+ "maps"
+
+ "google.golang.org/grpc/grpclog"
+ "google.golang.org/grpc/internal"
+)
+
+func init() {
+ internal.SnapshotMetricRegistryForTesting = snapshotMetricsRegistryForTesting
+}
+
+var logger = grpclog.Component("metrics-registry")
+
+// DefaultMetrics are the default metrics registered through global metrics
+// registry. This is written to at initialization time only, and is read only
+// after initialization.
+var DefaultMetrics = NewMetrics()
+
+// MetricDescriptor is the data for a registered metric.
+type MetricDescriptor struct {
+ // The name of this metric. This name must be unique across the whole binary
+ // (including any per call metrics). See
+ // https://github.com/grpc/proposal/blob/master/A79-non-per-call-metrics-architecture.md#metric-instrument-naming-conventions
+ // for metric naming conventions.
+ Name Metric
+ // The description of this metric.
+ Description string
+ // The unit (e.g. entries, seconds) of this metric.
+ Unit string
+ // The required label keys for this metric. These are intended to
+ // metrics emitted from a stats handler.
+ Labels []string
+ // The optional label keys for this metric. These are intended to attached
+ // to metrics emitted from a stats handler if configured.
+ OptionalLabels []string
+ // Whether this metric is on by default.
+ Default bool
+ // The type of metric. This is set by the metric registry, and not intended
+ // to be set by a component registering a metric.
+ Type MetricType
+ // Bounds are the bounds of this metric. This only applies to histogram
+ // metrics. If unset or set with length 0, stats handlers will fall back to
+ // default bounds.
+ Bounds []float64
+}
+
+// MetricType is the type of metric.
+type MetricType int
+
+// Type of metric supported by this instrument registry.
+const (
+ MetricTypeIntCount MetricType = iota
+ MetricTypeFloatCount
+ MetricTypeIntHisto
+ MetricTypeFloatHisto
+ MetricTypeIntGauge
+)
+
+// Int64CountHandle is a typed handle for a int count metric. This handle
+// is passed at the recording point in order to know which metric to record
+// on.
+type Int64CountHandle MetricDescriptor
+
+// Descriptor returns the int64 count handle typecast to a pointer to a
+// MetricDescriptor.
+func (h *Int64CountHandle) Descriptor() *MetricDescriptor {
+ return (*MetricDescriptor)(h)
+}
+
+// Record records the int64 count value on the metrics recorder provided.
+func (h *Int64CountHandle) Record(recorder MetricsRecorder, incr int64, labels ...string) {
+ recorder.RecordInt64Count(h, incr, labels...)
+}
+
+// Float64CountHandle is a typed handle for a float count metric. This handle is
+// passed at the recording point in order to know which metric to record on.
+type Float64CountHandle MetricDescriptor
+
+// Descriptor returns the float64 count handle typecast to a pointer to a
+// MetricDescriptor.
+func (h *Float64CountHandle) Descriptor() *MetricDescriptor {
+ return (*MetricDescriptor)(h)
+}
+
+// Record records the float64 count value on the metrics recorder provided.
+func (h *Float64CountHandle) Record(recorder MetricsRecorder, incr float64, labels ...string) {
+ recorder.RecordFloat64Count(h, incr, labels...)
+}
+
+// Int64HistoHandle is a typed handle for an int histogram metric. This handle
+// is passed at the recording point in order to know which metric to record on.
+type Int64HistoHandle MetricDescriptor
+
+// Descriptor returns the int64 histo handle typecast to a pointer to a
+// MetricDescriptor.
+func (h *Int64HistoHandle) Descriptor() *MetricDescriptor {
+ return (*MetricDescriptor)(h)
+}
+
+// Record records the int64 histo value on the metrics recorder provided.
+func (h *Int64HistoHandle) Record(recorder MetricsRecorder, incr int64, labels ...string) {
+ recorder.RecordInt64Histo(h, incr, labels...)
+}
+
+// Float64HistoHandle is a typed handle for a float histogram metric. This
+// handle is passed at the recording point in order to know which metric to
+// record on.
+type Float64HistoHandle MetricDescriptor
+
+// Descriptor returns the float64 histo handle typecast to a pointer to a
+// MetricDescriptor.
+func (h *Float64HistoHandle) Descriptor() *MetricDescriptor {
+ return (*MetricDescriptor)(h)
+}
+
+// Record records the float64 histo value on the metrics recorder provided.
+func (h *Float64HistoHandle) Record(recorder MetricsRecorder, incr float64, labels ...string) {
+ recorder.RecordFloat64Histo(h, incr, labels...)
+}
+
+// Int64GaugeHandle is a typed handle for an int gauge metric. This handle is
+// passed at the recording point in order to know which metric to record on.
+type Int64GaugeHandle MetricDescriptor
+
+// Descriptor returns the int64 gauge handle typecast to a pointer to a
+// MetricDescriptor.
+func (h *Int64GaugeHandle) Descriptor() *MetricDescriptor {
+ return (*MetricDescriptor)(h)
+}
+
+// Record records the int64 histo value on the metrics recorder provided.
+func (h *Int64GaugeHandle) Record(recorder MetricsRecorder, incr int64, labels ...string) {
+ recorder.RecordInt64Gauge(h, incr, labels...)
+}
+
+// registeredMetrics are the registered metric descriptor names.
+var registeredMetrics = make(map[Metric]bool)
+
+// metricsRegistry contains all of the registered metrics.
+//
+// This is written to only at init time, and read only after that.
+var metricsRegistry = make(map[Metric]*MetricDescriptor)
+
+// DescriptorForMetric returns the MetricDescriptor from the global registry.
+//
+// Returns nil if MetricDescriptor not present.
+func DescriptorForMetric(metric Metric) *MetricDescriptor {
+ return metricsRegistry[metric]
+}
+
+func registerMetric(name Metric, def bool) {
+ if registeredMetrics[name] {
+ logger.Fatalf("metric %v already registered", name)
+ }
+ registeredMetrics[name] = true
+ if def {
+ DefaultMetrics = DefaultMetrics.Add(name)
+ }
+}
+
+// RegisterInt64Count registers the metric description onto the global registry.
+// It returns a typed handle to use to recording data.
+//
+// NOTE: this function must only be called during initialization time (i.e. in
+// an init() function), and is not thread-safe. If multiple metrics are
+// registered with the same name, this function will panic.
+func RegisterInt64Count(descriptor MetricDescriptor) *Int64CountHandle {
+ registerMetric(descriptor.Name, descriptor.Default)
+ descriptor.Type = MetricTypeIntCount
+ descPtr := &descriptor
+ metricsRegistry[descriptor.Name] = descPtr
+ return (*Int64CountHandle)(descPtr)
+}
+
+// RegisterFloat64Count registers the metric description onto the global
+// registry. It returns a typed handle to use to recording data.
+//
+// NOTE: this function must only be called during initialization time (i.e. in
+// an init() function), and is not thread-safe. If multiple metrics are
+// registered with the same name, this function will panic.
+func RegisterFloat64Count(descriptor MetricDescriptor) *Float64CountHandle {
+ registerMetric(descriptor.Name, descriptor.Default)
+ descriptor.Type = MetricTypeFloatCount
+ descPtr := &descriptor
+ metricsRegistry[descriptor.Name] = descPtr
+ return (*Float64CountHandle)(descPtr)
+}
+
+// RegisterInt64Histo registers the metric description onto the global registry.
+// It returns a typed handle to use to recording data.
+//
+// NOTE: this function must only be called during initialization time (i.e. in
+// an init() function), and is not thread-safe. If multiple metrics are
+// registered with the same name, this function will panic.
+func RegisterInt64Histo(descriptor MetricDescriptor) *Int64HistoHandle {
+ registerMetric(descriptor.Name, descriptor.Default)
+ descriptor.Type = MetricTypeIntHisto
+ descPtr := &descriptor
+ metricsRegistry[descriptor.Name] = descPtr
+ return (*Int64HistoHandle)(descPtr)
+}
+
+// RegisterFloat64Histo registers the metric description onto the global
+// registry. It returns a typed handle to use to recording data.
+//
+// NOTE: this function must only be called during initialization time (i.e. in
+// an init() function), and is not thread-safe. If multiple metrics are
+// registered with the same name, this function will panic.
+func RegisterFloat64Histo(descriptor MetricDescriptor) *Float64HistoHandle {
+ registerMetric(descriptor.Name, descriptor.Default)
+ descriptor.Type = MetricTypeFloatHisto
+ descPtr := &descriptor
+ metricsRegistry[descriptor.Name] = descPtr
+ return (*Float64HistoHandle)(descPtr)
+}
+
+// RegisterInt64Gauge registers the metric description onto the global registry.
+// It returns a typed handle to use to recording data.
+//
+// NOTE: this function must only be called during initialization time (i.e. in
+// an init() function), and is not thread-safe. If multiple metrics are
+// registered with the same name, this function will panic.
+func RegisterInt64Gauge(descriptor MetricDescriptor) *Int64GaugeHandle {
+ registerMetric(descriptor.Name, descriptor.Default)
+ descriptor.Type = MetricTypeIntGauge
+ descPtr := &descriptor
+ metricsRegistry[descriptor.Name] = descPtr
+ return (*Int64GaugeHandle)(descPtr)
+}
+
+// snapshotMetricsRegistryForTesting snapshots the global data of the metrics
+// registry. Returns a cleanup function that sets the metrics registry to its
+// original state.
+func snapshotMetricsRegistryForTesting() func() {
+ oldDefaultMetrics := DefaultMetrics
+ oldRegisteredMetrics := registeredMetrics
+ oldMetricsRegistry := metricsRegistry
+
+ registeredMetrics = make(map[Metric]bool)
+ metricsRegistry = make(map[Metric]*MetricDescriptor)
+ maps.Copy(registeredMetrics, registeredMetrics)
+ maps.Copy(metricsRegistry, metricsRegistry)
+
+ return func() {
+ DefaultMetrics = oldDefaultMetrics
+ registeredMetrics = oldRegisteredMetrics
+ metricsRegistry = oldMetricsRegistry
+ }
+}
diff --git a/vendor/google.golang.org/grpc/experimental/stats/metrics.go b/vendor/google.golang.org/grpc/experimental/stats/metrics.go
new file mode 100644
index 0000000000..3221f7a633
--- /dev/null
+++ b/vendor/google.golang.org/grpc/experimental/stats/metrics.go
@@ -0,0 +1,114 @@
+/*
+ *
+ * Copyright 2024 gRPC 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 stats contains experimental metrics/stats API's.
+package stats
+
+import "maps"
+
+// MetricsRecorder records on metrics derived from metric registry.
+type MetricsRecorder interface {
+ // RecordInt64Count records the measurement alongside labels on the int
+ // count associated with the provided handle.
+ RecordInt64Count(handle *Int64CountHandle, incr int64, labels ...string)
+ // RecordFloat64Count records the measurement alongside labels on the float
+ // count associated with the provided handle.
+ RecordFloat64Count(handle *Float64CountHandle, incr float64, labels ...string)
+ // RecordInt64Histo records the measurement alongside labels on the int
+ // histo associated with the provided handle.
+ RecordInt64Histo(handle *Int64HistoHandle, incr int64, labels ...string)
+ // RecordFloat64Histo records the measurement alongside labels on the float
+ // histo associated with the provided handle.
+ RecordFloat64Histo(handle *Float64HistoHandle, incr float64, labels ...string)
+ // RecordInt64Gauge records the measurement alongside labels on the int
+ // gauge associated with the provided handle.
+ RecordInt64Gauge(handle *Int64GaugeHandle, incr int64, labels ...string)
+}
+
+// Metric is an identifier for a metric.
+type Metric string
+
+// Metrics is a set of metrics to record. Once created, Metrics is immutable,
+// however Add and Remove can make copies with specific metrics added or
+// removed, respectively.
+//
+// Do not construct directly; use NewMetrics instead.
+type Metrics struct {
+ // metrics are the set of metrics to initialize.
+ metrics map[Metric]bool
+}
+
+// NewMetrics returns a Metrics containing Metrics.
+func NewMetrics(metrics ...Metric) *Metrics {
+ newMetrics := make(map[Metric]bool)
+ for _, metric := range metrics {
+ newMetrics[metric] = true
+ }
+ return &Metrics{
+ metrics: newMetrics,
+ }
+}
+
+// Metrics returns the metrics set. The returned map is read-only and must not
+// be modified.
+func (m *Metrics) Metrics() map[Metric]bool {
+ return m.metrics
+}
+
+// Add adds the metrics to the metrics set and returns a new copy with the
+// additional metrics.
+func (m *Metrics) Add(metrics ...Metric) *Metrics {
+ newMetrics := make(map[Metric]bool)
+ for metric := range m.metrics {
+ newMetrics[metric] = true
+ }
+
+ for _, metric := range metrics {
+ newMetrics[metric] = true
+ }
+ return &Metrics{
+ metrics: newMetrics,
+ }
+}
+
+// Join joins the metrics passed in with the metrics set, and returns a new copy
+// with the merged metrics.
+func (m *Metrics) Join(metrics *Metrics) *Metrics {
+ newMetrics := make(map[Metric]bool)
+ maps.Copy(newMetrics, m.metrics)
+ maps.Copy(newMetrics, metrics.metrics)
+ return &Metrics{
+ metrics: newMetrics,
+ }
+}
+
+// Remove removes the metrics from the metrics set and returns a new copy with
+// the metrics removed.
+func (m *Metrics) Remove(metrics ...Metric) *Metrics {
+ newMetrics := make(map[Metric]bool)
+ for metric := range m.metrics {
+ newMetrics[metric] = true
+ }
+
+ for _, metric := range metrics {
+ delete(newMetrics, metric)
+ }
+ return &Metrics{
+ metrics: newMetrics,
+ }
+}
diff --git a/vendor/google.golang.org/grpc/grpclog/component.go b/vendor/google.golang.org/grpc/grpclog/component.go
index ac73c9ced2..f1ae080dcb 100644
--- a/vendor/google.golang.org/grpc/grpclog/component.go
+++ b/vendor/google.golang.org/grpc/grpclog/component.go
@@ -20,8 +20,6 @@ package grpclog
import (
"fmt"
-
- "google.golang.org/grpc/internal/grpclog"
)
// componentData records the settings for a component.
@@ -33,22 +31,22 @@ var cache = map[string]*componentData{}
func (c *componentData) InfoDepth(depth int, args ...any) {
args = append([]any{"[" + string(c.name) + "]"}, args...)
- grpclog.InfoDepth(depth+1, args...)
+ InfoDepth(depth+1, args...)
}
func (c *componentData) WarningDepth(depth int, args ...any) {
args = append([]any{"[" + string(c.name) + "]"}, args...)
- grpclog.WarningDepth(depth+1, args...)
+ WarningDepth(depth+1, args...)
}
func (c *componentData) ErrorDepth(depth int, args ...any) {
args = append([]any{"[" + string(c.name) + "]"}, args...)
- grpclog.ErrorDepth(depth+1, args...)
+ ErrorDepth(depth+1, args...)
}
func (c *componentData) FatalDepth(depth int, args ...any) {
args = append([]any{"[" + string(c.name) + "]"}, args...)
- grpclog.FatalDepth(depth+1, args...)
+ FatalDepth(depth+1, args...)
}
func (c *componentData) Info(args ...any) {
diff --git a/vendor/google.golang.org/grpc/grpclog/grpclog.go b/vendor/google.golang.org/grpc/grpclog/grpclog.go
index 16928c9cb9..db320105e6 100644
--- a/vendor/google.golang.org/grpc/grpclog/grpclog.go
+++ b/vendor/google.golang.org/grpc/grpclog/grpclog.go
@@ -18,18 +18,15 @@
// Package grpclog defines logging for grpc.
//
-// All logs in transport and grpclb packages only go to verbose level 2.
-// All logs in other packages in grpc are logged in spite of the verbosity level.
-//
-// In the default logger,
-// severity level can be set by environment variable GRPC_GO_LOG_SEVERITY_LEVEL,
-// verbosity level can be set by GRPC_GO_LOG_VERBOSITY_LEVEL.
-package grpclog // import "google.golang.org/grpc/grpclog"
+// In the default logger, severity level can be set by environment variable
+// GRPC_GO_LOG_SEVERITY_LEVEL, verbosity level can be set by
+// GRPC_GO_LOG_VERBOSITY_LEVEL.
+package grpclog
import (
"os"
- "google.golang.org/grpc/internal/grpclog"
+ "google.golang.org/grpc/grpclog/internal"
)
func init() {
@@ -38,58 +35,58 @@ func init() {
// V reports whether verbosity level l is at least the requested verbose level.
func V(l int) bool {
- return grpclog.Logger.V(l)
+ return internal.LoggerV2Impl.V(l)
}
// Info logs to the INFO log.
func Info(args ...any) {
- grpclog.Logger.Info(args...)
+ internal.LoggerV2Impl.Info(args...)
}
// Infof logs to the INFO log. Arguments are handled in the manner of fmt.Printf.
func Infof(format string, args ...any) {
- grpclog.Logger.Infof(format, args...)
+ internal.LoggerV2Impl.Infof(format, args...)
}
// Infoln logs to the INFO log. Arguments are handled in the manner of fmt.Println.
func Infoln(args ...any) {
- grpclog.Logger.Infoln(args...)
+ internal.LoggerV2Impl.Infoln(args...)
}
// Warning logs to the WARNING log.
func Warning(args ...any) {
- grpclog.Logger.Warning(args...)
+ internal.LoggerV2Impl.Warning(args...)
}
// Warningf logs to the WARNING log. Arguments are handled in the manner of fmt.Printf.
func Warningf(format string, args ...any) {
- grpclog.Logger.Warningf(format, args...)
+ internal.LoggerV2Impl.Warningf(format, args...)
}
// Warningln logs to the WARNING log. Arguments are handled in the manner of fmt.Println.
func Warningln(args ...any) {
- grpclog.Logger.Warningln(args...)
+ internal.LoggerV2Impl.Warningln(args...)
}
// Error logs to the ERROR log.
func Error(args ...any) {
- grpclog.Logger.Error(args...)
+ internal.LoggerV2Impl.Error(args...)
}
// Errorf logs to the ERROR log. Arguments are handled in the manner of fmt.Printf.
func Errorf(format string, args ...any) {
- grpclog.Logger.Errorf(format, args...)
+ internal.LoggerV2Impl.Errorf(format, args...)
}
// Errorln logs to the ERROR log. Arguments are handled in the manner of fmt.Println.
func Errorln(args ...any) {
- grpclog.Logger.Errorln(args...)
+ internal.LoggerV2Impl.Errorln(args...)
}
// Fatal logs to the FATAL log. Arguments are handled in the manner of fmt.Print.
// It calls os.Exit() with exit code 1.
func Fatal(args ...any) {
- grpclog.Logger.Fatal(args...)
+ internal.LoggerV2Impl.Fatal(args...)
// Make sure fatal logs will exit.
os.Exit(1)
}
@@ -97,15 +94,15 @@ func Fatal(args ...any) {
// Fatalf logs to the FATAL log. Arguments are handled in the manner of fmt.Printf.
// It calls os.Exit() with exit code 1.
func Fatalf(format string, args ...any) {
- grpclog.Logger.Fatalf(format, args...)
+ internal.LoggerV2Impl.Fatalf(format, args...)
// Make sure fatal logs will exit.
os.Exit(1)
}
// Fatalln logs to the FATAL log. Arguments are handled in the manner of fmt.Println.
-// It calle os.Exit()) with exit code 1.
+// It calls os.Exit() with exit code 1.
func Fatalln(args ...any) {
- grpclog.Logger.Fatalln(args...)
+ internal.LoggerV2Impl.Fatalln(args...)
// Make sure fatal logs will exit.
os.Exit(1)
}
@@ -114,19 +111,76 @@ func Fatalln(args ...any) {
//
// Deprecated: use Info.
func Print(args ...any) {
- grpclog.Logger.Info(args...)
+ internal.LoggerV2Impl.Info(args...)
}
// Printf prints to the logger. Arguments are handled in the manner of fmt.Printf.
//
// Deprecated: use Infof.
func Printf(format string, args ...any) {
- grpclog.Logger.Infof(format, args...)
+ internal.LoggerV2Impl.Infof(format, args...)
}
// Println prints to the logger. Arguments are handled in the manner of fmt.Println.
//
// Deprecated: use Infoln.
func Println(args ...any) {
- grpclog.Logger.Infoln(args...)
+ internal.LoggerV2Impl.Infoln(args...)
+}
+
+// InfoDepth logs to the INFO log at the specified depth.
+//
+// # Experimental
+//
+// Notice: This API is EXPERIMENTAL and may be changed or removed in a
+// later release.
+func InfoDepth(depth int, args ...any) {
+ if internal.DepthLoggerV2Impl != nil {
+ internal.DepthLoggerV2Impl.InfoDepth(depth, args...)
+ } else {
+ internal.LoggerV2Impl.Infoln(args...)
+ }
+}
+
+// WarningDepth logs to the WARNING log at the specified depth.
+//
+// # Experimental
+//
+// Notice: This API is EXPERIMENTAL and may be changed or removed in a
+// later release.
+func WarningDepth(depth int, args ...any) {
+ if internal.DepthLoggerV2Impl != nil {
+ internal.DepthLoggerV2Impl.WarningDepth(depth, args...)
+ } else {
+ internal.LoggerV2Impl.Warningln(args...)
+ }
+}
+
+// ErrorDepth logs to the ERROR log at the specified depth.
+//
+// # Experimental
+//
+// Notice: This API is EXPERIMENTAL and may be changed or removed in a
+// later release.
+func ErrorDepth(depth int, args ...any) {
+ if internal.DepthLoggerV2Impl != nil {
+ internal.DepthLoggerV2Impl.ErrorDepth(depth, args...)
+ } else {
+ internal.LoggerV2Impl.Errorln(args...)
+ }
+}
+
+// FatalDepth logs to the FATAL log at the specified depth.
+//
+// # Experimental
+//
+// Notice: This API is EXPERIMENTAL and may be changed or removed in a
+// later release.
+func FatalDepth(depth int, args ...any) {
+ if internal.DepthLoggerV2Impl != nil {
+ internal.DepthLoggerV2Impl.FatalDepth(depth, args...)
+ } else {
+ internal.LoggerV2Impl.Fatalln(args...)
+ }
+ os.Exit(1)
}
diff --git a/vendor/google.golang.org/grpc/grpclog/internal/grpclog.go b/vendor/google.golang.org/grpc/grpclog/internal/grpclog.go
new file mode 100644
index 0000000000..59c03bc14c
--- /dev/null
+++ b/vendor/google.golang.org/grpc/grpclog/internal/grpclog.go
@@ -0,0 +1,26 @@
+/*
+ *
+ * Copyright 2024 gRPC 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 internal contains functionality internal to the grpclog package.
+package internal
+
+// LoggerV2Impl is the logger used for the non-depth log functions.
+var LoggerV2Impl LoggerV2
+
+// DepthLoggerV2Impl is the logger used for the depth log functions.
+var DepthLoggerV2Impl DepthLoggerV2
diff --git a/vendor/google.golang.org/grpc/grpclog/internal/logger.go b/vendor/google.golang.org/grpc/grpclog/internal/logger.go
new file mode 100644
index 0000000000..e524fdd40b
--- /dev/null
+++ b/vendor/google.golang.org/grpc/grpclog/internal/logger.go
@@ -0,0 +1,87 @@
+/*
+ *
+ * Copyright 2024 gRPC 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 internal
+
+// Logger mimics golang's standard Logger as an interface.
+//
+// Deprecated: use LoggerV2.
+type Logger interface {
+ Fatal(args ...any)
+ Fatalf(format string, args ...any)
+ Fatalln(args ...any)
+ Print(args ...any)
+ Printf(format string, args ...any)
+ Println(args ...any)
+}
+
+// LoggerWrapper wraps Logger into a LoggerV2.
+type LoggerWrapper struct {
+ Logger
+}
+
+// Info logs to INFO log. Arguments are handled in the manner of fmt.Print.
+func (l *LoggerWrapper) Info(args ...any) {
+ l.Logger.Print(args...)
+}
+
+// Infoln logs to INFO log. Arguments are handled in the manner of fmt.Println.
+func (l *LoggerWrapper) Infoln(args ...any) {
+ l.Logger.Println(args...)
+}
+
+// Infof logs to INFO log. Arguments are handled in the manner of fmt.Printf.
+func (l *LoggerWrapper) Infof(format string, args ...any) {
+ l.Logger.Printf(format, args...)
+}
+
+// Warning logs to WARNING log. Arguments are handled in the manner of fmt.Print.
+func (l *LoggerWrapper) Warning(args ...any) {
+ l.Logger.Print(args...)
+}
+
+// Warningln logs to WARNING log. Arguments are handled in the manner of fmt.Println.
+func (l *LoggerWrapper) Warningln(args ...any) {
+ l.Logger.Println(args...)
+}
+
+// Warningf logs to WARNING log. Arguments are handled in the manner of fmt.Printf.
+func (l *LoggerWrapper) Warningf(format string, args ...any) {
+ l.Logger.Printf(format, args...)
+}
+
+// Error logs to ERROR log. Arguments are handled in the manner of fmt.Print.
+func (l *LoggerWrapper) Error(args ...any) {
+ l.Logger.Print(args...)
+}
+
+// Errorln logs to ERROR log. Arguments are handled in the manner of fmt.Println.
+func (l *LoggerWrapper) Errorln(args ...any) {
+ l.Logger.Println(args...)
+}
+
+// Errorf logs to ERROR log. Arguments are handled in the manner of fmt.Printf.
+func (l *LoggerWrapper) Errorf(format string, args ...any) {
+ l.Logger.Printf(format, args...)
+}
+
+// V reports whether verbosity level l is at least the requested verbose level.
+func (*LoggerWrapper) V(int) bool {
+ // Returns true for all verbose level.
+ return true
+}
diff --git a/vendor/google.golang.org/grpc/internal/grpclog/grpclog.go b/vendor/google.golang.org/grpc/grpclog/internal/loggerv2.go
similarity index 52%
rename from vendor/google.golang.org/grpc/internal/grpclog/grpclog.go
rename to vendor/google.golang.org/grpc/grpclog/internal/loggerv2.go
index bfc45102ab..07df71e98a 100644
--- a/vendor/google.golang.org/grpc/internal/grpclog/grpclog.go
+++ b/vendor/google.golang.org/grpc/grpclog/internal/loggerv2.go
@@ -1,6 +1,6 @@
/*
*
- * Copyright 2020 gRPC authors.
+ * Copyright 2024 gRPC authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,59 +16,17 @@
*
*/
-// Package grpclog (internal) defines depth logging for grpc.
-package grpclog
+package internal
import (
+ "encoding/json"
+ "fmt"
+ "io"
+ "log"
"os"
)
-// Logger is the logger used for the non-depth log functions.
-var Logger LoggerV2
-
-// DepthLogger is the logger used for the depth log functions.
-var DepthLogger DepthLoggerV2
-
-// InfoDepth logs to the INFO log at the specified depth.
-func InfoDepth(depth int, args ...any) {
- if DepthLogger != nil {
- DepthLogger.InfoDepth(depth, args...)
- } else {
- Logger.Infoln(args...)
- }
-}
-
-// WarningDepth logs to the WARNING log at the specified depth.
-func WarningDepth(depth int, args ...any) {
- if DepthLogger != nil {
- DepthLogger.WarningDepth(depth, args...)
- } else {
- Logger.Warningln(args...)
- }
-}
-
-// ErrorDepth logs to the ERROR log at the specified depth.
-func ErrorDepth(depth int, args ...any) {
- if DepthLogger != nil {
- DepthLogger.ErrorDepth(depth, args...)
- } else {
- Logger.Errorln(args...)
- }
-}
-
-// FatalDepth logs to the FATAL log at the specified depth.
-func FatalDepth(depth int, args ...any) {
- if DepthLogger != nil {
- DepthLogger.FatalDepth(depth, args...)
- } else {
- Logger.Fatalln(args...)
- }
- os.Exit(1)
-}
-
// LoggerV2 does underlying logging work for grpclog.
-// This is a copy of the LoggerV2 defined in the external grpclog package. It
-// is defined here to avoid a circular dependency.
type LoggerV2 interface {
// Info logs to INFO log. Arguments are handled in the manner of fmt.Print.
Info(args ...any)
@@ -107,14 +65,13 @@ type LoggerV2 interface {
// DepthLoggerV2 logs at a specified call frame. If a LoggerV2 also implements
// DepthLoggerV2, the below functions will be called with the appropriate stack
// depth set for trivial functions the logger may ignore.
-// This is a copy of the DepthLoggerV2 defined in the external grpclog package.
-// It is defined here to avoid a circular dependency.
//
// # Experimental
//
// Notice: This type is EXPERIMENTAL and may be changed or removed in a
// later release.
type DepthLoggerV2 interface {
+ LoggerV2
// InfoDepth logs to INFO log at the specified depth. Arguments are handled in the manner of fmt.Println.
InfoDepth(depth int, args ...any)
// WarningDepth logs to WARNING log at the specified depth. Arguments are handled in the manner of fmt.Println.
@@ -124,3 +81,124 @@ type DepthLoggerV2 interface {
// FatalDepth logs to FATAL log at the specified depth. Arguments are handled in the manner of fmt.Println.
FatalDepth(depth int, args ...any)
}
+
+const (
+ // infoLog indicates Info severity.
+ infoLog int = iota
+ // warningLog indicates Warning severity.
+ warningLog
+ // errorLog indicates Error severity.
+ errorLog
+ // fatalLog indicates Fatal severity.
+ fatalLog
+)
+
+// severityName contains the string representation of each severity.
+var severityName = []string{
+ infoLog: "INFO",
+ warningLog: "WARNING",
+ errorLog: "ERROR",
+ fatalLog: "FATAL",
+}
+
+// loggerT is the default logger used by grpclog.
+type loggerT struct {
+ m []*log.Logger
+ v int
+ jsonFormat bool
+}
+
+func (g *loggerT) output(severity int, s string) {
+ sevStr := severityName[severity]
+ if !g.jsonFormat {
+ g.m[severity].Output(2, fmt.Sprintf("%v: %v", sevStr, s))
+ return
+ }
+ // TODO: we can also include the logging component, but that needs more
+ // (API) changes.
+ b, _ := json.Marshal(map[string]string{
+ "severity": sevStr,
+ "message": s,
+ })
+ g.m[severity].Output(2, string(b))
+}
+
+func (g *loggerT) Info(args ...any) {
+ g.output(infoLog, fmt.Sprint(args...))
+}
+
+func (g *loggerT) Infoln(args ...any) {
+ g.output(infoLog, fmt.Sprintln(args...))
+}
+
+func (g *loggerT) Infof(format string, args ...any) {
+ g.output(infoLog, fmt.Sprintf(format, args...))
+}
+
+func (g *loggerT) Warning(args ...any) {
+ g.output(warningLog, fmt.Sprint(args...))
+}
+
+func (g *loggerT) Warningln(args ...any) {
+ g.output(warningLog, fmt.Sprintln(args...))
+}
+
+func (g *loggerT) Warningf(format string, args ...any) {
+ g.output(warningLog, fmt.Sprintf(format, args...))
+}
+
+func (g *loggerT) Error(args ...any) {
+ g.output(errorLog, fmt.Sprint(args...))
+}
+
+func (g *loggerT) Errorln(args ...any) {
+ g.output(errorLog, fmt.Sprintln(args...))
+}
+
+func (g *loggerT) Errorf(format string, args ...any) {
+ g.output(errorLog, fmt.Sprintf(format, args...))
+}
+
+func (g *loggerT) Fatal(args ...any) {
+ g.output(fatalLog, fmt.Sprint(args...))
+ os.Exit(1)
+}
+
+func (g *loggerT) Fatalln(args ...any) {
+ g.output(fatalLog, fmt.Sprintln(args...))
+ os.Exit(1)
+}
+
+func (g *loggerT) Fatalf(format string, args ...any) {
+ g.output(fatalLog, fmt.Sprintf(format, args...))
+ os.Exit(1)
+}
+
+func (g *loggerT) V(l int) bool {
+ return l <= g.v
+}
+
+// LoggerV2Config configures the LoggerV2 implementation.
+type LoggerV2Config struct {
+ // Verbosity sets the verbosity level of the logger.
+ Verbosity int
+ // FormatJSON controls whether the logger should output logs in JSON format.
+ FormatJSON bool
+}
+
+// NewLoggerV2 creates a new LoggerV2 instance with the provided configuration.
+// The infoW, warningW, and errorW writers are used to write log messages of
+// different severity levels.
+func NewLoggerV2(infoW, warningW, errorW io.Writer, c LoggerV2Config) LoggerV2 {
+ var m []*log.Logger
+ flag := log.LstdFlags
+ if c.FormatJSON {
+ flag = 0
+ }
+ m = append(m, log.New(infoW, "", flag))
+ m = append(m, log.New(io.MultiWriter(infoW, warningW), "", flag))
+ ew := io.MultiWriter(infoW, warningW, errorW) // ew will be used for error and fatal.
+ m = append(m, log.New(ew, "", flag))
+ m = append(m, log.New(ew, "", flag))
+ return &loggerT{m: m, v: c.Verbosity, jsonFormat: c.FormatJSON}
+}
diff --git a/vendor/google.golang.org/grpc/grpclog/logger.go b/vendor/google.golang.org/grpc/grpclog/logger.go
index b1674d8267..4b20358570 100644
--- a/vendor/google.golang.org/grpc/grpclog/logger.go
+++ b/vendor/google.golang.org/grpc/grpclog/logger.go
@@ -18,70 +18,17 @@
package grpclog
-import "google.golang.org/grpc/internal/grpclog"
+import "google.golang.org/grpc/grpclog/internal"
// Logger mimics golang's standard Logger as an interface.
//
// Deprecated: use LoggerV2.
-type Logger interface {
- Fatal(args ...any)
- Fatalf(format string, args ...any)
- Fatalln(args ...any)
- Print(args ...any)
- Printf(format string, args ...any)
- Println(args ...any)
-}
+type Logger internal.Logger
// SetLogger sets the logger that is used in grpc. Call only from
// init() functions.
//
// Deprecated: use SetLoggerV2.
func SetLogger(l Logger) {
- grpclog.Logger = &loggerWrapper{Logger: l}
-}
-
-// loggerWrapper wraps Logger into a LoggerV2.
-type loggerWrapper struct {
- Logger
-}
-
-func (g *loggerWrapper) Info(args ...any) {
- g.Logger.Print(args...)
-}
-
-func (g *loggerWrapper) Infoln(args ...any) {
- g.Logger.Println(args...)
-}
-
-func (g *loggerWrapper) Infof(format string, args ...any) {
- g.Logger.Printf(format, args...)
-}
-
-func (g *loggerWrapper) Warning(args ...any) {
- g.Logger.Print(args...)
-}
-
-func (g *loggerWrapper) Warningln(args ...any) {
- g.Logger.Println(args...)
-}
-
-func (g *loggerWrapper) Warningf(format string, args ...any) {
- g.Logger.Printf(format, args...)
-}
-
-func (g *loggerWrapper) Error(args ...any) {
- g.Logger.Print(args...)
-}
-
-func (g *loggerWrapper) Errorln(args ...any) {
- g.Logger.Println(args...)
-}
-
-func (g *loggerWrapper) Errorf(format string, args ...any) {
- g.Logger.Printf(format, args...)
-}
-
-func (g *loggerWrapper) V(l int) bool {
- // Returns true for all verbose level.
- return true
+ internal.LoggerV2Impl = &internal.LoggerWrapper{Logger: l}
}
diff --git a/vendor/google.golang.org/grpc/grpclog/loggerv2.go b/vendor/google.golang.org/grpc/grpclog/loggerv2.go
index ecfd36d713..892dc13d16 100644
--- a/vendor/google.golang.org/grpc/grpclog/loggerv2.go
+++ b/vendor/google.golang.org/grpc/grpclog/loggerv2.go
@@ -19,52 +19,16 @@
package grpclog
import (
- "encoding/json"
- "fmt"
"io"
- "log"
"os"
"strconv"
"strings"
- "google.golang.org/grpc/internal/grpclog"
+ "google.golang.org/grpc/grpclog/internal"
)
// LoggerV2 does underlying logging work for grpclog.
-type LoggerV2 interface {
- // Info logs to INFO log. Arguments are handled in the manner of fmt.Print.
- Info(args ...any)
- // Infoln logs to INFO log. Arguments are handled in the manner of fmt.Println.
- Infoln(args ...any)
- // Infof logs to INFO log. Arguments are handled in the manner of fmt.Printf.
- Infof(format string, args ...any)
- // Warning logs to WARNING log. Arguments are handled in the manner of fmt.Print.
- Warning(args ...any)
- // Warningln logs to WARNING log. Arguments are handled in the manner of fmt.Println.
- Warningln(args ...any)
- // Warningf logs to WARNING log. Arguments are handled in the manner of fmt.Printf.
- Warningf(format string, args ...any)
- // Error logs to ERROR log. Arguments are handled in the manner of fmt.Print.
- Error(args ...any)
- // Errorln logs to ERROR log. Arguments are handled in the manner of fmt.Println.
- Errorln(args ...any)
- // Errorf logs to ERROR log. Arguments are handled in the manner of fmt.Printf.
- Errorf(format string, args ...any)
- // Fatal logs to ERROR log. Arguments are handled in the manner of fmt.Print.
- // gRPC ensures that all Fatal logs will exit with os.Exit(1).
- // Implementations may also call os.Exit() with a non-zero exit code.
- Fatal(args ...any)
- // Fatalln logs to ERROR log. Arguments are handled in the manner of fmt.Println.
- // gRPC ensures that all Fatal logs will exit with os.Exit(1).
- // Implementations may also call os.Exit() with a non-zero exit code.
- Fatalln(args ...any)
- // Fatalf logs to ERROR log. Arguments are handled in the manner of fmt.Printf.
- // gRPC ensures that all Fatal logs will exit with os.Exit(1).
- // Implementations may also call os.Exit() with a non-zero exit code.
- Fatalf(format string, args ...any)
- // V reports whether verbosity level l is at least the requested verbose level.
- V(l int) bool
-}
+type LoggerV2 internal.LoggerV2
// SetLoggerV2 sets logger that is used in grpc to a V2 logger.
// Not mutex-protected, should be called before any gRPC functions.
@@ -72,34 +36,8 @@ func SetLoggerV2(l LoggerV2) {
if _, ok := l.(*componentData); ok {
panic("cannot use component logger as grpclog logger")
}
- grpclog.Logger = l
- grpclog.DepthLogger, _ = l.(grpclog.DepthLoggerV2)
-}
-
-const (
- // infoLog indicates Info severity.
- infoLog int = iota
- // warningLog indicates Warning severity.
- warningLog
- // errorLog indicates Error severity.
- errorLog
- // fatalLog indicates Fatal severity.
- fatalLog
-)
-
-// severityName contains the string representation of each severity.
-var severityName = []string{
- infoLog: "INFO",
- warningLog: "WARNING",
- errorLog: "ERROR",
- fatalLog: "FATAL",
-}
-
-// loggerT is the default logger used by grpclog.
-type loggerT struct {
- m []*log.Logger
- v int
- jsonFormat bool
+ internal.LoggerV2Impl = l
+ internal.DepthLoggerV2Impl, _ = l.(internal.DepthLoggerV2)
}
// NewLoggerV2 creates a loggerV2 with the provided writers.
@@ -108,32 +46,13 @@ type loggerT struct {
// Warning logs will be written to warningW and infoW.
// Info logs will be written to infoW.
func NewLoggerV2(infoW, warningW, errorW io.Writer) LoggerV2 {
- return newLoggerV2WithConfig(infoW, warningW, errorW, loggerV2Config{})
+ return internal.NewLoggerV2(infoW, warningW, errorW, internal.LoggerV2Config{})
}
// NewLoggerV2WithVerbosity creates a loggerV2 with the provided writers and
// verbosity level.
func NewLoggerV2WithVerbosity(infoW, warningW, errorW io.Writer, v int) LoggerV2 {
- return newLoggerV2WithConfig(infoW, warningW, errorW, loggerV2Config{verbose: v})
-}
-
-type loggerV2Config struct {
- verbose int
- jsonFormat bool
-}
-
-func newLoggerV2WithConfig(infoW, warningW, errorW io.Writer, c loggerV2Config) LoggerV2 {
- var m []*log.Logger
- flag := log.LstdFlags
- if c.jsonFormat {
- flag = 0
- }
- m = append(m, log.New(infoW, "", flag))
- m = append(m, log.New(io.MultiWriter(infoW, warningW), "", flag))
- ew := io.MultiWriter(infoW, warningW, errorW) // ew will be used for error and fatal.
- m = append(m, log.New(ew, "", flag))
- m = append(m, log.New(ew, "", flag))
- return &loggerT{m: m, v: c.verbose, jsonFormat: c.jsonFormat}
+ return internal.NewLoggerV2(infoW, warningW, errorW, internal.LoggerV2Config{Verbosity: v})
}
// newLoggerV2 creates a loggerV2 to be used as default logger.
@@ -161,80 +80,10 @@ func newLoggerV2() LoggerV2 {
jsonFormat := strings.EqualFold(os.Getenv("GRPC_GO_LOG_FORMATTER"), "json")
- return newLoggerV2WithConfig(infoW, warningW, errorW, loggerV2Config{
- verbose: v,
- jsonFormat: jsonFormat,
- })
-}
-
-func (g *loggerT) output(severity int, s string) {
- sevStr := severityName[severity]
- if !g.jsonFormat {
- g.m[severity].Output(2, fmt.Sprintf("%v: %v", sevStr, s))
- return
- }
- // TODO: we can also include the logging component, but that needs more
- // (API) changes.
- b, _ := json.Marshal(map[string]string{
- "severity": sevStr,
- "message": s,
+ return internal.NewLoggerV2(infoW, warningW, errorW, internal.LoggerV2Config{
+ Verbosity: v,
+ FormatJSON: jsonFormat,
})
- g.m[severity].Output(2, string(b))
-}
-
-func (g *loggerT) Info(args ...any) {
- g.output(infoLog, fmt.Sprint(args...))
-}
-
-func (g *loggerT) Infoln(args ...any) {
- g.output(infoLog, fmt.Sprintln(args...))
-}
-
-func (g *loggerT) Infof(format string, args ...any) {
- g.output(infoLog, fmt.Sprintf(format, args...))
-}
-
-func (g *loggerT) Warning(args ...any) {
- g.output(warningLog, fmt.Sprint(args...))
-}
-
-func (g *loggerT) Warningln(args ...any) {
- g.output(warningLog, fmt.Sprintln(args...))
-}
-
-func (g *loggerT) Warningf(format string, args ...any) {
- g.output(warningLog, fmt.Sprintf(format, args...))
-}
-
-func (g *loggerT) Error(args ...any) {
- g.output(errorLog, fmt.Sprint(args...))
-}
-
-func (g *loggerT) Errorln(args ...any) {
- g.output(errorLog, fmt.Sprintln(args...))
-}
-
-func (g *loggerT) Errorf(format string, args ...any) {
- g.output(errorLog, fmt.Sprintf(format, args...))
-}
-
-func (g *loggerT) Fatal(args ...any) {
- g.output(fatalLog, fmt.Sprint(args...))
- os.Exit(1)
-}
-
-func (g *loggerT) Fatalln(args ...any) {
- g.output(fatalLog, fmt.Sprintln(args...))
- os.Exit(1)
-}
-
-func (g *loggerT) Fatalf(format string, args ...any) {
- g.output(fatalLog, fmt.Sprintf(format, args...))
- os.Exit(1)
-}
-
-func (g *loggerT) V(l int) bool {
- return l <= g.v
}
// DepthLoggerV2 logs at a specified call frame. If a LoggerV2 also implements
@@ -245,14 +94,4 @@ func (g *loggerT) V(l int) bool {
//
// Notice: This type is EXPERIMENTAL and may be changed or removed in a
// later release.
-type DepthLoggerV2 interface {
- LoggerV2
- // InfoDepth logs to INFO log at the specified depth. Arguments are handled in the manner of fmt.Println.
- InfoDepth(depth int, args ...any)
- // WarningDepth logs to WARNING log at the specified depth. Arguments are handled in the manner of fmt.Println.
- WarningDepth(depth int, args ...any)
- // ErrorDepth logs to ERROR log at the specified depth. Arguments are handled in the manner of fmt.Println.
- ErrorDepth(depth int, args ...any)
- // FatalDepth logs to FATAL log at the specified depth. Arguments are handled in the manner of fmt.Println.
- FatalDepth(depth int, args ...any)
-}
+type DepthLoggerV2 internal.DepthLoggerV2
diff --git a/vendor/google.golang.org/grpc/health/grpc_health_v1/health.pb.go b/vendor/google.golang.org/grpc/health/grpc_health_v1/health.pb.go
index 6a93475a7f..d92335445f 100644
--- a/vendor/google.golang.org/grpc/health/grpc_health_v1/health.pb.go
+++ b/vendor/google.golang.org/grpc/health/grpc_health_v1/health.pb.go
@@ -17,8 +17,8 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
-// protoc-gen-go v1.33.0
-// protoc v4.25.2
+// protoc-gen-go v1.34.2
+// protoc v5.27.1
// source: grpc/health/v1/health.proto
package grpc_health_v1
@@ -237,7 +237,7 @@ func file_grpc_health_v1_health_proto_rawDescGZIP() []byte {
var file_grpc_health_v1_health_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_grpc_health_v1_health_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
-var file_grpc_health_v1_health_proto_goTypes = []interface{}{
+var file_grpc_health_v1_health_proto_goTypes = []any{
(HealthCheckResponse_ServingStatus)(0), // 0: grpc.health.v1.HealthCheckResponse.ServingStatus
(*HealthCheckRequest)(nil), // 1: grpc.health.v1.HealthCheckRequest
(*HealthCheckResponse)(nil), // 2: grpc.health.v1.HealthCheckResponse
@@ -261,7 +261,7 @@ func file_grpc_health_v1_health_proto_init() {
return
}
if !protoimpl.UnsafeEnabled {
- file_grpc_health_v1_health_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ file_grpc_health_v1_health_proto_msgTypes[0].Exporter = func(v any, i int) any {
switch v := v.(*HealthCheckRequest); i {
case 0:
return &v.state
@@ -273,7 +273,7 @@ func file_grpc_health_v1_health_proto_init() {
return nil
}
}
- file_grpc_health_v1_health_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ file_grpc_health_v1_health_proto_msgTypes[1].Exporter = func(v any, i int) any {
switch v := v.(*HealthCheckResponse); i {
case 0:
return &v.state
diff --git a/vendor/google.golang.org/grpc/health/grpc_health_v1/health_grpc.pb.go b/vendor/google.golang.org/grpc/health/grpc_health_v1/health_grpc.pb.go
index 8f793e6e89..f96b8ab492 100644
--- a/vendor/google.golang.org/grpc/health/grpc_health_v1/health_grpc.pb.go
+++ b/vendor/google.golang.org/grpc/health/grpc_health_v1/health_grpc.pb.go
@@ -17,8 +17,8 @@
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
-// - protoc-gen-go-grpc v1.3.0
-// - protoc v4.25.2
+// - protoc-gen-go-grpc v1.5.1
+// - protoc v5.27.1
// source: grpc/health/v1/health.proto
package grpc_health_v1
@@ -32,8 +32,8 @@ import (
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.62.0 or later.
-const _ = grpc.SupportPackageIsVersion8
+// Requires gRPC-Go v1.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
const (
Health_Check_FullMethodName = "/grpc.health.v1.Health/Check"
@@ -43,6 +43,10 @@ const (
// HealthClient is the client API for Health service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+//
+// Health is gRPC's mechanism for checking whether a server is able to handle
+// RPCs. Its semantics are documented in
+// https://github.com/grpc/grpc/blob/master/doc/health-checking.md.
type HealthClient interface {
// Check gets the health of the specified service. If the requested service
// is unknown, the call will fail with status NOT_FOUND. If the caller does
@@ -69,7 +73,7 @@ type HealthClient interface {
// should assume this method is not supported and should not retry the
// call. If the call terminates with any other status (including OK),
// clients should retry the call with appropriate exponential backoff.
- Watch(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (Health_WatchClient, error)
+ Watch(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[HealthCheckResponse], error)
}
type healthClient struct {
@@ -90,13 +94,13 @@ func (c *healthClient) Check(ctx context.Context, in *HealthCheckRequest, opts .
return out, nil
}
-func (c *healthClient) Watch(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (Health_WatchClient, error) {
+func (c *healthClient) Watch(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[HealthCheckResponse], error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
stream, err := c.cc.NewStream(ctx, &Health_ServiceDesc.Streams[0], Health_Watch_FullMethodName, cOpts...)
if err != nil {
return nil, err
}
- x := &healthWatchClient{ClientStream: stream}
+ x := &grpc.GenericClientStream[HealthCheckRequest, HealthCheckResponse]{ClientStream: stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
@@ -106,26 +110,16 @@ func (c *healthClient) Watch(ctx context.Context, in *HealthCheckRequest, opts .
return x, nil
}
-type Health_WatchClient interface {
- Recv() (*HealthCheckResponse, error)
- grpc.ClientStream
-}
-
-type healthWatchClient struct {
- grpc.ClientStream
-}
-
-func (x *healthWatchClient) Recv() (*HealthCheckResponse, error) {
- m := new(HealthCheckResponse)
- if err := x.ClientStream.RecvMsg(m); err != nil {
- return nil, err
- }
- return m, nil
-}
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type Health_WatchClient = grpc.ServerStreamingClient[HealthCheckResponse]
// HealthServer is the server API for Health service.
// All implementations should embed UnimplementedHealthServer
-// for forward compatibility
+// for forward compatibility.
+//
+// Health is gRPC's mechanism for checking whether a server is able to handle
+// RPCs. Its semantics are documented in
+// https://github.com/grpc/grpc/blob/master/doc/health-checking.md.
type HealthServer interface {
// Check gets the health of the specified service. If the requested service
// is unknown, the call will fail with status NOT_FOUND. If the caller does
@@ -152,19 +146,23 @@ type HealthServer interface {
// should assume this method is not supported and should not retry the
// call. If the call terminates with any other status (including OK),
// clients should retry the call with appropriate exponential backoff.
- Watch(*HealthCheckRequest, Health_WatchServer) error
+ Watch(*HealthCheckRequest, grpc.ServerStreamingServer[HealthCheckResponse]) error
}
-// UnimplementedHealthServer should be embedded to have forward compatible implementations.
-type UnimplementedHealthServer struct {
-}
+// UnimplementedHealthServer should be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedHealthServer struct{}
func (UnimplementedHealthServer) Check(context.Context, *HealthCheckRequest) (*HealthCheckResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Check not implemented")
}
-func (UnimplementedHealthServer) Watch(*HealthCheckRequest, Health_WatchServer) error {
+func (UnimplementedHealthServer) Watch(*HealthCheckRequest, grpc.ServerStreamingServer[HealthCheckResponse]) error {
return status.Errorf(codes.Unimplemented, "method Watch not implemented")
}
+func (UnimplementedHealthServer) testEmbeddedByValue() {}
// UnsafeHealthServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to HealthServer will
@@ -174,6 +172,13 @@ type UnsafeHealthServer interface {
}
func RegisterHealthServer(s grpc.ServiceRegistrar, srv HealthServer) {
+ // If the following call panics, it indicates UnimplementedHealthServer was
+ // embedded by pointer and is nil. This will cause panics if an
+ // unimplemented method is ever invoked, so we test this at initialization
+ // time to prevent it from happening at runtime later due to I/O.
+ if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+ t.testEmbeddedByValue()
+ }
s.RegisterService(&Health_ServiceDesc, srv)
}
@@ -200,21 +205,11 @@ func _Health_Watch_Handler(srv interface{}, stream grpc.ServerStream) error {
if err := stream.RecvMsg(m); err != nil {
return err
}
- return srv.(HealthServer).Watch(m, &healthWatchServer{ServerStream: stream})
-}
-
-type Health_WatchServer interface {
- Send(*HealthCheckResponse) error
- grpc.ServerStream
-}
-
-type healthWatchServer struct {
- grpc.ServerStream
+ return srv.(HealthServer).Watch(m, &grpc.GenericServerStream[HealthCheckRequest, HealthCheckResponse]{ServerStream: stream})
}
-func (x *healthWatchServer) Send(m *HealthCheckResponse) error {
- return x.ServerStream.SendMsg(m)
-}
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type Health_WatchServer = grpc.ServerStreamingServer[HealthCheckResponse]
// Health_ServiceDesc is the grpc.ServiceDesc for Health service.
// It's only intended for direct use with grpc.RegisterService,
diff --git a/vendor/google.golang.org/grpc/internal/backoff/backoff.go b/vendor/google.golang.org/grpc/internal/backoff/backoff.go
index fed1c011a3..b15cf482d2 100644
--- a/vendor/google.golang.org/grpc/internal/backoff/backoff.go
+++ b/vendor/google.golang.org/grpc/internal/backoff/backoff.go
@@ -25,10 +25,10 @@ package backoff
import (
"context"
"errors"
+ "math/rand"
"time"
grpcbackoff "google.golang.org/grpc/backoff"
- "google.golang.org/grpc/internal/grpcrand"
)
// Strategy defines the methodology for backing off after a grpc connection
@@ -67,7 +67,7 @@ func (bc Exponential) Backoff(retries int) time.Duration {
}
// Randomize backoff delays so that if a cluster of requests start at
// the same time, they won't operate in lockstep.
- backoff *= 1 + bc.Config.Jitter*(grpcrand.Float64()*2-1)
+ backoff *= 1 + bc.Config.Jitter*(rand.Float64()*2-1)
if backoff < 0 {
return 0
}
diff --git a/vendor/google.golang.org/grpc/internal/balancer/gracefulswitch/config.go b/vendor/google.golang.org/grpc/internal/balancer/gracefulswitch/config.go
index 13821a9266..85540f86a7 100644
--- a/vendor/google.golang.org/grpc/internal/balancer/gracefulswitch/config.go
+++ b/vendor/google.golang.org/grpc/internal/balancer/gracefulswitch/config.go
@@ -33,6 +33,8 @@ type lbConfig struct {
childConfig serviceconfig.LoadBalancingConfig
}
+// ChildName returns the name of the child balancer of the gracefulswitch
+// Balancer.
func ChildName(l serviceconfig.LoadBalancingConfig) string {
return l.(*lbConfig).childBuilder.Name()
}
diff --git a/vendor/google.golang.org/grpc/internal/binarylog/method_logger.go b/vendor/google.golang.org/grpc/internal/binarylog/method_logger.go
index aa4505a871..9669328914 100644
--- a/vendor/google.golang.org/grpc/internal/binarylog/method_logger.go
+++ b/vendor/google.golang.org/grpc/internal/binarylog/method_logger.go
@@ -106,7 +106,7 @@ func (ml *TruncatingMethodLogger) Build(c LogEntryConfig) *binlogpb.GrpcLogEntry
}
// Log creates a proto binary log entry, and logs it to the sink.
-func (ml *TruncatingMethodLogger) Log(ctx context.Context, c LogEntryConfig) {
+func (ml *TruncatingMethodLogger) Log(_ context.Context, c LogEntryConfig) {
ml.sink.Write(ml.Build(c))
}
diff --git a/vendor/google.golang.org/grpc/internal/channelz/channel.go b/vendor/google.golang.org/grpc/internal/channelz/channel.go
index d7e9e1d54e..3ec662799a 100644
--- a/vendor/google.golang.org/grpc/internal/channelz/channel.go
+++ b/vendor/google.golang.org/grpc/internal/channelz/channel.go
@@ -43,6 +43,8 @@ type Channel struct {
// Non-zero traceRefCount means the trace of this channel cannot be deleted.
traceRefCount int32
+ // ChannelMetrics holds connectivity state, target and call metrics for the
+ // channel within channelz.
ChannelMetrics ChannelMetrics
}
@@ -50,6 +52,8 @@ type Channel struct {
// nesting.
func (c *Channel) channelzIdentifier() {}
+// String returns a string representation of the Channel, including its parent
+// entity and ID.
func (c *Channel) String() string {
if c.Parent == nil {
return fmt.Sprintf("Channel #%d", c.ID)
@@ -61,24 +65,31 @@ func (c *Channel) id() int64 {
return c.ID
}
+// SubChans returns a copy of the map of sub-channels associated with the
+// Channel.
func (c *Channel) SubChans() map[int64]string {
db.mu.RLock()
defer db.mu.RUnlock()
return copyMap(c.subChans)
}
+// NestedChans returns a copy of the map of nested channels associated with the
+// Channel.
func (c *Channel) NestedChans() map[int64]string {
db.mu.RLock()
defer db.mu.RUnlock()
return copyMap(c.nestedChans)
}
+// Trace returns a copy of the Channel's trace data.
func (c *Channel) Trace() *ChannelTrace {
db.mu.RLock()
defer db.mu.RUnlock()
return c.trace.copy()
}
+// ChannelMetrics holds connectivity state, target and call metrics for the
+// channel within channelz.
type ChannelMetrics struct {
// The current connectivity state of the channel.
State atomic.Pointer[connectivity.State]
@@ -136,12 +147,16 @@ func strFromPointer(s *string) string {
return *s
}
+// String returns a string representation of the ChannelMetrics, including its
+// state, target, and call metrics.
func (c *ChannelMetrics) String() string {
return fmt.Sprintf("State: %v, Target: %s, CallsStarted: %v, CallsSucceeded: %v, CallsFailed: %v, LastCallStartedTimestamp: %v",
c.State.Load(), strFromPointer(c.Target.Load()), c.CallsStarted.Load(), c.CallsSucceeded.Load(), c.CallsFailed.Load(), c.LastCallStartedTimestamp.Load(),
)
}
+// NewChannelMetricForTesting creates a new instance of ChannelMetrics with
+// specified initial values for testing purposes.
func NewChannelMetricForTesting(state connectivity.State, target string, started, succeeded, failed, timestamp int64) *ChannelMetrics {
c := &ChannelMetrics{}
c.State.Store(&state)
diff --git a/vendor/google.golang.org/grpc/internal/channelz/channelmap.go b/vendor/google.golang.org/grpc/internal/channelz/channelmap.go
index dfe18b0892..64c791953d 100644
--- a/vendor/google.golang.org/grpc/internal/channelz/channelmap.go
+++ b/vendor/google.golang.org/grpc/internal/channelz/channelmap.go
@@ -46,7 +46,7 @@ type entry interface {
// channelMap is the storage data structure for channelz.
//
-// Methods of channelMap can be divided in two two categories with respect to
+// Methods of channelMap can be divided into two categories with respect to
// locking.
//
// 1. Methods acquire the global lock.
@@ -234,13 +234,6 @@ func copyMap(m map[int64]string) map[int64]string {
return n
}
-func min(a, b int) int {
- if a < b {
- return a
- }
- return b
-}
-
func (c *channelMap) getTopChannels(id int64, maxResults int) ([]*Channel, bool) {
if maxResults <= 0 {
maxResults = EntriesPerPage
diff --git a/vendor/google.golang.org/grpc/internal/channelz/funcs.go b/vendor/google.golang.org/grpc/internal/channelz/funcs.go
index 03e24e1507..078bb81238 100644
--- a/vendor/google.golang.org/grpc/internal/channelz/funcs.go
+++ b/vendor/google.golang.org/grpc/internal/channelz/funcs.go
@@ -33,7 +33,7 @@ var (
// outside this package except by tests.
IDGen IDGenerator
- db *channelMap = newChannelMap()
+ db = newChannelMap()
// EntriesPerPage defines the number of channelz entries to be shown on a web page.
EntriesPerPage = 50
curState int32
diff --git a/vendor/google.golang.org/grpc/internal/channelz/server.go b/vendor/google.golang.org/grpc/internal/channelz/server.go
index cdfc49d6ea..b5a8249929 100644
--- a/vendor/google.golang.org/grpc/internal/channelz/server.go
+++ b/vendor/google.golang.org/grpc/internal/channelz/server.go
@@ -59,6 +59,8 @@ func NewServerMetricsForTesting(started, succeeded, failed, timestamp int64) *Se
return sm
}
+// CopyFrom copies the metrics data from the provided ServerMetrics
+// instance into the current instance.
func (sm *ServerMetrics) CopyFrom(o *ServerMetrics) {
sm.CallsStarted.Store(o.CallsStarted.Load())
sm.CallsSucceeded.Store(o.CallsSucceeded.Load())
diff --git a/vendor/google.golang.org/grpc/internal/channelz/socket.go b/vendor/google.golang.org/grpc/internal/channelz/socket.go
index fa64834b25..90103847c5 100644
--- a/vendor/google.golang.org/grpc/internal/channelz/socket.go
+++ b/vendor/google.golang.org/grpc/internal/channelz/socket.go
@@ -70,13 +70,18 @@ type EphemeralSocketMetrics struct {
RemoteFlowControlWindow int64
}
+// SocketType represents the type of socket.
type SocketType string
+// SocketType can be one of these.
const (
SocketTypeNormal = "NormalSocket"
SocketTypeListen = "ListenSocket"
)
+// Socket represents a socket within channelz which includes socket
+// metrics and data related to socket activity and provides methods
+// for managing and interacting with sockets.
type Socket struct {
Entity
SocketType SocketType
@@ -100,6 +105,8 @@ type Socket struct {
Security credentials.ChannelzSecurityValue
}
+// String returns a string representation of the Socket, including its parent
+// entity, socket type, and ID.
func (ls *Socket) String() string {
return fmt.Sprintf("%s %s #%d", ls.Parent, ls.SocketType, ls.ID)
}
diff --git a/vendor/google.golang.org/grpc/internal/channelz/subchannel.go b/vendor/google.golang.org/grpc/internal/channelz/subchannel.go
index 3b88e4cba8..b20802e6e9 100644
--- a/vendor/google.golang.org/grpc/internal/channelz/subchannel.go
+++ b/vendor/google.golang.org/grpc/internal/channelz/subchannel.go
@@ -47,12 +47,14 @@ func (sc *SubChannel) id() int64 {
return sc.ID
}
+// Sockets returns a copy of the sockets map associated with the SubChannel.
func (sc *SubChannel) Sockets() map[int64]string {
db.mu.RLock()
defer db.mu.RUnlock()
return copyMap(sc.sockets)
}
+// Trace returns a copy of the ChannelTrace associated with the SubChannel.
func (sc *SubChannel) Trace() *ChannelTrace {
db.mu.RLock()
defer db.mu.RUnlock()
diff --git a/vendor/google.golang.org/grpc/internal/channelz/syscall_nonlinux.go b/vendor/google.golang.org/grpc/internal/channelz/syscall_nonlinux.go
index d1ed8df6a5..0e6e18e185 100644
--- a/vendor/google.golang.org/grpc/internal/channelz/syscall_nonlinux.go
+++ b/vendor/google.golang.org/grpc/internal/channelz/syscall_nonlinux.go
@@ -35,13 +35,13 @@ type SocketOptionData struct {
// Getsockopt defines the function to get socket options requested by channelz.
// It is to be passed to syscall.RawConn.Control().
// Windows OS doesn't support Socket Option
-func (s *SocketOptionData) Getsockopt(fd uintptr) {
+func (s *SocketOptionData) Getsockopt(uintptr) {
once.Do(func() {
logger.Warning("Channelz: socket options are not supported on non-linux environments")
})
}
// GetSocketOption gets the socket option info of the conn.
-func GetSocketOption(c any) *SocketOptionData {
+func GetSocketOption(any) *SocketOptionData {
return nil
}
diff --git a/vendor/google.golang.org/grpc/internal/channelz/trace.go b/vendor/google.golang.org/grpc/internal/channelz/trace.go
index 36b8674032..2bffe47776 100644
--- a/vendor/google.golang.org/grpc/internal/channelz/trace.go
+++ b/vendor/google.golang.org/grpc/internal/channelz/trace.go
@@ -79,13 +79,21 @@ type TraceEvent struct {
Parent *TraceEvent
}
+// ChannelTrace provides tracing information for a channel.
+// It tracks various events and metadata related to the channel's lifecycle
+// and operations.
type ChannelTrace struct {
- cm *channelMap
- clearCalled bool
+ cm *channelMap
+ clearCalled bool
+ // The time when the trace was created.
CreationTime time.Time
- EventNum int64
- mu sync.Mutex
- Events []*traceEvent
+ // A counter for the number of events recorded in the
+ // trace.
+ EventNum int64
+ mu sync.Mutex
+ // A slice of traceEvent pointers representing the events recorded for
+ // this channel.
+ Events []*traceEvent
}
func (c *ChannelTrace) copy() *ChannelTrace {
@@ -175,6 +183,7 @@ var refChannelTypeToString = map[RefChannelType]string{
RefNormalSocket: "NormalSocket",
}
+// String returns a string representation of the RefChannelType
func (r RefChannelType) String() string {
return refChannelTypeToString[r]
}
diff --git a/vendor/google.golang.org/grpc/internal/envconfig/envconfig.go b/vendor/google.golang.org/grpc/internal/envconfig/envconfig.go
index 9c915d9e4b..6e7dd6b772 100644
--- a/vendor/google.golang.org/grpc/internal/envconfig/envconfig.go
+++ b/vendor/google.golang.org/grpc/internal/envconfig/envconfig.go
@@ -40,6 +40,21 @@ var (
// ALTSMaxConcurrentHandshakes is the maximum number of concurrent ALTS
// handshakes that can be performed.
ALTSMaxConcurrentHandshakes = uint64FromEnv("GRPC_ALTS_MAX_CONCURRENT_HANDSHAKES", 100, 1, 100)
+ // EnforceALPNEnabled is set if TLS connections to servers with ALPN disabled
+ // should be rejected. The HTTP/2 protocol requires ALPN to be enabled, this
+ // option is present for backward compatibility. This option may be overridden
+ // by setting the environment variable "GRPC_ENFORCE_ALPN_ENABLED" to "true"
+ // or "false".
+ EnforceALPNEnabled = boolFromEnv("GRPC_ENFORCE_ALPN_ENABLED", true)
+ // XDSFallbackSupport is the env variable that controls whether support for
+ // xDS fallback is turned on. If this is unset or is false, only the first
+ // xDS server in the list of server configs will be used.
+ XDSFallbackSupport = boolFromEnv("GRPC_EXPERIMENTAL_XDS_FALLBACK", false)
+ // NewPickFirstEnabled is set if the new pickfirst leaf policy is to be used
+ // instead of the exiting pickfirst implementation. This can be enabled by
+ // setting the environment variable "GRPC_EXPERIMENTAL_ENABLE_NEW_PICK_FIRST"
+ // to "true".
+ NewPickFirstEnabled = boolFromEnv("GRPC_EXPERIMENTAL_ENABLE_NEW_PICK_FIRST", false)
)
func boolFromEnv(envVar string, def bool) bool {
diff --git a/vendor/google.golang.org/grpc/internal/experimental.go b/vendor/google.golang.org/grpc/internal/experimental.go
index 7f7044e173..7617be2158 100644
--- a/vendor/google.golang.org/grpc/internal/experimental.go
+++ b/vendor/google.golang.org/grpc/internal/experimental.go
@@ -18,11 +18,11 @@
package internal
var (
- // WithRecvBufferPool is implemented by the grpc package and returns a dial
+ // WithBufferPool is implemented by the grpc package and returns a dial
// option to configure a shared buffer pool for a grpc.ClientConn.
- WithRecvBufferPool any // func (grpc.SharedBufferPool) grpc.DialOption
+ WithBufferPool any // func (grpc.SharedBufferPool) grpc.DialOption
- // RecvBufferPool is implemented by the grpc package and returns a server
+ // BufferPool is implemented by the grpc package and returns a server
// option to configure a shared buffer pool for a grpc.Server.
- RecvBufferPool any // func (grpc.SharedBufferPool) grpc.ServerOption
+ BufferPool any // func (grpc.SharedBufferPool) grpc.ServerOption
)
diff --git a/vendor/google.golang.org/grpc/internal/grpclog/prefixLogger.go b/vendor/google.golang.org/grpc/internal/grpclog/prefix_logger.go
similarity index 63%
rename from vendor/google.golang.org/grpc/internal/grpclog/prefixLogger.go
rename to vendor/google.golang.org/grpc/internal/grpclog/prefix_logger.go
index faa998de76..092ad187a2 100644
--- a/vendor/google.golang.org/grpc/internal/grpclog/prefixLogger.go
+++ b/vendor/google.golang.org/grpc/internal/grpclog/prefix_logger.go
@@ -16,17 +16,21 @@
*
*/
+// Package grpclog provides logging functionality for internal gRPC packages,
+// outside of the functionality provided by the external `grpclog` package.
package grpclog
import (
"fmt"
+
+ "google.golang.org/grpc/grpclog"
)
// PrefixLogger does logging with a prefix.
//
// Logging method on a nil logs without any prefix.
type PrefixLogger struct {
- logger DepthLoggerV2
+ logger grpclog.DepthLoggerV2
prefix string
}
@@ -38,7 +42,7 @@ func (pl *PrefixLogger) Infof(format string, args ...any) {
pl.logger.InfoDepth(1, fmt.Sprintf(format, args...))
return
}
- InfoDepth(1, fmt.Sprintf(format, args...))
+ grpclog.InfoDepth(1, fmt.Sprintf(format, args...))
}
// Warningf does warning logging.
@@ -48,7 +52,7 @@ func (pl *PrefixLogger) Warningf(format string, args ...any) {
pl.logger.WarningDepth(1, fmt.Sprintf(format, args...))
return
}
- WarningDepth(1, fmt.Sprintf(format, args...))
+ grpclog.WarningDepth(1, fmt.Sprintf(format, args...))
}
// Errorf does error logging.
@@ -58,36 +62,18 @@ func (pl *PrefixLogger) Errorf(format string, args ...any) {
pl.logger.ErrorDepth(1, fmt.Sprintf(format, args...))
return
}
- ErrorDepth(1, fmt.Sprintf(format, args...))
-}
-
-// Debugf does info logging at verbose level 2.
-func (pl *PrefixLogger) Debugf(format string, args ...any) {
- // TODO(6044): Refactor interfaces LoggerV2 and DepthLogger, and maybe
- // rewrite PrefixLogger a little to ensure that we don't use the global
- // `Logger` here, and instead use the `logger` field.
- if !Logger.V(2) {
- return
- }
- if pl != nil {
- // Handle nil, so the tests can pass in a nil logger.
- format = pl.prefix + format
- pl.logger.InfoDepth(1, fmt.Sprintf(format, args...))
- return
- }
- InfoDepth(1, fmt.Sprintf(format, args...))
-
+ grpclog.ErrorDepth(1, fmt.Sprintf(format, args...))
}
// V reports whether verbosity level l is at least the requested verbose level.
func (pl *PrefixLogger) V(l int) bool {
- // TODO(6044): Refactor interfaces LoggerV2 and DepthLogger, and maybe
- // rewrite PrefixLogger a little to ensure that we don't use the global
- // `Logger` here, and instead use the `logger` field.
- return Logger.V(l)
+ if pl != nil {
+ return pl.logger.V(l)
+ }
+ return true
}
// NewPrefixLogger creates a prefix logger with the given prefix.
-func NewPrefixLogger(logger DepthLoggerV2, prefix string) *PrefixLogger {
+func NewPrefixLogger(logger grpclog.DepthLoggerV2, prefix string) *PrefixLogger {
return &PrefixLogger{logger: logger, prefix: prefix}
}
diff --git a/vendor/google.golang.org/grpc/internal/grpcrand/grpcrand.go b/vendor/google.golang.org/grpc/internal/grpcrand/grpcrand.go
deleted file mode 100644
index 0126d6b510..0000000000
--- a/vendor/google.golang.org/grpc/internal/grpcrand/grpcrand.go
+++ /dev/null
@@ -1,100 +0,0 @@
-//go:build !go1.21
-
-// TODO: when this file is deleted (after Go 1.20 support is dropped), delete
-// all of grpcrand and call the rand package directly.
-
-/*
- *
- * Copyright 2018 gRPC 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 grpcrand implements math/rand functions in a concurrent-safe way
-// with a global random source, independent of math/rand's global source.
-package grpcrand
-
-import (
- "math/rand"
- "sync"
- "time"
-)
-
-var (
- r = rand.New(rand.NewSource(time.Now().UnixNano()))
- mu sync.Mutex
-)
-
-// Int implements rand.Int on the grpcrand global source.
-func Int() int {
- mu.Lock()
- defer mu.Unlock()
- return r.Int()
-}
-
-// Int63n implements rand.Int63n on the grpcrand global source.
-func Int63n(n int64) int64 {
- mu.Lock()
- defer mu.Unlock()
- return r.Int63n(n)
-}
-
-// Intn implements rand.Intn on the grpcrand global source.
-func Intn(n int) int {
- mu.Lock()
- defer mu.Unlock()
- return r.Intn(n)
-}
-
-// Int31n implements rand.Int31n on the grpcrand global source.
-func Int31n(n int32) int32 {
- mu.Lock()
- defer mu.Unlock()
- return r.Int31n(n)
-}
-
-// Float64 implements rand.Float64 on the grpcrand global source.
-func Float64() float64 {
- mu.Lock()
- defer mu.Unlock()
- return r.Float64()
-}
-
-// Uint64 implements rand.Uint64 on the grpcrand global source.
-func Uint64() uint64 {
- mu.Lock()
- defer mu.Unlock()
- return r.Uint64()
-}
-
-// Uint32 implements rand.Uint32 on the grpcrand global source.
-func Uint32() uint32 {
- mu.Lock()
- defer mu.Unlock()
- return r.Uint32()
-}
-
-// ExpFloat64 implements rand.ExpFloat64 on the grpcrand global source.
-func ExpFloat64() float64 {
- mu.Lock()
- defer mu.Unlock()
- return r.ExpFloat64()
-}
-
-// Shuffle implements rand.Shuffle on the grpcrand global source.
-var Shuffle = func(n int, f func(int, int)) {
- mu.Lock()
- defer mu.Unlock()
- r.Shuffle(n, f)
-}
diff --git a/vendor/google.golang.org/grpc/internal/grpcrand/grpcrand_go1.21.go b/vendor/google.golang.org/grpc/internal/grpcrand/grpcrand_go1.21.go
deleted file mode 100644
index c37299af1e..0000000000
--- a/vendor/google.golang.org/grpc/internal/grpcrand/grpcrand_go1.21.go
+++ /dev/null
@@ -1,73 +0,0 @@
-//go:build go1.21
-
-/*
- *
- * Copyright 2024 gRPC 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 grpcrand implements math/rand functions in a concurrent-safe way
-// with a global random source, independent of math/rand's global source.
-package grpcrand
-
-import "math/rand"
-
-// This implementation will be used for Go version 1.21 or newer.
-// For older versions, the original implementation with mutex will be used.
-
-// Int implements rand.Int on the grpcrand global source.
-func Int() int {
- return rand.Int()
-}
-
-// Int63n implements rand.Int63n on the grpcrand global source.
-func Int63n(n int64) int64 {
- return rand.Int63n(n)
-}
-
-// Intn implements rand.Intn on the grpcrand global source.
-func Intn(n int) int {
- return rand.Intn(n)
-}
-
-// Int31n implements rand.Int31n on the grpcrand global source.
-func Int31n(n int32) int32 {
- return rand.Int31n(n)
-}
-
-// Float64 implements rand.Float64 on the grpcrand global source.
-func Float64() float64 {
- return rand.Float64()
-}
-
-// Uint64 implements rand.Uint64 on the grpcrand global source.
-func Uint64() uint64 {
- return rand.Uint64()
-}
-
-// Uint32 implements rand.Uint32 on the grpcrand global source.
-func Uint32() uint32 {
- return rand.Uint32()
-}
-
-// ExpFloat64 implements rand.ExpFloat64 on the grpcrand global source.
-func ExpFloat64() float64 {
- return rand.ExpFloat64()
-}
-
-// Shuffle implements rand.Shuffle on the grpcrand global source.
-var Shuffle = func(n int, f func(int, int)) {
- rand.Shuffle(n, f)
-}
diff --git a/vendor/google.golang.org/grpc/internal/grpcsync/callback_serializer.go b/vendor/google.golang.org/grpc/internal/grpcsync/callback_serializer.go
index f7f40a16ac..8e8e861280 100644
--- a/vendor/google.golang.org/grpc/internal/grpcsync/callback_serializer.go
+++ b/vendor/google.golang.org/grpc/internal/grpcsync/callback_serializer.go
@@ -53,16 +53,28 @@ func NewCallbackSerializer(ctx context.Context) *CallbackSerializer {
return cs
}
-// Schedule adds a callback to be scheduled after existing callbacks are run.
+// TrySchedule tries to schedule the provided callback function f to be
+// executed in the order it was added. This is a best-effort operation. If the
+// context passed to NewCallbackSerializer was canceled before this method is
+// called, the callback will not be scheduled.
//
// Callbacks are expected to honor the context when performing any blocking
// operations, and should return early when the context is canceled.
+func (cs *CallbackSerializer) TrySchedule(f func(ctx context.Context)) {
+ cs.callbacks.Put(f)
+}
+
+// ScheduleOr schedules the provided callback function f to be executed in the
+// order it was added. If the context passed to NewCallbackSerializer has been
+// canceled before this method is called, the onFailure callback will be
+// executed inline instead.
//
-// Return value indicates if the callback was successfully added to the list of
-// callbacks to be executed by the serializer. It is not possible to add
-// callbacks once the context passed to NewCallbackSerializer is cancelled.
-func (cs *CallbackSerializer) Schedule(f func(ctx context.Context)) bool {
- return cs.callbacks.Put(f) == nil
+// Callbacks are expected to honor the context when performing any blocking
+// operations, and should return early when the context is canceled.
+func (cs *CallbackSerializer) ScheduleOr(f func(ctx context.Context), onFailure func()) {
+ if cs.callbacks.Put(f) != nil {
+ onFailure()
+ }
}
func (cs *CallbackSerializer) run(ctx context.Context) {
diff --git a/vendor/google.golang.org/grpc/internal/grpcsync/pubsub.go b/vendor/google.golang.org/grpc/internal/grpcsync/pubsub.go
index aef8cec1ab..6d8c2f518d 100644
--- a/vendor/google.golang.org/grpc/internal/grpcsync/pubsub.go
+++ b/vendor/google.golang.org/grpc/internal/grpcsync/pubsub.go
@@ -77,7 +77,7 @@ func (ps *PubSub) Subscribe(sub Subscriber) (cancel func()) {
if ps.msg != nil {
msg := ps.msg
- ps.cs.Schedule(func(context.Context) {
+ ps.cs.TrySchedule(func(context.Context) {
ps.mu.Lock()
defer ps.mu.Unlock()
if !ps.subscribers[sub] {
@@ -103,7 +103,7 @@ func (ps *PubSub) Publish(msg any) {
ps.msg = msg
for sub := range ps.subscribers {
s := sub
- ps.cs.Schedule(func(context.Context) {
+ ps.cs.TrySchedule(func(context.Context) {
ps.mu.Lock()
defer ps.mu.Unlock()
if !ps.subscribers[s] {
diff --git a/vendor/google.golang.org/grpc/internal/grpcutil/method.go b/vendor/google.golang.org/grpc/internal/grpcutil/method.go
index ec62b4775e..683d1955c6 100644
--- a/vendor/google.golang.org/grpc/internal/grpcutil/method.go
+++ b/vendor/google.golang.org/grpc/internal/grpcutil/method.go
@@ -39,7 +39,7 @@ func ParseMethod(methodName string) (service, method string, _ error) {
}
// baseContentType is the base content-type for gRPC. This is a valid
-// content-type on it's own, but can also include a content-subtype such as
+// content-type on its own, but can also include a content-subtype such as
// "proto" as a suffix after "+" or ";". See
// https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#requests
// for more details.
diff --git a/vendor/google.golang.org/grpc/internal/idle/idle.go b/vendor/google.golang.org/grpc/internal/idle/idle.go
index fe49cb74c5..2c13ee9dac 100644
--- a/vendor/google.golang.org/grpc/internal/idle/idle.go
+++ b/vendor/google.golang.org/grpc/internal/idle/idle.go
@@ -182,6 +182,7 @@ func (m *Manager) tryEnterIdleMode() bool {
return true
}
+// EnterIdleModeForTesting instructs the channel to enter idle mode.
func (m *Manager) EnterIdleModeForTesting() {
m.tryEnterIdleMode()
}
@@ -225,7 +226,7 @@ func (m *Manager) ExitIdleMode() error {
// came in and OnCallBegin() noticed that the calls count is negative.
// - Channel is in idle mode, and multiple new RPCs come in at the same
// time, all of them notice a negative calls count in OnCallBegin and get
- // here. The first one to get the lock would got the channel to exit idle.
+ // here. The first one to get the lock would get the channel to exit idle.
// - Channel is not in idle mode, and the user calls Connect which calls
// m.ExitIdleMode.
//
@@ -266,6 +267,7 @@ func (m *Manager) isClosed() bool {
return atomic.LoadInt32(&m.closed) == 1
}
+// Close stops the timer associated with the Manager, if it exists.
func (m *Manager) Close() {
atomic.StoreInt32(&m.closed, 1)
diff --git a/vendor/google.golang.org/grpc/internal/internal.go b/vendor/google.golang.org/grpc/internal/internal.go
index 48d24bdb4e..20b4dc3d35 100644
--- a/vendor/google.golang.org/grpc/internal/internal.go
+++ b/vendor/google.golang.org/grpc/internal/internal.go
@@ -106,6 +106,14 @@ var (
// This is used in the 1.0 release of gcp/observability, and thus must not be
// deleted or changed.
ClearGlobalDialOptions func()
+
+ // AddGlobalPerTargetDialOptions adds a PerTargetDialOption that will be
+ // configured for newly created ClientConns.
+ AddGlobalPerTargetDialOptions any // func (opt any)
+ // ClearGlobalPerTargetDialOptions clears the slice of global late apply
+ // dial options.
+ ClearGlobalPerTargetDialOptions func()
+
// JoinDialOptions combines the dial options passed as arguments into a
// single dial option.
JoinDialOptions any // func(...grpc.DialOption) grpc.DialOption
@@ -126,7 +134,8 @@ var (
// deleted or changed.
BinaryLogger any // func(binarylog.Logger) grpc.ServerOption
- // SubscribeToConnectivityStateChanges adds a grpcsync.Subscriber to a provided grpc.ClientConn
+ // SubscribeToConnectivityStateChanges adds a grpcsync.Subscriber to a
+ // provided grpc.ClientConn.
SubscribeToConnectivityStateChanges any // func(*grpc.ClientConn, grpcsync.Subscriber)
// NewXDSResolverWithConfigForTesting creates a new xds resolver builder using
@@ -174,7 +183,7 @@ var (
// GRPCResolverSchemeExtraMetadata determines when gRPC will add extra
// metadata to RPCs.
- GRPCResolverSchemeExtraMetadata string = "xds"
+ GRPCResolverSchemeExtraMetadata = "xds"
// EnterIdleModeForTesting gets the ClientConn to enter IDLE mode.
EnterIdleModeForTesting any // func(*grpc.ClientConn)
@@ -182,31 +191,49 @@ var (
// ExitIdleModeForTesting gets the ClientConn to exit IDLE mode.
ExitIdleModeForTesting any // func(*grpc.ClientConn) error
+ // ChannelzTurnOffForTesting disables the Channelz service for testing
+ // purposes.
ChannelzTurnOffForTesting func()
- // TriggerXDSResourceNameNotFoundForTesting triggers the resource-not-found
- // error for a given resource type and name. This is usually triggered when
- // the associated watch timer fires. For testing purposes, having this
- // function makes events more predictable than relying on timer events.
- TriggerXDSResourceNameNotFoundForTesting any // func(func(xdsresource.Type, string), string, string) error
+ // TriggerXDSResourceNotFoundForTesting causes the provided xDS Client to
+ // invoke resource-not-found error for the given resource type and name.
+ TriggerXDSResourceNotFoundForTesting any // func(xdsclient.XDSClient, xdsresource.Type, string) error
- // TriggerXDSResourceNameNotFoundClient invokes the testing xDS Client
- // singleton to invoke resource not found for a resource type name and
- // resource name.
- TriggerXDSResourceNameNotFoundClient any // func(string, string) error
-
- // FromOutgoingContextRaw returns the un-merged, intermediary contents of metadata.rawMD.
+ // FromOutgoingContextRaw returns the un-merged, intermediary contents of
+ // metadata.rawMD.
FromOutgoingContextRaw any // func(context.Context) (metadata.MD, [][]string, bool)
- // UserSetDefaultScheme is set to true if the user has overridden the default resolver scheme.
- UserSetDefaultScheme bool = false
+ // UserSetDefaultScheme is set to true if the user has overridden the
+ // default resolver scheme.
+ UserSetDefaultScheme = false
+
+ // ConnectedAddress returns the connected address for a SubConnState. The
+ // address is only valid if the state is READY.
+ ConnectedAddress any // func (scs SubConnState) resolver.Address
+
+ // SetConnectedAddress sets the connected address for a SubConnState.
+ SetConnectedAddress any // func(scs *SubConnState, addr resolver.Address)
+
+ // SnapshotMetricRegistryForTesting snapshots the global data of the metric
+ // registry. Returns a cleanup function that sets the metric registry to its
+ // original state. Only called in testing functions.
+ SnapshotMetricRegistryForTesting func() func()
+
+ // SetDefaultBufferPoolForTesting updates the default buffer pool, for
+ // testing purposes.
+ SetDefaultBufferPoolForTesting any // func(mem.BufferPool)
+
+ // SetBufferPoolingThresholdForTesting updates the buffer pooling threshold, for
+ // testing purposes.
+ SetBufferPoolingThresholdForTesting any // func(int)
)
-// HealthChecker defines the signature of the client-side LB channel health checking function.
+// HealthChecker defines the signature of the client-side LB channel health
+// checking function.
//
// The implementation is expected to create a health checking RPC stream by
// calling newStream(), watch for the health status of serviceName, and report
-// it's health back by calling setConnectivityState().
+// its health back by calling setConnectivityState().
//
// The health checking protocol is defined at:
// https://github.com/grpc/grpc/blob/master/doc/health-checking.md
diff --git a/vendor/google.golang.org/grpc/internal/resolver/dns/dns_resolver.go b/vendor/google.golang.org/grpc/internal/resolver/dns/dns_resolver.go
index f3f52a59a8..8691698ef2 100644
--- a/vendor/google.golang.org/grpc/internal/resolver/dns/dns_resolver.go
+++ b/vendor/google.golang.org/grpc/internal/resolver/dns/dns_resolver.go
@@ -24,6 +24,7 @@ import (
"context"
"encoding/json"
"fmt"
+ "math/rand"
"net"
"os"
"strconv"
@@ -35,7 +36,6 @@ import (
"google.golang.org/grpc/grpclog"
"google.golang.org/grpc/internal/backoff"
"google.golang.org/grpc/internal/envconfig"
- "google.golang.org/grpc/internal/grpcrand"
"google.golang.org/grpc/internal/resolver/dns/internal"
"google.golang.org/grpc/resolver"
"google.golang.org/grpc/serviceconfig"
@@ -63,6 +63,8 @@ var (
func init() {
resolver.Register(NewBuilder())
internal.TimeAfterFunc = time.After
+ internal.TimeNowFunc = time.Now
+ internal.TimeUntilFunc = time.Until
internal.NewNetResolver = newNetResolver
internal.AddressDialer = addressDialer
}
@@ -175,7 +177,7 @@ type dnsResolver struct {
// finished. Otherwise, data race will be possible. [Race Example] in
// dns_resolver_test we replace the real lookup functions with mocked ones to
// facilitate testing. If Close() doesn't wait for watcher() goroutine
- // finishes, race detector sometimes will warns lookup (READ the lookup
+ // finishes, race detector sometimes will warn lookup (READ the lookup
// function pointers) inside watcher() goroutine has data race with
// replaceNetFunc (WRITE the lookup function pointers).
wg sync.WaitGroup
@@ -209,12 +211,12 @@ func (d *dnsResolver) watcher() {
err = d.cc.UpdateState(*state)
}
- var waitTime time.Duration
+ var nextResolutionTime time.Time
if err == nil {
// Success resolving, wait for the next ResolveNow. However, also wait 30
// seconds at the very least to prevent constantly re-resolving.
backoffIndex = 1
- waitTime = MinResolutionInterval
+ nextResolutionTime = internal.TimeNowFunc().Add(MinResolutionInterval)
select {
case <-d.ctx.Done():
return
@@ -223,13 +225,13 @@ func (d *dnsResolver) watcher() {
} else {
// Poll on an error found in DNS Resolver or an error received from
// ClientConn.
- waitTime = backoff.DefaultExponential.Backoff(backoffIndex)
+ nextResolutionTime = internal.TimeNowFunc().Add(backoff.DefaultExponential.Backoff(backoffIndex))
backoffIndex++
}
select {
case <-d.ctx.Done():
return
- case <-internal.TimeAfterFunc(waitTime):
+ case <-internal.TimeAfterFunc(internal.TimeUntilFunc(nextResolutionTime)):
}
}
}
@@ -423,7 +425,7 @@ func chosenByPercentage(a *int) bool {
if a == nil {
return true
}
- return grpcrand.Intn(100)+1 <= *a
+ return rand.Intn(100)+1 <= *a
}
func canaryingSC(js string) string {
diff --git a/vendor/google.golang.org/grpc/internal/resolver/dns/internal/internal.go b/vendor/google.golang.org/grpc/internal/resolver/dns/internal/internal.go
index a7ecaf8d52..c0eae4f5f8 100644
--- a/vendor/google.golang.org/grpc/internal/resolver/dns/internal/internal.go
+++ b/vendor/google.golang.org/grpc/internal/resolver/dns/internal/internal.go
@@ -51,11 +51,22 @@ var (
// The following vars are overridden from tests.
var (
// TimeAfterFunc is used by the DNS resolver to wait for the given duration
- // to elapse. In non-test code, this is implemented by time.After. In test
+ // to elapse. In non-test code, this is implemented by time.After. In test
// code, this can be used to control the amount of time the resolver is
// blocked waiting for the duration to elapse.
TimeAfterFunc func(time.Duration) <-chan time.Time
+ // TimeNowFunc is used by the DNS resolver to get the current time.
+ // In non-test code, this is implemented by time.Now. In test code,
+ // this can be used to control the current time for the resolver.
+ TimeNowFunc func() time.Time
+
+ // TimeUntilFunc is used by the DNS resolver to calculate the remaining
+ // wait time for re-resolution. In non-test code, this is implemented by
+ // time.Until. In test code, this can be used to control the remaining
+ // time for resolver to wait for re-resolution.
+ TimeUntilFunc func(time.Time) time.Duration
+
// NewNetResolver returns the net.Resolver instance for the given target.
NewNetResolver func(string) (NetResolver, error)
diff --git a/vendor/google.golang.org/grpc/internal/resolver/passthrough/passthrough.go b/vendor/google.golang.org/grpc/internal/resolver/passthrough/passthrough.go
index afac56572a..b901c7bace 100644
--- a/vendor/google.golang.org/grpc/internal/resolver/passthrough/passthrough.go
+++ b/vendor/google.golang.org/grpc/internal/resolver/passthrough/passthrough.go
@@ -55,7 +55,7 @@ func (r *passthroughResolver) start() {
r.cc.UpdateState(resolver.State{Addresses: []resolver.Address{{Addr: r.target.Endpoint()}}})
}
-func (*passthroughResolver) ResolveNow(o resolver.ResolveNowOptions) {}
+func (*passthroughResolver) ResolveNow(resolver.ResolveNowOptions) {}
func (*passthroughResolver) Close() {}
diff --git a/vendor/google.golang.org/grpc/internal/stats/labels.go b/vendor/google.golang.org/grpc/internal/stats/labels.go
new file mode 100644
index 0000000000..fd33af51ae
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/stats/labels.go
@@ -0,0 +1,42 @@
+/*
+ *
+ * Copyright 2024 gRPC 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 stats provides internal stats related functionality.
+package stats
+
+import "context"
+
+// Labels are the labels for metrics.
+type Labels struct {
+ // TelemetryLabels are the telemetry labels to record.
+ TelemetryLabels map[string]string
+}
+
+type labelsKey struct{}
+
+// GetLabels returns the Labels stored in the context, or nil if there is one.
+func GetLabels(ctx context.Context) *Labels {
+ labels, _ := ctx.Value(labelsKey{}).(*Labels)
+ return labels
+}
+
+// SetLabels sets the Labels in the context.
+func SetLabels(ctx context.Context, labels *Labels) context.Context {
+ // could also append
+ return context.WithValue(ctx, labelsKey{}, labels)
+}
diff --git a/vendor/google.golang.org/grpc/internal/stats/metrics_recorder_list.go b/vendor/google.golang.org/grpc/internal/stats/metrics_recorder_list.go
new file mode 100644
index 0000000000..79044657be
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/stats/metrics_recorder_list.go
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2024 gRPC 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 stats
+
+import (
+ "fmt"
+
+ estats "google.golang.org/grpc/experimental/stats"
+ "google.golang.org/grpc/stats"
+)
+
+// MetricsRecorderList forwards Record calls to all of its metricsRecorders.
+//
+// It eats any record calls where the label values provided do not match the
+// number of label keys.
+type MetricsRecorderList struct {
+ // metricsRecorders are the metrics recorders this list will forward to.
+ metricsRecorders []estats.MetricsRecorder
+}
+
+// NewMetricsRecorderList creates a new metric recorder list with all the stats
+// handlers provided which implement the MetricsRecorder interface.
+// If no stats handlers provided implement the MetricsRecorder interface,
+// the MetricsRecorder list returned is a no-op.
+func NewMetricsRecorderList(shs []stats.Handler) *MetricsRecorderList {
+ var mrs []estats.MetricsRecorder
+ for _, sh := range shs {
+ if mr, ok := sh.(estats.MetricsRecorder); ok {
+ mrs = append(mrs, mr)
+ }
+ }
+ return &MetricsRecorderList{
+ metricsRecorders: mrs,
+ }
+}
+
+func verifyLabels(desc *estats.MetricDescriptor, labelsRecv ...string) {
+ if got, want := len(labelsRecv), len(desc.Labels)+len(desc.OptionalLabels); got != want {
+ panic(fmt.Sprintf("Received %d labels in call to record metric %q, but expected %d.", got, desc.Name, want))
+ }
+}
+
+// RecordInt64Count records the measurement alongside labels on the int
+// count associated with the provided handle.
+func (l *MetricsRecorderList) RecordInt64Count(handle *estats.Int64CountHandle, incr int64, labels ...string) {
+ verifyLabels(handle.Descriptor(), labels...)
+
+ for _, metricRecorder := range l.metricsRecorders {
+ metricRecorder.RecordInt64Count(handle, incr, labels...)
+ }
+}
+
+// RecordFloat64Count records the measurement alongside labels on the float
+// count associated with the provided handle.
+func (l *MetricsRecorderList) RecordFloat64Count(handle *estats.Float64CountHandle, incr float64, labels ...string) {
+ verifyLabels(handle.Descriptor(), labels...)
+
+ for _, metricRecorder := range l.metricsRecorders {
+ metricRecorder.RecordFloat64Count(handle, incr, labels...)
+ }
+}
+
+// RecordInt64Histo records the measurement alongside labels on the int
+// histo associated with the provided handle.
+func (l *MetricsRecorderList) RecordInt64Histo(handle *estats.Int64HistoHandle, incr int64, labels ...string) {
+ verifyLabels(handle.Descriptor(), labels...)
+
+ for _, metricRecorder := range l.metricsRecorders {
+ metricRecorder.RecordInt64Histo(handle, incr, labels...)
+ }
+}
+
+// RecordFloat64Histo records the measurement alongside labels on the float
+// histo associated with the provided handle.
+func (l *MetricsRecorderList) RecordFloat64Histo(handle *estats.Float64HistoHandle, incr float64, labels ...string) {
+ verifyLabels(handle.Descriptor(), labels...)
+
+ for _, metricRecorder := range l.metricsRecorders {
+ metricRecorder.RecordFloat64Histo(handle, incr, labels...)
+ }
+}
+
+// RecordInt64Gauge records the measurement alongside labels on the int
+// gauge associated with the provided handle.
+func (l *MetricsRecorderList) RecordInt64Gauge(handle *estats.Int64GaugeHandle, incr int64, labels ...string) {
+ verifyLabels(handle.Descriptor(), labels...)
+
+ for _, metricRecorder := range l.metricsRecorders {
+ metricRecorder.RecordInt64Gauge(handle, incr, labels...)
+ }
+}
diff --git a/vendor/google.golang.org/grpc/internal/status/status.go b/vendor/google.golang.org/grpc/internal/status/status.go
index c7dbc82059..1186f1e9a9 100644
--- a/vendor/google.golang.org/grpc/internal/status/status.go
+++ b/vendor/google.golang.org/grpc/internal/status/status.go
@@ -138,17 +138,19 @@ func (s *Status) WithDetails(details ...protoadapt.MessageV1) (*Status, error) {
// s.Code() != OK implies that s.Proto() != nil.
p := s.Proto()
for _, detail := range details {
- any, err := anypb.New(protoadapt.MessageV2Of(detail))
+ m, err := anypb.New(protoadapt.MessageV2Of(detail))
if err != nil {
return nil, err
}
- p.Details = append(p.Details, any)
+ p.Details = append(p.Details, m)
}
return &Status{s: p}, nil
}
// Details returns a slice of details messages attached to the status.
// If a detail cannot be decoded, the error is returned in place of the detail.
+// If the detail can be decoded, the proto message returned is of the same
+// type that was given to WithDetails().
func (s *Status) Details() []any {
if s == nil || s.s == nil {
return nil
@@ -160,7 +162,38 @@ func (s *Status) Details() []any {
details = append(details, err)
continue
}
- details = append(details, detail)
+ // The call to MessageV1Of is required to unwrap the proto message if
+ // it implemented only the MessageV1 API. The proto message would have
+ // been wrapped in a V2 wrapper in Status.WithDetails. V2 messages are
+ // added to a global registry used by any.UnmarshalNew().
+ // MessageV1Of has the following behaviour:
+ // 1. If the given message is a wrapped MessageV1, it returns the
+ // unwrapped value.
+ // 2. If the given message already implements MessageV1, it returns it
+ // as is.
+ // 3. Else, it wraps the MessageV2 in a MessageV1 wrapper.
+ //
+ // Since the Status.WithDetails() API only accepts MessageV1, calling
+ // MessageV1Of ensures we return the same type that was given to
+ // WithDetails:
+ // * If the give type implemented only MessageV1, the unwrapping from
+ // point 1 above will restore the type.
+ // * If the given type implemented both MessageV1 and MessageV2, point 2
+ // above will ensure no wrapping is performed.
+ // * If the given type implemented only MessageV2 and was wrapped using
+ // MessageV1Of before passing to WithDetails(), it would be unwrapped
+ // in WithDetails by calling MessageV2Of(). Point 3 above will ensure
+ // that the type is wrapped in a MessageV1 wrapper again before
+ // returning. Note that protoc-gen-go doesn't generate code which
+ // implements ONLY MessageV2 at the time of writing.
+ //
+ // NOTE: Status details can also be added using the FromProto method.
+ // This could theoretically allow passing a Detail message that only
+ // implements the V2 API. In such a case the message will be wrapped in
+ // a MessageV1 wrapper when fetched using Details().
+ // Since protoc-gen-go generates only code that implements both V1 and
+ // V2 APIs for backward compatibility, this is not a concern.
+ details = append(details, protoadapt.MessageV1Of(detail))
}
return details
}
diff --git a/vendor/google.golang.org/grpc/internal/syscall/syscall_nonlinux.go b/vendor/google.golang.org/grpc/internal/syscall/syscall_nonlinux.go
index 999f52cd75..54c24c2ff3 100644
--- a/vendor/google.golang.org/grpc/internal/syscall/syscall_nonlinux.go
+++ b/vendor/google.golang.org/grpc/internal/syscall/syscall_nonlinux.go
@@ -58,20 +58,20 @@ func GetRusage() *Rusage {
// CPUTimeDiff returns the differences of user CPU time and system CPU time used
// between two Rusage structs. It a no-op function for non-linux environments.
-func CPUTimeDiff(first *Rusage, latest *Rusage) (float64, float64) {
+func CPUTimeDiff(*Rusage, *Rusage) (float64, float64) {
log()
return 0, 0
}
// SetTCPUserTimeout is a no-op function under non-linux environments.
-func SetTCPUserTimeout(conn net.Conn, timeout time.Duration) error {
+func SetTCPUserTimeout(net.Conn, time.Duration) error {
log()
return nil
}
// GetTCPUserTimeout is a no-op function under non-linux environments.
// A negative return value indicates the operation is not supported
-func GetTCPUserTimeout(conn net.Conn) (int, error) {
+func GetTCPUserTimeout(net.Conn) (int, error) {
log()
return -1, nil
}
diff --git a/vendor/google.golang.org/grpc/internal/tcp_keepalive_unix.go b/vendor/google.golang.org/grpc/internal/tcp_keepalive_unix.go
index 078137b7fd..7e7aaa5463 100644
--- a/vendor/google.golang.org/grpc/internal/tcp_keepalive_unix.go
+++ b/vendor/google.golang.org/grpc/internal/tcp_keepalive_unix.go
@@ -44,7 +44,7 @@ func NetDialerWithTCPKeepalive() *net.Dialer {
// combination of unconditionally enabling TCP keepalives here, and
// disabling the overriding of TCP keepalive parameters by setting the
// KeepAlive field to a negative value above, results in OS defaults for
- // the TCP keealive interval and time parameters.
+ // the TCP keepalive interval and time parameters.
Control: func(_, _ string, c syscall.RawConn) error {
return c.Control(func(fd uintptr) {
unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_KEEPALIVE, 1)
diff --git a/vendor/google.golang.org/grpc/internal/tcp_keepalive_windows.go b/vendor/google.golang.org/grpc/internal/tcp_keepalive_windows.go
index fd7d43a890..d5c1085eea 100644
--- a/vendor/google.golang.org/grpc/internal/tcp_keepalive_windows.go
+++ b/vendor/google.golang.org/grpc/internal/tcp_keepalive_windows.go
@@ -44,7 +44,7 @@ func NetDialerWithTCPKeepalive() *net.Dialer {
// combination of unconditionally enabling TCP keepalives here, and
// disabling the overriding of TCP keepalive parameters by setting the
// KeepAlive field to a negative value above, results in OS defaults for
- // the TCP keealive interval and time parameters.
+ // the TCP keepalive interval and time parameters.
Control: func(_, _ string, c syscall.RawConn) error {
return c.Control(func(fd uintptr) {
windows.SetsockoptInt(windows.Handle(fd), windows.SOL_SOCKET, windows.SO_KEEPALIVE, 1)
diff --git a/vendor/google.golang.org/grpc/internal/transport/controlbuf.go b/vendor/google.golang.org/grpc/internal/transport/controlbuf.go
index 3deadfb4a2..ef72fbb3a0 100644
--- a/vendor/google.golang.org/grpc/internal/transport/controlbuf.go
+++ b/vendor/google.golang.org/grpc/internal/transport/controlbuf.go
@@ -32,6 +32,7 @@ import (
"golang.org/x/net/http2/hpack"
"google.golang.org/grpc/internal/grpclog"
"google.golang.org/grpc/internal/grpcutil"
+ "google.golang.org/grpc/mem"
"google.golang.org/grpc/status"
)
@@ -148,9 +149,9 @@ type dataFrame struct {
streamID uint32
endStream bool
h []byte
- d []byte
+ reader mem.Reader
// onEachWrite is called every time
- // a part of d is written out.
+ // a part of data is written out.
onEachWrite func()
}
@@ -289,18 +290,22 @@ func (l *outStreamList) dequeue() *outStream {
}
// controlBuffer is a way to pass information to loopy.
-// Information is passed as specific struct types called control frames.
-// A control frame not only represents data, messages or headers to be sent out
-// but can also be used to instruct loopy to update its internal state.
-// It shouldn't be confused with an HTTP2 frame, although some of the control frames
-// like dataFrame and headerFrame do go out on wire as HTTP2 frames.
+//
+// Information is passed as specific struct types called control frames. A
+// control frame not only represents data, messages or headers to be sent out
+// but can also be used to instruct loopy to update its internal state. It
+// shouldn't be confused with an HTTP2 frame, although some of the control
+// frames like dataFrame and headerFrame do go out on wire as HTTP2 frames.
type controlBuffer struct {
- ch chan struct{}
- done <-chan struct{}
+ wakeupCh chan struct{} // Unblocks readers waiting for something to read.
+ done <-chan struct{} // Closed when the transport is done.
+
+ // Mutex guards all the fields below, except trfChan which can be read
+ // atomically without holding mu.
mu sync.Mutex
- consumerWaiting bool
- list *itemList
- err error
+ consumerWaiting bool // True when readers are blocked waiting for new data.
+ closed bool // True when the controlbuf is finished.
+ list *itemList // List of queued control frames.
// transportResponseFrames counts the number of queued items that represent
// the response of an action initiated by the peer. trfChan is created
@@ -308,47 +313,59 @@ type controlBuffer struct {
// closed and nilled when transportResponseFrames drops below the
// threshold. Both fields are protected by mu.
transportResponseFrames int
- trfChan atomic.Value // chan struct{}
+ trfChan atomic.Pointer[chan struct{}]
}
func newControlBuffer(done <-chan struct{}) *controlBuffer {
return &controlBuffer{
- ch: make(chan struct{}, 1),
- list: &itemList{},
- done: done,
+ wakeupCh: make(chan struct{}, 1),
+ list: &itemList{},
+ done: done,
}
}
-// throttle blocks if there are too many incomingSettings/cleanupStreams in the
-// controlbuf.
+// throttle blocks if there are too many frames in the control buf that
+// represent the response of an action initiated by the peer, like
+// incomingSettings cleanupStreams etc.
func (c *controlBuffer) throttle() {
- ch, _ := c.trfChan.Load().(chan struct{})
- if ch != nil {
+ if ch := c.trfChan.Load(); ch != nil {
select {
- case <-ch:
+ case <-(*ch):
case <-c.done:
}
}
}
+// put adds an item to the controlbuf.
func (c *controlBuffer) put(it cbItem) error {
_, err := c.executeAndPut(nil, it)
return err
}
+// executeAndPut runs f, and if the return value is true, adds the given item to
+// the controlbuf. The item could be nil, in which case, this method simply
+// executes f and does not add the item to the controlbuf.
+//
+// The first return value indicates whether the item was successfully added to
+// the control buffer. A non-nil error, specifically ErrConnClosing, is returned
+// if the control buffer is already closed.
func (c *controlBuffer) executeAndPut(f func() bool, it cbItem) (bool, error) {
- var wakeUp bool
c.mu.Lock()
- if c.err != nil {
- c.mu.Unlock()
- return false, c.err
+ defer c.mu.Unlock()
+
+ if c.closed {
+ return false, ErrConnClosing
}
if f != nil {
if !f() { // f wasn't successful
- c.mu.Unlock()
return false, nil
}
}
+ if it == nil {
+ return true, nil
+ }
+
+ var wakeUp bool
if c.consumerWaiting {
wakeUp = true
c.consumerWaiting = false
@@ -359,98 +376,102 @@ func (c *controlBuffer) executeAndPut(f func() bool, it cbItem) (bool, error) {
if c.transportResponseFrames == maxQueuedTransportResponseFrames {
// We are adding the frame that puts us over the threshold; create
// a throttling channel.
- c.trfChan.Store(make(chan struct{}))
+ ch := make(chan struct{})
+ c.trfChan.Store(&ch)
}
}
- c.mu.Unlock()
if wakeUp {
select {
- case c.ch <- struct{}{}:
+ case c.wakeupCh <- struct{}{}:
default:
}
}
return true, nil
}
-// Note argument f should never be nil.
-func (c *controlBuffer) execute(f func(it any) bool, it any) (bool, error) {
- c.mu.Lock()
- if c.err != nil {
- c.mu.Unlock()
- return false, c.err
- }
- if !f(it) { // f wasn't successful
- c.mu.Unlock()
- return false, nil
- }
- c.mu.Unlock()
- return true, nil
-}
-
+// get returns the next control frame from the control buffer. If block is true
+// **and** there are no control frames in the control buffer, the call blocks
+// until one of the conditions is met: there is a frame to return or the
+// transport is closed.
func (c *controlBuffer) get(block bool) (any, error) {
for {
c.mu.Lock()
- if c.err != nil {
+ frame, err := c.getOnceLocked()
+ if frame != nil || err != nil || !block {
+ // If we read a frame or an error, we can return to the caller. The
+ // call to getOnceLocked() returns a nil frame and a nil error if
+ // there is nothing to read, and in that case, if the caller asked
+ // us not to block, we can return now as well.
c.mu.Unlock()
- return nil, c.err
- }
- if !c.list.isEmpty() {
- h := c.list.dequeue().(cbItem)
- if h.isTransportResponseFrame() {
- if c.transportResponseFrames == maxQueuedTransportResponseFrames {
- // We are removing the frame that put us over the
- // threshold; close and clear the throttling channel.
- ch := c.trfChan.Load().(chan struct{})
- close(ch)
- c.trfChan.Store((chan struct{})(nil))
- }
- c.transportResponseFrames--
- }
- c.mu.Unlock()
- return h, nil
- }
- if !block {
- c.mu.Unlock()
- return nil, nil
+ return frame, err
}
c.consumerWaiting = true
c.mu.Unlock()
+
+ // Release the lock above and wait to be woken up.
select {
- case <-c.ch:
+ case <-c.wakeupCh:
case <-c.done:
return nil, errors.New("transport closed by client")
}
}
}
+// Callers must not use this method, but should instead use get().
+//
+// Caller must hold c.mu.
+func (c *controlBuffer) getOnceLocked() (any, error) {
+ if c.closed {
+ return false, ErrConnClosing
+ }
+ if c.list.isEmpty() {
+ return nil, nil
+ }
+ h := c.list.dequeue().(cbItem)
+ if h.isTransportResponseFrame() {
+ if c.transportResponseFrames == maxQueuedTransportResponseFrames {
+ // We are removing the frame that put us over the
+ // threshold; close and clear the throttling channel.
+ ch := c.trfChan.Swap(nil)
+ close(*ch)
+ }
+ c.transportResponseFrames--
+ }
+ return h, nil
+}
+
+// finish closes the control buffer, cleaning up any streams that have queued
+// header frames. Once this method returns, no more frames can be added to the
+// control buffer, and attempts to do so will return ErrConnClosing.
func (c *controlBuffer) finish() {
c.mu.Lock()
- if c.err != nil {
- c.mu.Unlock()
+ defer c.mu.Unlock()
+
+ if c.closed {
return
}
- c.err = ErrConnClosing
+ c.closed = true
// There may be headers for streams in the control buffer.
// These streams need to be cleaned out since the transport
// is still not aware of these yet.
for head := c.list.dequeueAll(); head != nil; head = head.next {
- hdr, ok := head.it.(*headerFrame)
- if !ok {
- continue
- }
- if hdr.onOrphaned != nil { // It will be nil on the server-side.
- hdr.onOrphaned(ErrConnClosing)
+ switch v := head.it.(type) {
+ case *headerFrame:
+ if v.onOrphaned != nil { // It will be nil on the server-side.
+ v.onOrphaned(ErrConnClosing)
+ }
+ case *dataFrame:
+ _ = v.reader.Close()
}
}
+
// In case throttle() is currently in flight, it needs to be unblocked.
// Otherwise, the transport may not close, since the transport is closed by
// the reader encountering the connection error.
- ch, _ := c.trfChan.Load().(chan struct{})
+ ch := c.trfChan.Swap(nil)
if ch != nil {
- close(ch)
+ close(*ch)
}
- c.trfChan.Store((chan struct{})(nil))
- c.mu.Unlock()
}
type side int
@@ -466,7 +487,7 @@ const (
// stream maintains a queue of data frames; as loopy receives data frames
// it gets added to the queue of the relevant stream.
// Loopy goes over this list of active streams by processing one node every iteration,
-// thereby closely resemebling to a round-robin scheduling over all streams. While
+// thereby closely resembling a round-robin scheduling over all streams. While
// processing a stream, loopy writes out data bytes from this stream capped by the min
// of http2MaxFrameLen, connection-level flow control and stream-level flow control.
type loopyWriter struct {
@@ -490,12 +511,13 @@ type loopyWriter struct {
draining bool
conn net.Conn
logger *grpclog.PrefixLogger
+ bufferPool mem.BufferPool
// Side-specific handlers
ssGoAwayHandler func(*goAway) (bool, error)
}
-func newLoopyWriter(s side, fr *framer, cbuf *controlBuffer, bdpEst *bdpEstimator, conn net.Conn, logger *grpclog.PrefixLogger, goAwayHandler func(*goAway) (bool, error)) *loopyWriter {
+func newLoopyWriter(s side, fr *framer, cbuf *controlBuffer, bdpEst *bdpEstimator, conn net.Conn, logger *grpclog.PrefixLogger, goAwayHandler func(*goAway) (bool, error), bufferPool mem.BufferPool) *loopyWriter {
var buf bytes.Buffer
l := &loopyWriter{
side: s,
@@ -511,6 +533,7 @@ func newLoopyWriter(s side, fr *framer, cbuf *controlBuffer, bdpEst *bdpEstimato
conn: conn,
logger: logger,
ssGoAwayHandler: goAwayHandler,
+ bufferPool: bufferPool,
}
return l
}
@@ -768,6 +791,11 @@ func (l *loopyWriter) cleanupStreamHandler(c *cleanupStream) error {
// not be established yet.
delete(l.estdStreams, c.streamID)
str.deleteSelf()
+ for head := str.itl.dequeueAll(); head != nil; head = head.next {
+ if df, ok := head.it.(*dataFrame); ok {
+ _ = df.reader.Close()
+ }
+ }
}
if c.rst { // If RST_STREAM needs to be sent.
if err := l.framer.fr.WriteRSTStream(c.streamID, c.rstCode); err != nil {
@@ -903,16 +931,18 @@ func (l *loopyWriter) processData() (bool, error) {
dataItem := str.itl.peek().(*dataFrame) // Peek at the first data item this stream.
// A data item is represented by a dataFrame, since it later translates into
// multiple HTTP2 data frames.
- // Every dataFrame has two buffers; h that keeps grpc-message header and d that is actual data.
- // As an optimization to keep wire traffic low, data from d is copied to h to make as big as the
- // maximum possible HTTP2 frame size.
+ // Every dataFrame has two buffers; h that keeps grpc-message header and data
+ // that is the actual message. As an optimization to keep wire traffic low, data
+ // from data is copied to h to make as big as the maximum possible HTTP2 frame
+ // size.
- if len(dataItem.h) == 0 && len(dataItem.d) == 0 { // Empty data frame
+ if len(dataItem.h) == 0 && dataItem.reader.Remaining() == 0 { // Empty data frame
// Client sends out empty data frame with endStream = true
if err := l.framer.fr.WriteData(dataItem.streamID, dataItem.endStream, nil); err != nil {
return false, err
}
str.itl.dequeue() // remove the empty data item from stream
+ _ = dataItem.reader.Close()
if str.itl.isEmpty() {
str.state = empty
} else if trailer, ok := str.itl.peek().(*headerFrame); ok { // the next item is trailers.
@@ -927,9 +957,7 @@ func (l *loopyWriter) processData() (bool, error) {
}
return false, nil
}
- var (
- buf []byte
- )
+
// Figure out the maximum size we can send
maxSize := http2MaxFrameLen
if strQuota := int(l.oiws) - str.bytesOutStanding; strQuota <= 0 { // stream-level flow control.
@@ -943,43 +971,50 @@ func (l *loopyWriter) processData() (bool, error) {
}
// Compute how much of the header and data we can send within quota and max frame length
hSize := min(maxSize, len(dataItem.h))
- dSize := min(maxSize-hSize, len(dataItem.d))
- if hSize != 0 {
- if dSize == 0 {
- buf = dataItem.h
- } else {
- // We can add some data to grpc message header to distribute bytes more equally across frames.
- // Copy on the stack to avoid generating garbage
- var localBuf [http2MaxFrameLen]byte
- copy(localBuf[:hSize], dataItem.h)
- copy(localBuf[hSize:], dataItem.d[:dSize])
- buf = localBuf[:hSize+dSize]
- }
+ dSize := min(maxSize-hSize, dataItem.reader.Remaining())
+ remainingBytes := len(dataItem.h) + dataItem.reader.Remaining() - hSize - dSize
+ size := hSize + dSize
+
+ var buf *[]byte
+
+ if hSize != 0 && dSize == 0 {
+ buf = &dataItem.h
} else {
- buf = dataItem.d
- }
+ // Note: this is only necessary because the http2.Framer does not support
+ // partially writing a frame, so the sequence must be materialized into a buffer.
+ // TODO: Revisit once https://github.com/golang/go/issues/66655 is addressed.
+ pool := l.bufferPool
+ if pool == nil {
+ // Note that this is only supposed to be nil in tests. Otherwise, stream is
+ // always initialized with a BufferPool.
+ pool = mem.DefaultBufferPool()
+ }
+ buf = pool.Get(size)
+ defer pool.Put(buf)
- size := hSize + dSize
+ copy((*buf)[:hSize], dataItem.h)
+ _, _ = dataItem.reader.Read((*buf)[hSize:])
+ }
// Now that outgoing flow controls are checked we can replenish str's write quota
str.wq.replenish(size)
var endStream bool
// If this is the last data message on this stream and all of it can be written in this iteration.
- if dataItem.endStream && len(dataItem.h)+len(dataItem.d) <= size {
+ if dataItem.endStream && remainingBytes == 0 {
endStream = true
}
if dataItem.onEachWrite != nil {
dataItem.onEachWrite()
}
- if err := l.framer.fr.WriteData(dataItem.streamID, endStream, buf[:size]); err != nil {
+ if err := l.framer.fr.WriteData(dataItem.streamID, endStream, (*buf)[:size]); err != nil {
return false, err
}
str.bytesOutStanding += size
l.sendQuota -= uint32(size)
dataItem.h = dataItem.h[hSize:]
- dataItem.d = dataItem.d[dSize:]
- if len(dataItem.h) == 0 && len(dataItem.d) == 0 { // All the data from that message was written out.
+ if remainingBytes == 0 { // All the data from that message was written out.
+ _ = dataItem.reader.Close()
str.itl.dequeue()
}
if str.itl.isEmpty() {
@@ -998,10 +1033,3 @@ func (l *loopyWriter) processData() (bool, error) {
}
return false, nil
}
-
-func min(a, b int) int {
- if a < b {
- return a
- }
- return b
-}
diff --git a/vendor/google.golang.org/grpc/internal/transport/handler_server.go b/vendor/google.golang.org/grpc/internal/transport/handler_server.go
index 4a3ddce29a..ce878693bd 100644
--- a/vendor/google.golang.org/grpc/internal/transport/handler_server.go
+++ b/vendor/google.golang.org/grpc/internal/transport/handler_server.go
@@ -24,7 +24,6 @@
package transport
import (
- "bytes"
"context"
"errors"
"fmt"
@@ -40,6 +39,7 @@ import (
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/internal/grpclog"
"google.golang.org/grpc/internal/grpcutil"
+ "google.golang.org/grpc/mem"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/peer"
"google.golang.org/grpc/stats"
@@ -50,7 +50,7 @@ import (
// NewServerHandlerTransport returns a ServerTransport handling gRPC from
// inside an http.Handler, or writes an HTTP error to w and returns an error.
// It requires that the http Server supports HTTP/2.
-func NewServerHandlerTransport(w http.ResponseWriter, r *http.Request, stats []stats.Handler) (ServerTransport, error) {
+func NewServerHandlerTransport(w http.ResponseWriter, r *http.Request, stats []stats.Handler, bufferPool mem.BufferPool) (ServerTransport, error) {
if r.Method != http.MethodPost {
w.Header().Set("Allow", http.MethodPost)
msg := fmt.Sprintf("invalid gRPC request method %q", r.Method)
@@ -98,6 +98,7 @@ func NewServerHandlerTransport(w http.ResponseWriter, r *http.Request, stats []s
contentType: contentType,
contentSubtype: contentSubtype,
stats: stats,
+ bufferPool: bufferPool,
}
st.logger = prefixLoggerForServerHandlerTransport(st)
@@ -171,6 +172,8 @@ type serverHandlerTransport struct {
stats []stats.Handler
logger *grpclog.PrefixLogger
+
+ bufferPool mem.BufferPool
}
func (ht *serverHandlerTransport) Close(err error) {
@@ -244,6 +247,7 @@ func (ht *serverHandlerTransport) WriteStatus(s *Stream, st *status.Status) erro
}
s.hdrMu.Lock()
+ defer s.hdrMu.Unlock()
if p := st.Proto(); p != nil && len(p.Details) > 0 {
delete(s.trailer, grpcStatusDetailsBinHeader)
stBytes, err := proto.Marshal(p)
@@ -268,7 +272,6 @@ func (ht *serverHandlerTransport) WriteStatus(s *Stream, st *status.Status) erro
}
}
}
- s.hdrMu.Unlock()
})
if err == nil { // transport has not been closed
@@ -330,16 +333,28 @@ func (ht *serverHandlerTransport) writeCustomHeaders(s *Stream) {
s.hdrMu.Unlock()
}
-func (ht *serverHandlerTransport) Write(s *Stream, hdr []byte, data []byte, opts *Options) error {
+func (ht *serverHandlerTransport) Write(s *Stream, hdr []byte, data mem.BufferSlice, _ *Options) error {
+ // Always take a reference because otherwise there is no guarantee the data will
+ // be available after this function returns. This is what callers to Write
+ // expect.
+ data.Ref()
headersWritten := s.updateHeaderSent()
- return ht.do(func() {
+ err := ht.do(func() {
+ defer data.Free()
if !headersWritten {
ht.writePendingHeaders(s)
}
ht.rw.Write(hdr)
- ht.rw.Write(data)
+ for _, b := range data {
+ _, _ = ht.rw.Write(b.ReadOnlyData())
+ }
ht.rw.(http.Flusher).Flush()
})
+ if err != nil {
+ data.Free()
+ return err
+ }
+ return nil
}
func (ht *serverHandlerTransport) WriteHeader(s *Stream, md metadata.MD) error {
@@ -406,7 +421,7 @@ func (ht *serverHandlerTransport) HandleStreams(ctx context.Context, startStream
headerWireLength: 0, // won't have access to header wire length until golang/go#18997.
}
s.trReader = &transportReader{
- reader: &recvBufferReader{ctx: s.ctx, ctxDone: s.ctx.Done(), recv: s.buf, freeBuffer: func(*bytes.Buffer) {}},
+ reader: &recvBufferReader{ctx: s.ctx, ctxDone: s.ctx.Done(), recv: s.buf},
windowHandler: func(int) {},
}
@@ -415,21 +430,19 @@ func (ht *serverHandlerTransport) HandleStreams(ctx context.Context, startStream
go func() {
defer close(readerDone)
- // TODO: minimize garbage, optimize recvBuffer code/ownership
- const readSize = 8196
- for buf := make([]byte, readSize); ; {
- n, err := req.Body.Read(buf)
+ for {
+ buf := ht.bufferPool.Get(http2MaxFrameLen)
+ n, err := req.Body.Read(*buf)
if n > 0 {
- s.buf.put(recvMsg{buffer: bytes.NewBuffer(buf[:n:n])})
- buf = buf[n:]
+ *buf = (*buf)[:n]
+ s.buf.put(recvMsg{buffer: mem.NewBuffer(buf, ht.bufferPool)})
+ } else {
+ ht.bufferPool.Put(buf)
}
if err != nil {
s.buf.put(recvMsg{err: mapRecvMsgError(err)})
return
}
- if len(buf) == 0 {
- buf = make([]byte, readSize)
- }
}
}()
@@ -462,7 +475,7 @@ func (ht *serverHandlerTransport) IncrMsgSent() {}
func (ht *serverHandlerTransport) IncrMsgRecv() {}
-func (ht *serverHandlerTransport) Drain(debugData string) {
+func (ht *serverHandlerTransport) Drain(string) {
panic("Drain() is not implemented")
}
diff --git a/vendor/google.golang.org/grpc/internal/transport/http2_client.go b/vendor/google.golang.org/grpc/internal/transport/http2_client.go
index 3c63c70698..62b81885d8 100644
--- a/vendor/google.golang.org/grpc/internal/transport/http2_client.go
+++ b/vendor/google.golang.org/grpc/internal/transport/http2_client.go
@@ -47,6 +47,7 @@ import (
isyscall "google.golang.org/grpc/internal/syscall"
"google.golang.org/grpc/internal/transport/networktype"
"google.golang.org/grpc/keepalive"
+ "google.golang.org/grpc/mem"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/peer"
"google.golang.org/grpc/resolver"
@@ -59,6 +60,8 @@ import (
// atomically.
var clientConnectionCounter uint64
+var goAwayLoopyWriterTimeout = 5 * time.Second
+
var metadataFromOutgoingContextRaw = internal.FromOutgoingContextRaw.(func(context.Context) (metadata.MD, [][]string, bool))
// http2Client implements the ClientTransport interface with HTTP2.
@@ -83,9 +86,9 @@ type http2Client struct {
writerDone chan struct{} // sync point to enable testing.
// goAway is closed to notify the upper layer (i.e., addrConn.transportMonitor)
// that the server sent GoAway on this transport.
- goAway chan struct{}
-
- framer *framer
+ goAway chan struct{}
+ keepaliveDone chan struct{} // Closed when the keepalive goroutine exits.
+ framer *framer
// controlBuf delivers all the control related tasks (e.g., window
// updates, reset streams, and various settings) to the controller.
// Do not access controlBuf with mu held.
@@ -144,7 +147,7 @@ type http2Client struct {
onClose func(GoAwayReason)
- bufferPool *bufferPool
+ bufferPool mem.BufferPool
connectionID uint64
logger *grpclog.PrefixLogger
@@ -229,7 +232,7 @@ func newHTTP2Client(connectCtx, ctx context.Context, addr resolver.Address, opts
}
}(conn)
- // The following defer and goroutine monitor the connectCtx for cancelation
+ // The following defer and goroutine monitor the connectCtx for cancellation
// and deadline. On context expiration, the connection is hard closed and
// this function will naturally fail as a result. Otherwise, the defer
// waits for the goroutine to exit to prevent the context from being
@@ -332,6 +335,7 @@ func newHTTP2Client(connectCtx, ctx context.Context, addr resolver.Address, opts
readerDone: make(chan struct{}),
writerDone: make(chan struct{}),
goAway: make(chan struct{}),
+ keepaliveDone: make(chan struct{}),
framer: newFramer(conn, writeBufSize, readBufSize, opts.SharedWriteBuffer, maxHeaderListSize),
fc: &trInFlow{limit: uint32(icwz)},
scheme: scheme,
@@ -346,7 +350,7 @@ func newHTTP2Client(connectCtx, ctx context.Context, addr resolver.Address, opts
streamQuota: defaultMaxStreamsClient,
streamsQuotaAvailable: make(chan struct{}, 1),
keepaliveEnabled: keepaliveEnabled,
- bufferPool: newBufferPool(),
+ bufferPool: opts.BufferPool,
onClose: onClose,
}
var czSecurity credentials.ChannelzSecurityValue
@@ -463,7 +467,7 @@ func newHTTP2Client(connectCtx, ctx context.Context, addr resolver.Address, opts
return nil, err
}
go func() {
- t.loopy = newLoopyWriter(clientSide, t.framer, t.controlBuf, t.bdpEst, t.conn, t.logger, t.outgoingGoAwayHandler)
+ t.loopy = newLoopyWriter(clientSide, t.framer, t.controlBuf, t.bdpEst, t.conn, t.logger, t.outgoingGoAwayHandler, t.bufferPool)
if err := t.loopy.run(); !isIOError(err) {
// Immediately close the connection, as the loopy writer returns
// when there are no more active streams and we were draining (the
@@ -504,7 +508,6 @@ func (t *http2Client) newStream(ctx context.Context, callHdr *CallHdr) *Stream {
closeStream: func(err error) {
t.CloseStream(s, err)
},
- freeBuffer: t.bufferPool.put,
},
windowHandler: func(n int) {
t.updateWindow(s, uint32(n))
@@ -525,8 +528,9 @@ func (t *http2Client) getPeer() *peer.Peer {
// to be the last frame loopy writes to the transport.
func (t *http2Client) outgoingGoAwayHandler(g *goAway) (bool, error) {
t.mu.Lock()
- defer t.mu.Unlock()
- if err := t.framer.fr.WriteGoAway(t.nextID-2, http2.ErrCodeNo, g.debugData); err != nil {
+ maxStreamID := t.nextID - 2
+ t.mu.Unlock()
+ if err := t.framer.fr.WriteGoAway(maxStreamID, http2.ErrCodeNo, g.debugData); err != nil {
return false, err
}
return false, g.closeConn
@@ -770,7 +774,7 @@ func (t *http2Client) NewStream(ctx context.Context, callHdr *CallHdr) (*Stream,
hdr := &headerFrame{
hf: headerFields,
endStream: false,
- initStream: func(id uint32) error {
+ initStream: func(uint32) error {
t.mu.Lock()
// TODO: handle transport closure in loopy instead and remove this
// initStream is never called when transport is draining.
@@ -983,6 +987,7 @@ func (t *http2Client) closeStream(s *Stream, err error, rst bool, rstCode http2.
// only once on a transport. Once it is called, the transport should not be
// accessed anymore.
func (t *http2Client) Close(err error) {
+ t.conn.SetWriteDeadline(time.Now().Add(time.Second * 10))
t.mu.Lock()
// Make sure we only close once.
if t.state == closing {
@@ -1005,18 +1010,33 @@ func (t *http2Client) Close(err error) {
// should unblock it so that the goroutine eventually exits.
t.kpDormancyCond.Signal()
}
+ // Append info about previous goaways if there were any, since this may be important
+ // for understanding the root cause for this connection to be closed.
+ goAwayDebugMessage := t.goAwayDebugMessage
t.mu.Unlock()
+
// Per HTTP/2 spec, a GOAWAY frame must be sent before closing the
- // connection. See https://httpwg.org/specs/rfc7540.html#GOAWAY.
+ // connection. See https://httpwg.org/specs/rfc7540.html#GOAWAY. It
+ // also waits for loopyWriter to be closed with a timer to avoid the
+ // long blocking in case the connection is blackholed, i.e. TCP is
+ // just stuck.
t.controlBuf.put(&goAway{code: http2.ErrCodeNo, debugData: []byte("client transport shutdown"), closeConn: err})
- <-t.writerDone
+ timer := time.NewTimer(goAwayLoopyWriterTimeout)
+ defer timer.Stop()
+ select {
+ case <-t.writerDone: // success
+ case <-timer.C:
+ t.logger.Infof("Failed to write a GOAWAY frame as part of connection close after %s. Giving up and closing the transport.", goAwayLoopyWriterTimeout)
+ }
t.cancel()
t.conn.Close()
+ // Waits for the reader and keepalive goroutines to exit before returning to
+ // ensure all resources are cleaned up before Close can return.
+ <-t.readerDone
+ if t.keepaliveEnabled {
+ <-t.keepaliveDone
+ }
channelz.RemoveEntry(t.channelz.ID)
- // Append info about previous goaways if there were any, since this may be important
- // for understanding the root cause for this connection to be closed.
- _, goAwayDebugMessage := t.GetGoAwayReason()
-
var st *status.Status
if len(goAwayDebugMessage) > 0 {
st = status.Newf(codes.Unavailable, "closing transport due to: %v, received prior goaway: %v", err, goAwayDebugMessage)
@@ -1065,27 +1085,36 @@ func (t *http2Client) GracefulClose() {
// Write formats the data into HTTP2 data frame(s) and sends it out. The caller
// should proceed only if Write returns nil.
-func (t *http2Client) Write(s *Stream, hdr []byte, data []byte, opts *Options) error {
+func (t *http2Client) Write(s *Stream, hdr []byte, data mem.BufferSlice, opts *Options) error {
+ reader := data.Reader()
+
if opts.Last {
// If it's the last message, update stream state.
if !s.compareAndSwapState(streamActive, streamWriteDone) {
+ _ = reader.Close()
return errStreamDone
}
} else if s.getState() != streamActive {
+ _ = reader.Close()
return errStreamDone
}
df := &dataFrame{
streamID: s.id,
endStream: opts.Last,
h: hdr,
- d: data,
+ reader: reader,
}
- if hdr != nil || data != nil { // If it's not an empty data frame, check quota.
- if err := s.wq.get(int32(len(hdr) + len(data))); err != nil {
+ if hdr != nil || df.reader.Remaining() != 0 { // If it's not an empty data frame, check quota.
+ if err := s.wq.get(int32(len(hdr) + df.reader.Remaining())); err != nil {
+ _ = reader.Close()
return err
}
}
- return t.controlBuf.put(df)
+ if err := t.controlBuf.put(df); err != nil {
+ _ = reader.Close()
+ return err
+ }
+ return nil
}
func (t *http2Client) getStream(f http2.Frame) *Stream {
@@ -1190,10 +1219,13 @@ func (t *http2Client) handleData(f *http2.DataFrame) {
// guarantee f.Data() is consumed before the arrival of next frame.
// Can this copy be eliminated?
if len(f.Data()) > 0 {
- buffer := t.bufferPool.get()
- buffer.Reset()
- buffer.Write(f.Data())
- s.write(recvMsg{buffer: buffer})
+ pool := t.bufferPool
+ if pool == nil {
+ // Note that this is only supposed to be nil in tests. Otherwise, stream is
+ // always initialized with a BufferPool.
+ pool = mem.DefaultBufferPool()
+ }
+ s.write(recvMsg{buffer: mem.Copy(f.Data(), pool)})
}
}
// The server has closed the stream without sending trailers. Record that
@@ -1222,7 +1254,7 @@ func (t *http2Client) handleRSTStream(f *http2.RSTStreamFrame) {
if statusCode == codes.Canceled {
if d, ok := s.ctx.Deadline(); ok && !d.After(time.Now()) {
// Our deadline was already exceeded, and that was likely the cause
- // of this cancelation. Alter the status code accordingly.
+ // of this cancellation. Alter the status code accordingly.
statusCode = codes.DeadlineExceeded
}
}
@@ -1291,11 +1323,11 @@ func (t *http2Client) handlePing(f *http2.PingFrame) {
t.controlBuf.put(pingAck)
}
-func (t *http2Client) handleGoAway(f *http2.GoAwayFrame) {
+func (t *http2Client) handleGoAway(f *http2.GoAwayFrame) error {
t.mu.Lock()
if t.state == closing {
t.mu.Unlock()
- return
+ return nil
}
if f.ErrCode == http2.ErrCodeEnhanceYourCalm && string(f.DebugData()) == "too_many_pings" {
// When a client receives a GOAWAY with error code ENHANCE_YOUR_CALM and debug
@@ -1307,8 +1339,7 @@ func (t *http2Client) handleGoAway(f *http2.GoAwayFrame) {
id := f.LastStreamID
if id > 0 && id%2 == 0 {
t.mu.Unlock()
- t.Close(connectionErrorf(true, nil, "received goaway with non-zero even-numbered numbered stream id: %v", id))
- return
+ return connectionErrorf(true, nil, "received goaway with non-zero even-numbered stream id: %v", id)
}
// A client can receive multiple GoAways from the server (see
// https://github.com/grpc/grpc-go/issues/1387). The idea is that the first
@@ -1325,8 +1356,7 @@ func (t *http2Client) handleGoAway(f *http2.GoAwayFrame) {
// If there are multiple GoAways the first one should always have an ID greater than the following ones.
if id > t.prevGoAwayID {
t.mu.Unlock()
- t.Close(connectionErrorf(true, nil, "received goaway with stream id: %v, which exceeds stream id of previous goaway: %v", id, t.prevGoAwayID))
- return
+ return connectionErrorf(true, nil, "received goaway with stream id: %v, which exceeds stream id of previous goaway: %v", id, t.prevGoAwayID)
}
default:
t.setGoAwayReason(f)
@@ -1350,8 +1380,7 @@ func (t *http2Client) handleGoAway(f *http2.GoAwayFrame) {
t.prevGoAwayID = id
if len(t.activeStreams) == 0 {
t.mu.Unlock()
- t.Close(connectionErrorf(true, nil, "received goaway and there are no active streams"))
- return
+ return connectionErrorf(true, nil, "received goaway and there are no active streams")
}
streamsToClose := make([]*Stream, 0)
@@ -1368,6 +1397,7 @@ func (t *http2Client) handleGoAway(f *http2.GoAwayFrame) {
for _, stream := range streamsToClose {
t.closeStream(stream, errStreamDrain, false, http2.ErrCodeNo, statusGoAway, nil, false)
}
+ return nil
}
// setGoAwayReason sets the value of t.goAwayReason based
@@ -1603,7 +1633,13 @@ func (t *http2Client) readServerPreface() error {
// network connection. If the server preface is not read successfully, an
// error is pushed to errCh; otherwise errCh is closed with no error.
func (t *http2Client) reader(errCh chan<- error) {
- defer close(t.readerDone)
+ var errClose error
+ defer func() {
+ close(t.readerDone)
+ if errClose != nil {
+ t.Close(errClose)
+ }
+ }()
if err := t.readServerPreface(); err != nil {
errCh <- err
@@ -1642,11 +1678,10 @@ func (t *http2Client) reader(errCh chan<- error) {
t.closeStream(s, status.Error(code, msg), true, http2.ErrCodeProtocol, status.New(code, msg), nil, false)
}
continue
- } else {
- // Transport error.
- t.Close(connectionErrorf(true, err, "error reading from server: %v", err))
- return
}
+ // Transport error.
+ errClose = connectionErrorf(true, err, "error reading from server: %v", err)
+ return
}
switch frame := frame.(type) {
case *http2.MetaHeadersFrame:
@@ -1660,7 +1695,7 @@ func (t *http2Client) reader(errCh chan<- error) {
case *http2.PingFrame:
t.handlePing(frame)
case *http2.GoAwayFrame:
- t.handleGoAway(frame)
+ errClose = t.handleGoAway(frame)
case *http2.WindowUpdateFrame:
t.handleWindowUpdate(frame)
default:
@@ -1671,15 +1706,15 @@ func (t *http2Client) reader(errCh chan<- error) {
}
}
-func minTime(a, b time.Duration) time.Duration {
- if a < b {
- return a
- }
- return b
-}
-
// keepalive running in a separate goroutine makes sure the connection is alive by sending pings.
func (t *http2Client) keepalive() {
+ var err error
+ defer func() {
+ close(t.keepaliveDone)
+ if err != nil {
+ t.Close(err)
+ }
+ }()
p := &ping{data: [8]byte{}}
// True iff a ping has been sent, and no data has been received since then.
outstandingPing := false
@@ -1703,7 +1738,7 @@ func (t *http2Client) keepalive() {
continue
}
if outstandingPing && timeoutLeft <= 0 {
- t.Close(connectionErrorf(true, nil, "keepalive ping failed to receive ACK within timeout"))
+ err = connectionErrorf(true, nil, "keepalive ping failed to receive ACK within timeout")
return
}
t.mu.Lock()
@@ -1745,7 +1780,7 @@ func (t *http2Client) keepalive() {
// timeoutLeft. This will ensure that we wait only for kp.Time
// before sending out the next ping (for cases where the ping is
// acked).
- sleepDuration := minTime(t.kp.Time, timeoutLeft)
+ sleepDuration := min(t.kp.Time, timeoutLeft)
timeoutLeft -= sleepDuration
timer.Reset(sleepDuration)
case <-t.ctx.Done():
diff --git a/vendor/google.golang.org/grpc/internal/transport/http2_server.go b/vendor/google.golang.org/grpc/internal/transport/http2_server.go
index cab0e2d3d4..584b50fe55 100644
--- a/vendor/google.golang.org/grpc/internal/transport/http2_server.go
+++ b/vendor/google.golang.org/grpc/internal/transport/http2_server.go
@@ -25,6 +25,7 @@ import (
"fmt"
"io"
"math"
+ "math/rand"
"net"
"net/http"
"strconv"
@@ -38,12 +39,12 @@ import (
"google.golang.org/grpc/internal/grpcutil"
"google.golang.org/grpc/internal/pretty"
"google.golang.org/grpc/internal/syscall"
+ "google.golang.org/grpc/mem"
"google.golang.org/protobuf/proto"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/internal/channelz"
- "google.golang.org/grpc/internal/grpcrand"
"google.golang.org/grpc/internal/grpcsync"
"google.golang.org/grpc/keepalive"
"google.golang.org/grpc/metadata"
@@ -119,7 +120,7 @@ type http2Server struct {
// Fields below are for channelz metric collection.
channelz *channelz.Socket
- bufferPool *bufferPool
+ bufferPool mem.BufferPool
connectionID uint64
@@ -261,7 +262,7 @@ func NewServerTransport(conn net.Conn, config *ServerConfig) (_ ServerTransport,
idle: time.Now(),
kep: kep,
initialWindowSize: iwz,
- bufferPool: newBufferPool(),
+ bufferPool: config.BufferPool,
}
var czSecurity credentials.ChannelzSecurityValue
if au, ok := authInfo.(credentials.ChannelzSecurityInfo); ok {
@@ -330,7 +331,7 @@ func NewServerTransport(conn net.Conn, config *ServerConfig) (_ ServerTransport,
t.handleSettings(sf)
go func() {
- t.loopy = newLoopyWriter(serverSide, t.framer, t.controlBuf, t.bdpEst, t.conn, t.logger, t.outgoingGoAwayHandler)
+ t.loopy = newLoopyWriter(serverSide, t.framer, t.controlBuf, t.bdpEst, t.conn, t.logger, t.outgoingGoAwayHandler, t.bufferPool)
err := t.loopy.run()
close(t.loopyWriterDone)
if !isIOError(err) {
@@ -613,10 +614,9 @@ func (t *http2Server) operateHeaders(ctx context.Context, frame *http2.MetaHeade
s.wq = newWriteQuota(defaultWriteQuota, s.ctxDone)
s.trReader = &transportReader{
reader: &recvBufferReader{
- ctx: s.ctx,
- ctxDone: s.ctxDone,
- recv: s.buf,
- freeBuffer: t.bufferPool.put,
+ ctx: s.ctx,
+ ctxDone: s.ctxDone,
+ recv: s.buf,
},
windowHandler: func(n int) {
t.updateWindow(s, uint32(n))
@@ -813,10 +813,13 @@ func (t *http2Server) handleData(f *http2.DataFrame) {
// guarantee f.Data() is consumed before the arrival of next frame.
// Can this copy be eliminated?
if len(f.Data()) > 0 {
- buffer := t.bufferPool.get()
- buffer.Reset()
- buffer.Write(f.Data())
- s.write(recvMsg{buffer: buffer})
+ pool := t.bufferPool
+ if pool == nil {
+ // Note that this is only supposed to be nil in tests. Otherwise, stream is
+ // always initialized with a BufferPool.
+ pool = mem.DefaultBufferPool()
+ }
+ s.write(recvMsg{buffer: mem.Copy(f.Data(), pool)})
}
}
if f.StreamEnded() {
@@ -1089,7 +1092,9 @@ func (t *http2Server) WriteStatus(s *Stream, st *status.Status) error {
onWrite: t.setResetPingStrikes,
}
- success, err := t.controlBuf.execute(t.checkForHeaderListSize, trailingHeader)
+ success, err := t.controlBuf.executeAndPut(func() bool {
+ return t.checkForHeaderListSize(trailingHeader)
+ }, nil)
if !success {
if err != nil {
return err
@@ -1112,27 +1117,37 @@ func (t *http2Server) WriteStatus(s *Stream, st *status.Status) error {
// Write converts the data into HTTP2 data frame and sends it out. Non-nil error
// is returns if it fails (e.g., framing error, transport error).
-func (t *http2Server) Write(s *Stream, hdr []byte, data []byte, opts *Options) error {
+func (t *http2Server) Write(s *Stream, hdr []byte, data mem.BufferSlice, _ *Options) error {
+ reader := data.Reader()
+
if !s.isHeaderSent() { // Headers haven't been written yet.
if err := t.WriteHeader(s, nil); err != nil {
+ _ = reader.Close()
return err
}
} else {
// Writing headers checks for this condition.
if s.getState() == streamDone {
+ _ = reader.Close()
return t.streamContextErr(s)
}
}
+
df := &dataFrame{
streamID: s.id,
h: hdr,
- d: data,
+ reader: reader,
onEachWrite: t.setResetPingStrikes,
}
- if err := s.wq.get(int32(len(hdr) + len(data))); err != nil {
+ if err := s.wq.get(int32(len(hdr) + df.reader.Remaining())); err != nil {
+ _ = reader.Close()
return t.streamContextErr(s)
}
- return t.controlBuf.put(df)
+ if err := t.controlBuf.put(df); err != nil {
+ _ = reader.Close()
+ return err
+ }
+ return nil
}
// keepalive running in a separate goroutine does the following:
@@ -1223,7 +1238,7 @@ func (t *http2Server) keepalive() {
// timeoutLeft. This will ensure that we wait only for kp.Time
// before sending out the next ping (for cases where the ping is
// acked).
- sleepDuration := minTime(t.kp.Time, kpTimeoutLeft)
+ sleepDuration := min(t.kp.Time, kpTimeoutLeft)
kpTimeoutLeft -= sleepDuration
kpTimer.Reset(sleepDuration)
case <-t.done:
@@ -1440,7 +1455,7 @@ func getJitter(v time.Duration) time.Duration {
}
// Generate a jitter between +/- 10% of the value.
r := int64(v / 10)
- j := grpcrand.Int63n(2*r) - r
+ j := rand.Int63n(2*r) - r
return time.Duration(j)
}
diff --git a/vendor/google.golang.org/grpc/internal/transport/http_util.go b/vendor/google.golang.org/grpc/internal/transport/http_util.go
index 39cef3bd44..3613d7b648 100644
--- a/vendor/google.golang.org/grpc/internal/transport/http_util.go
+++ b/vendor/google.golang.org/grpc/internal/transport/http_util.go
@@ -317,28 +317,32 @@ func newBufWriter(conn net.Conn, batchSize int, pool *sync.Pool) *bufWriter {
return w
}
-func (w *bufWriter) Write(b []byte) (n int, err error) {
+func (w *bufWriter) Write(b []byte) (int, error) {
if w.err != nil {
return 0, w.err
}
if w.batchSize == 0 { // Buffer has been disabled.
- n, err = w.conn.Write(b)
+ n, err := w.conn.Write(b)
return n, toIOError(err)
}
if w.buf == nil {
b := w.pool.Get().(*[]byte)
w.buf = *b
}
+ written := 0
for len(b) > 0 {
- nn := copy(w.buf[w.offset:], b)
- b = b[nn:]
- w.offset += nn
- n += nn
- if w.offset >= w.batchSize {
- err = w.flushKeepBuffer()
+ copied := copy(w.buf[w.offset:], b)
+ b = b[copied:]
+ written += copied
+ w.offset += copied
+ if w.offset < w.batchSize {
+ continue
+ }
+ if err := w.flushKeepBuffer(); err != nil {
+ return written, err
}
}
- return n, err
+ return written, nil
}
func (w *bufWriter) Flush() error {
@@ -389,7 +393,7 @@ type framer struct {
fr *http2.Framer
}
-var writeBufferPoolMap map[int]*sync.Pool = make(map[int]*sync.Pool)
+var writeBufferPoolMap = make(map[int]*sync.Pool)
var writeBufferMutex sync.Mutex
func newFramer(conn net.Conn, writeBufferSize, readBufferSize int, sharedWriteBuffer bool, maxHeaderListSize uint32) *framer {
diff --git a/vendor/google.golang.org/grpc/internal/transport/proxy.go b/vendor/google.golang.org/grpc/internal/transport/proxy.go
index 24fa103257..54b2244365 100644
--- a/vendor/google.golang.org/grpc/internal/transport/proxy.go
+++ b/vendor/google.golang.org/grpc/internal/transport/proxy.go
@@ -107,8 +107,14 @@ func doHTTPConnectHandshake(ctx context.Context, conn net.Conn, backendAddr stri
}
return nil, fmt.Errorf("failed to do connect handshake, response: %q", dump)
}
-
- return &bufConn{Conn: conn, r: r}, nil
+ // The buffer could contain extra bytes from the target server, so we can't
+ // discard it. However, in many cases where the server waits for the client
+ // to send the first message (e.g. when TLS is being used), the buffer will
+ // be empty, so we can avoid the overhead of reading through this buffer.
+ if r.Buffered() != 0 {
+ return &bufConn{Conn: conn, r: r}, nil
+ }
+ return conn, nil
}
// proxyDial dials, connecting to a proxy first if necessary. Checks if a proxy
diff --git a/vendor/google.golang.org/grpc/internal/transport/transport.go b/vendor/google.golang.org/grpc/internal/transport/transport.go
index 4b39c0ade9..e12cb0bc91 100644
--- a/vendor/google.golang.org/grpc/internal/transport/transport.go
+++ b/vendor/google.golang.org/grpc/internal/transport/transport.go
@@ -22,7 +22,6 @@
package transport
import (
- "bytes"
"context"
"errors"
"fmt"
@@ -37,6 +36,7 @@ import (
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/internal/channelz"
"google.golang.org/grpc/keepalive"
+ "google.golang.org/grpc/mem"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/peer"
"google.golang.org/grpc/resolver"
@@ -47,32 +47,10 @@ import (
const logLevel = 2
-type bufferPool struct {
- pool sync.Pool
-}
-
-func newBufferPool() *bufferPool {
- return &bufferPool{
- pool: sync.Pool{
- New: func() any {
- return new(bytes.Buffer)
- },
- },
- }
-}
-
-func (p *bufferPool) get() *bytes.Buffer {
- return p.pool.Get().(*bytes.Buffer)
-}
-
-func (p *bufferPool) put(b *bytes.Buffer) {
- p.pool.Put(b)
-}
-
// recvMsg represents the received msg from the transport. All transport
// protocol specific info has been removed.
type recvMsg struct {
- buffer *bytes.Buffer
+ buffer mem.Buffer
// nil: received some data
// io.EOF: stream is completed. data is nil.
// other non-nil error: transport failure. data is nil.
@@ -102,6 +80,9 @@ func newRecvBuffer() *recvBuffer {
func (b *recvBuffer) put(r recvMsg) {
b.mu.Lock()
if b.err != nil {
+ // drop the buffer on the floor. Since b.err is not nil, any subsequent reads
+ // will always return an error, making this buffer inaccessible.
+ r.buffer.Free()
b.mu.Unlock()
// An error had occurred earlier, don't accept more
// data or errors.
@@ -148,45 +129,97 @@ type recvBufferReader struct {
ctx context.Context
ctxDone <-chan struct{} // cache of ctx.Done() (for performance).
recv *recvBuffer
- last *bytes.Buffer // Stores the remaining data in the previous calls.
+ last mem.Buffer // Stores the remaining data in the previous calls.
err error
- freeBuffer func(*bytes.Buffer)
}
-// Read reads the next len(p) bytes from last. If last is drained, it tries to
-// read additional data from recv. It blocks if there no additional data available
-// in recv. If Read returns any non-nil error, it will continue to return that error.
-func (r *recvBufferReader) Read(p []byte) (n int, err error) {
+func (r *recvBufferReader) ReadHeader(header []byte) (n int, err error) {
if r.err != nil {
return 0, r.err
}
if r.last != nil {
- // Read remaining data left in last call.
- copied, _ := r.last.Read(p)
- if r.last.Len() == 0 {
- r.freeBuffer(r.last)
+ n, r.last = mem.ReadUnsafe(header, r.last)
+ return n, nil
+ }
+ if r.closeStream != nil {
+ n, r.err = r.readHeaderClient(header)
+ } else {
+ n, r.err = r.readHeader(header)
+ }
+ return n, r.err
+}
+
+// Read reads the next n bytes from last. If last is drained, it tries to read
+// additional data from recv. It blocks if there no additional data available in
+// recv. If Read returns any non-nil error, it will continue to return that
+// error.
+func (r *recvBufferReader) Read(n int) (buf mem.Buffer, err error) {
+ if r.err != nil {
+ return nil, r.err
+ }
+ if r.last != nil {
+ buf = r.last
+ if r.last.Len() > n {
+ buf, r.last = mem.SplitUnsafe(buf, n)
+ } else {
r.last = nil
}
- return copied, nil
+ return buf, nil
}
if r.closeStream != nil {
- n, r.err = r.readClient(p)
+ buf, r.err = r.readClient(n)
} else {
- n, r.err = r.read(p)
+ buf, r.err = r.read(n)
}
- return n, r.err
+ return buf, r.err
}
-func (r *recvBufferReader) read(p []byte) (n int, err error) {
+func (r *recvBufferReader) readHeader(header []byte) (n int, err error) {
select {
case <-r.ctxDone:
return 0, ContextErr(r.ctx.Err())
case m := <-r.recv.get():
- return r.readAdditional(m, p)
+ return r.readHeaderAdditional(m, header)
+ }
+}
+
+func (r *recvBufferReader) read(n int) (buf mem.Buffer, err error) {
+ select {
+ case <-r.ctxDone:
+ return nil, ContextErr(r.ctx.Err())
+ case m := <-r.recv.get():
+ return r.readAdditional(m, n)
+ }
+}
+
+func (r *recvBufferReader) readHeaderClient(header []byte) (n int, err error) {
+ // If the context is canceled, then closes the stream with nil metadata.
+ // closeStream writes its error parameter to r.recv as a recvMsg.
+ // r.readAdditional acts on that message and returns the necessary error.
+ select {
+ case <-r.ctxDone:
+ // Note that this adds the ctx error to the end of recv buffer, and
+ // reads from the head. This will delay the error until recv buffer is
+ // empty, thus will delay ctx cancellation in Recv().
+ //
+ // It's done this way to fix a race between ctx cancel and trailer. The
+ // race was, stream.Recv() may return ctx error if ctxDone wins the
+ // race, but stream.Trailer() may return a non-nil md because the stream
+ // was not marked as done when trailer is received. This closeStream
+ // call will mark stream as done, thus fix the race.
+ //
+ // TODO: delaying ctx error seems like a unnecessary side effect. What
+ // we really want is to mark the stream as done, and return ctx error
+ // faster.
+ r.closeStream(ContextErr(r.ctx.Err()))
+ m := <-r.recv.get()
+ return r.readHeaderAdditional(m, header)
+ case m := <-r.recv.get():
+ return r.readHeaderAdditional(m, header)
}
}
-func (r *recvBufferReader) readClient(p []byte) (n int, err error) {
+func (r *recvBufferReader) readClient(n int) (buf mem.Buffer, err error) {
// If the context is canceled, then closes the stream with nil metadata.
// closeStream writes its error parameter to r.recv as a recvMsg.
// r.readAdditional acts on that message and returns the necessary error.
@@ -207,25 +240,40 @@ func (r *recvBufferReader) readClient(p []byte) (n int, err error) {
// faster.
r.closeStream(ContextErr(r.ctx.Err()))
m := <-r.recv.get()
- return r.readAdditional(m, p)
+ return r.readAdditional(m, n)
case m := <-r.recv.get():
- return r.readAdditional(m, p)
+ return r.readAdditional(m, n)
}
}
-func (r *recvBufferReader) readAdditional(m recvMsg, p []byte) (n int, err error) {
+func (r *recvBufferReader) readHeaderAdditional(m recvMsg, header []byte) (n int, err error) {
r.recv.load()
if m.err != nil {
+ if m.buffer != nil {
+ m.buffer.Free()
+ }
return 0, m.err
}
- copied, _ := m.buffer.Read(p)
- if m.buffer.Len() == 0 {
- r.freeBuffer(m.buffer)
- r.last = nil
- } else {
- r.last = m.buffer
+
+ n, r.last = mem.ReadUnsafe(header, m.buffer)
+
+ return n, nil
+}
+
+func (r *recvBufferReader) readAdditional(m recvMsg, n int) (b mem.Buffer, err error) {
+ r.recv.load()
+ if m.err != nil {
+ if m.buffer != nil {
+ m.buffer.Free()
+ }
+ return nil, m.err
+ }
+
+ if m.buffer.Len() > n {
+ m.buffer, r.last = mem.SplitUnsafe(m.buffer, n)
}
- return copied, nil
+
+ return m.buffer, nil
}
type streamState uint32
@@ -241,7 +289,7 @@ const (
type Stream struct {
id uint32
st ServerTransport // nil for client side Stream
- ct *http2Client // nil for server side Stream
+ ct ClientTransport // nil for server side Stream
ctx context.Context // the associated context of the stream
cancel context.CancelFunc // always nil for client side Stream
done chan struct{} // closed at the end of stream to unblock writers. On the client side.
@@ -251,7 +299,7 @@ type Stream struct {
recvCompress string
sendCompress string
buf *recvBuffer
- trReader io.Reader
+ trReader *transportReader
fc *inFlow
wq *writeQuota
@@ -408,7 +456,7 @@ func (s *Stream) TrailersOnly() bool {
return s.noHeaders
}
-// Trailer returns the cached trailer metedata. Note that if it is not called
+// Trailer returns the cached trailer metadata. Note that if it is not called
// after the entire stream is done, it could return an empty MD. Client
// side only.
// It can be safely read only after stream has ended that is either read
@@ -499,36 +547,96 @@ func (s *Stream) write(m recvMsg) {
s.buf.put(m)
}
-// Read reads all p bytes from the wire for this stream.
-func (s *Stream) Read(p []byte) (n int, err error) {
+// ReadHeader reads data into the provided header slice from the stream. It
+// first checks if there was an error during a previous read operation and
+// returns it if present. It then requests a read operation for the length of
+// the header. It continues to read from the stream until the entire header
+// slice is filled or an error occurs. If an `io.EOF` error is encountered
+// with partially read data, it is converted to `io.ErrUnexpectedEOF` to
+// indicate an unexpected end of the stream. The method returns any error
+// encountered during the read process or nil if the header was successfully
+// read.
+func (s *Stream) ReadHeader(header []byte) (err error) {
+ // Don't request a read if there was an error earlier
+ if er := s.trReader.er; er != nil {
+ return er
+ }
+ s.requestRead(len(header))
+ for len(header) != 0 {
+ n, err := s.trReader.ReadHeader(header)
+ header = header[n:]
+ if len(header) == 0 {
+ err = nil
+ }
+ if err != nil {
+ if n > 0 && err == io.EOF {
+ err = io.ErrUnexpectedEOF
+ }
+ return err
+ }
+ }
+ return nil
+}
+
+// Read reads n bytes from the wire for this stream.
+func (s *Stream) Read(n int) (data mem.BufferSlice, err error) {
// Don't request a read if there was an error earlier
- if er := s.trReader.(*transportReader).er; er != nil {
- return 0, er
+ if er := s.trReader.er; er != nil {
+ return nil, er
}
- s.requestRead(len(p))
- return io.ReadFull(s.trReader, p)
+ s.requestRead(n)
+ for n != 0 {
+ buf, err := s.trReader.Read(n)
+ var bufLen int
+ if buf != nil {
+ bufLen = buf.Len()
+ }
+ n -= bufLen
+ if n == 0 {
+ err = nil
+ }
+ if err != nil {
+ if bufLen > 0 && err == io.EOF {
+ err = io.ErrUnexpectedEOF
+ }
+ data.Free()
+ return nil, err
+ }
+ data = append(data, buf)
+ }
+ return data, nil
}
-// tranportReader reads all the data available for this Stream from the transport and
+// transportReader reads all the data available for this Stream from the transport and
// passes them into the decoder, which converts them into a gRPC message stream.
// The error is io.EOF when the stream is done or another non-nil error if
// the stream broke.
type transportReader struct {
- reader io.Reader
+ reader *recvBufferReader
// The handler to control the window update procedure for both this
// particular stream and the associated transport.
windowHandler func(int)
er error
}
-func (t *transportReader) Read(p []byte) (n int, err error) {
- n, err = t.reader.Read(p)
+func (t *transportReader) ReadHeader(header []byte) (int, error) {
+ n, err := t.reader.ReadHeader(header)
if err != nil {
t.er = err
- return
+ return 0, err
}
t.windowHandler(n)
- return
+ return n, nil
+}
+
+func (t *transportReader) Read(n int) (mem.Buffer, error) {
+ buf, err := t.reader.Read(n)
+ if err != nil {
+ t.er = err
+ return buf, err
+ }
+ t.windowHandler(buf.Len())
+ return buf, nil
}
// BytesReceived indicates whether any bytes have been received on this stream.
@@ -574,6 +682,7 @@ type ServerConfig struct {
ChannelzParent *channelz.Server
MaxHeaderListSize *uint32
HeaderTableSize *uint32
+ BufferPool mem.BufferPool
}
// ConnectOptions covers all relevant options for communicating with the server.
@@ -612,6 +721,8 @@ type ConnectOptions struct {
MaxHeaderListSize *uint32
// UseProxy specifies if a proxy should be used.
UseProxy bool
+ // The mem.BufferPool to use when reading/writing to the wire.
+ BufferPool mem.BufferPool
}
// NewClientTransport establishes the transport with the required ConnectOptions
@@ -673,7 +784,7 @@ type ClientTransport interface {
// Write sends the data for the given stream. A nil stream indicates
// the write is to be performed on the transport as a whole.
- Write(s *Stream, hdr []byte, data []byte, opts *Options) error
+ Write(s *Stream, hdr []byte, data mem.BufferSlice, opts *Options) error
// NewStream creates a Stream for an RPC.
NewStream(ctx context.Context, callHdr *CallHdr) (*Stream, error)
@@ -725,7 +836,7 @@ type ServerTransport interface {
// Write sends the data for the given stream.
// Write may not be called on all streams.
- Write(s *Stream, hdr []byte, data []byte, opts *Options) error
+ Write(s *Stream, hdr []byte, data mem.BufferSlice, opts *Options) error
// WriteStatus sends the status of a stream to the client. WriteStatus is
// the final call made on a stream and always occurs.
@@ -798,7 +909,7 @@ var (
// connection is draining. This could be caused by goaway or balancer
// removing the address.
errStreamDrain = status.Error(codes.Unavailable, "the connection is draining")
- // errStreamDone is returned from write at the client side to indiacte application
+ // errStreamDone is returned from write at the client side to indicate application
// layer of an error.
errStreamDone = errors.New("the stream is done")
// StatusGoAway indicates that the server sent a GOAWAY that included this
diff --git a/vendor/google.golang.org/grpc/keepalive/keepalive.go b/vendor/google.golang.org/grpc/keepalive/keepalive.go
index 34d31b5e7d..eb42b19fb9 100644
--- a/vendor/google.golang.org/grpc/keepalive/keepalive.go
+++ b/vendor/google.golang.org/grpc/keepalive/keepalive.go
@@ -34,15 +34,29 @@ type ClientParameters struct {
// After a duration of this time if the client doesn't see any activity it
// pings the server to see if the transport is still alive.
// If set below 10s, a minimum value of 10s will be used instead.
- Time time.Duration // The current default value is infinity.
+ //
+ // Note that gRPC servers have a default EnforcementPolicy.MinTime of 5
+ // minutes (which means the client shouldn't ping more frequently than every
+ // 5 minutes).
+ //
+ // Though not ideal, it's not a strong requirement for Time to be less than
+ // EnforcementPolicy.MinTime. Time will automatically double if the server
+ // disconnects due to its enforcement policy.
+ //
+ // For more details, see
+ // https://github.com/grpc/proposal/blob/master/A8-client-side-keepalive.md
+ Time time.Duration
// After having pinged for keepalive check, the client waits for a duration
// of Timeout and if no activity is seen even after that the connection is
// closed.
- Timeout time.Duration // The current default value is 20 seconds.
+ //
+ // If keepalive is enabled, and this value is not explicitly set, the default
+ // is 20 seconds.
+ Timeout time.Duration
// If true, client sends keepalive pings even with no active RPCs. If false,
// when there are no active RPCs, Time and Timeout will be ignored and no
// keepalive pings will be sent.
- PermitWithoutStream bool // false by default.
+ PermitWithoutStream bool
}
// ServerParameters is used to set keepalive and max-age parameters on the
diff --git a/vendor/google.golang.org/grpc/mem/buffer_pool.go b/vendor/google.golang.org/grpc/mem/buffer_pool.go
new file mode 100644
index 0000000000..c37c58c023
--- /dev/null
+++ b/vendor/google.golang.org/grpc/mem/buffer_pool.go
@@ -0,0 +1,194 @@
+/*
+ *
+ * Copyright 2024 gRPC 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 mem
+
+import (
+ "sort"
+ "sync"
+
+ "google.golang.org/grpc/internal"
+)
+
+// BufferPool is a pool of buffers that can be shared and reused, resulting in
+// decreased memory allocation.
+type BufferPool interface {
+ // Get returns a buffer with specified length from the pool.
+ Get(length int) *[]byte
+
+ // Put returns a buffer to the pool.
+ Put(*[]byte)
+}
+
+var defaultBufferPoolSizes = []int{
+ 256,
+ 4 << 10, // 4KB (go page size)
+ 16 << 10, // 16KB (max HTTP/2 frame size used by gRPC)
+ 32 << 10, // 32KB (default buffer size for io.Copy)
+ 1 << 20, // 1MB
+}
+
+var defaultBufferPool BufferPool
+
+func init() {
+ defaultBufferPool = NewTieredBufferPool(defaultBufferPoolSizes...)
+
+ internal.SetDefaultBufferPoolForTesting = func(pool BufferPool) {
+ defaultBufferPool = pool
+ }
+
+ internal.SetBufferPoolingThresholdForTesting = func(threshold int) {
+ bufferPoolingThreshold = threshold
+ }
+}
+
+// DefaultBufferPool returns the current default buffer pool. It is a BufferPool
+// created with NewBufferPool that uses a set of default sizes optimized for
+// expected workflows.
+func DefaultBufferPool() BufferPool {
+ return defaultBufferPool
+}
+
+// NewTieredBufferPool returns a BufferPool implementation that uses multiple
+// underlying pools of the given pool sizes.
+func NewTieredBufferPool(poolSizes ...int) BufferPool {
+ sort.Ints(poolSizes)
+ pools := make([]*sizedBufferPool, len(poolSizes))
+ for i, s := range poolSizes {
+ pools[i] = newSizedBufferPool(s)
+ }
+ return &tieredBufferPool{
+ sizedPools: pools,
+ }
+}
+
+// tieredBufferPool implements the BufferPool interface with multiple tiers of
+// buffer pools for different sizes of buffers.
+type tieredBufferPool struct {
+ sizedPools []*sizedBufferPool
+ fallbackPool simpleBufferPool
+}
+
+func (p *tieredBufferPool) Get(size int) *[]byte {
+ return p.getPool(size).Get(size)
+}
+
+func (p *tieredBufferPool) Put(buf *[]byte) {
+ p.getPool(cap(*buf)).Put(buf)
+}
+
+func (p *tieredBufferPool) getPool(size int) BufferPool {
+ poolIdx := sort.Search(len(p.sizedPools), func(i int) bool {
+ return p.sizedPools[i].defaultSize >= size
+ })
+
+ if poolIdx == len(p.sizedPools) {
+ return &p.fallbackPool
+ }
+
+ return p.sizedPools[poolIdx]
+}
+
+// sizedBufferPool is a BufferPool implementation that is optimized for specific
+// buffer sizes. For example, HTTP/2 frames within gRPC have a default max size
+// of 16kb and a sizedBufferPool can be configured to only return buffers with a
+// capacity of 16kb. Note that however it does not support returning larger
+// buffers and in fact panics if such a buffer is requested. Because of this,
+// this BufferPool implementation is not meant to be used on its own and rather
+// is intended to be embedded in a tieredBufferPool such that Get is only
+// invoked when the required size is smaller than or equal to defaultSize.
+type sizedBufferPool struct {
+ pool sync.Pool
+ defaultSize int
+}
+
+func (p *sizedBufferPool) Get(size int) *[]byte {
+ buf := p.pool.Get().(*[]byte)
+ b := *buf
+ clear(b[:cap(b)])
+ *buf = b[:size]
+ return buf
+}
+
+func (p *sizedBufferPool) Put(buf *[]byte) {
+ if cap(*buf) < p.defaultSize {
+ // Ignore buffers that are too small to fit in the pool. Otherwise, when
+ // Get is called it will panic as it tries to index outside the bounds
+ // of the buffer.
+ return
+ }
+ p.pool.Put(buf)
+}
+
+func newSizedBufferPool(size int) *sizedBufferPool {
+ return &sizedBufferPool{
+ pool: sync.Pool{
+ New: func() any {
+ buf := make([]byte, size)
+ return &buf
+ },
+ },
+ defaultSize: size,
+ }
+}
+
+var _ BufferPool = (*simpleBufferPool)(nil)
+
+// simpleBufferPool is an implementation of the BufferPool interface that
+// attempts to pool buffers with a sync.Pool. When Get is invoked, it tries to
+// acquire a buffer from the pool but if that buffer is too small, it returns it
+// to the pool and creates a new one.
+type simpleBufferPool struct {
+ pool sync.Pool
+}
+
+func (p *simpleBufferPool) Get(size int) *[]byte {
+ bs, ok := p.pool.Get().(*[]byte)
+ if ok && cap(*bs) >= size {
+ *bs = (*bs)[:size]
+ return bs
+ }
+
+ // A buffer was pulled from the pool, but it is too small. Put it back in
+ // the pool and create one large enough.
+ if ok {
+ p.pool.Put(bs)
+ }
+
+ b := make([]byte, size)
+ return &b
+}
+
+func (p *simpleBufferPool) Put(buf *[]byte) {
+ p.pool.Put(buf)
+}
+
+var _ BufferPool = NopBufferPool{}
+
+// NopBufferPool is a buffer pool that returns new buffers without pooling.
+type NopBufferPool struct{}
+
+// Get returns a buffer with specified length from the pool.
+func (NopBufferPool) Get(length int) *[]byte {
+ b := make([]byte, length)
+ return &b
+}
+
+// Put returns a buffer to the pool.
+func (NopBufferPool) Put(*[]byte) {
+}
diff --git a/vendor/google.golang.org/grpc/mem/buffer_slice.go b/vendor/google.golang.org/grpc/mem/buffer_slice.go
new file mode 100644
index 0000000000..228e9c2f20
--- /dev/null
+++ b/vendor/google.golang.org/grpc/mem/buffer_slice.go
@@ -0,0 +1,226 @@
+/*
+ *
+ * Copyright 2024 gRPC 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 mem
+
+import (
+ "io"
+)
+
+// BufferSlice offers a means to represent data that spans one or more Buffer
+// instances. A BufferSlice is meant to be immutable after creation, and methods
+// like Ref create and return copies of the slice. This is why all methods have
+// value receivers rather than pointer receivers.
+//
+// Note that any of the methods that read the underlying buffers such as Ref,
+// Len or CopyTo etc., will panic if any underlying buffers have already been
+// freed. It is recommended to not directly interact with any of the underlying
+// buffers directly, rather such interactions should be mediated through the
+// various methods on this type.
+//
+// By convention, any APIs that return (mem.BufferSlice, error) should reduce
+// the burden on the caller by never returning a mem.BufferSlice that needs to
+// be freed if the error is non-nil, unless explicitly stated.
+type BufferSlice []Buffer
+
+// Len returns the sum of the length of all the Buffers in this slice.
+//
+// # Warning
+//
+// Invoking the built-in len on a BufferSlice will return the number of buffers
+// in the slice, and *not* the value returned by this function.
+func (s BufferSlice) Len() int {
+ var length int
+ for _, b := range s {
+ length += b.Len()
+ }
+ return length
+}
+
+// Ref invokes Ref on each buffer in the slice.
+func (s BufferSlice) Ref() {
+ for _, b := range s {
+ b.Ref()
+ }
+}
+
+// Free invokes Buffer.Free() on each Buffer in the slice.
+func (s BufferSlice) Free() {
+ for _, b := range s {
+ b.Free()
+ }
+}
+
+// CopyTo copies each of the underlying Buffer's data into the given buffer,
+// returning the number of bytes copied. Has the same semantics as the copy
+// builtin in that it will copy as many bytes as it can, stopping when either dst
+// is full or s runs out of data, returning the minimum of s.Len() and len(dst).
+func (s BufferSlice) CopyTo(dst []byte) int {
+ off := 0
+ for _, b := range s {
+ off += copy(dst[off:], b.ReadOnlyData())
+ }
+ return off
+}
+
+// Materialize concatenates all the underlying Buffer's data into a single
+// contiguous buffer using CopyTo.
+func (s BufferSlice) Materialize() []byte {
+ l := s.Len()
+ if l == 0 {
+ return nil
+ }
+ out := make([]byte, l)
+ s.CopyTo(out)
+ return out
+}
+
+// MaterializeToBuffer functions like Materialize except that it writes the data
+// to a single Buffer pulled from the given BufferPool.
+//
+// As a special case, if the input BufferSlice only actually has one Buffer, this
+// function simply increases the refcount before returning said Buffer. Freeing this
+// buffer won't release it until the BufferSlice is itself released.
+func (s BufferSlice) MaterializeToBuffer(pool BufferPool) Buffer {
+ if len(s) == 1 {
+ s[0].Ref()
+ return s[0]
+ }
+ sLen := s.Len()
+ if sLen == 0 {
+ return emptyBuffer{}
+ }
+ buf := pool.Get(sLen)
+ s.CopyTo(*buf)
+ return NewBuffer(buf, pool)
+}
+
+// Reader returns a new Reader for the input slice after taking references to
+// each underlying buffer.
+func (s BufferSlice) Reader() Reader {
+ s.Ref()
+ return &sliceReader{
+ data: s,
+ len: s.Len(),
+ }
+}
+
+// Reader exposes a BufferSlice's data as an io.Reader, allowing it to interface
+// with other parts systems. It also provides an additional convenience method
+// Remaining(), which returns the number of unread bytes remaining in the slice.
+// Buffers will be freed as they are read.
+type Reader interface {
+ io.Reader
+ io.ByteReader
+ // Close frees the underlying BufferSlice and never returns an error. Subsequent
+ // calls to Read will return (0, io.EOF).
+ Close() error
+ // Remaining returns the number of unread bytes remaining in the slice.
+ Remaining() int
+}
+
+type sliceReader struct {
+ data BufferSlice
+ len int
+ // The index into data[0].ReadOnlyData().
+ bufferIdx int
+}
+
+func (r *sliceReader) Remaining() int {
+ return r.len
+}
+
+func (r *sliceReader) Close() error {
+ r.data.Free()
+ r.data = nil
+ r.len = 0
+ return nil
+}
+
+func (r *sliceReader) freeFirstBufferIfEmpty() bool {
+ if len(r.data) == 0 || r.bufferIdx != len(r.data[0].ReadOnlyData()) {
+ return false
+ }
+
+ r.data[0].Free()
+ r.data = r.data[1:]
+ r.bufferIdx = 0
+ return true
+}
+
+func (r *sliceReader) Read(buf []byte) (n int, _ error) {
+ if r.len == 0 {
+ return 0, io.EOF
+ }
+
+ for len(buf) != 0 && r.len != 0 {
+ // Copy as much as possible from the first Buffer in the slice into the
+ // given byte slice.
+ data := r.data[0].ReadOnlyData()
+ copied := copy(buf, data[r.bufferIdx:])
+ r.len -= copied // Reduce len by the number of bytes copied.
+ r.bufferIdx += copied // Increment the buffer index.
+ n += copied // Increment the total number of bytes read.
+ buf = buf[copied:] // Shrink the given byte slice.
+
+ // If we have copied all the data from the first Buffer, free it and advance to
+ // the next in the slice.
+ r.freeFirstBufferIfEmpty()
+ }
+
+ return n, nil
+}
+
+func (r *sliceReader) ReadByte() (byte, error) {
+ if r.len == 0 {
+ return 0, io.EOF
+ }
+
+ // There may be any number of empty buffers in the slice, clear them all until a
+ // non-empty buffer is reached. This is guaranteed to exit since r.len is not 0.
+ for r.freeFirstBufferIfEmpty() {
+ }
+
+ b := r.data[0].ReadOnlyData()[r.bufferIdx]
+ r.len--
+ r.bufferIdx++
+ // Free the first buffer in the slice if the last byte was read
+ r.freeFirstBufferIfEmpty()
+ return b, nil
+}
+
+var _ io.Writer = (*writer)(nil)
+
+type writer struct {
+ buffers *BufferSlice
+ pool BufferPool
+}
+
+func (w *writer) Write(p []byte) (n int, err error) {
+ b := Copy(p, w.pool)
+ *w.buffers = append(*w.buffers, b)
+ return b.Len(), nil
+}
+
+// NewWriter wraps the given BufferSlice and BufferPool to implement the
+// io.Writer interface. Every call to Write copies the contents of the given
+// buffer into a new Buffer pulled from the given pool and the Buffer is added to
+// the given BufferSlice.
+func NewWriter(buffers *BufferSlice, pool BufferPool) io.Writer {
+ return &writer{buffers: buffers, pool: pool}
+}
diff --git a/vendor/google.golang.org/grpc/mem/buffers.go b/vendor/google.golang.org/grpc/mem/buffers.go
new file mode 100644
index 0000000000..ecbf0b9a73
--- /dev/null
+++ b/vendor/google.golang.org/grpc/mem/buffers.go
@@ -0,0 +1,268 @@
+/*
+ *
+ * Copyright 2024 gRPC 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 mem provides utilities that facilitate memory reuse in byte slices
+// that are used as buffers.
+//
+// # Experimental
+//
+// Notice: All APIs in this package are EXPERIMENTAL and may be changed or
+// removed in a later release.
+package mem
+
+import (
+ "fmt"
+ "sync"
+ "sync/atomic"
+)
+
+// A Buffer represents a reference counted piece of data (in bytes) that can be
+// acquired by a call to NewBuffer() or Copy(). A reference to a Buffer may be
+// released by calling Free(), which invokes the free function given at creation
+// only after all references are released.
+//
+// Note that a Buffer is not safe for concurrent access and instead each
+// goroutine should use its own reference to the data, which can be acquired via
+// a call to Ref().
+//
+// Attempts to access the underlying data after releasing the reference to the
+// Buffer will panic.
+type Buffer interface {
+ // ReadOnlyData returns the underlying byte slice. Note that it is undefined
+ // behavior to modify the contents of this slice in any way.
+ ReadOnlyData() []byte
+ // Ref increases the reference counter for this Buffer.
+ Ref()
+ // Free decrements this Buffer's reference counter and frees the underlying
+ // byte slice if the counter reaches 0 as a result of this call.
+ Free()
+ // Len returns the Buffer's size.
+ Len() int
+
+ split(n int) (left, right Buffer)
+ read(buf []byte) (int, Buffer)
+}
+
+var (
+ bufferPoolingThreshold = 1 << 10
+
+ bufferObjectPool = sync.Pool{New: func() any { return new(buffer) }}
+ refObjectPool = sync.Pool{New: func() any { return new(atomic.Int32) }}
+)
+
+// IsBelowBufferPoolingThreshold returns true if the given size is less than or
+// equal to the threshold for buffer pooling. This is used to determine whether
+// to pool buffers or allocate them directly.
+func IsBelowBufferPoolingThreshold(size int) bool {
+ return size <= bufferPoolingThreshold
+}
+
+type buffer struct {
+ origData *[]byte
+ data []byte
+ refs *atomic.Int32
+ pool BufferPool
+}
+
+func newBuffer() *buffer {
+ return bufferObjectPool.Get().(*buffer)
+}
+
+// NewBuffer creates a new Buffer from the given data, initializing the reference
+// counter to 1. The data will then be returned to the given pool when all
+// references to the returned Buffer are released. As a special case to avoid
+// additional allocations, if the given buffer pool is nil, the returned buffer
+// will be a "no-op" Buffer where invoking Buffer.Free() does nothing and the
+// underlying data is never freed.
+//
+// Note that the backing array of the given data is not copied.
+func NewBuffer(data *[]byte, pool BufferPool) Buffer {
+ // Use the buffer's capacity instead of the length, otherwise buffers may
+ // not be reused under certain conditions. For example, if a large buffer
+ // is acquired from the pool, but fewer bytes than the buffering threshold
+ // are written to it, the buffer will not be returned to the pool.
+ if pool == nil || IsBelowBufferPoolingThreshold(cap(*data)) {
+ return (SliceBuffer)(*data)
+ }
+ b := newBuffer()
+ b.origData = data
+ b.data = *data
+ b.pool = pool
+ b.refs = refObjectPool.Get().(*atomic.Int32)
+ b.refs.Add(1)
+ return b
+}
+
+// Copy creates a new Buffer from the given data, initializing the reference
+// counter to 1.
+//
+// It acquires a []byte from the given pool and copies over the backing array
+// of the given data. The []byte acquired from the pool is returned to the
+// pool when all references to the returned Buffer are released.
+func Copy(data []byte, pool BufferPool) Buffer {
+ if IsBelowBufferPoolingThreshold(len(data)) {
+ buf := make(SliceBuffer, len(data))
+ copy(buf, data)
+ return buf
+ }
+
+ buf := pool.Get(len(data))
+ copy(*buf, data)
+ return NewBuffer(buf, pool)
+}
+
+func (b *buffer) ReadOnlyData() []byte {
+ if b.refs == nil {
+ panic("Cannot read freed buffer")
+ }
+ return b.data
+}
+
+func (b *buffer) Ref() {
+ if b.refs == nil {
+ panic("Cannot ref freed buffer")
+ }
+ b.refs.Add(1)
+}
+
+func (b *buffer) Free() {
+ if b.refs == nil {
+ panic("Cannot free freed buffer")
+ }
+
+ refs := b.refs.Add(-1)
+ switch {
+ case refs > 0:
+ return
+ case refs == 0:
+ if b.pool != nil {
+ b.pool.Put(b.origData)
+ }
+
+ refObjectPool.Put(b.refs)
+ b.origData = nil
+ b.data = nil
+ b.refs = nil
+ b.pool = nil
+ bufferObjectPool.Put(b)
+ default:
+ panic("Cannot free freed buffer")
+ }
+}
+
+func (b *buffer) Len() int {
+ return len(b.ReadOnlyData())
+}
+
+func (b *buffer) split(n int) (Buffer, Buffer) {
+ if b.refs == nil {
+ panic("Cannot split freed buffer")
+ }
+
+ b.refs.Add(1)
+ split := newBuffer()
+ split.origData = b.origData
+ split.data = b.data[n:]
+ split.refs = b.refs
+ split.pool = b.pool
+
+ b.data = b.data[:n]
+
+ return b, split
+}
+
+func (b *buffer) read(buf []byte) (int, Buffer) {
+ if b.refs == nil {
+ panic("Cannot read freed buffer")
+ }
+
+ n := copy(buf, b.data)
+ if n == len(b.data) {
+ b.Free()
+ return n, nil
+ }
+
+ b.data = b.data[n:]
+ return n, b
+}
+
+func (b *buffer) String() string {
+ return fmt.Sprintf("mem.Buffer(%p, data: %p, length: %d)", b, b.ReadOnlyData(), len(b.ReadOnlyData()))
+}
+
+// ReadUnsafe reads bytes from the given Buffer into the provided slice.
+// It does not perform safety checks.
+func ReadUnsafe(dst []byte, buf Buffer) (int, Buffer) {
+ return buf.read(dst)
+}
+
+// SplitUnsafe modifies the receiver to point to the first n bytes while it
+// returns a new reference to the remaining bytes. The returned Buffer
+// functions just like a normal reference acquired using Ref().
+func SplitUnsafe(buf Buffer, n int) (left, right Buffer) {
+ return buf.split(n)
+}
+
+type emptyBuffer struct{}
+
+func (e emptyBuffer) ReadOnlyData() []byte {
+ return nil
+}
+
+func (e emptyBuffer) Ref() {}
+func (e emptyBuffer) Free() {}
+
+func (e emptyBuffer) Len() int {
+ return 0
+}
+
+func (e emptyBuffer) split(int) (left, right Buffer) {
+ return e, e
+}
+
+func (e emptyBuffer) read([]byte) (int, Buffer) {
+ return 0, e
+}
+
+// SliceBuffer is a Buffer implementation that wraps a byte slice. It provides
+// methods for reading, splitting, and managing the byte slice.
+type SliceBuffer []byte
+
+// ReadOnlyData returns the byte slice.
+func (s SliceBuffer) ReadOnlyData() []byte { return s }
+
+// Ref is a noop implementation of Ref.
+func (s SliceBuffer) Ref() {}
+
+// Free is a noop implementation of Free.
+func (s SliceBuffer) Free() {}
+
+// Len is a noop implementation of Len.
+func (s SliceBuffer) Len() int { return len(s) }
+
+func (s SliceBuffer) split(n int) (left, right Buffer) {
+ return s[:n], s[n:]
+}
+
+func (s SliceBuffer) read(buf []byte) (int, Buffer) {
+ n := copy(buf, s)
+ if n == len(s) {
+ return n, nil
+ }
+ return n, s[n:]
+}
diff --git a/vendor/google.golang.org/grpc/metadata/metadata.go b/vendor/google.golang.org/grpc/metadata/metadata.go
index 6c01a9b359..d2e15253bb 100644
--- a/vendor/google.golang.org/grpc/metadata/metadata.go
+++ b/vendor/google.golang.org/grpc/metadata/metadata.go
@@ -90,21 +90,6 @@ func Pairs(kv ...string) MD {
return md
}
-// String implements the Stringer interface for pretty-printing a MD.
-// Ordering of the values is non-deterministic as it ranges over a map.
-func (md MD) String() string {
- var sb strings.Builder
- fmt.Fprintf(&sb, "MD{")
- for k, v := range md {
- if sb.Len() > 3 {
- fmt.Fprintf(&sb, ", ")
- }
- fmt.Fprintf(&sb, "%s=[%s]", k, strings.Join(v, ", "))
- }
- fmt.Fprintf(&sb, "}")
- return sb.String()
-}
-
// Len returns the number of items in md.
func (md MD) Len() int {
return len(md)
@@ -228,11 +213,6 @@ func FromIncomingContext(ctx context.Context) (MD, bool) {
// ValueFromIncomingContext returns the metadata value corresponding to the metadata
// key from the incoming metadata if it exists. Keys are matched in a case insensitive
// manner.
-//
-// # Experimental
-//
-// Notice: This API is EXPERIMENTAL and may be changed or removed in a
-// later release.
func ValueFromIncomingContext(ctx context.Context, key string) []string {
md, ok := ctx.Value(mdIncomingKey{}).(MD)
if !ok {
@@ -243,7 +223,7 @@ func ValueFromIncomingContext(ctx context.Context, key string) []string {
return copyOf(v)
}
for k, v := range md {
- // Case insenitive comparison: MD is a map, and there's no guarantee
+ // Case insensitive comparison: MD is a map, and there's no guarantee
// that the MD attached to the context is created using our helper
// functions.
if strings.EqualFold(k, key) {
diff --git a/vendor/google.golang.org/grpc/picker_wrapper.go b/vendor/google.golang.org/grpc/picker_wrapper.go
index 56e8aba783..bdaa2130e4 100644
--- a/vendor/google.golang.org/grpc/picker_wrapper.go
+++ b/vendor/google.golang.org/grpc/picker_wrapper.go
@@ -22,7 +22,7 @@ import (
"context"
"fmt"
"io"
- "sync"
+ "sync/atomic"
"google.golang.org/grpc/balancer"
"google.golang.org/grpc/codes"
@@ -33,35 +33,43 @@ import (
"google.golang.org/grpc/status"
)
+// pickerGeneration stores a picker and a channel used to signal that a picker
+// newer than this one is available.
+type pickerGeneration struct {
+ // picker is the picker produced by the LB policy. May be nil if a picker
+ // has never been produced.
+ picker balancer.Picker
+ // blockingCh is closed when the picker has been invalidated because there
+ // is a new one available.
+ blockingCh chan struct{}
+}
+
// pickerWrapper is a wrapper of balancer.Picker. It blocks on certain pick
// actions and unblock when there's a picker update.
type pickerWrapper struct {
- mu sync.Mutex
- done bool
- blockingCh chan struct{}
- picker balancer.Picker
+ // If pickerGen holds a nil pointer, the pickerWrapper is closed.
+ pickerGen atomic.Pointer[pickerGeneration]
statsHandlers []stats.Handler // to record blocking picker calls
}
func newPickerWrapper(statsHandlers []stats.Handler) *pickerWrapper {
- return &pickerWrapper{
- blockingCh: make(chan struct{}),
+ pw := &pickerWrapper{
statsHandlers: statsHandlers,
}
+ pw.pickerGen.Store(&pickerGeneration{
+ blockingCh: make(chan struct{}),
+ })
+ return pw
}
-// updatePicker is called by UpdateBalancerState. It unblocks all blocked pick.
+// updatePicker is called by UpdateState calls from the LB policy. It
+// unblocks all blocked pick.
func (pw *pickerWrapper) updatePicker(p balancer.Picker) {
- pw.mu.Lock()
- if pw.done {
- pw.mu.Unlock()
- return
- }
- pw.picker = p
- // pw.blockingCh should never be nil.
- close(pw.blockingCh)
- pw.blockingCh = make(chan struct{})
- pw.mu.Unlock()
+ old := pw.pickerGen.Swap(&pickerGeneration{
+ picker: p,
+ blockingCh: make(chan struct{}),
+ })
+ close(old.blockingCh)
}
// doneChannelzWrapper performs the following:
@@ -98,20 +106,17 @@ func (pw *pickerWrapper) pick(ctx context.Context, failfast bool, info balancer.
var lastPickErr error
for {
- pw.mu.Lock()
- if pw.done {
- pw.mu.Unlock()
+ pg := pw.pickerGen.Load()
+ if pg == nil {
return nil, balancer.PickResult{}, ErrClientConnClosing
}
-
- if pw.picker == nil {
- ch = pw.blockingCh
+ if pg.picker == nil {
+ ch = pg.blockingCh
}
- if ch == pw.blockingCh {
+ if ch == pg.blockingCh {
// This could happen when either:
// - pw.picker is nil (the previous if condition), or
- // - has called pick on the current picker.
- pw.mu.Unlock()
+ // - we have already called pick on the current picker.
select {
case <-ctx.Done():
var errStr string
@@ -145,9 +150,8 @@ func (pw *pickerWrapper) pick(ctx context.Context, failfast bool, info balancer.
}
}
- ch = pw.blockingCh
- p := pw.picker
- pw.mu.Unlock()
+ ch = pg.blockingCh
+ p := pg.picker
pickResult, err := p.Pick(info)
if err != nil {
@@ -197,24 +201,15 @@ func (pw *pickerWrapper) pick(ctx context.Context, failfast bool, info balancer.
}
func (pw *pickerWrapper) close() {
- pw.mu.Lock()
- defer pw.mu.Unlock()
- if pw.done {
- return
- }
- pw.done = true
- close(pw.blockingCh)
+ old := pw.pickerGen.Swap(nil)
+ close(old.blockingCh)
}
// reset clears the pickerWrapper and prepares it for being used again when idle
// mode is exited.
func (pw *pickerWrapper) reset() {
- pw.mu.Lock()
- defer pw.mu.Unlock()
- if pw.done {
- return
- }
- pw.blockingCh = make(chan struct{})
+ old := pw.pickerGen.Swap(&pickerGeneration{blockingCh: make(chan struct{})})
+ close(old.blockingCh)
}
// dropError is a wrapper error that indicates the LB policy wishes to drop the
diff --git a/vendor/google.golang.org/grpc/preloader.go b/vendor/google.golang.org/grpc/preloader.go
index 73bd633643..e87a17f36a 100644
--- a/vendor/google.golang.org/grpc/preloader.go
+++ b/vendor/google.golang.org/grpc/preloader.go
@@ -20,6 +20,7 @@ package grpc
import (
"google.golang.org/grpc/codes"
+ "google.golang.org/grpc/mem"
"google.golang.org/grpc/status"
)
@@ -31,9 +32,10 @@ import (
// later release.
type PreparedMsg struct {
// Struct for preparing msg before sending them
- encodedData []byte
+ encodedData mem.BufferSlice
hdr []byte
- payload []byte
+ payload mem.BufferSlice
+ pf payloadFormat
}
// Encode marshalls and compresses the message using the codec and compressor for the stream.
@@ -57,11 +59,27 @@ func (p *PreparedMsg) Encode(s Stream, msg any) error {
if err != nil {
return err
}
- p.encodedData = data
- compData, err := compress(data, rpcInfo.preloaderInfo.cp, rpcInfo.preloaderInfo.comp)
+
+ materializedData := data.Materialize()
+ data.Free()
+ p.encodedData = mem.BufferSlice{mem.NewBuffer(&materializedData, nil)}
+
+ // TODO: it should be possible to grab the bufferPool from the underlying
+ // stream implementation with a type cast to its actual type (such as
+ // addrConnStream) and accessing the buffer pool directly.
+ var compData mem.BufferSlice
+ compData, p.pf, err = compress(p.encodedData, rpcInfo.preloaderInfo.cp, rpcInfo.preloaderInfo.comp, mem.DefaultBufferPool())
if err != nil {
return err
}
- p.hdr, p.payload = msgHeader(data, compData)
+
+ if p.pf.isCompressed() {
+ materializedCompData := compData.Materialize()
+ compData.Free()
+ compData = mem.BufferSlice{mem.NewBuffer(&materializedCompData, nil)}
+ }
+
+ p.hdr, p.payload = msgHeader(p.encodedData, compData, p.pf)
+
return nil
}
diff --git a/vendor/google.golang.org/grpc/regenerate.sh b/vendor/google.golang.org/grpc/regenerate.sh
deleted file mode 100644
index 3edca296c2..0000000000
--- a/vendor/google.golang.org/grpc/regenerate.sh
+++ /dev/null
@@ -1,123 +0,0 @@
-#!/bin/bash
-# Copyright 2020 gRPC 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.
-
-set -eu -o pipefail
-
-WORKDIR=$(mktemp -d)
-
-function finish {
- rm -rf "$WORKDIR"
-}
-trap finish EXIT
-
-export GOBIN=${WORKDIR}/bin
-export PATH=${GOBIN}:${PATH}
-mkdir -p ${GOBIN}
-
-echo "remove existing generated files"
-# grpc_testing_not_regenerate/*.pb.go is not re-generated,
-# see grpc_testing_not_regenerate/README.md for details.
-rm -f $(find . -name '*.pb.go' | grep -v 'grpc_testing_not_regenerate')
-
-echo "go install google.golang.org/protobuf/cmd/protoc-gen-go"
-(cd test/tools && go install google.golang.org/protobuf/cmd/protoc-gen-go)
-
-echo "go install cmd/protoc-gen-go-grpc"
-(cd cmd/protoc-gen-go-grpc && go install .)
-
-echo "git clone https://github.com/grpc/grpc-proto"
-git clone --quiet https://github.com/grpc/grpc-proto ${WORKDIR}/grpc-proto
-
-echo "git clone https://github.com/protocolbuffers/protobuf"
-git clone --quiet https://github.com/protocolbuffers/protobuf ${WORKDIR}/protobuf
-
-# Pull in code.proto as a proto dependency
-mkdir -p ${WORKDIR}/googleapis/google/rpc
-echo "curl https://raw.githubusercontent.com/googleapis/googleapis/master/google/rpc/code.proto"
-curl --silent https://raw.githubusercontent.com/googleapis/googleapis/master/google/rpc/code.proto > ${WORKDIR}/googleapis/google/rpc/code.proto
-
-mkdir -p ${WORKDIR}/out
-
-# Generates sources without the embed requirement
-LEGACY_SOURCES=(
- ${WORKDIR}/grpc-proto/grpc/binlog/v1/binarylog.proto
- ${WORKDIR}/grpc-proto/grpc/channelz/v1/channelz.proto
- ${WORKDIR}/grpc-proto/grpc/health/v1/health.proto
- ${WORKDIR}/grpc-proto/grpc/lb/v1/load_balancer.proto
- profiling/proto/service.proto
- ${WORKDIR}/grpc-proto/grpc/reflection/v1alpha/reflection.proto
- ${WORKDIR}/grpc-proto/grpc/reflection/v1/reflection.proto
-)
-
-# Generates only the new gRPC Service symbols
-SOURCES=(
- $(git ls-files --exclude-standard --cached --others "*.proto" | grep -v '^profiling/proto/service.proto$')
- ${WORKDIR}/grpc-proto/grpc/gcp/altscontext.proto
- ${WORKDIR}/grpc-proto/grpc/gcp/handshaker.proto
- ${WORKDIR}/grpc-proto/grpc/gcp/transport_security_common.proto
- ${WORKDIR}/grpc-proto/grpc/lookup/v1/rls.proto
- ${WORKDIR}/grpc-proto/grpc/lookup/v1/rls_config.proto
- ${WORKDIR}/grpc-proto/grpc/testing/*.proto
- ${WORKDIR}/grpc-proto/grpc/core/*.proto
-)
-
-# These options of the form 'Mfoo.proto=bar' instruct the codegen to use an
-# import path of 'bar' in the generated code when 'foo.proto' is imported in
-# one of the sources.
-#
-# Note that the protos listed here are all for testing purposes. All protos to
-# be used externally should have a go_package option (and they don't need to be
-# listed here).
-OPTS=Mgrpc/core/stats.proto=google.golang.org/grpc/interop/grpc_testing/core,\
-Mgrpc/testing/benchmark_service.proto=google.golang.org/grpc/interop/grpc_testing,\
-Mgrpc/testing/stats.proto=google.golang.org/grpc/interop/grpc_testing,\
-Mgrpc/testing/report_qps_scenario_service.proto=google.golang.org/grpc/interop/grpc_testing,\
-Mgrpc/testing/messages.proto=google.golang.org/grpc/interop/grpc_testing,\
-Mgrpc/testing/worker_service.proto=google.golang.org/grpc/interop/grpc_testing,\
-Mgrpc/testing/control.proto=google.golang.org/grpc/interop/grpc_testing,\
-Mgrpc/testing/test.proto=google.golang.org/grpc/interop/grpc_testing,\
-Mgrpc/testing/payloads.proto=google.golang.org/grpc/interop/grpc_testing,\
-Mgrpc/testing/empty.proto=google.golang.org/grpc/interop/grpc_testing
-
-for src in ${SOURCES[@]}; do
- echo "protoc ${src}"
- protoc --go_out=${OPTS}:${WORKDIR}/out --go-grpc_out=${OPTS},use_generic_streams_experimental=true:${WORKDIR}/out \
- -I"." \
- -I${WORKDIR}/grpc-proto \
- -I${WORKDIR}/googleapis \
- -I${WORKDIR}/protobuf/src \
- ${src}
-done
-
-for src in ${LEGACY_SOURCES[@]}; do
- echo "protoc ${src}"
- protoc --go_out=${OPTS}:${WORKDIR}/out --go-grpc_out=${OPTS},require_unimplemented_servers=false:${WORKDIR}/out \
- -I"." \
- -I${WORKDIR}/grpc-proto \
- -I${WORKDIR}/googleapis \
- -I${WORKDIR}/protobuf/src \
- ${src}
-done
-
-# The go_package option in grpc/lookup/v1/rls.proto doesn't match the
-# current location. Move it into the right place.
-mkdir -p ${WORKDIR}/out/google.golang.org/grpc/internal/proto/grpc_lookup_v1
-mv ${WORKDIR}/out/google.golang.org/grpc/lookup/grpc_lookup_v1/* ${WORKDIR}/out/google.golang.org/grpc/internal/proto/grpc_lookup_v1
-
-# grpc_testing_not_regenerate/*.pb.go are not re-generated,
-# see grpc_testing_not_regenerate/README.md for details.
-rm ${WORKDIR}/out/google.golang.org/grpc/reflection/test/grpc_testing_not_regenerate/*.pb.go
-
-cp -R ${WORKDIR}/out/google.golang.org/grpc/* .
diff --git a/vendor/google.golang.org/grpc/resolver/manual/manual.go b/vendor/google.golang.org/grpc/resolver/manual/manual.go
index f2efa2a2cb..09e864a89d 100644
--- a/vendor/google.golang.org/grpc/resolver/manual/manual.go
+++ b/vendor/google.golang.org/grpc/resolver/manual/manual.go
@@ -76,9 +76,11 @@ func (r *Resolver) InitialState(s resolver.State) {
// Build returns itself for Resolver, because it's both a builder and a resolver.
func (r *Resolver) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOptions) (resolver.Resolver, error) {
- r.BuildCallback(target, cc, opts)
r.mu.Lock()
defer r.mu.Unlock()
+ // Call BuildCallback after locking to avoid a race when UpdateState
+ // or ReportError is called before Build returns.
+ r.BuildCallback(target, cc, opts)
r.CC = cc
if r.lastSeenState != nil {
err := r.CC.UpdateState(*r.lastSeenState)
diff --git a/vendor/google.golang.org/grpc/resolver_wrapper.go b/vendor/google.golang.org/grpc/resolver_wrapper.go
index 9dcc9780f8..23bb3fb258 100644
--- a/vendor/google.golang.org/grpc/resolver_wrapper.go
+++ b/vendor/google.golang.org/grpc/resolver_wrapper.go
@@ -66,7 +66,7 @@ func newCCResolverWrapper(cc *ClientConn) *ccResolverWrapper {
// any newly created ccResolverWrapper, except that close may be called instead.
func (ccr *ccResolverWrapper) start() error {
errCh := make(chan error)
- ccr.serializer.Schedule(func(ctx context.Context) {
+ ccr.serializer.TrySchedule(func(ctx context.Context) {
if ctx.Err() != nil {
return
}
@@ -85,7 +85,7 @@ func (ccr *ccResolverWrapper) start() error {
}
func (ccr *ccResolverWrapper) resolveNow(o resolver.ResolveNowOptions) {
- ccr.serializer.Schedule(func(ctx context.Context) {
+ ccr.serializer.TrySchedule(func(ctx context.Context) {
if ctx.Err() != nil || ccr.resolver == nil {
return
}
@@ -102,7 +102,7 @@ func (ccr *ccResolverWrapper) close() {
ccr.closed = true
ccr.mu.Unlock()
- ccr.serializer.Schedule(func(context.Context) {
+ ccr.serializer.TrySchedule(func(context.Context) {
if ccr.resolver == nil {
return
}
@@ -171,12 +171,15 @@ func (ccr *ccResolverWrapper) NewAddress(addrs []resolver.Address) {
// ParseServiceConfig is called by resolver implementations to parse a JSON
// representation of the service config.
func (ccr *ccResolverWrapper) ParseServiceConfig(scJSON string) *serviceconfig.ParseResult {
- return parseServiceConfig(scJSON)
+ return parseServiceConfig(scJSON, ccr.cc.dopts.maxCallAttempts)
}
// addChannelzTraceEvent adds a channelz trace event containing the new
// state received from resolver implementations.
func (ccr *ccResolverWrapper) addChannelzTraceEvent(s resolver.State) {
+ if !logger.V(0) && !channelz.IsOn() {
+ return
+ }
var updates []string
var oldSC, newSC *ServiceConfig
var oldOK, newOK bool
diff --git a/vendor/google.golang.org/grpc/rpc_util.go b/vendor/google.golang.org/grpc/rpc_util.go
index fdd49e6e91..aba1ae3e67 100644
--- a/vendor/google.golang.org/grpc/rpc_util.go
+++ b/vendor/google.golang.org/grpc/rpc_util.go
@@ -19,7 +19,6 @@
package grpc
import (
- "bytes"
"compress/gzip"
"context"
"encoding/binary"
@@ -35,6 +34,7 @@ import (
"google.golang.org/grpc/encoding"
"google.golang.org/grpc/encoding/proto"
"google.golang.org/grpc/internal/transport"
+ "google.golang.org/grpc/mem"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/peer"
"google.golang.org/grpc/stats"
@@ -220,8 +220,8 @@ type HeaderCallOption struct {
HeaderAddr *metadata.MD
}
-func (o HeaderCallOption) before(c *callInfo) error { return nil }
-func (o HeaderCallOption) after(c *callInfo, attempt *csAttempt) {
+func (o HeaderCallOption) before(*callInfo) error { return nil }
+func (o HeaderCallOption) after(_ *callInfo, attempt *csAttempt) {
*o.HeaderAddr, _ = attempt.s.Header()
}
@@ -242,8 +242,8 @@ type TrailerCallOption struct {
TrailerAddr *metadata.MD
}
-func (o TrailerCallOption) before(c *callInfo) error { return nil }
-func (o TrailerCallOption) after(c *callInfo, attempt *csAttempt) {
+func (o TrailerCallOption) before(*callInfo) error { return nil }
+func (o TrailerCallOption) after(_ *callInfo, attempt *csAttempt) {
*o.TrailerAddr = attempt.s.Trailer()
}
@@ -264,24 +264,20 @@ type PeerCallOption struct {
PeerAddr *peer.Peer
}
-func (o PeerCallOption) before(c *callInfo) error { return nil }
-func (o PeerCallOption) after(c *callInfo, attempt *csAttempt) {
+func (o PeerCallOption) before(*callInfo) error { return nil }
+func (o PeerCallOption) after(_ *callInfo, attempt *csAttempt) {
if x, ok := peer.FromContext(attempt.s.Context()); ok {
*o.PeerAddr = *x
}
}
-// WaitForReady configures the action to take when an RPC is attempted on broken
-// connections or unreachable servers. If waitForReady is false and the
-// connection is in the TRANSIENT_FAILURE state, the RPC will fail
-// immediately. Otherwise, the RPC client will block the call until a
-// connection is available (or the call is canceled or times out) and will
-// retry the call if it fails due to a transient error. gRPC will not retry if
-// data was written to the wire unless the server indicates it did not process
-// the data. Please refer to
-// https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md.
+// WaitForReady configures the RPC's behavior when the client is in
+// TRANSIENT_FAILURE, which occurs when all addresses fail to connect. If
+// waitForReady is false, the RPC will fail immediately. Otherwise, the client
+// will wait until a connection becomes available or the RPC's deadline is
+// reached.
//
-// By default, RPCs don't "wait for ready".
+// By default, RPCs do not "wait for ready".
func WaitForReady(waitForReady bool) CallOption {
return FailFastCallOption{FailFast: !waitForReady}
}
@@ -308,7 +304,7 @@ func (o FailFastCallOption) before(c *callInfo) error {
c.failFast = o.FailFast
return nil
}
-func (o FailFastCallOption) after(c *callInfo, attempt *csAttempt) {}
+func (o FailFastCallOption) after(*callInfo, *csAttempt) {}
// OnFinish returns a CallOption that configures a callback to be called when
// the call completes. The error passed to the callback is the status of the
@@ -343,7 +339,7 @@ func (o OnFinishCallOption) before(c *callInfo) error {
return nil
}
-func (o OnFinishCallOption) after(c *callInfo, attempt *csAttempt) {}
+func (o OnFinishCallOption) after(*callInfo, *csAttempt) {}
// MaxCallRecvMsgSize returns a CallOption which sets the maximum message size
// in bytes the client can receive. If this is not set, gRPC uses the default
@@ -367,7 +363,7 @@ func (o MaxRecvMsgSizeCallOption) before(c *callInfo) error {
c.maxReceiveMessageSize = &o.MaxRecvMsgSize
return nil
}
-func (o MaxRecvMsgSizeCallOption) after(c *callInfo, attempt *csAttempt) {}
+func (o MaxRecvMsgSizeCallOption) after(*callInfo, *csAttempt) {}
// MaxCallSendMsgSize returns a CallOption which sets the maximum message size
// in bytes the client can send. If this is not set, gRPC uses the default
@@ -391,7 +387,7 @@ func (o MaxSendMsgSizeCallOption) before(c *callInfo) error {
c.maxSendMessageSize = &o.MaxSendMsgSize
return nil
}
-func (o MaxSendMsgSizeCallOption) after(c *callInfo, attempt *csAttempt) {}
+func (o MaxSendMsgSizeCallOption) after(*callInfo, *csAttempt) {}
// PerRPCCredentials returns a CallOption that sets credentials.PerRPCCredentials
// for a call.
@@ -414,7 +410,7 @@ func (o PerRPCCredsCallOption) before(c *callInfo) error {
c.creds = o.Creds
return nil
}
-func (o PerRPCCredsCallOption) after(c *callInfo, attempt *csAttempt) {}
+func (o PerRPCCredsCallOption) after(*callInfo, *csAttempt) {}
// UseCompressor returns a CallOption which sets the compressor used when
// sending the request. If WithCompressor is also set, UseCompressor has
@@ -442,7 +438,7 @@ func (o CompressorCallOption) before(c *callInfo) error {
c.compressorType = o.CompressorType
return nil
}
-func (o CompressorCallOption) after(c *callInfo, attempt *csAttempt) {}
+func (o CompressorCallOption) after(*callInfo, *csAttempt) {}
// CallContentSubtype returns a CallOption that will set the content-subtype
// for a call. For example, if content-subtype is "json", the Content-Type over
@@ -479,7 +475,7 @@ func (o ContentSubtypeCallOption) before(c *callInfo) error {
c.contentSubtype = o.ContentSubtype
return nil
}
-func (o ContentSubtypeCallOption) after(c *callInfo, attempt *csAttempt) {}
+func (o ContentSubtypeCallOption) after(*callInfo, *csAttempt) {}
// ForceCodec returns a CallOption that will set codec to be used for all
// request and response messages for a call. The result of calling Name() will
@@ -515,10 +511,50 @@ type ForceCodecCallOption struct {
}
func (o ForceCodecCallOption) before(c *callInfo) error {
- c.codec = o.Codec
+ c.codec = newCodecV1Bridge(o.Codec)
return nil
}
-func (o ForceCodecCallOption) after(c *callInfo, attempt *csAttempt) {}
+func (o ForceCodecCallOption) after(*callInfo, *csAttempt) {}
+
+// ForceCodecV2 returns a CallOption that will set codec to be used for all
+// request and response messages for a call. The result of calling Name() will
+// be used as the content-subtype after converting to lowercase, unless
+// CallContentSubtype is also used.
+//
+// See Content-Type on
+// https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#requests for
+// more details. Also see the documentation on RegisterCodec and
+// CallContentSubtype for more details on the interaction between Codec and
+// content-subtype.
+//
+// This function is provided for advanced users; prefer to use only
+// CallContentSubtype to select a registered codec instead.
+//
+// # Experimental
+//
+// Notice: This API is EXPERIMENTAL and may be changed or removed in a
+// later release.
+func ForceCodecV2(codec encoding.CodecV2) CallOption {
+ return ForceCodecV2CallOption{CodecV2: codec}
+}
+
+// ForceCodecV2CallOption is a CallOption that indicates the codec used for
+// marshaling messages.
+//
+// # Experimental
+//
+// Notice: This type is EXPERIMENTAL and may be changed or removed in a
+// later release.
+type ForceCodecV2CallOption struct {
+ CodecV2 encoding.CodecV2
+}
+
+func (o ForceCodecV2CallOption) before(c *callInfo) error {
+ c.codec = o.CodecV2
+ return nil
+}
+
+func (o ForceCodecV2CallOption) after(*callInfo, *csAttempt) {}
// CallCustomCodec behaves like ForceCodec, but accepts a grpc.Codec instead of
// an encoding.Codec.
@@ -540,10 +576,10 @@ type CustomCodecCallOption struct {
}
func (o CustomCodecCallOption) before(c *callInfo) error {
- c.codec = o.Codec
+ c.codec = newCodecV0Bridge(o.Codec)
return nil
}
-func (o CustomCodecCallOption) after(c *callInfo, attempt *csAttempt) {}
+func (o CustomCodecCallOption) after(*callInfo, *csAttempt) {}
// MaxRetryRPCBufferSize returns a CallOption that limits the amount of memory
// used for buffering this RPC's requests for retry purposes.
@@ -571,7 +607,7 @@ func (o MaxRetryRPCBufferSizeCallOption) before(c *callInfo) error {
c.maxRetryRPCBufferSize = o.MaxRetryRPCBufferSize
return nil
}
-func (o MaxRetryRPCBufferSizeCallOption) after(c *callInfo, attempt *csAttempt) {}
+func (o MaxRetryRPCBufferSizeCallOption) after(*callInfo, *csAttempt) {}
// The format of the payload: compressed or not?
type payloadFormat uint8
@@ -581,19 +617,28 @@ const (
compressionMade payloadFormat = 1 // compressed
)
+func (pf payloadFormat) isCompressed() bool {
+ return pf == compressionMade
+}
+
+type streamReader interface {
+ ReadHeader(header []byte) error
+ Read(n int) (mem.BufferSlice, error)
+}
+
// parser reads complete gRPC messages from the underlying reader.
type parser struct {
// r is the underlying reader.
// See the comment on recvMsg for the permissible
// error types.
- r io.Reader
+ r streamReader
// The header of a gRPC message. Find more detail at
// https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md
header [5]byte
- // recvBufferPool is the pool of shared receive buffers.
- recvBufferPool SharedBufferPool
+ // bufferPool is the pool of shared receive buffers.
+ bufferPool mem.BufferPool
}
// recvMsg reads a complete gRPC message from the stream.
@@ -608,14 +653,15 @@ type parser struct {
// - an error from the status package
//
// No other error values or types must be returned, which also means
-// that the underlying io.Reader must not return an incompatible
+// that the underlying streamReader must not return an incompatible
// error.
-func (p *parser) recvMsg(maxReceiveMessageSize int) (pf payloadFormat, msg []byte, err error) {
- if _, err := p.r.Read(p.header[:]); err != nil {
+func (p *parser) recvMsg(maxReceiveMessageSize int) (payloadFormat, mem.BufferSlice, error) {
+ err := p.r.ReadHeader(p.header[:])
+ if err != nil {
return 0, nil, err
}
- pf = payloadFormat(p.header[0])
+ pf := payloadFormat(p.header[0])
length := binary.BigEndian.Uint32(p.header[1:])
if length == 0 {
@@ -627,20 +673,21 @@ func (p *parser) recvMsg(maxReceiveMessageSize int) (pf payloadFormat, msg []byt
if int(length) > maxReceiveMessageSize {
return 0, nil, status.Errorf(codes.ResourceExhausted, "grpc: received message larger than max (%d vs. %d)", length, maxReceiveMessageSize)
}
- msg = p.recvBufferPool.Get(int(length))
- if _, err := p.r.Read(msg); err != nil {
+
+ data, err := p.r.Read(int(length))
+ if err != nil {
if err == io.EOF {
err = io.ErrUnexpectedEOF
}
return 0, nil, err
}
- return pf, msg, nil
+ return pf, data, nil
}
// encode serializes msg and returns a buffer containing the message, or an
// error if it is too large to be transmitted by grpc. If msg is nil, it
// generates an empty message.
-func encode(c baseCodec, msg any) ([]byte, error) {
+func encode(c baseCodec, msg any) (mem.BufferSlice, error) {
if msg == nil { // NOTE: typed nils will not be caught by this check
return nil, nil
}
@@ -648,7 +695,8 @@ func encode(c baseCodec, msg any) ([]byte, error) {
if err != nil {
return nil, status.Errorf(codes.Internal, "grpc: error while marshaling: %v", err.Error())
}
- if uint(len(b)) > math.MaxUint32 {
+ if uint(b.Len()) > math.MaxUint32 {
+ b.Free()
return nil, status.Errorf(codes.ResourceExhausted, "grpc: message too large (%d bytes)", len(b))
}
return b, nil
@@ -659,34 +707,41 @@ func encode(c baseCodec, msg any) ([]byte, error) {
// indicating no compression was done.
//
// TODO(dfawley): eliminate cp parameter by wrapping Compressor in an encoding.Compressor.
-func compress(in []byte, cp Compressor, compressor encoding.Compressor) ([]byte, error) {
- if compressor == nil && cp == nil {
- return nil, nil
- }
- if len(in) == 0 {
- return nil, nil
+func compress(in mem.BufferSlice, cp Compressor, compressor encoding.Compressor, pool mem.BufferPool) (mem.BufferSlice, payloadFormat, error) {
+ if (compressor == nil && cp == nil) || in.Len() == 0 {
+ return nil, compressionNone, nil
}
+ var out mem.BufferSlice
+ w := mem.NewWriter(&out, pool)
wrapErr := func(err error) error {
+ out.Free()
return status.Errorf(codes.Internal, "grpc: error while compressing: %v", err.Error())
}
- cbuf := &bytes.Buffer{}
if compressor != nil {
- z, err := compressor.Compress(cbuf)
+ z, err := compressor.Compress(w)
if err != nil {
- return nil, wrapErr(err)
+ return nil, 0, wrapErr(err)
}
- if _, err := z.Write(in); err != nil {
- return nil, wrapErr(err)
+ for _, b := range in {
+ if _, err := z.Write(b.ReadOnlyData()); err != nil {
+ return nil, 0, wrapErr(err)
+ }
}
if err := z.Close(); err != nil {
- return nil, wrapErr(err)
+ return nil, 0, wrapErr(err)
}
} else {
- if err := cp.Do(cbuf, in); err != nil {
- return nil, wrapErr(err)
+ // This is obviously really inefficient since it fully materializes the data, but
+ // there is no way around this with the old Compressor API. At least it attempts
+ // to return the buffer to the provider, in the hopes it can be reused (maybe
+ // even by a subsequent call to this very function).
+ buf := in.MaterializeToBuffer(pool)
+ defer buf.Free()
+ if err := cp.Do(w, buf.ReadOnlyData()); err != nil {
+ return nil, 0, wrapErr(err)
}
}
- return cbuf.Bytes(), nil
+ return out, compressionMade, nil
}
const (
@@ -697,33 +752,36 @@ const (
// msgHeader returns a 5-byte header for the message being transmitted and the
// payload, which is compData if non-nil or data otherwise.
-func msgHeader(data, compData []byte) (hdr []byte, payload []byte) {
+func msgHeader(data, compData mem.BufferSlice, pf payloadFormat) (hdr []byte, payload mem.BufferSlice) {
hdr = make([]byte, headerLen)
- if compData != nil {
- hdr[0] = byte(compressionMade)
- data = compData
+ hdr[0] = byte(pf)
+
+ var length uint32
+ if pf.isCompressed() {
+ length = uint32(compData.Len())
+ payload = compData
} else {
- hdr[0] = byte(compressionNone)
+ length = uint32(data.Len())
+ payload = data
}
// Write length of payload into buf
- binary.BigEndian.PutUint32(hdr[payloadLen:], uint32(len(data)))
- return hdr, data
+ binary.BigEndian.PutUint32(hdr[payloadLen:], length)
+ return hdr, payload
}
-func outPayload(client bool, msg any, data, payload []byte, t time.Time) *stats.OutPayload {
+func outPayload(client bool, msg any, dataLength, payloadLength int, t time.Time) *stats.OutPayload {
return &stats.OutPayload{
Client: client,
Payload: msg,
- Data: data,
- Length: len(data),
- WireLength: len(payload) + headerLen,
- CompressedLength: len(payload),
+ Length: dataLength,
+ WireLength: payloadLength + headerLen,
+ CompressedLength: payloadLength,
SentTime: t,
}
}
-func checkRecvPayload(pf payloadFormat, recvCompress string, haveCompressor bool) *status.Status {
+func checkRecvPayload(pf payloadFormat, recvCompress string, haveCompressor bool, isServer bool) *status.Status {
switch pf {
case compressionNone:
case compressionMade:
@@ -731,7 +789,10 @@ func checkRecvPayload(pf payloadFormat, recvCompress string, haveCompressor bool
return status.New(codes.Internal, "grpc: compressed flag set with identity or empty encoding")
}
if !haveCompressor {
- return status.Newf(codes.Unimplemented, "grpc: Decompressor is not installed for grpc-encoding %q", recvCompress)
+ if isServer {
+ return status.Newf(codes.Unimplemented, "grpc: Decompressor is not installed for grpc-encoding %q", recvCompress)
+ }
+ return status.Newf(codes.Internal, "grpc: Decompressor is not installed for grpc-encoding %q", recvCompress)
}
default:
return status.Newf(codes.Internal, "grpc: received unexpected payload format %d", pf)
@@ -741,104 +802,129 @@ func checkRecvPayload(pf payloadFormat, recvCompress string, haveCompressor bool
type payloadInfo struct {
compressedLength int // The compressed length got from wire.
- uncompressedBytes []byte
+ uncompressedBytes mem.BufferSlice
+}
+
+func (p *payloadInfo) free() {
+ if p != nil && p.uncompressedBytes != nil {
+ p.uncompressedBytes.Free()
+ }
}
// recvAndDecompress reads a message from the stream, decompressing it if necessary.
//
// Cancelling the returned cancel function releases the buffer back to the pool. So the caller should cancel as soon as
// the buffer is no longer needed.
-func recvAndDecompress(p *parser, s *transport.Stream, dc Decompressor, maxReceiveMessageSize int, payInfo *payloadInfo, compressor encoding.Compressor,
-) (uncompressedBuf []byte, cancel func(), err error) {
- pf, compressedBuf, err := p.recvMsg(maxReceiveMessageSize)
+// TODO: Refactor this function to reduce the number of arguments.
+// See: https://google.github.io/styleguide/go/best-practices.html#function-argument-lists
+func recvAndDecompress(p *parser, s *transport.Stream, dc Decompressor, maxReceiveMessageSize int, payInfo *payloadInfo, compressor encoding.Compressor, isServer bool,
+) (out mem.BufferSlice, err error) {
+ pf, compressed, err := p.recvMsg(maxReceiveMessageSize)
if err != nil {
- return nil, nil, err
+ return nil, err
}
- if st := checkRecvPayload(pf, s.RecvCompress(), compressor != nil || dc != nil); st != nil {
- return nil, nil, st.Err()
+ compressedLength := compressed.Len()
+
+ if st := checkRecvPayload(pf, s.RecvCompress(), compressor != nil || dc != nil, isServer); st != nil {
+ compressed.Free()
+ return nil, st.Err()
}
var size int
- if pf == compressionMade {
+ if pf.isCompressed() {
+ defer compressed.Free()
+
// To match legacy behavior, if the decompressor is set by WithDecompressor or RPCDecompressor,
// use this decompressor as the default.
if dc != nil {
- uncompressedBuf, err = dc.Do(bytes.NewReader(compressedBuf))
+ var uncompressedBuf []byte
+ uncompressedBuf, err = dc.Do(compressed.Reader())
+ if err == nil {
+ out = mem.BufferSlice{mem.NewBuffer(&uncompressedBuf, nil)}
+ }
size = len(uncompressedBuf)
} else {
- uncompressedBuf, size, err = decompress(compressor, compressedBuf, maxReceiveMessageSize)
+ out, size, err = decompress(compressor, compressed, maxReceiveMessageSize, p.bufferPool)
}
if err != nil {
- return nil, nil, status.Errorf(codes.Internal, "grpc: failed to decompress the received message: %v", err)
+ return nil, status.Errorf(codes.Internal, "grpc: failed to decompress the received message: %v", err)
}
if size > maxReceiveMessageSize {
+ out.Free()
// TODO: Revisit the error code. Currently keep it consistent with java
// implementation.
- return nil, nil, status.Errorf(codes.ResourceExhausted, "grpc: received message after decompression larger than max (%d vs. %d)", size, maxReceiveMessageSize)
+ return nil, status.Errorf(codes.ResourceExhausted, "grpc: received message after decompression larger than max (%d vs. %d)", size, maxReceiveMessageSize)
}
} else {
- uncompressedBuf = compressedBuf
+ out = compressed
}
if payInfo != nil {
- payInfo.compressedLength = len(compressedBuf)
- payInfo.uncompressedBytes = uncompressedBuf
-
- cancel = func() {}
- } else {
- cancel = func() {
- p.recvBufferPool.Put(&compressedBuf)
- }
+ payInfo.compressedLength = compressedLength
+ out.Ref()
+ payInfo.uncompressedBytes = out
}
- return uncompressedBuf, cancel, nil
+ return out, nil
}
// Using compressor, decompress d, returning data and size.
// Optionally, if data will be over maxReceiveMessageSize, just return the size.
-func decompress(compressor encoding.Compressor, d []byte, maxReceiveMessageSize int) ([]byte, int, error) {
- dcReader, err := compressor.Decompress(bytes.NewReader(d))
+func decompress(compressor encoding.Compressor, d mem.BufferSlice, maxReceiveMessageSize int, pool mem.BufferPool) (mem.BufferSlice, int, error) {
+ dcReader, err := compressor.Decompress(d.Reader())
if err != nil {
return nil, 0, err
}
- if sizer, ok := compressor.(interface {
- DecompressedSize(compressedBytes []byte) int
- }); ok {
- if size := sizer.DecompressedSize(d); size >= 0 {
- if size > maxReceiveMessageSize {
- return nil, size, nil
- }
- // size is used as an estimate to size the buffer, but we
- // will read more data if available.
- // +MinRead so ReadFrom will not reallocate if size is correct.
- //
- // TODO: If we ensure that the buffer size is the same as the DecompressedSize,
- // we can also utilize the recv buffer pool here.
- buf := bytes.NewBuffer(make([]byte, 0, size+bytes.MinRead))
- bytesRead, err := buf.ReadFrom(io.LimitReader(dcReader, int64(maxReceiveMessageSize)+1))
- return buf.Bytes(), int(bytesRead), err
- }
+
+ // TODO: Can/should this still be preserved with the new BufferSlice API? Are
+ // there any actual benefits to allocating a single large buffer instead of
+ // multiple smaller ones?
+ //if sizer, ok := compressor.(interface {
+ // DecompressedSize(compressedBytes []byte) int
+ //}); ok {
+ // if size := sizer.DecompressedSize(d); size >= 0 {
+ // if size > maxReceiveMessageSize {
+ // return nil, size, nil
+ // }
+ // // size is used as an estimate to size the buffer, but we
+ // // will read more data if available.
+ // // +MinRead so ReadFrom will not reallocate if size is correct.
+ // //
+ // // TODO: If we ensure that the buffer size is the same as the DecompressedSize,
+ // // we can also utilize the recv buffer pool here.
+ // buf := bytes.NewBuffer(make([]byte, 0, size+bytes.MinRead))
+ // bytesRead, err := buf.ReadFrom(io.LimitReader(dcReader, int64(maxReceiveMessageSize)+1))
+ // return buf.Bytes(), int(bytesRead), err
+ // }
+ //}
+
+ var out mem.BufferSlice
+ _, err = io.Copy(mem.NewWriter(&out, pool), io.LimitReader(dcReader, int64(maxReceiveMessageSize)+1))
+ if err != nil {
+ out.Free()
+ return nil, 0, err
}
- // Read from LimitReader with limit max+1. So if the underlying
- // reader is over limit, the result will be bigger than max.
- d, err = io.ReadAll(io.LimitReader(dcReader, int64(maxReceiveMessageSize)+1))
- return d, len(d), err
+ return out, out.Len(), nil
}
// For the two compressor parameters, both should not be set, but if they are,
// dc takes precedence over compressor.
// TODO(dfawley): wrap the old compressor/decompressor using the new API?
-func recv(p *parser, c baseCodec, s *transport.Stream, dc Decompressor, m any, maxReceiveMessageSize int, payInfo *payloadInfo, compressor encoding.Compressor) error {
- buf, cancel, err := recvAndDecompress(p, s, dc, maxReceiveMessageSize, payInfo, compressor)
+func recv(p *parser, c baseCodec, s *transport.Stream, dc Decompressor, m any, maxReceiveMessageSize int, payInfo *payloadInfo, compressor encoding.Compressor, isServer bool) error {
+ data, err := recvAndDecompress(p, s, dc, maxReceiveMessageSize, payInfo, compressor, isServer)
if err != nil {
return err
}
- defer cancel()
- if err := c.Unmarshal(buf, m); err != nil {
+ // If the codec wants its own reference to the data, it can get it. Otherwise, always
+ // free the buffers.
+ defer data.Free()
+
+ if err := c.Unmarshal(data, m); err != nil {
return status.Errorf(codes.Internal, "grpc: failed to unmarshal the received message: %v", err)
}
+
return nil
}
@@ -941,7 +1027,7 @@ func setCallInfoCodec(c *callInfo) error {
// encoding.Codec (Name vs. String method name). We only support
// setting content subtype from encoding.Codec to avoid a behavior
// change with the deprecated version.
- if ec, ok := c.codec.(encoding.Codec); ok {
+ if ec, ok := c.codec.(encoding.CodecV2); ok {
c.contentSubtype = strings.ToLower(ec.Name())
}
}
@@ -950,12 +1036,12 @@ func setCallInfoCodec(c *callInfo) error {
if c.contentSubtype == "" {
// No codec specified in CallOptions; use proto by default.
- c.codec = encoding.GetCodec(proto.Name)
+ c.codec = getCodec(proto.Name)
return nil
}
// c.contentSubtype is already lowercased in CallContentSubtype
- c.codec = encoding.GetCodec(c.contentSubtype)
+ c.codec = getCodec(c.contentSubtype)
if c.codec == nil {
return status.Errorf(codes.Internal, "no codec registered for content-subtype %s", c.contentSubtype)
}
diff --git a/vendor/google.golang.org/grpc/server.go b/vendor/google.golang.org/grpc/server.go
index 89f8e4792b..d1e1415a40 100644
--- a/vendor/google.golang.org/grpc/server.go
+++ b/vendor/google.golang.org/grpc/server.go
@@ -45,6 +45,7 @@ import (
"google.golang.org/grpc/internal/grpcutil"
"google.golang.org/grpc/internal/transport"
"google.golang.org/grpc/keepalive"
+ "google.golang.org/grpc/mem"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/peer"
"google.golang.org/grpc/stats"
@@ -80,7 +81,7 @@ func init() {
}
internal.BinaryLogger = binaryLogger
internal.JoinServerOptions = newJoinServerOption
- internal.RecvBufferPool = recvBufferPool
+ internal.BufferPool = bufferPool
}
var statusOK = status.New(codes.OK, "")
@@ -170,7 +171,7 @@ type serverOptions struct {
maxHeaderListSize *uint32
headerTableSize *uint32
numServerWorkers uint32
- recvBufferPool SharedBufferPool
+ bufferPool mem.BufferPool
waitForHandlers bool
}
@@ -181,7 +182,7 @@ var defaultServerOptions = serverOptions{
connectionTimeout: 120 * time.Second,
writeBufferSize: defaultWriteBufSize,
readBufferSize: defaultReadBufSize,
- recvBufferPool: nopBufferPool{},
+ bufferPool: mem.DefaultBufferPool(),
}
var globalServerOptions []ServerOption
@@ -313,7 +314,7 @@ func KeepaliveEnforcementPolicy(kep keepalive.EnforcementPolicy) ServerOption {
// Will be supported throughout 1.x.
func CustomCodec(codec Codec) ServerOption {
return newFuncServerOption(func(o *serverOptions) {
- o.codec = codec
+ o.codec = newCodecV0Bridge(codec)
})
}
@@ -342,7 +343,22 @@ func CustomCodec(codec Codec) ServerOption {
// later release.
func ForceServerCodec(codec encoding.Codec) ServerOption {
return newFuncServerOption(func(o *serverOptions) {
- o.codec = codec
+ o.codec = newCodecV1Bridge(codec)
+ })
+}
+
+// ForceServerCodecV2 is the equivalent of ForceServerCodec, but for the new
+// CodecV2 interface.
+//
+// Will be supported throughout 1.x.
+//
+// # Experimental
+//
+// Notice: This API is EXPERIMENTAL and may be changed or removed in a
+// later release.
+func ForceServerCodecV2(codecV2 encoding.CodecV2) ServerOption {
+ return newFuncServerOption(func(o *serverOptions) {
+ o.codec = codecV2
})
}
@@ -592,26 +608,9 @@ func WaitForHandlers(w bool) ServerOption {
})
}
-// RecvBufferPool returns a ServerOption that configures the server
-// to use the provided shared buffer pool for parsing incoming messages. Depending
-// on the application's workload, this could result in reduced memory allocation.
-//
-// If you are unsure about how to implement a memory pool but want to utilize one,
-// begin with grpc.NewSharedBufferPool.
-//
-// Note: The shared buffer pool feature will not be active if any of the following
-// options are used: StatsHandler, EnableTracing, or binary logging. In such
-// cases, the shared buffer pool will be ignored.
-//
-// Deprecated: use experimental.WithRecvBufferPool instead. Will be deleted in
-// v1.60.0 or later.
-func RecvBufferPool(bufferPool SharedBufferPool) ServerOption {
- return recvBufferPool(bufferPool)
-}
-
-func recvBufferPool(bufferPool SharedBufferPool) ServerOption {
+func bufferPool(bufferPool mem.BufferPool) ServerOption {
return newFuncServerOption(func(o *serverOptions) {
- o.recvBufferPool = bufferPool
+ o.bufferPool = bufferPool
})
}
@@ -622,7 +621,7 @@ func recvBufferPool(bufferPool SharedBufferPool) ServerOption {
// workload (assuming a QPS of a few thousand requests/sec).
const serverWorkerResetThreshold = 1 << 16
-// serverWorkers blocks on a *transport.Stream channel forever and waits for
+// serverWorker blocks on a *transport.Stream channel forever and waits for
// data to be fed by serveStreams. This allows multiple requests to be
// processed by the same goroutine, removing the need for expensive stack
// re-allocations (see the runtime.morestack problem [1]).
@@ -980,6 +979,7 @@ func (s *Server) newHTTP2Transport(c net.Conn) transport.ServerTransport {
ChannelzParent: s.channelz,
MaxHeaderListSize: s.opts.maxHeaderListSize,
HeaderTableSize: s.opts.headerTableSize,
+ BufferPool: s.opts.bufferPool,
}
st, err := transport.NewServerTransport(c, config)
if err != nil {
@@ -1072,7 +1072,7 @@ var _ http.Handler = (*Server)(nil)
// Notice: This API is EXPERIMENTAL and may be changed or removed in a
// later release.
func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
- st, err := transport.NewServerHandlerTransport(w, r, s.opts.statsHandlers)
+ st, err := transport.NewServerHandlerTransport(w, r, s.opts.statsHandlers, s.opts.bufferPool)
if err != nil {
// Errors returned from transport.NewServerHandlerTransport have
// already been written to w.
@@ -1142,20 +1142,35 @@ func (s *Server) sendResponse(ctx context.Context, t transport.ServerTransport,
channelz.Error(logger, s.channelz, "grpc: server failed to encode response: ", err)
return err
}
- compData, err := compress(data, cp, comp)
+
+ compData, pf, err := compress(data, cp, comp, s.opts.bufferPool)
if err != nil {
+ data.Free()
channelz.Error(logger, s.channelz, "grpc: server failed to compress response: ", err)
return err
}
- hdr, payload := msgHeader(data, compData)
+
+ hdr, payload := msgHeader(data, compData, pf)
+
+ defer func() {
+ compData.Free()
+ data.Free()
+ // payload does not need to be freed here, it is either data or compData, both of
+ // which are already freed.
+ }()
+
+ dataLen := data.Len()
+ payloadLen := payload.Len()
// TODO(dfawley): should we be checking len(data) instead?
- if len(payload) > s.opts.maxSendMessageSize {
- return status.Errorf(codes.ResourceExhausted, "grpc: trying to send message larger than max (%d vs. %d)", len(payload), s.opts.maxSendMessageSize)
+ if payloadLen > s.opts.maxSendMessageSize {
+ return status.Errorf(codes.ResourceExhausted, "grpc: trying to send message larger than max (%d vs. %d)", payloadLen, s.opts.maxSendMessageSize)
}
err = t.Write(stream, hdr, payload, opts)
if err == nil {
- for _, sh := range s.opts.statsHandlers {
- sh.HandleRPC(ctx, outPayload(false, msg, data, payload, time.Now()))
+ if len(s.opts.statsHandlers) != 0 {
+ for _, sh := range s.opts.statsHandlers {
+ sh.HandleRPC(ctx, outPayload(false, msg, dataLen, payloadLen, time.Now()))
+ }
}
}
return err
@@ -1334,37 +1349,37 @@ func (s *Server) processUnaryRPC(ctx context.Context, t transport.ServerTranspor
var payInfo *payloadInfo
if len(shs) != 0 || len(binlogs) != 0 {
payInfo = &payloadInfo{}
+ defer payInfo.free()
}
- d, cancel, err := recvAndDecompress(&parser{r: stream, recvBufferPool: s.opts.recvBufferPool}, stream, dc, s.opts.maxReceiveMessageSize, payInfo, decomp)
+ d, err := recvAndDecompress(&parser{r: stream, bufferPool: s.opts.bufferPool}, stream, dc, s.opts.maxReceiveMessageSize, payInfo, decomp, true)
if err != nil {
if e := t.WriteStatus(stream, status.Convert(err)); e != nil {
channelz.Warningf(logger, s.channelz, "grpc: Server.processUnaryRPC failed to write status: %v", e)
}
return err
}
+ defer d.Free()
if channelz.IsOn() {
t.IncrMsgRecv()
}
df := func(v any) error {
- defer cancel()
-
if err := s.getCodec(stream.ContentSubtype()).Unmarshal(d, v); err != nil {
return status.Errorf(codes.Internal, "grpc: error unmarshalling request: %v", err)
}
+
for _, sh := range shs {
sh.HandleRPC(ctx, &stats.InPayload{
RecvTime: time.Now(),
Payload: v,
- Length: len(d),
+ Length: d.Len(),
WireLength: payInfo.compressedLength + headerLen,
CompressedLength: payInfo.compressedLength,
- Data: d,
})
}
if len(binlogs) != 0 {
cm := &binarylog.ClientMessage{
- Message: d,
+ Message: d.Materialize(),
}
for _, binlog := range binlogs {
binlog.Log(ctx, cm)
@@ -1548,7 +1563,7 @@ func (s *Server) processStreamingRPC(ctx context.Context, t transport.ServerTran
ctx: ctx,
t: t,
s: stream,
- p: &parser{r: stream, recvBufferPool: s.opts.recvBufferPool},
+ p: &parser{r: stream, bufferPool: s.opts.bufferPool},
codec: s.getCodec(stream.ContentSubtype()),
maxReceiveMessageSize: s.opts.maxReceiveMessageSize,
maxSendMessageSize: s.opts.maxSendMessageSize,
@@ -1963,12 +1978,12 @@ func (s *Server) getCodec(contentSubtype string) baseCodec {
return s.opts.codec
}
if contentSubtype == "" {
- return encoding.GetCodec(proto.Name)
+ return getCodec(proto.Name)
}
- codec := encoding.GetCodec(contentSubtype)
+ codec := getCodec(contentSubtype)
if codec == nil {
logger.Warningf("Unsupported codec %q. Defaulting to %q for now. This will start to fail in future releases.", contentSubtype, proto.Name)
- return encoding.GetCodec(proto.Name)
+ return getCodec(proto.Name)
}
return codec
}
diff --git a/vendor/google.golang.org/grpc/service_config.go b/vendor/google.golang.org/grpc/service_config.go
index 9da8fc8027..2671c5ef69 100644
--- a/vendor/google.golang.org/grpc/service_config.go
+++ b/vendor/google.golang.org/grpc/service_config.go
@@ -26,6 +26,7 @@ import (
"time"
"google.golang.org/grpc/balancer"
+ "google.golang.org/grpc/balancer/pickfirst"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/internal"
"google.golang.org/grpc/internal/balancer/gracefulswitch"
@@ -163,9 +164,11 @@ type jsonSC struct {
}
func init() {
- internal.ParseServiceConfig = parseServiceConfig
+ internal.ParseServiceConfig = func(js string) *serviceconfig.ParseResult {
+ return parseServiceConfig(js, defaultMaxCallAttempts)
+ }
}
-func parseServiceConfig(js string) *serviceconfig.ParseResult {
+func parseServiceConfig(js string, maxAttempts int) *serviceconfig.ParseResult {
if len(js) == 0 {
return &serviceconfig.ParseResult{Err: fmt.Errorf("no JSON service config provided")}
}
@@ -183,12 +186,12 @@ func parseServiceConfig(js string) *serviceconfig.ParseResult {
}
c := rsc.LoadBalancingConfig
if c == nil {
- name := PickFirstBalancerName
+ name := pickfirst.Name
if rsc.LoadBalancingPolicy != nil {
name = *rsc.LoadBalancingPolicy
}
if balancer.Get(name) == nil {
- name = PickFirstBalancerName
+ name = pickfirst.Name
}
cfg := []map[string]any{{name: struct{}{}}}
strCfg, err := json.Marshal(cfg)
@@ -218,7 +221,7 @@ func parseServiceConfig(js string) *serviceconfig.ParseResult {
WaitForReady: m.WaitForReady,
Timeout: (*time.Duration)(m.Timeout),
}
- if mc.RetryPolicy, err = convertRetryPolicy(m.RetryPolicy); err != nil {
+ if mc.RetryPolicy, err = convertRetryPolicy(m.RetryPolicy, maxAttempts); err != nil {
logger.Warningf("grpc: unmarshalling service config %s: %v", js, err)
return &serviceconfig.ParseResult{Err: err}
}
@@ -264,7 +267,7 @@ func parseServiceConfig(js string) *serviceconfig.ParseResult {
return &serviceconfig.ParseResult{Config: &sc}
}
-func convertRetryPolicy(jrp *jsonRetryPolicy) (p *internalserviceconfig.RetryPolicy, err error) {
+func convertRetryPolicy(jrp *jsonRetryPolicy, maxAttempts int) (p *internalserviceconfig.RetryPolicy, err error) {
if jrp == nil {
return nil, nil
}
@@ -278,17 +281,16 @@ func convertRetryPolicy(jrp *jsonRetryPolicy) (p *internalserviceconfig.RetryPol
return nil, nil
}
+ if jrp.MaxAttempts < maxAttempts {
+ maxAttempts = jrp.MaxAttempts
+ }
rp := &internalserviceconfig.RetryPolicy{
- MaxAttempts: jrp.MaxAttempts,
+ MaxAttempts: maxAttempts,
InitialBackoff: time.Duration(jrp.InitialBackoff),
MaxBackoff: time.Duration(jrp.MaxBackoff),
BackoffMultiplier: jrp.BackoffMultiplier,
RetryableStatusCodes: make(map[codes.Code]bool),
}
- if rp.MaxAttempts > 5 {
- // TODO(retry): Make the max maxAttempts configurable.
- rp.MaxAttempts = 5
- }
for _, code := range jrp.RetryableStatusCodes {
rp.RetryableStatusCodes[code] = true
}
diff --git a/vendor/google.golang.org/grpc/shared_buffer_pool.go b/vendor/google.golang.org/grpc/shared_buffer_pool.go
deleted file mode 100644
index 48a64cfe8e..0000000000
--- a/vendor/google.golang.org/grpc/shared_buffer_pool.go
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- *
- * Copyright 2023 gRPC 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 grpc
-
-import "sync"
-
-// SharedBufferPool is a pool of buffers that can be shared, resulting in
-// decreased memory allocation. Currently, in gRPC-go, it is only utilized
-// for parsing incoming messages.
-//
-// # Experimental
-//
-// Notice: This API is EXPERIMENTAL and may be changed or removed in a
-// later release.
-type SharedBufferPool interface {
- // Get returns a buffer with specified length from the pool.
- //
- // The returned byte slice may be not zero initialized.
- Get(length int) []byte
-
- // Put returns a buffer to the pool.
- Put(*[]byte)
-}
-
-// NewSharedBufferPool creates a simple SharedBufferPool with buckets
-// of different sizes to optimize memory usage. This prevents the pool from
-// wasting large amounts of memory, even when handling messages of varying sizes.
-//
-// # Experimental
-//
-// Notice: This API is EXPERIMENTAL and may be changed or removed in a
-// later release.
-func NewSharedBufferPool() SharedBufferPool {
- return &simpleSharedBufferPool{
- pools: [poolArraySize]simpleSharedBufferChildPool{
- newBytesPool(level0PoolMaxSize),
- newBytesPool(level1PoolMaxSize),
- newBytesPool(level2PoolMaxSize),
- newBytesPool(level3PoolMaxSize),
- newBytesPool(level4PoolMaxSize),
- newBytesPool(0),
- },
- }
-}
-
-// simpleSharedBufferPool is a simple implementation of SharedBufferPool.
-type simpleSharedBufferPool struct {
- pools [poolArraySize]simpleSharedBufferChildPool
-}
-
-func (p *simpleSharedBufferPool) Get(size int) []byte {
- return p.pools[p.poolIdx(size)].Get(size)
-}
-
-func (p *simpleSharedBufferPool) Put(bs *[]byte) {
- p.pools[p.poolIdx(cap(*bs))].Put(bs)
-}
-
-func (p *simpleSharedBufferPool) poolIdx(size int) int {
- switch {
- case size <= level0PoolMaxSize:
- return level0PoolIdx
- case size <= level1PoolMaxSize:
- return level1PoolIdx
- case size <= level2PoolMaxSize:
- return level2PoolIdx
- case size <= level3PoolMaxSize:
- return level3PoolIdx
- case size <= level4PoolMaxSize:
- return level4PoolIdx
- default:
- return levelMaxPoolIdx
- }
-}
-
-const (
- level0PoolMaxSize = 16 // 16 B
- level1PoolMaxSize = level0PoolMaxSize * 16 // 256 B
- level2PoolMaxSize = level1PoolMaxSize * 16 // 4 KB
- level3PoolMaxSize = level2PoolMaxSize * 16 // 64 KB
- level4PoolMaxSize = level3PoolMaxSize * 16 // 1 MB
-)
-
-const (
- level0PoolIdx = iota
- level1PoolIdx
- level2PoolIdx
- level3PoolIdx
- level4PoolIdx
- levelMaxPoolIdx
- poolArraySize
-)
-
-type simpleSharedBufferChildPool interface {
- Get(size int) []byte
- Put(any)
-}
-
-type bufferPool struct {
- sync.Pool
-
- defaultSize int
-}
-
-func (p *bufferPool) Get(size int) []byte {
- bs := p.Pool.Get().(*[]byte)
-
- if cap(*bs) < size {
- p.Pool.Put(bs)
-
- return make([]byte, size)
- }
-
- return (*bs)[:size]
-}
-
-func newBytesPool(size int) simpleSharedBufferChildPool {
- return &bufferPool{
- Pool: sync.Pool{
- New: func() any {
- bs := make([]byte, size)
- return &bs
- },
- },
- defaultSize: size,
- }
-}
-
-// nopBufferPool is a buffer pool just makes new buffer without pooling.
-type nopBufferPool struct {
-}
-
-func (nopBufferPool) Get(length int) []byte {
- return make([]byte, length)
-}
-
-func (nopBufferPool) Put(*[]byte) {
-}
diff --git a/vendor/google.golang.org/grpc/stats/stats.go b/vendor/google.golang.org/grpc/stats/stats.go
index fdb0bd6518..71195c4943 100644
--- a/vendor/google.golang.org/grpc/stats/stats.go
+++ b/vendor/google.golang.org/grpc/stats/stats.go
@@ -77,9 +77,6 @@ type InPayload struct {
// the call to HandleRPC which provides the InPayload returns and must be
// copied if needed later.
Payload any
- // Data is the serialized message payload.
- // Deprecated: Data will be removed in the next release.
- Data []byte
// Length is the size of the uncompressed payload data. Does not include any
// framing (gRPC or HTTP/2).
@@ -150,9 +147,6 @@ type OutPayload struct {
// the call to HandleRPC which provides the OutPayload returns and must be
// copied if needed later.
Payload any
- // Data is the serialized message payload.
- // Deprecated: Data will be removed in the next release.
- Data []byte
// Length is the size of the uncompressed payload data. Does not include any
// framing (gRPC or HTTP/2).
Length int
diff --git a/vendor/google.golang.org/grpc/stream.go b/vendor/google.golang.org/grpc/stream.go
index b54563e81c..bb2b2a216c 100644
--- a/vendor/google.golang.org/grpc/stream.go
+++ b/vendor/google.golang.org/grpc/stream.go
@@ -23,6 +23,7 @@ import (
"errors"
"io"
"math"
+ "math/rand"
"strconv"
"sync"
"time"
@@ -34,13 +35,13 @@ import (
"google.golang.org/grpc/internal/balancerload"
"google.golang.org/grpc/internal/binarylog"
"google.golang.org/grpc/internal/channelz"
- "google.golang.org/grpc/internal/grpcrand"
"google.golang.org/grpc/internal/grpcutil"
imetadata "google.golang.org/grpc/internal/metadata"
iresolver "google.golang.org/grpc/internal/resolver"
"google.golang.org/grpc/internal/serviceconfig"
istatus "google.golang.org/grpc/internal/status"
"google.golang.org/grpc/internal/transport"
+ "google.golang.org/grpc/mem"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/peer"
"google.golang.org/grpc/stats"
@@ -359,7 +360,7 @@ func newClientStreamWithParams(ctx context.Context, desc *StreamDesc, cc *Client
cs.attempt = a
return nil
}
- if err := cs.withRetry(op, func() { cs.bufferForRetryLocked(0, op) }); err != nil {
+ if err := cs.withRetry(op, func() { cs.bufferForRetryLocked(0, op, nil) }); err != nil {
return nil, err
}
@@ -517,7 +518,7 @@ func (a *csAttempt) newStream() error {
}
a.s = s
a.ctx = s.Context()
- a.p = &parser{r: s, recvBufferPool: a.cs.cc.dopts.recvBufferPool}
+ a.p = &parser{r: s, bufferPool: a.cs.cc.dopts.copts.BufferPool}
return nil
}
@@ -566,10 +567,15 @@ type clientStream struct {
// place where we need to check if the attempt is nil.
attempt *csAttempt
// TODO(hedging): hedging will have multiple attempts simultaneously.
- committed bool // active attempt committed for retry?
- onCommit func()
- buffer []func(a *csAttempt) error // operations to replay on retry
- bufferSize int // current size of buffer
+ committed bool // active attempt committed for retry?
+ onCommit func()
+ replayBuffer []replayOp // operations to replay on retry
+ replayBufferSize int // current size of replayBuffer
+}
+
+type replayOp struct {
+ op func(a *csAttempt) error
+ cleanup func()
}
// csAttempt implements a single transport stream attempt within a
@@ -607,7 +613,12 @@ func (cs *clientStream) commitAttemptLocked() {
cs.onCommit()
}
cs.committed = true
- cs.buffer = nil
+ for _, op := range cs.replayBuffer {
+ if op.cleanup != nil {
+ op.cleanup()
+ }
+ }
+ cs.replayBuffer = nil
}
func (cs *clientStream) commitAttempt() {
@@ -699,7 +710,7 @@ func (a *csAttempt) shouldRetry(err error) (bool, error) {
if max := float64(rp.MaxBackoff); cur > max {
cur = max
}
- dur = time.Duration(grpcrand.Int63n(int64(cur)))
+ dur = time.Duration(rand.Int63n(int64(cur)))
cs.numRetriesSincePushback++
}
@@ -732,7 +743,7 @@ func (cs *clientStream) retryLocked(attempt *csAttempt, lastErr error) error {
// the stream is canceled.
return err
}
- // Note that the first op in the replay buffer always sets cs.attempt
+ // Note that the first op in replayBuffer always sets cs.attempt
// if it is able to pick a transport and create a stream.
if lastErr = cs.replayBufferLocked(attempt); lastErr == nil {
return nil
@@ -761,7 +772,7 @@ func (cs *clientStream) withRetry(op func(a *csAttempt) error, onSuccess func())
// already be status errors.
return toRPCErr(op(cs.attempt))
}
- if len(cs.buffer) == 0 {
+ if len(cs.replayBuffer) == 0 {
// For the first op, which controls creation of the stream and
// assigns cs.attempt, we need to create a new attempt inline
// before executing the first op. On subsequent ops, the attempt
@@ -851,25 +862,26 @@ func (cs *clientStream) Trailer() metadata.MD {
}
func (cs *clientStream) replayBufferLocked(attempt *csAttempt) error {
- for _, f := range cs.buffer {
- if err := f(attempt); err != nil {
+ for _, f := range cs.replayBuffer {
+ if err := f.op(attempt); err != nil {
return err
}
}
return nil
}
-func (cs *clientStream) bufferForRetryLocked(sz int, op func(a *csAttempt) error) {
+func (cs *clientStream) bufferForRetryLocked(sz int, op func(a *csAttempt) error, cleanup func()) {
// Note: we still will buffer if retry is disabled (for transparent retries).
if cs.committed {
return
}
- cs.bufferSize += sz
- if cs.bufferSize > cs.callInfo.maxRetryRPCBufferSize {
+ cs.replayBufferSize += sz
+ if cs.replayBufferSize > cs.callInfo.maxRetryRPCBufferSize {
cs.commitAttemptLocked()
+ cleanup()
return
}
- cs.buffer = append(cs.buffer, op)
+ cs.replayBuffer = append(cs.replayBuffer, replayOp{op: op, cleanup: cleanup})
}
func (cs *clientStream) SendMsg(m any) (err error) {
@@ -891,23 +903,50 @@ func (cs *clientStream) SendMsg(m any) (err error) {
}
// load hdr, payload, data
- hdr, payload, data, err := prepareMsg(m, cs.codec, cs.cp, cs.comp)
+ hdr, data, payload, pf, err := prepareMsg(m, cs.codec, cs.cp, cs.comp, cs.cc.dopts.copts.BufferPool)
if err != nil {
return err
}
+ defer func() {
+ data.Free()
+ // only free payload if compression was made, and therefore it is a different set
+ // of buffers from data.
+ if pf.isCompressed() {
+ payload.Free()
+ }
+ }()
+
+ dataLen := data.Len()
+ payloadLen := payload.Len()
// TODO(dfawley): should we be checking len(data) instead?
- if len(payload) > *cs.callInfo.maxSendMessageSize {
- return status.Errorf(codes.ResourceExhausted, "trying to send message larger than max (%d vs. %d)", len(payload), *cs.callInfo.maxSendMessageSize)
+ if payloadLen > *cs.callInfo.maxSendMessageSize {
+ return status.Errorf(codes.ResourceExhausted, "trying to send message larger than max (%d vs. %d)", payloadLen, *cs.callInfo.maxSendMessageSize)
}
+
+ // always take an extra ref in case data == payload (i.e. when the data isn't
+ // compressed). The original ref will always be freed by the deferred free above.
+ payload.Ref()
op := func(a *csAttempt) error {
- return a.sendMsg(m, hdr, payload, data)
+ return a.sendMsg(m, hdr, payload, dataLen, payloadLen)
+ }
+
+ // onSuccess is invoked when the op is captured for a subsequent retry. If the
+ // stream was established by a previous message and therefore retries are
+ // disabled, onSuccess will not be invoked, and payloadRef can be freed
+ // immediately.
+ onSuccessCalled := false
+ err = cs.withRetry(op, func() {
+ cs.bufferForRetryLocked(len(hdr)+payloadLen, op, payload.Free)
+ onSuccessCalled = true
+ })
+ if !onSuccessCalled {
+ payload.Free()
}
- err = cs.withRetry(op, func() { cs.bufferForRetryLocked(len(hdr)+len(payload), op) })
if len(cs.binlogs) != 0 && err == nil {
cm := &binarylog.ClientMessage{
OnClientSide: true,
- Message: data,
+ Message: data.Materialize(),
}
for _, binlog := range cs.binlogs {
binlog.Log(cs.ctx, cm)
@@ -924,6 +963,7 @@ func (cs *clientStream) RecvMsg(m any) error {
var recvInfo *payloadInfo
if len(cs.binlogs) != 0 {
recvInfo = &payloadInfo{}
+ defer recvInfo.free()
}
err := cs.withRetry(func(a *csAttempt) error {
return a.recvMsg(m, recvInfo)
@@ -931,7 +971,7 @@ func (cs *clientStream) RecvMsg(m any) error {
if len(cs.binlogs) != 0 && err == nil {
sm := &binarylog.ServerMessage{
OnClientSide: true,
- Message: recvInfo.uncompressedBytes,
+ Message: recvInfo.uncompressedBytes.Materialize(),
}
for _, binlog := range cs.binlogs {
binlog.Log(cs.ctx, sm)
@@ -958,7 +998,7 @@ func (cs *clientStream) CloseSend() error {
// RecvMsg. This also matches historical behavior.
return nil
}
- cs.withRetry(op, func() { cs.bufferForRetryLocked(0, op) })
+ cs.withRetry(op, func() { cs.bufferForRetryLocked(0, op, nil) })
if len(cs.binlogs) != 0 {
chc := &binarylog.ClientHalfClose{
OnClientSide: true,
@@ -1034,7 +1074,7 @@ func (cs *clientStream) finish(err error) {
cs.cancel()
}
-func (a *csAttempt) sendMsg(m any, hdr, payld, data []byte) error {
+func (a *csAttempt) sendMsg(m any, hdr []byte, payld mem.BufferSlice, dataLength, payloadLength int) error {
cs := a.cs
if a.trInfo != nil {
a.mu.Lock()
@@ -1052,8 +1092,10 @@ func (a *csAttempt) sendMsg(m any, hdr, payld, data []byte) error {
}
return io.EOF
}
- for _, sh := range a.statsHandlers {
- sh.HandleRPC(a.ctx, outPayload(true, m, data, payld, time.Now()))
+ if len(a.statsHandlers) != 0 {
+ for _, sh := range a.statsHandlers {
+ sh.HandleRPC(a.ctx, outPayload(true, m, dataLength, payloadLength, time.Now()))
+ }
}
if channelz.IsOn() {
a.t.IncrMsgSent()
@@ -1065,6 +1107,7 @@ func (a *csAttempt) recvMsg(m any, payInfo *payloadInfo) (err error) {
cs := a.cs
if len(a.statsHandlers) != 0 && payInfo == nil {
payInfo = &payloadInfo{}
+ defer payInfo.free()
}
if !a.decompSet {
@@ -1083,8 +1126,7 @@ func (a *csAttempt) recvMsg(m any, payInfo *payloadInfo) (err error) {
// Only initialize this state once per stream.
a.decompSet = true
}
- err = recv(a.p, cs.codec, a.s, a.dc, m, *cs.callInfo.maxReceiveMessageSize, payInfo, a.decomp)
- if err != nil {
+ if err := recv(a.p, cs.codec, a.s, a.dc, m, *cs.callInfo.maxReceiveMessageSize, payInfo, a.decomp, false); err != nil {
if err == io.EOF {
if statusErr := a.s.Status().Err(); statusErr != nil {
return statusErr
@@ -1103,14 +1145,12 @@ func (a *csAttempt) recvMsg(m any, payInfo *payloadInfo) (err error) {
}
for _, sh := range a.statsHandlers {
sh.HandleRPC(a.ctx, &stats.InPayload{
- Client: true,
- RecvTime: time.Now(),
- Payload: m,
- // TODO truncate large payload.
- Data: payInfo.uncompressedBytes,
+ Client: true,
+ RecvTime: time.Now(),
+ Payload: m,
WireLength: payInfo.compressedLength + headerLen,
CompressedLength: payInfo.compressedLength,
- Length: len(payInfo.uncompressedBytes),
+ Length: payInfo.uncompressedBytes.Len(),
})
}
if channelz.IsOn() {
@@ -1122,14 +1162,12 @@ func (a *csAttempt) recvMsg(m any, payInfo *payloadInfo) (err error) {
}
// Special handling for non-server-stream rpcs.
// This recv expects EOF or errors, so we don't collect inPayload.
- err = recv(a.p, cs.codec, a.s, a.dc, m, *cs.callInfo.maxReceiveMessageSize, nil, a.decomp)
- if err == nil {
- return toRPCErr(errors.New("grpc: client streaming protocol violation: get , want "))
- }
- if err == io.EOF {
+ if err := recv(a.p, cs.codec, a.s, a.dc, m, *cs.callInfo.maxReceiveMessageSize, nil, a.decomp, false); err == io.EOF {
return a.s.Status().Err() // non-server streaming Recv returns nil on success
+ } else if err != nil {
+ return toRPCErr(err)
}
- return toRPCErr(err)
+ return toRPCErr(errors.New("grpc: client streaming protocol violation: get , want "))
}
func (a *csAttempt) finish(err error) {
@@ -1185,12 +1223,12 @@ func (a *csAttempt) finish(err error) {
a.mu.Unlock()
}
-// newClientStream creates a ClientStream with the specified transport, on the
+// newNonRetryClientStream creates a ClientStream with the specified transport, on the
// given addrConn.
//
// It's expected that the given transport is either the same one in addrConn, or
// is already closed. To avoid race, transport is specified separately, instead
-// of using ac.transpot.
+// of using ac.transport.
//
// Main difference between this and ClientConn.NewStream:
// - no retry
@@ -1276,7 +1314,7 @@ func newNonRetryClientStream(ctx context.Context, desc *StreamDesc, method strin
return nil, err
}
as.s = s
- as.p = &parser{r: s, recvBufferPool: ac.dopts.recvBufferPool}
+ as.p = &parser{r: s, bufferPool: ac.dopts.copts.BufferPool}
ac.incrCallsStarted()
if desc != unaryStreamDesc {
// Listen on stream context to cleanup when the stream context is
@@ -1373,17 +1411,26 @@ func (as *addrConnStream) SendMsg(m any) (err error) {
}
// load hdr, payload, data
- hdr, payld, _, err := prepareMsg(m, as.codec, as.cp, as.comp)
+ hdr, data, payload, pf, err := prepareMsg(m, as.codec, as.cp, as.comp, as.ac.dopts.copts.BufferPool)
if err != nil {
return err
}
+ defer func() {
+ data.Free()
+ // only free payload if compression was made, and therefore it is a different set
+ // of buffers from data.
+ if pf.isCompressed() {
+ payload.Free()
+ }
+ }()
+
// TODO(dfawley): should we be checking len(data) instead?
- if len(payld) > *as.callInfo.maxSendMessageSize {
- return status.Errorf(codes.ResourceExhausted, "trying to send message larger than max (%d vs. %d)", len(payld), *as.callInfo.maxSendMessageSize)
+ if payload.Len() > *as.callInfo.maxSendMessageSize {
+ return status.Errorf(codes.ResourceExhausted, "trying to send message larger than max (%d vs. %d)", payload.Len(), *as.callInfo.maxSendMessageSize)
}
- if err := as.t.Write(as.s, hdr, payld, &transport.Options{Last: !as.desc.ClientStreams}); err != nil {
+ if err := as.t.Write(as.s, hdr, payload, &transport.Options{Last: !as.desc.ClientStreams}); err != nil {
if !as.desc.ClientStreams {
// For non-client-streaming RPCs, we return nil instead of EOF on error
// because the generated code requires it. finish is not called; RecvMsg()
@@ -1423,8 +1470,7 @@ func (as *addrConnStream) RecvMsg(m any) (err error) {
// Only initialize this state once per stream.
as.decompSet = true
}
- err = recv(as.p, as.codec, as.s, as.dc, m, *as.callInfo.maxReceiveMessageSize, nil, as.decomp)
- if err != nil {
+ if err := recv(as.p, as.codec, as.s, as.dc, m, *as.callInfo.maxReceiveMessageSize, nil, as.decomp, false); err != nil {
if err == io.EOF {
if statusErr := as.s.Status().Err(); statusErr != nil {
return statusErr
@@ -1444,14 +1490,12 @@ func (as *addrConnStream) RecvMsg(m any) (err error) {
// Special handling for non-server-stream rpcs.
// This recv expects EOF or errors, so we don't collect inPayload.
- err = recv(as.p, as.codec, as.s, as.dc, m, *as.callInfo.maxReceiveMessageSize, nil, as.decomp)
- if err == nil {
- return toRPCErr(errors.New("grpc: client streaming protocol violation: get , want "))
- }
- if err == io.EOF {
+ if err := recv(as.p, as.codec, as.s, as.dc, m, *as.callInfo.maxReceiveMessageSize, nil, as.decomp, false); err == io.EOF {
return as.s.Status().Err() // non-server streaming Recv returns nil on success
+ } else if err != nil {
+ return toRPCErr(err)
}
- return toRPCErr(err)
+ return toRPCErr(errors.New("grpc: client streaming protocol violation: get , want "))
}
func (as *addrConnStream) finish(err error) {
@@ -1645,18 +1689,31 @@ func (ss *serverStream) SendMsg(m any) (err error) {
}
// load hdr, payload, data
- hdr, payload, data, err := prepareMsg(m, ss.codec, ss.cp, ss.comp)
+ hdr, data, payload, pf, err := prepareMsg(m, ss.codec, ss.cp, ss.comp, ss.p.bufferPool)
if err != nil {
return err
}
+ defer func() {
+ data.Free()
+ // only free payload if compression was made, and therefore it is a different set
+ // of buffers from data.
+ if pf.isCompressed() {
+ payload.Free()
+ }
+ }()
+
+ dataLen := data.Len()
+ payloadLen := payload.Len()
+
// TODO(dfawley): should we be checking len(data) instead?
- if len(payload) > ss.maxSendMessageSize {
- return status.Errorf(codes.ResourceExhausted, "trying to send message larger than max (%d vs. %d)", len(payload), ss.maxSendMessageSize)
+ if payloadLen > ss.maxSendMessageSize {
+ return status.Errorf(codes.ResourceExhausted, "trying to send message larger than max (%d vs. %d)", payloadLen, ss.maxSendMessageSize)
}
if err := ss.t.Write(ss.s, hdr, payload, &transport.Options{Last: false}); err != nil {
return toRPCErr(err)
}
+
if len(ss.binlogs) != 0 {
if !ss.serverHeaderBinlogged {
h, _ := ss.s.Header()
@@ -1669,7 +1726,7 @@ func (ss *serverStream) SendMsg(m any) (err error) {
}
}
sm := &binarylog.ServerMessage{
- Message: data,
+ Message: data.Materialize(),
}
for _, binlog := range ss.binlogs {
binlog.Log(ss.ctx, sm)
@@ -1677,7 +1734,7 @@ func (ss *serverStream) SendMsg(m any) (err error) {
}
if len(ss.statsHandler) != 0 {
for _, sh := range ss.statsHandler {
- sh.HandleRPC(ss.s.Context(), outPayload(false, m, data, payload, time.Now()))
+ sh.HandleRPC(ss.s.Context(), outPayload(false, m, dataLen, payloadLen, time.Now()))
}
}
return nil
@@ -1714,8 +1771,9 @@ func (ss *serverStream) RecvMsg(m any) (err error) {
var payInfo *payloadInfo
if len(ss.statsHandler) != 0 || len(ss.binlogs) != 0 {
payInfo = &payloadInfo{}
+ defer payInfo.free()
}
- if err := recv(ss.p, ss.codec, ss.s, ss.dc, m, ss.maxReceiveMessageSize, payInfo, ss.decomp); err != nil {
+ if err := recv(ss.p, ss.codec, ss.s, ss.dc, m, ss.maxReceiveMessageSize, payInfo, ss.decomp, true); err != nil {
if err == io.EOF {
if len(ss.binlogs) != 0 {
chc := &binarylog.ClientHalfClose{}
@@ -1733,11 +1791,9 @@ func (ss *serverStream) RecvMsg(m any) (err error) {
if len(ss.statsHandler) != 0 {
for _, sh := range ss.statsHandler {
sh.HandleRPC(ss.s.Context(), &stats.InPayload{
- RecvTime: time.Now(),
- Payload: m,
- // TODO truncate large payload.
- Data: payInfo.uncompressedBytes,
- Length: len(payInfo.uncompressedBytes),
+ RecvTime: time.Now(),
+ Payload: m,
+ Length: payInfo.uncompressedBytes.Len(),
WireLength: payInfo.compressedLength + headerLen,
CompressedLength: payInfo.compressedLength,
})
@@ -1745,7 +1801,7 @@ func (ss *serverStream) RecvMsg(m any) (err error) {
}
if len(ss.binlogs) != 0 {
cm := &binarylog.ClientMessage{
- Message: payInfo.uncompressedBytes,
+ Message: payInfo.uncompressedBytes.Materialize(),
}
for _, binlog := range ss.binlogs {
binlog.Log(ss.ctx, cm)
@@ -1760,23 +1816,26 @@ func MethodFromServerStream(stream ServerStream) (string, bool) {
return Method(stream.Context())
}
-// prepareMsg returns the hdr, payload and data
-// using the compressors passed or using the
-// passed preparedmsg
-func prepareMsg(m any, codec baseCodec, cp Compressor, comp encoding.Compressor) (hdr, payload, data []byte, err error) {
+// prepareMsg returns the hdr, payload and data using the compressors passed or
+// using the passed preparedmsg. The returned boolean indicates whether
+// compression was made and therefore whether the payload needs to be freed in
+// addition to the returned data. Freeing the payload if the returned boolean is
+// false can lead to undefined behavior.
+func prepareMsg(m any, codec baseCodec, cp Compressor, comp encoding.Compressor, pool mem.BufferPool) (hdr []byte, data, payload mem.BufferSlice, pf payloadFormat, err error) {
if preparedMsg, ok := m.(*PreparedMsg); ok {
- return preparedMsg.hdr, preparedMsg.payload, preparedMsg.encodedData, nil
+ return preparedMsg.hdr, preparedMsg.encodedData, preparedMsg.payload, preparedMsg.pf, nil
}
// The input interface is not a prepared msg.
// Marshal and Compress the data at this point
data, err = encode(codec, m)
if err != nil {
- return nil, nil, nil, err
+ return nil, nil, nil, 0, err
}
- compData, err := compress(data, cp, comp)
+ compData, pf, err := compress(data, cp, comp, pool)
if err != nil {
- return nil, nil, nil, err
+ data.Free()
+ return nil, nil, nil, 0, err
}
- hdr, payload = msgHeader(data, compData)
- return hdr, payload, data, nil
+ hdr, payload = msgHeader(data, compData, pf)
+ return hdr, data, payload, pf, nil
}
diff --git a/vendor/google.golang.org/grpc/stream_interfaces.go b/vendor/google.golang.org/grpc/stream_interfaces.go
index 8b813529c0..0037fee0bd 100644
--- a/vendor/google.golang.org/grpc/stream_interfaces.go
+++ b/vendor/google.golang.org/grpc/stream_interfaces.go
@@ -22,15 +22,35 @@ package grpc
// request, many responses) RPC. It is generic over the type of the response
// message. It is used in generated code.
type ServerStreamingClient[Res any] interface {
+ // Recv receives the next response message from the server. The client may
+ // repeatedly call Recv to read messages from the response stream. If
+ // io.EOF is returned, the stream has terminated with an OK status. Any
+ // other error is compatible with the status package and indicates the
+ // RPC's status code and message.
Recv() (*Res, error)
+
+ // ClientStream is embedded to provide Context, Header, and Trailer
+ // functionality. No other methods in the ClientStream should be called
+ // directly.
ClientStream
}
// ServerStreamingServer represents the server side of a server-streaming (one
// request, many responses) RPC. It is generic over the type of the response
// message. It is used in generated code.
+//
+// To terminate the response stream, return from the handler method and return
+// an error from the status package, or use nil to indicate an OK status code.
type ServerStreamingServer[Res any] interface {
+ // Send sends a response message to the client. The server handler may
+ // call Send multiple times to send multiple messages to the client. An
+ // error is returned if the stream was terminated unexpectedly, and the
+ // handler method should return, as the stream is no longer usable.
Send(*Res) error
+
+ // ServerStream is embedded to provide Context, SetHeader, SendHeader, and
+ // SetTrailer functionality. No other methods in the ServerStream should
+ // be called directly.
ServerStream
}
@@ -39,8 +59,22 @@ type ServerStreamingServer[Res any] interface {
// message stream and the type of the unary response message. It is used in
// generated code.
type ClientStreamingClient[Req any, Res any] interface {
+ // Send sends a request message to the server. The client may call Send
+ // multiple times to send multiple messages to the server. On error, Send
+ // aborts the stream. If the error was generated by the client, the status
+ // is returned directly. Otherwise, io.EOF is returned, and the status of
+ // the stream may be discovered using CloseAndRecv().
Send(*Req) error
+
+ // CloseAndRecv closes the request stream and waits for the server's
+ // response. This method must be called once and only once after sending
+ // all request messages. Any error returned is implemented by the status
+ // package.
CloseAndRecv() (*Res, error)
+
+ // ClientStream is embedded to provide Context, Header, and Trailer
+ // functionality. No other methods in the ClientStream should be called
+ // directly.
ClientStream
}
@@ -48,9 +82,28 @@ type ClientStreamingClient[Req any, Res any] interface {
// requests, one response) RPC. It is generic over both the type of the request
// message stream and the type of the unary response message. It is used in
// generated code.
+//
+// To terminate the RPC, call SendAndClose and return nil from the method
+// handler or do not call SendAndClose and return an error from the status
+// package.
type ClientStreamingServer[Req any, Res any] interface {
+ // Recv receives the next request message from the client. The server may
+ // repeatedly call Recv to read messages from the request stream. If
+ // io.EOF is returned, it indicates the client called CloseAndRecv on its
+ // ClientStreamingClient. Any other error indicates the stream was
+ // terminated unexpectedly, and the handler method should return, as the
+ // stream is no longer usable.
Recv() (*Req, error)
+
+ // SendAndClose sends a single response message to the client and closes
+ // the stream. This method must be called once and only once after all
+ // request messages have been processed. Recv should not be called after
+ // calling SendAndClose.
SendAndClose(*Res) error
+
+ // ServerStream is embedded to provide Context, SetHeader, SendHeader, and
+ // SetTrailer functionality. No other methods in the ServerStream should
+ // be called directly.
ServerStream
}
@@ -59,8 +112,23 @@ type ClientStreamingServer[Req any, Res any] interface {
// request message stream and the type of the response message stream. It is
// used in generated code.
type BidiStreamingClient[Req any, Res any] interface {
+ // Send sends a request message to the server. The client may call Send
+ // multiple times to send multiple messages to the server. On error, Send
+ // aborts the stream. If the error was generated by the client, the status
+ // is returned directly. Otherwise, io.EOF is returned, and the status of
+ // the stream may be discovered using Recv().
Send(*Req) error
+
+ // Recv receives the next response message from the server. The client may
+ // repeatedly call Recv to read messages from the response stream. If
+ // io.EOF is returned, the stream has terminated with an OK status. Any
+ // other error is compatible with the status package and indicates the
+ // RPC's status code and message.
Recv() (*Res, error)
+
+ // ClientStream is embedded to provide Context, Header, Trailer, and
+ // CloseSend functionality. No other methods in the ClientStream should be
+ // called directly.
ClientStream
}
@@ -68,9 +136,27 @@ type BidiStreamingClient[Req any, Res any] interface {
// (many requests, many responses) RPC. It is generic over both the type of the
// request message stream and the type of the response message stream. It is
// used in generated code.
+//
+// To terminate the stream, return from the handler method and return
+// an error from the status package, or use nil to indicate an OK status code.
type BidiStreamingServer[Req any, Res any] interface {
+ // Recv receives the next request message from the client. The server may
+ // repeatedly call Recv to read messages from the request stream. If
+ // io.EOF is returned, it indicates the client called CloseSend on its
+ // BidiStreamingClient. Any other error indicates the stream was
+ // terminated unexpectedly, and the handler method should return, as the
+ // stream is no longer usable.
Recv() (*Req, error)
+
+ // Send sends a response message to the client. The server handler may
+ // call Send multiple times to send multiple messages to the client. An
+ // error is returned if the stream was terminated unexpectedly, and the
+ // handler method should return, as the stream is no longer usable.
Send(*Res) error
+
+ // ServerStream is embedded to provide Context, SetHeader, SendHeader, and
+ // SetTrailer functionality. No other methods in the ServerStream should
+ // be called directly.
ServerStream
}
diff --git a/vendor/google.golang.org/grpc/version.go b/vendor/google.golang.org/grpc/version.go
index e1806e7600..d50e843598 100644
--- a/vendor/google.golang.org/grpc/version.go
+++ b/vendor/google.golang.org/grpc/version.go
@@ -19,4 +19,4 @@
package grpc
// Version is the current grpc version.
-const Version = "1.64.0"
+const Version = "1.68.0"
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/decode.go b/vendor/google.golang.org/protobuf/encoding/protojson/decode.go
index bb2966e3b4..8f9e592f87 100644
--- a/vendor/google.golang.org/protobuf/encoding/protojson/decode.go
+++ b/vendor/google.golang.org/protobuf/encoding/protojson/decode.go
@@ -351,7 +351,7 @@ func (d decoder) unmarshalScalar(fd protoreflect.FieldDescriptor) (protoreflect.
panic(fmt.Sprintf("unmarshalScalar: invalid scalar kind %v", kind))
}
- return protoreflect.Value{}, d.newError(tok.Pos(), "invalid value for %v type: %v", kind, tok.RawString())
+ return protoreflect.Value{}, d.newError(tok.Pos(), "invalid value for %v field %v: %v", kind, fd.JSONName(), tok.RawString())
}
func unmarshalInt(tok json.Token, bitSize int) (protoreflect.Value, bool) {
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/encode.go b/vendor/google.golang.org/protobuf/encoding/protojson/encode.go
index 29846df222..0e72d85378 100644
--- a/vendor/google.golang.org/protobuf/encoding/protojson/encode.go
+++ b/vendor/google.golang.org/protobuf/encoding/protojson/encode.go
@@ -216,9 +216,7 @@ func (m unpopulatedFieldRanger) Range(f func(protoreflect.FieldDescriptor, proto
}
v := m.Get(fd)
- isProto2Scalar := fd.Syntax() == protoreflect.Proto2 && fd.Default().IsValid()
- isSingularMessage := fd.Cardinality() != protoreflect.Repeated && fd.Message() != nil
- if isProto2Scalar || isSingularMessage {
+ if fd.HasPresence() {
if m.skipNull {
continue
}
diff --git a/vendor/google.golang.org/protobuf/internal/descopts/options.go b/vendor/google.golang.org/protobuf/internal/descopts/options.go
index 8401be8c84..024ffebd3d 100644
--- a/vendor/google.golang.org/protobuf/internal/descopts/options.go
+++ b/vendor/google.golang.org/protobuf/internal/descopts/options.go
@@ -9,7 +9,7 @@
// dependency on the descriptor proto package).
package descopts
-import pref "google.golang.org/protobuf/reflect/protoreflect"
+import "google.golang.org/protobuf/reflect/protoreflect"
// These variables are set by the init function in descriptor.pb.go via logic
// in internal/filetype. In other words, so long as the descriptor proto package
@@ -17,13 +17,13 @@ import pref "google.golang.org/protobuf/reflect/protoreflect"
//
// Each variable is populated with a nil pointer to the options struct.
var (
- File pref.ProtoMessage
- Enum pref.ProtoMessage
- EnumValue pref.ProtoMessage
- Message pref.ProtoMessage
- Field pref.ProtoMessage
- Oneof pref.ProtoMessage
- ExtensionRange pref.ProtoMessage
- Service pref.ProtoMessage
- Method pref.ProtoMessage
+ File protoreflect.ProtoMessage
+ Enum protoreflect.ProtoMessage
+ EnumValue protoreflect.ProtoMessage
+ Message protoreflect.ProtoMessage
+ Field protoreflect.ProtoMessage
+ Oneof protoreflect.ProtoMessage
+ ExtensionRange protoreflect.ProtoMessage
+ Service protoreflect.ProtoMessage
+ Method protoreflect.ProtoMessage
)
diff --git a/vendor/google.golang.org/protobuf/internal/editionssupport/editions.go b/vendor/google.golang.org/protobuf/internal/editionssupport/editions.go
index 029a6a12d7..08dad7692c 100644
--- a/vendor/google.golang.org/protobuf/internal/editionssupport/editions.go
+++ b/vendor/google.golang.org/protobuf/internal/editionssupport/editions.go
@@ -5,7 +5,7 @@
// Package editionssupport defines constants for editions that are supported.
package editionssupport
-import descriptorpb "google.golang.org/protobuf/types/descriptorpb"
+import "google.golang.org/protobuf/types/descriptorpb"
const (
Minimum = descriptorpb.Edition_EDITION_PROTO2
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc.go
index df53ff40b2..fa790e0ff1 100644
--- a/vendor/google.golang.org/protobuf/internal/filedesc/desc.go
+++ b/vendor/google.golang.org/protobuf/internal/filedesc/desc.go
@@ -258,6 +258,7 @@ type (
StringName stringName
IsProto3Optional bool // promoted from google.protobuf.FieldDescriptorProto
IsWeak bool // promoted from google.protobuf.FieldOptions
+ IsLazy bool // promoted from google.protobuf.FieldOptions
Default defaultValue
ContainingOneof protoreflect.OneofDescriptor // must be consistent with Message.Oneofs.Fields
Enum protoreflect.EnumDescriptor
@@ -351,6 +352,7 @@ func (fd *Field) IsPacked() bool {
}
func (fd *Field) IsExtension() bool { return false }
func (fd *Field) IsWeak() bool { return fd.L1.IsWeak }
+func (fd *Field) IsLazy() bool { return fd.L1.IsLazy }
func (fd *Field) IsList() bool { return fd.Cardinality() == protoreflect.Repeated && !fd.IsMap() }
func (fd *Field) IsMap() bool { return fd.Message() != nil && fd.Message().IsMapEntry() }
func (fd *Field) MapKey() protoreflect.FieldDescriptor {
@@ -425,6 +427,7 @@ type (
Extendee protoreflect.MessageDescriptor
Cardinality protoreflect.Cardinality
Kind protoreflect.Kind
+ IsLazy bool
EditionFeatures EditionFeatures
}
ExtensionL2 struct {
@@ -465,6 +468,7 @@ func (xd *Extension) IsPacked() bool {
}
func (xd *Extension) IsExtension() bool { return true }
func (xd *Extension) IsWeak() bool { return false }
+func (xd *Extension) IsLazy() bool { return xd.L1.IsLazy }
func (xd *Extension) IsList() bool { return xd.Cardinality() == protoreflect.Repeated }
func (xd *Extension) IsMap() bool { return false }
func (xd *Extension) MapKey() protoreflect.FieldDescriptor { return nil }
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc_init.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc_init.go
index 8a57d60b08..d2f549497e 100644
--- a/vendor/google.golang.org/protobuf/internal/filedesc/desc_init.go
+++ b/vendor/google.golang.org/protobuf/internal/filedesc/desc_init.go
@@ -495,6 +495,8 @@ func (xd *Extension) unmarshalOptions(b []byte) {
switch num {
case genid.FieldOptions_Packed_field_number:
xd.L1.EditionFeatures.IsPacked = protowire.DecodeBool(v)
+ case genid.FieldOptions_Lazy_field_number:
+ xd.L1.IsLazy = protowire.DecodeBool(v)
}
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go
index e56c91a8db..67a51b327c 100644
--- a/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go
+++ b/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go
@@ -504,6 +504,8 @@ func (fd *Field) unmarshalOptions(b []byte) {
fd.L1.EditionFeatures.IsPacked = protowire.DecodeBool(v)
case genid.FieldOptions_Weak_field_number:
fd.L1.IsWeak = protowire.DecodeBool(v)
+ case genid.FieldOptions_Lazy_field_number:
+ fd.L1.IsLazy = protowire.DecodeBool(v)
case FieldOptions_EnforceUTF8:
fd.L1.EditionFeatures.IsUTF8Validated = protowire.DecodeBool(v)
}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/editions.go b/vendor/google.golang.org/protobuf/internal/filedesc/editions.go
index 11f5f356b6..fd4d0c83d2 100644
--- a/vendor/google.golang.org/protobuf/internal/filedesc/editions.go
+++ b/vendor/google.golang.org/protobuf/internal/filedesc/editions.go
@@ -68,7 +68,7 @@ func unmarshalFeatureSet(b []byte, parent EditionFeatures) EditionFeatures {
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
- case genid.GoFeatures_LegacyUnmarshalJsonEnum_field_number:
+ case genid.FeatureSet_Go_ext_number:
parent = unmarshalGoFeature(v, parent)
}
}
diff --git a/vendor/google.golang.org/protobuf/internal/genid/doc.go b/vendor/google.golang.org/protobuf/internal/genid/doc.go
index 45ccd01211..d9b9d916a2 100644
--- a/vendor/google.golang.org/protobuf/internal/genid/doc.go
+++ b/vendor/google.golang.org/protobuf/internal/genid/doc.go
@@ -6,6 +6,6 @@
// and the well-known types.
package genid
-import protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+import "google.golang.org/protobuf/reflect/protoreflect"
const GoogleProtobuf_package protoreflect.FullName = "google.protobuf"
diff --git a/vendor/google.golang.org/protobuf/internal/genid/go_features_gen.go b/vendor/google.golang.org/protobuf/internal/genid/go_features_gen.go
index 9a652a2b42..7f67cbb6e9 100644
--- a/vendor/google.golang.org/protobuf/internal/genid/go_features_gen.go
+++ b/vendor/google.golang.org/protobuf/internal/genid/go_features_gen.go
@@ -12,20 +12,25 @@ import (
const File_google_protobuf_go_features_proto = "google/protobuf/go_features.proto"
-// Names for google.protobuf.GoFeatures.
+// Names for pb.GoFeatures.
const (
GoFeatures_message_name protoreflect.Name = "GoFeatures"
- GoFeatures_message_fullname protoreflect.FullName = "google.protobuf.GoFeatures"
+ GoFeatures_message_fullname protoreflect.FullName = "pb.GoFeatures"
)
-// Field names for google.protobuf.GoFeatures.
+// Field names for pb.GoFeatures.
const (
GoFeatures_LegacyUnmarshalJsonEnum_field_name protoreflect.Name = "legacy_unmarshal_json_enum"
- GoFeatures_LegacyUnmarshalJsonEnum_field_fullname protoreflect.FullName = "google.protobuf.GoFeatures.legacy_unmarshal_json_enum"
+ GoFeatures_LegacyUnmarshalJsonEnum_field_fullname protoreflect.FullName = "pb.GoFeatures.legacy_unmarshal_json_enum"
)
-// Field numbers for google.protobuf.GoFeatures.
+// Field numbers for pb.GoFeatures.
const (
GoFeatures_LegacyUnmarshalJsonEnum_field_number protoreflect.FieldNumber = 1
)
+
+// Extension numbers
+const (
+ FeatureSet_Go_ext_number protoreflect.FieldNumber = 1002
+)
diff --git a/vendor/google.golang.org/protobuf/internal/genid/map_entry.go b/vendor/google.golang.org/protobuf/internal/genid/map_entry.go
index 8f9ea02ff2..bef5a25fbb 100644
--- a/vendor/google.golang.org/protobuf/internal/genid/map_entry.go
+++ b/vendor/google.golang.org/protobuf/internal/genid/map_entry.go
@@ -4,7 +4,7 @@
package genid
-import protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+import "google.golang.org/protobuf/reflect/protoreflect"
// Generic field names and numbers for synthetic map entry messages.
const (
diff --git a/vendor/google.golang.org/protobuf/internal/genid/wrappers.go b/vendor/google.golang.org/protobuf/internal/genid/wrappers.go
index 429384b85b..9404270de0 100644
--- a/vendor/google.golang.org/protobuf/internal/genid/wrappers.go
+++ b/vendor/google.golang.org/protobuf/internal/genid/wrappers.go
@@ -4,7 +4,7 @@
package genid
-import protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+import "google.golang.org/protobuf/reflect/protoreflect"
// Generic field name and number for messages in wrappers.proto.
const (
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_extension.go b/vendor/google.golang.org/protobuf/internal/impl/codec_extension.go
index 4bb0a7a20c..0d5b546e0e 100644
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_extension.go
+++ b/vendor/google.golang.org/protobuf/internal/impl/codec_extension.go
@@ -67,7 +67,6 @@ type lazyExtensionValue struct {
xi *extensionFieldInfo
value protoreflect.Value
b []byte
- fn func() protoreflect.Value
}
type ExtensionField struct {
@@ -158,10 +157,9 @@ func (f *ExtensionField) lazyInit() {
}
f.lazy.value = val
} else {
- f.lazy.value = f.lazy.fn()
+ panic("No support for lazy fns for ExtensionField")
}
f.lazy.xi = nil
- f.lazy.fn = nil
f.lazy.b = nil
atomic.StoreUint32(&f.lazy.atomicOnce, 1)
}
@@ -174,13 +172,6 @@ func (f *ExtensionField) Set(t protoreflect.ExtensionType, v protoreflect.Value)
f.lazy = nil
}
-// SetLazy sets the type and a value that is to be lazily evaluated upon first use.
-// This must not be called concurrently.
-func (f *ExtensionField) SetLazy(t protoreflect.ExtensionType, fn func() protoreflect.Value) {
- f.typ = t
- f.lazy = &lazyExtensionValue{fn: fn}
-}
-
// Value returns the value of the extension field.
// This may be called concurrently.
func (f *ExtensionField) Value() protoreflect.Value {
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_field.go b/vendor/google.golang.org/protobuf/internal/impl/codec_field.go
index 78ee47e44b..7c1f66c8c1 100644
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_field.go
+++ b/vendor/google.golang.org/protobuf/internal/impl/codec_field.go
@@ -65,6 +65,9 @@ func (mi *MessageInfo) initOneofFieldCoders(od protoreflect.OneofDescriptor, si
if err != nil {
return out, err
}
+ if cf.funcs.isInit == nil {
+ out.initialized = true
+ }
vi.Set(vw)
return out, nil
}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_message.go b/vendor/google.golang.org/protobuf/internal/impl/codec_message.go
index 6b2fdbb739..78be9df342 100644
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_message.go
+++ b/vendor/google.golang.org/protobuf/internal/impl/codec_message.go
@@ -189,6 +189,9 @@ func (mi *MessageInfo) makeCoderMethods(t reflect.Type, si structInfo) {
if mi.methods.Merge == nil {
mi.methods.Merge = mi.merge
}
+ if mi.methods.Equal == nil {
+ mi.methods.Equal = equal
+ }
}
// getUnknownBytes returns a *[]byte for the unknown fields.
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_reflect.go b/vendor/google.golang.org/protobuf/internal/impl/codec_reflect.go
deleted file mode 100644
index 145c577bd6..0000000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_reflect.go
+++ /dev/null
@@ -1,210 +0,0 @@
-// Copyright 2019 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 purego || appengine
-// +build purego appengine
-
-package impl
-
-import (
- "reflect"
-
- "google.golang.org/protobuf/encoding/protowire"
-)
-
-func sizeEnum(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := p.v.Elem().Int()
- return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-func appendEnum(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- v := p.v.Elem().Int()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, uint64(v))
- return b, nil
-}
-
-func consumeEnum(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return out, errDecode
- }
- p.v.Elem().SetInt(int64(v))
- out.n = n
- return out, nil
-}
-
-func mergeEnum(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- dst.v.Elem().Set(src.v.Elem())
-}
-
-var coderEnum = pointerCoderFuncs{
- size: sizeEnum,
- marshal: appendEnum,
- unmarshal: consumeEnum,
- merge: mergeEnum,
-}
-
-func sizeEnumNoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
- if p.v.Elem().Int() == 0 {
- return 0
- }
- return sizeEnum(p, f, opts)
-}
-
-func appendEnumNoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- if p.v.Elem().Int() == 0 {
- return b, nil
- }
- return appendEnum(b, p, f, opts)
-}
-
-func mergeEnumNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- if src.v.Elem().Int() != 0 {
- dst.v.Elem().Set(src.v.Elem())
- }
-}
-
-var coderEnumNoZero = pointerCoderFuncs{
- size: sizeEnumNoZero,
- marshal: appendEnumNoZero,
- unmarshal: consumeEnum,
- merge: mergeEnumNoZero,
-}
-
-func sizeEnumPtr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
- return sizeEnum(pointer{p.v.Elem()}, f, opts)
-}
-
-func appendEnumPtr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- return appendEnum(b, pointer{p.v.Elem()}, f, opts)
-}
-
-func consumeEnumPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- if p.v.Elem().IsNil() {
- p.v.Elem().Set(reflect.New(p.v.Elem().Type().Elem()))
- }
- return consumeEnum(b, pointer{p.v.Elem()}, wtyp, f, opts)
-}
-
-func mergeEnumPtr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- if !src.v.Elem().IsNil() {
- v := reflect.New(dst.v.Type().Elem().Elem())
- v.Elem().Set(src.v.Elem().Elem())
- dst.v.Elem().Set(v)
- }
-}
-
-var coderEnumPtr = pointerCoderFuncs{
- size: sizeEnumPtr,
- marshal: appendEnumPtr,
- unmarshal: consumeEnumPtr,
- merge: mergeEnumPtr,
-}
-
-func sizeEnumSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
- s := p.v.Elem()
- for i, llen := 0, s.Len(); i < llen; i++ {
- size += protowire.SizeVarint(uint64(s.Index(i).Int())) + f.tagsize
- }
- return size
-}
-
-func appendEnumSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- s := p.v.Elem()
- for i, llen := 0, s.Len(); i < llen; i++ {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, uint64(s.Index(i).Int()))
- }
- return b, nil
-}
-
-func consumeEnumSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
- s := p.v.Elem()
- if wtyp == protowire.BytesType {
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, errDecode
- }
- for len(b) > 0 {
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return out, errDecode
- }
- rv := reflect.New(s.Type().Elem()).Elem()
- rv.SetInt(int64(v))
- s.Set(reflect.Append(s, rv))
- b = b[n:]
- }
- out.n = n
- return out, nil
- }
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return out, errDecode
- }
- rv := reflect.New(s.Type().Elem()).Elem()
- rv.SetInt(int64(v))
- s.Set(reflect.Append(s, rv))
- out.n = n
- return out, nil
-}
-
-func mergeEnumSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- dst.v.Elem().Set(reflect.AppendSlice(dst.v.Elem(), src.v.Elem()))
-}
-
-var coderEnumSlice = pointerCoderFuncs{
- size: sizeEnumSlice,
- marshal: appendEnumSlice,
- unmarshal: consumeEnumSlice,
- merge: mergeEnumSlice,
-}
-
-func sizeEnumPackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
- s := p.v.Elem()
- llen := s.Len()
- if llen == 0 {
- return 0
- }
- n := 0
- for i := 0; i < llen; i++ {
- n += protowire.SizeVarint(uint64(s.Index(i).Int()))
- }
- return f.tagsize + protowire.SizeBytes(n)
-}
-
-func appendEnumPackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- s := p.v.Elem()
- llen := s.Len()
- if llen == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- n := 0
- for i := 0; i < llen; i++ {
- n += protowire.SizeVarint(uint64(s.Index(i).Int()))
- }
- b = protowire.AppendVarint(b, uint64(n))
- for i := 0; i < llen; i++ {
- b = protowire.AppendVarint(b, uint64(s.Index(i).Int()))
- }
- return b, nil
-}
-
-var coderEnumPackedSlice = pointerCoderFuncs{
- size: sizeEnumPackedSlice,
- marshal: appendEnumPackedSlice,
- unmarshal: consumeEnumSlice,
- merge: mergeEnumSlice,
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_unsafe.go b/vendor/google.golang.org/protobuf/internal/impl/codec_unsafe.go
index 757642e23c..077712c2c5 100644
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_unsafe.go
+++ b/vendor/google.golang.org/protobuf/internal/impl/codec_unsafe.go
@@ -2,9 +2,6 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-//go:build !purego && !appengine
-// +build !purego,!appengine
-
package impl
// When using unsafe pointers, we can just treat enum values as int32s.
diff --git a/vendor/google.golang.org/protobuf/internal/impl/convert.go b/vendor/google.golang.org/protobuf/internal/impl/convert.go
index e06ece55a2..f72ddd882f 100644
--- a/vendor/google.golang.org/protobuf/internal/impl/convert.go
+++ b/vendor/google.golang.org/protobuf/internal/impl/convert.go
@@ -322,7 +322,7 @@ func (c *stringConverter) PBValueOf(v reflect.Value) protoreflect.Value {
return protoreflect.ValueOfString(v.Convert(stringType).String())
}
func (c *stringConverter) GoValueOf(v protoreflect.Value) reflect.Value {
- // pref.Value.String never panics, so we go through an interface
+ // protoreflect.Value.String never panics, so we go through an interface
// conversion here to check the type.
s := v.Interface().(string)
if c.goType.Kind() == reflect.Slice && s == "" {
diff --git a/vendor/google.golang.org/protobuf/internal/impl/encode.go b/vendor/google.golang.org/protobuf/internal/impl/encode.go
index febd212247..6254f5de41 100644
--- a/vendor/google.golang.org/protobuf/internal/impl/encode.go
+++ b/vendor/google.golang.org/protobuf/internal/impl/encode.go
@@ -10,7 +10,7 @@ import (
"sync/atomic"
"google.golang.org/protobuf/internal/flags"
- proto "google.golang.org/protobuf/proto"
+ "google.golang.org/protobuf/proto"
piface "google.golang.org/protobuf/runtime/protoiface"
)
diff --git a/vendor/google.golang.org/protobuf/internal/impl/equal.go b/vendor/google.golang.org/protobuf/internal/impl/equal.go
new file mode 100644
index 0000000000..9f6c32a7d8
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/impl/equal.go
@@ -0,0 +1,224 @@
+// Copyright 2024 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 impl
+
+import (
+ "bytes"
+
+ "google.golang.org/protobuf/encoding/protowire"
+ "google.golang.org/protobuf/reflect/protoreflect"
+ "google.golang.org/protobuf/runtime/protoiface"
+)
+
+func equal(in protoiface.EqualInput) protoiface.EqualOutput {
+ return protoiface.EqualOutput{Equal: equalMessage(in.MessageA, in.MessageB)}
+}
+
+// equalMessage is a fast-path variant of protoreflect.equalMessage.
+// It takes advantage of the internal messageState type to avoid
+// unnecessary allocations, type assertions.
+func equalMessage(mx, my protoreflect.Message) bool {
+ if mx == nil || my == nil {
+ return mx == my
+ }
+ if mx.Descriptor() != my.Descriptor() {
+ return false
+ }
+
+ msx, ok := mx.(*messageState)
+ if !ok {
+ return protoreflect.ValueOfMessage(mx).Equal(protoreflect.ValueOfMessage(my))
+ }
+ msy, ok := my.(*messageState)
+ if !ok {
+ return protoreflect.ValueOfMessage(mx).Equal(protoreflect.ValueOfMessage(my))
+ }
+
+ mi := msx.messageInfo()
+ miy := msy.messageInfo()
+ if mi != miy {
+ return protoreflect.ValueOfMessage(mx).Equal(protoreflect.ValueOfMessage(my))
+ }
+ mi.init()
+ // Compares regular fields
+ // Modified Message.Range code that compares two messages of the same type
+ // while going over the fields.
+ for _, ri := range mi.rangeInfos {
+ var fd protoreflect.FieldDescriptor
+ var vx, vy protoreflect.Value
+
+ switch ri := ri.(type) {
+ case *fieldInfo:
+ hx := ri.has(msx.pointer())
+ hy := ri.has(msy.pointer())
+ if hx != hy {
+ return false
+ }
+ if !hx {
+ continue
+ }
+ fd = ri.fieldDesc
+ vx = ri.get(msx.pointer())
+ vy = ri.get(msy.pointer())
+ case *oneofInfo:
+ fnx := ri.which(msx.pointer())
+ fny := ri.which(msy.pointer())
+ if fnx != fny {
+ return false
+ }
+ if fnx <= 0 {
+ continue
+ }
+ fi := mi.fields[fnx]
+ fd = fi.fieldDesc
+ vx = fi.get(msx.pointer())
+ vy = fi.get(msy.pointer())
+ }
+
+ if !equalValue(fd, vx, vy) {
+ return false
+ }
+ }
+
+ // Compare extensions.
+ // This is more complicated because mx or my could have empty/nil extension maps,
+ // however some populated extension map values are equal to nil extension maps.
+ emx := mi.extensionMap(msx.pointer())
+ emy := mi.extensionMap(msy.pointer())
+ if emx != nil {
+ for k, x := range *emx {
+ xd := x.Type().TypeDescriptor()
+ xv := x.Value()
+ var y ExtensionField
+ ok := false
+ if emy != nil {
+ y, ok = (*emy)[k]
+ }
+ // We need to treat empty lists as equal to nil values
+ if emy == nil || !ok {
+ if xd.IsList() && xv.List().Len() == 0 {
+ continue
+ }
+ return false
+ }
+
+ if !equalValue(xd, xv, y.Value()) {
+ return false
+ }
+ }
+ }
+ if emy != nil {
+ // emy may have extensions emx does not have, need to check them as well
+ for k, y := range *emy {
+ if emx != nil {
+ // emx has the field, so we already checked it
+ if _, ok := (*emx)[k]; ok {
+ continue
+ }
+ }
+ // Empty lists are equal to nil
+ if y.Type().TypeDescriptor().IsList() && y.Value().List().Len() == 0 {
+ continue
+ }
+
+ // Cant be equal if the extension is populated
+ return false
+ }
+ }
+
+ return equalUnknown(mx.GetUnknown(), my.GetUnknown())
+}
+
+func equalValue(fd protoreflect.FieldDescriptor, vx, vy protoreflect.Value) bool {
+ // slow path
+ if fd.Kind() != protoreflect.MessageKind {
+ return vx.Equal(vy)
+ }
+
+ // fast path special cases
+ if fd.IsMap() {
+ if fd.MapValue().Kind() == protoreflect.MessageKind {
+ return equalMessageMap(vx.Map(), vy.Map())
+ }
+ return vx.Equal(vy)
+ }
+
+ if fd.IsList() {
+ return equalMessageList(vx.List(), vy.List())
+ }
+
+ return equalMessage(vx.Message(), vy.Message())
+}
+
+// Mostly copied from protoreflect.equalMap.
+// This variant only works for messages as map types.
+// All other map types should be handled via Value.Equal.
+func equalMessageMap(mx, my protoreflect.Map) bool {
+ if mx.Len() != my.Len() {
+ return false
+ }
+ equal := true
+ mx.Range(func(k protoreflect.MapKey, vx protoreflect.Value) bool {
+ if !my.Has(k) {
+ equal = false
+ return false
+ }
+ vy := my.Get(k)
+ equal = equalMessage(vx.Message(), vy.Message())
+ return equal
+ })
+ return equal
+}
+
+// Mostly copied from protoreflect.equalList.
+// The only change is the usage of equalImpl instead of protoreflect.equalValue.
+func equalMessageList(lx, ly protoreflect.List) bool {
+ if lx.Len() != ly.Len() {
+ return false
+ }
+ for i := 0; i < lx.Len(); i++ {
+ // We only operate on messages here since equalImpl will not call us in any other case.
+ if !equalMessage(lx.Get(i).Message(), ly.Get(i).Message()) {
+ return false
+ }
+ }
+ return true
+}
+
+// equalUnknown compares unknown fields by direct comparison on the raw bytes
+// of each individual field number.
+// Copied from protoreflect.equalUnknown.
+func equalUnknown(x, y protoreflect.RawFields) bool {
+ if len(x) != len(y) {
+ return false
+ }
+ if bytes.Equal([]byte(x), []byte(y)) {
+ return true
+ }
+
+ mx := make(map[protoreflect.FieldNumber]protoreflect.RawFields)
+ my := make(map[protoreflect.FieldNumber]protoreflect.RawFields)
+ for len(x) > 0 {
+ fnum, _, n := protowire.ConsumeField(x)
+ mx[fnum] = append(mx[fnum], x[:n]...)
+ x = x[n:]
+ }
+ for len(y) > 0 {
+ fnum, _, n := protowire.ConsumeField(y)
+ my[fnum] = append(my[fnum], y[:n]...)
+ y = y[n:]
+ }
+ if len(mx) != len(my) {
+ return false
+ }
+
+ for k, v1 := range mx {
+ if v2, ok := my[k]; !ok || !bytes.Equal([]byte(v1), []byte(v2)) {
+ return false
+ }
+ }
+
+ return true
+}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_extension.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_extension.go
index 6e8677ee63..b6849d6692 100644
--- a/vendor/google.golang.org/protobuf/internal/impl/legacy_extension.go
+++ b/vendor/google.golang.org/protobuf/internal/impl/legacy_extension.go
@@ -160,6 +160,7 @@ func (x placeholderExtension) HasPresence() bool
func (x placeholderExtension) HasOptionalKeyword() bool { return false }
func (x placeholderExtension) IsExtension() bool { return true }
func (x placeholderExtension) IsWeak() bool { return false }
+func (x placeholderExtension) IsLazy() bool { return false }
func (x placeholderExtension) IsPacked() bool { return false }
func (x placeholderExtension) IsList() bool { return false }
func (x placeholderExtension) IsMap() bool { return false }
diff --git a/vendor/google.golang.org/protobuf/internal/impl/message.go b/vendor/google.golang.org/protobuf/internal/impl/message.go
index 019399d454..741b5ed29c 100644
--- a/vendor/google.golang.org/protobuf/internal/impl/message.go
+++ b/vendor/google.golang.org/protobuf/internal/impl/message.go
@@ -30,8 +30,8 @@ type MessageInfo struct {
// Desc is the underlying message descriptor type and must be populated.
Desc protoreflect.MessageDescriptor
- // Exporter must be provided in a purego environment in order to provide
- // access to unexported fields.
+ // Deprecated: Exporter will be removed the next time we bump
+ // protoimpl.GenVersion. See https://github.com/golang/protobuf/issues/1640
Exporter exporter
// OneofWrappers is list of pointers to oneof wrapper struct types.
diff --git a/vendor/google.golang.org/protobuf/internal/impl/pointer_reflect.go b/vendor/google.golang.org/protobuf/internal/impl/pointer_reflect.go
deleted file mode 100644
index da685e8a29..0000000000
--- a/vendor/google.golang.org/protobuf/internal/impl/pointer_reflect.go
+++ /dev/null
@@ -1,215 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build purego || appengine
-// +build purego appengine
-
-package impl
-
-import (
- "fmt"
- "reflect"
- "sync"
-)
-
-const UnsafeEnabled = false
-
-// Pointer is an opaque pointer type.
-type Pointer any
-
-// offset represents the offset to a struct field, accessible from a pointer.
-// The offset is the field index into a struct.
-type offset struct {
- index int
- export exporter
-}
-
-// offsetOf returns a field offset for the struct field.
-func offsetOf(f reflect.StructField, x exporter) offset {
- if len(f.Index) != 1 {
- panic("embedded structs are not supported")
- }
- if f.PkgPath == "" {
- return offset{index: f.Index[0]} // field is already exported
- }
- if x == nil {
- panic("exporter must be provided for unexported field")
- }
- return offset{index: f.Index[0], export: x}
-}
-
-// IsValid reports whether the offset is valid.
-func (f offset) IsValid() bool { return f.index >= 0 }
-
-// invalidOffset is an invalid field offset.
-var invalidOffset = offset{index: -1}
-
-// zeroOffset is a noop when calling pointer.Apply.
-var zeroOffset = offset{index: 0}
-
-// pointer is an abstract representation of a pointer to a struct or field.
-type pointer struct{ v reflect.Value }
-
-// pointerOf returns p as a pointer.
-func pointerOf(p Pointer) pointer {
- return pointerOfIface(p)
-}
-
-// pointerOfValue returns v as a pointer.
-func pointerOfValue(v reflect.Value) pointer {
- return pointer{v: v}
-}
-
-// pointerOfIface returns the pointer portion of an interface.
-func pointerOfIface(v any) pointer {
- return pointer{v: reflect.ValueOf(v)}
-}
-
-// IsNil reports whether the pointer is nil.
-func (p pointer) IsNil() bool {
- return p.v.IsNil()
-}
-
-// Apply adds an offset to the pointer to derive a new pointer
-// to a specified field. The current pointer must be pointing at a struct.
-func (p pointer) Apply(f offset) pointer {
- if f.export != nil {
- if v := reflect.ValueOf(f.export(p.v.Interface(), f.index)); v.IsValid() {
- return pointer{v: v}
- }
- }
- return pointer{v: p.v.Elem().Field(f.index).Addr()}
-}
-
-// AsValueOf treats p as a pointer to an object of type t and returns the value.
-// It is equivalent to reflect.ValueOf(p.AsIfaceOf(t))
-func (p pointer) AsValueOf(t reflect.Type) reflect.Value {
- if got := p.v.Type().Elem(); got != t {
- panic(fmt.Sprintf("invalid type: got %v, want %v", got, t))
- }
- return p.v
-}
-
-// AsIfaceOf treats p as a pointer to an object of type t and returns the value.
-// It is equivalent to p.AsValueOf(t).Interface()
-func (p pointer) AsIfaceOf(t reflect.Type) any {
- return p.AsValueOf(t).Interface()
-}
-
-func (p pointer) Bool() *bool { return p.v.Interface().(*bool) }
-func (p pointer) BoolPtr() **bool { return p.v.Interface().(**bool) }
-func (p pointer) BoolSlice() *[]bool { return p.v.Interface().(*[]bool) }
-func (p pointer) Int32() *int32 { return p.v.Interface().(*int32) }
-func (p pointer) Int32Ptr() **int32 { return p.v.Interface().(**int32) }
-func (p pointer) Int32Slice() *[]int32 { return p.v.Interface().(*[]int32) }
-func (p pointer) Int64() *int64 { return p.v.Interface().(*int64) }
-func (p pointer) Int64Ptr() **int64 { return p.v.Interface().(**int64) }
-func (p pointer) Int64Slice() *[]int64 { return p.v.Interface().(*[]int64) }
-func (p pointer) Uint32() *uint32 { return p.v.Interface().(*uint32) }
-func (p pointer) Uint32Ptr() **uint32 { return p.v.Interface().(**uint32) }
-func (p pointer) Uint32Slice() *[]uint32 { return p.v.Interface().(*[]uint32) }
-func (p pointer) Uint64() *uint64 { return p.v.Interface().(*uint64) }
-func (p pointer) Uint64Ptr() **uint64 { return p.v.Interface().(**uint64) }
-func (p pointer) Uint64Slice() *[]uint64 { return p.v.Interface().(*[]uint64) }
-func (p pointer) Float32() *float32 { return p.v.Interface().(*float32) }
-func (p pointer) Float32Ptr() **float32 { return p.v.Interface().(**float32) }
-func (p pointer) Float32Slice() *[]float32 { return p.v.Interface().(*[]float32) }
-func (p pointer) Float64() *float64 { return p.v.Interface().(*float64) }
-func (p pointer) Float64Ptr() **float64 { return p.v.Interface().(**float64) }
-func (p pointer) Float64Slice() *[]float64 { return p.v.Interface().(*[]float64) }
-func (p pointer) String() *string { return p.v.Interface().(*string) }
-func (p pointer) StringPtr() **string { return p.v.Interface().(**string) }
-func (p pointer) StringSlice() *[]string { return p.v.Interface().(*[]string) }
-func (p pointer) Bytes() *[]byte { return p.v.Interface().(*[]byte) }
-func (p pointer) BytesPtr() **[]byte { return p.v.Interface().(**[]byte) }
-func (p pointer) BytesSlice() *[][]byte { return p.v.Interface().(*[][]byte) }
-func (p pointer) WeakFields() *weakFields { return (*weakFields)(p.v.Interface().(*WeakFields)) }
-func (p pointer) Extensions() *map[int32]ExtensionField {
- return p.v.Interface().(*map[int32]ExtensionField)
-}
-
-func (p pointer) Elem() pointer {
- return pointer{v: p.v.Elem()}
-}
-
-// PointerSlice copies []*T from p as a new []pointer.
-// This behavior differs from the implementation in pointer_unsafe.go.
-func (p pointer) PointerSlice() []pointer {
- // TODO: reconsider this
- if p.v.IsNil() {
- return nil
- }
- n := p.v.Elem().Len()
- s := make([]pointer, n)
- for i := 0; i < n; i++ {
- s[i] = pointer{v: p.v.Elem().Index(i)}
- }
- return s
-}
-
-// AppendPointerSlice appends v to p, which must be a []*T.
-func (p pointer) AppendPointerSlice(v pointer) {
- sp := p.v.Elem()
- sp.Set(reflect.Append(sp, v.v))
-}
-
-// SetPointer sets *p to v.
-func (p pointer) SetPointer(v pointer) {
- p.v.Elem().Set(v.v)
-}
-
-func growSlice(p pointer, addCap int) {
- // TODO: Once we only support Go 1.20 and newer, use reflect.Grow.
- in := p.v.Elem()
- out := reflect.MakeSlice(in.Type(), in.Len(), in.Len()+addCap)
- reflect.Copy(out, in)
- p.v.Elem().Set(out)
-}
-
-func (p pointer) growBoolSlice(addCap int) {
- growSlice(p, addCap)
-}
-
-func (p pointer) growInt32Slice(addCap int) {
- growSlice(p, addCap)
-}
-
-func (p pointer) growUint32Slice(addCap int) {
- growSlice(p, addCap)
-}
-
-func (p pointer) growInt64Slice(addCap int) {
- growSlice(p, addCap)
-}
-
-func (p pointer) growUint64Slice(addCap int) {
- growSlice(p, addCap)
-}
-
-func (p pointer) growFloat64Slice(addCap int) {
- growSlice(p, addCap)
-}
-
-func (p pointer) growFloat32Slice(addCap int) {
- growSlice(p, addCap)
-}
-
-func (Export) MessageStateOf(p Pointer) *messageState { panic("not supported") }
-func (ms *messageState) pointer() pointer { panic("not supported") }
-func (ms *messageState) messageInfo() *MessageInfo { panic("not supported") }
-func (ms *messageState) LoadMessageInfo() *MessageInfo { panic("not supported") }
-func (ms *messageState) StoreMessageInfo(mi *MessageInfo) { panic("not supported") }
-
-type atomicNilMessage struct {
- once sync.Once
- m messageReflectWrapper
-}
-
-func (m *atomicNilMessage) Init(mi *MessageInfo) *messageReflectWrapper {
- m.once.Do(func() {
- m.m.p = pointerOfIface(reflect.Zero(mi.GoReflectType).Interface())
- m.m.mi = mi
- })
- return &m.m
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe.go b/vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe.go
index 5f20ca5d8a..79e186667b 100644
--- a/vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe.go
+++ b/vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe.go
@@ -2,9 +2,6 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-//go:build !purego && !appengine
-// +build !purego,!appengine
-
package impl
import (
diff --git a/vendor/google.golang.org/protobuf/internal/strs/strings_pure.go b/vendor/google.golang.org/protobuf/internal/strs/strings_pure.go
deleted file mode 100644
index a1f6f33386..0000000000
--- a/vendor/google.golang.org/protobuf/internal/strs/strings_pure.go
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build purego || appengine
-// +build purego appengine
-
-package strs
-
-import pref "google.golang.org/protobuf/reflect/protoreflect"
-
-func UnsafeString(b []byte) string {
- return string(b)
-}
-
-func UnsafeBytes(s string) []byte {
- return []byte(s)
-}
-
-type Builder struct{}
-
-func (*Builder) AppendFullName(prefix pref.FullName, name pref.Name) pref.FullName {
- return prefix.Append(name)
-}
-
-func (*Builder) MakeString(b []byte) string {
- return string(b)
-}
diff --git a/vendor/google.golang.org/protobuf/internal/strs/strings_unsafe_go120.go b/vendor/google.golang.org/protobuf/internal/strs/strings_unsafe_go120.go
index a008acd090..832a7988f1 100644
--- a/vendor/google.golang.org/protobuf/internal/strs/strings_unsafe_go120.go
+++ b/vendor/google.golang.org/protobuf/internal/strs/strings_unsafe_go120.go
@@ -2,8 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-//go:build !purego && !appengine && !go1.21
-// +build !purego,!appengine,!go1.21
+//go:build !go1.21
package strs
diff --git a/vendor/google.golang.org/protobuf/internal/strs/strings_unsafe_go121.go b/vendor/google.golang.org/protobuf/internal/strs/strings_unsafe_go121.go
index 60166f2ba3..1ffddf6877 100644
--- a/vendor/google.golang.org/protobuf/internal/strs/strings_unsafe_go121.go
+++ b/vendor/google.golang.org/protobuf/internal/strs/strings_unsafe_go121.go
@@ -2,8 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-//go:build !purego && !appengine && go1.21
-// +build !purego,!appengine,go1.21
+//go:build go1.21
package strs
diff --git a/vendor/google.golang.org/protobuf/internal/version/version.go b/vendor/google.golang.org/protobuf/internal/version/version.go
index dbbf1f6862..fb8e15e8da 100644
--- a/vendor/google.golang.org/protobuf/internal/version/version.go
+++ b/vendor/google.golang.org/protobuf/internal/version/version.go
@@ -51,8 +51,8 @@ import (
// 10. Send out the CL for review and submit it.
const (
Major = 1
- Minor = 34
- Patch = 2
+ Minor = 35
+ Patch = 1
PreRelease = ""
)
diff --git a/vendor/google.golang.org/protobuf/proto/equal.go b/vendor/google.golang.org/protobuf/proto/equal.go
index 1a0be1b03c..c36d4a9cd7 100644
--- a/vendor/google.golang.org/protobuf/proto/equal.go
+++ b/vendor/google.golang.org/protobuf/proto/equal.go
@@ -8,6 +8,7 @@ import (
"reflect"
"google.golang.org/protobuf/reflect/protoreflect"
+ "google.golang.org/protobuf/runtime/protoiface"
)
// Equal reports whether two messages are equal,
@@ -51,6 +52,14 @@ func Equal(x, y Message) bool {
if mx.IsValid() != my.IsValid() {
return false
}
+
+ // Only one of the messages needs to implement the fast-path for it to work.
+ pmx := protoMethods(mx)
+ pmy := protoMethods(my)
+ if pmx != nil && pmy != nil && pmx.Equal != nil && pmy.Equal != nil {
+ return pmx.Equal(protoiface.EqualInput{MessageA: mx, MessageB: my}).Equal
+ }
+
vx := protoreflect.ValueOfMessage(mx)
vy := protoreflect.ValueOfMessage(my)
return vx.Equal(vy)
diff --git a/vendor/google.golang.org/protobuf/proto/extension.go b/vendor/google.golang.org/protobuf/proto/extension.go
index d248f29284..78445d116f 100644
--- a/vendor/google.golang.org/protobuf/proto/extension.go
+++ b/vendor/google.golang.org/protobuf/proto/extension.go
@@ -39,6 +39,48 @@ func ClearExtension(m Message, xt protoreflect.ExtensionType) {
// If the field is unpopulated, it returns the default value for
// scalars and an immutable, empty value for lists or messages.
// It panics if xt does not extend m.
+//
+// The type of the value is dependent on the field type of the extension.
+// For extensions generated by protoc-gen-go, the Go type is as follows:
+//
+// ╔═══════════════════╤═════════════════════════╗
+// ║ Go type │ Protobuf kind ║
+// ╠═══════════════════╪═════════════════════════╣
+// ║ bool │ bool ║
+// ║ int32 │ int32, sint32, sfixed32 ║
+// ║ int64 │ int64, sint64, sfixed64 ║
+// ║ uint32 │ uint32, fixed32 ║
+// ║ uint64 │ uint64, fixed64 ║
+// ║ float32 │ float ║
+// ║ float64 │ double ║
+// ║ string │ string ║
+// ║ []byte │ bytes ║
+// ║ protoreflect.Enum │ enum ║
+// ║ proto.Message │ message, group ║
+// ╚═══════════════════╧═════════════════════════╝
+//
+// The protoreflect.Enum and proto.Message types are the concrete Go type
+// associated with the named enum or message. Repeated fields are represented
+// using a Go slice of the base element type.
+//
+// If a generated extension descriptor variable is directly passed to
+// GetExtension, then the call should be followed immediately by a
+// type assertion to the expected output value. For example:
+//
+// mm := proto.GetExtension(m, foopb.E_MyExtension).(*foopb.MyMessage)
+//
+// This pattern enables static analysis tools to verify that the asserted type
+// matches the Go type associated with the extension field and
+// also enables a possible future migration to a type-safe extension API.
+//
+// Since singular messages are the most common extension type, the pattern of
+// calling HasExtension followed by GetExtension may be simplified to:
+//
+// if mm := proto.GetExtension(m, foopb.E_MyExtension).(*foopb.MyMessage); mm != nil {
+// ... // make use of mm
+// }
+//
+// The mm variable is non-nil if and only if HasExtension reports true.
func GetExtension(m Message, xt protoreflect.ExtensionType) any {
// Treat nil message interface as an empty message; return the default.
if m == nil {
@@ -51,6 +93,35 @@ func GetExtension(m Message, xt protoreflect.ExtensionType) any {
// SetExtension stores the value of an extension field.
// It panics if m is invalid, xt does not extend m, or if type of v
// is invalid for the specified extension field.
+//
+// The type of the value is dependent on the field type of the extension.
+// For extensions generated by protoc-gen-go, the Go type is as follows:
+//
+// ╔═══════════════════╤═════════════════════════╗
+// ║ Go type │ Protobuf kind ║
+// ╠═══════════════════╪═════════════════════════╣
+// ║ bool │ bool ║
+// ║ int32 │ int32, sint32, sfixed32 ║
+// ║ int64 │ int64, sint64, sfixed64 ║
+// ║ uint32 │ uint32, fixed32 ║
+// ║ uint64 │ uint64, fixed64 ║
+// ║ float32 │ float ║
+// ║ float64 │ double ║
+// ║ string │ string ║
+// ║ []byte │ bytes ║
+// ║ protoreflect.Enum │ enum ║
+// ║ proto.Message │ message, group ║
+// ╚═══════════════════╧═════════════════════════╝
+//
+// The protoreflect.Enum and proto.Message types are the concrete Go type
+// associated with the named enum or message. Repeated fields are represented
+// using a Go slice of the base element type.
+//
+// If a generated extension descriptor variable is directly passed to
+// SetExtension (e.g., foopb.E_MyExtension), then the value should be a
+// concrete type that matches the expected Go type for the extension descriptor
+// so that static analysis tools can verify type correctness.
+// This also enables a possible future migration to a type-safe extension API.
func SetExtension(m Message, xt protoreflect.ExtensionType, v any) {
xd := xt.TypeDescriptor()
pv := xt.ValueOf(v)
diff --git a/vendor/google.golang.org/protobuf/reflect/protodesc/desc_init.go b/vendor/google.golang.org/protobuf/reflect/protodesc/desc_init.go
index 8561755427..ebcb4a8ab1 100644
--- a/vendor/google.golang.org/protobuf/reflect/protodesc/desc_init.go
+++ b/vendor/google.golang.org/protobuf/reflect/protodesc/desc_init.go
@@ -150,6 +150,7 @@ func (r descsByName) initFieldsFromDescriptorProto(fds []*descriptorpb.FieldDesc
opts = proto.Clone(opts).(*descriptorpb.FieldOptions)
f.L1.Options = func() protoreflect.ProtoMessage { return opts }
f.L1.IsWeak = opts.GetWeak()
+ f.L1.IsLazy = opts.GetLazy()
if opts.Packed != nil {
f.L1.EditionFeatures.IsPacked = opts.GetPacked()
}
@@ -214,6 +215,9 @@ func (r descsByName) initExtensionDeclarations(xds []*descriptorpb.FieldDescript
if xd.JsonName != nil {
x.L2.StringName.InitJSON(xd.GetJsonName())
}
+ if x.L1.Kind == protoreflect.MessageKind && x.L1.EditionFeatures.IsDelimitedEncoded {
+ x.L1.Kind = protoreflect.GroupKind
+ }
}
return xs, nil
}
diff --git a/vendor/google.golang.org/protobuf/reflect/protodesc/editions.go b/vendor/google.golang.org/protobuf/reflect/protodesc/editions.go
index 804830eda3..002e0047ae 100644
--- a/vendor/google.golang.org/protobuf/reflect/protodesc/editions.go
+++ b/vendor/google.golang.org/protobuf/reflect/protodesc/editions.go
@@ -14,7 +14,7 @@ import (
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/types/descriptorpb"
- gofeaturespb "google.golang.org/protobuf/types/gofeaturespb"
+ "google.golang.org/protobuf/types/gofeaturespb"
)
var defaults = &descriptorpb.FeatureSetDefaults{}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/methods.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/methods.go
index d5d5af6ebe..742cb518c4 100644
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/methods.go
+++ b/vendor/google.golang.org/protobuf/reflect/protoreflect/methods.go
@@ -23,6 +23,7 @@ type (
Unmarshal func(unmarshalInput) (unmarshalOutput, error)
Merge func(mergeInput) mergeOutput
CheckInitialized func(checkInitializedInput) (checkInitializedOutput, error)
+ Equal func(equalInput) equalOutput
}
supportFlags = uint64
sizeInput = struct {
@@ -75,4 +76,13 @@ type (
checkInitializedOutput = struct {
pragma.NoUnkeyedLiterals
}
+ equalInput = struct {
+ pragma.NoUnkeyedLiterals
+ MessageA Message
+ MessageB Message
+ }
+ equalOutput = struct {
+ pragma.NoUnkeyedLiterals
+ Equal bool
+ }
)
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_pure.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_pure.go
deleted file mode 100644
index 75f83a2af0..0000000000
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_pure.go
+++ /dev/null
@@ -1,60 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build purego || appengine
-// +build purego appengine
-
-package protoreflect
-
-import "google.golang.org/protobuf/internal/pragma"
-
-type valueType int
-
-const (
- nilType valueType = iota
- boolType
- int32Type
- int64Type
- uint32Type
- uint64Type
- float32Type
- float64Type
- stringType
- bytesType
- enumType
- ifaceType
-)
-
-// value is a union where only one type can be represented at a time.
-// This uses a distinct field for each type. This is type safe in Go, but
-// occupies more memory than necessary (72B).
-type value struct {
- pragma.DoNotCompare // 0B
-
- typ valueType // 8B
- num uint64 // 8B
- str string // 16B
- bin []byte // 24B
- iface any // 16B
-}
-
-func valueOfString(v string) Value {
- return Value{typ: stringType, str: v}
-}
-func valueOfBytes(v []byte) Value {
- return Value{typ: bytesType, bin: v}
-}
-func valueOfIface(v any) Value {
- return Value{typ: ifaceType, iface: v}
-}
-
-func (v Value) getString() string {
- return v.str
-}
-func (v Value) getBytes() []byte {
- return v.bin
-}
-func (v Value) getIface() any {
- return v.iface
-}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe_go120.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe_go120.go
index 7f3583ead8..0015fcb35d 100644
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe_go120.go
+++ b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe_go120.go
@@ -2,8 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-//go:build !purego && !appengine && !go1.21
-// +build !purego,!appengine,!go1.21
+//go:build !go1.21
package protoreflect
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe_go121.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe_go121.go
index f7d386990a..479527b58d 100644
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe_go121.go
+++ b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe_go121.go
@@ -2,8 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-//go:build !purego && !appengine && go1.21
-// +build !purego,!appengine,go1.21
+//go:build go1.21
package protoreflect
diff --git a/vendor/google.golang.org/protobuf/runtime/protoiface/methods.go b/vendor/google.golang.org/protobuf/runtime/protoiface/methods.go
index 44cf467d88..246156561c 100644
--- a/vendor/google.golang.org/protobuf/runtime/protoiface/methods.go
+++ b/vendor/google.golang.org/protobuf/runtime/protoiface/methods.go
@@ -39,6 +39,9 @@ type Methods = struct {
// CheckInitialized returns an error if any required fields in the message are not set.
CheckInitialized func(CheckInitializedInput) (CheckInitializedOutput, error)
+
+ // Equal compares two messages and returns EqualOutput.Equal == true if they are equal.
+ Equal func(EqualInput) EqualOutput
}
// SupportFlags indicate support for optional features.
@@ -166,3 +169,18 @@ type CheckInitializedInput = struct {
type CheckInitializedOutput = struct {
pragma.NoUnkeyedLiterals
}
+
+// EqualInput is input to the Equal method.
+type EqualInput = struct {
+ pragma.NoUnkeyedLiterals
+
+ MessageA protoreflect.Message
+ MessageB protoreflect.Message
+}
+
+// EqualOutput is output from the Equal method.
+type EqualOutput = struct {
+ pragma.NoUnkeyedLiterals
+
+ Equal bool
+}
diff --git a/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go b/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go
index 9403eb0750..6dea75cd5b 100644
--- a/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go
+++ b/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go
@@ -1217,11 +1217,9 @@ type FileDescriptorSet struct {
func (x *FileDescriptorSet) Reset() {
*x = FileDescriptorSet{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[0]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *FileDescriptorSet) String() string {
@@ -1232,7 +1230,7 @@ func (*FileDescriptorSet) ProtoMessage() {}
func (x *FileDescriptorSet) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[0]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -1291,11 +1289,9 @@ type FileDescriptorProto struct {
func (x *FileDescriptorProto) Reset() {
*x = FileDescriptorProto{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[1]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *FileDescriptorProto) String() string {
@@ -1306,7 +1302,7 @@ func (*FileDescriptorProto) ProtoMessage() {}
func (x *FileDescriptorProto) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[1]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -1434,11 +1430,9 @@ type DescriptorProto struct {
func (x *DescriptorProto) Reset() {
*x = DescriptorProto{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[2]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *DescriptorProto) String() string {
@@ -1449,7 +1443,7 @@ func (*DescriptorProto) ProtoMessage() {}
func (x *DescriptorProto) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[2]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -1561,11 +1555,9 @@ const (
func (x *ExtensionRangeOptions) Reset() {
*x = ExtensionRangeOptions{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[3]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[3]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *ExtensionRangeOptions) String() string {
@@ -1576,7 +1568,7 @@ func (*ExtensionRangeOptions) ProtoMessage() {}
func (x *ExtensionRangeOptions) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[3]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -1680,11 +1672,9 @@ type FieldDescriptorProto struct {
func (x *FieldDescriptorProto) Reset() {
*x = FieldDescriptorProto{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[4]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[4]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *FieldDescriptorProto) String() string {
@@ -1695,7 +1685,7 @@ func (*FieldDescriptorProto) ProtoMessage() {}
func (x *FieldDescriptorProto) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[4]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -1799,11 +1789,9 @@ type OneofDescriptorProto struct {
func (x *OneofDescriptorProto) Reset() {
*x = OneofDescriptorProto{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[5]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[5]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *OneofDescriptorProto) String() string {
@@ -1814,7 +1802,7 @@ func (*OneofDescriptorProto) ProtoMessage() {}
func (x *OneofDescriptorProto) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[5]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -1863,11 +1851,9 @@ type EnumDescriptorProto struct {
func (x *EnumDescriptorProto) Reset() {
*x = EnumDescriptorProto{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[6]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[6]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *EnumDescriptorProto) String() string {
@@ -1878,7 +1864,7 @@ func (*EnumDescriptorProto) ProtoMessage() {}
func (x *EnumDescriptorProto) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[6]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -1941,11 +1927,9 @@ type EnumValueDescriptorProto struct {
func (x *EnumValueDescriptorProto) Reset() {
*x = EnumValueDescriptorProto{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[7]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[7]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *EnumValueDescriptorProto) String() string {
@@ -1956,7 +1940,7 @@ func (*EnumValueDescriptorProto) ProtoMessage() {}
func (x *EnumValueDescriptorProto) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[7]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -2005,11 +1989,9 @@ type ServiceDescriptorProto struct {
func (x *ServiceDescriptorProto) Reset() {
*x = ServiceDescriptorProto{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[8]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[8]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *ServiceDescriptorProto) String() string {
@@ -2020,7 +2002,7 @@ func (*ServiceDescriptorProto) ProtoMessage() {}
func (x *ServiceDescriptorProto) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[8]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -2082,11 +2064,9 @@ const (
func (x *MethodDescriptorProto) Reset() {
*x = MethodDescriptorProto{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[9]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[9]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *MethodDescriptorProto) String() string {
@@ -2097,7 +2077,7 @@ func (*MethodDescriptorProto) ProtoMessage() {}
func (x *MethodDescriptorProto) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[9]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -2267,11 +2247,9 @@ const (
func (x *FileOptions) Reset() {
*x = FileOptions{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[10]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[10]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *FileOptions) String() string {
@@ -2282,7 +2260,7 @@ func (*FileOptions) ProtoMessage() {}
func (x *FileOptions) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[10]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -2534,11 +2512,9 @@ const (
func (x *MessageOptions) Reset() {
*x = MessageOptions{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[11]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[11]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *MessageOptions) String() string {
@@ -2549,7 +2525,7 @@ func (*MessageOptions) ProtoMessage() {}
func (x *MessageOptions) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[11]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -2707,11 +2683,9 @@ const (
func (x *FieldOptions) Reset() {
*x = FieldOptions{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[12]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[12]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *FieldOptions) String() string {
@@ -2722,7 +2696,7 @@ func (*FieldOptions) ProtoMessage() {}
func (x *FieldOptions) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[12]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -2849,11 +2823,9 @@ type OneofOptions struct {
func (x *OneofOptions) Reset() {
*x = OneofOptions{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[13]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[13]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *OneofOptions) String() string {
@@ -2864,7 +2836,7 @@ func (*OneofOptions) ProtoMessage() {}
func (x *OneofOptions) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[13]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -2929,11 +2901,9 @@ const (
func (x *EnumOptions) Reset() {
*x = EnumOptions{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[14]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[14]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *EnumOptions) String() string {
@@ -2944,7 +2914,7 @@ func (*EnumOptions) ProtoMessage() {}
func (x *EnumOptions) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[14]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -3026,11 +2996,9 @@ const (
func (x *EnumValueOptions) Reset() {
*x = EnumValueOptions{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[15]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[15]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *EnumValueOptions) String() string {
@@ -3041,7 +3009,7 @@ func (*EnumValueOptions) ProtoMessage() {}
func (x *EnumValueOptions) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[15]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -3115,11 +3083,9 @@ const (
func (x *ServiceOptions) Reset() {
*x = ServiceOptions{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[16]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[16]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *ServiceOptions) String() string {
@@ -3130,7 +3096,7 @@ func (*ServiceOptions) ProtoMessage() {}
func (x *ServiceOptions) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[16]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -3192,11 +3158,9 @@ const (
func (x *MethodOptions) Reset() {
*x = MethodOptions{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[17]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[17]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *MethodOptions) String() string {
@@ -3207,7 +3171,7 @@ func (*MethodOptions) ProtoMessage() {}
func (x *MethodOptions) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[17]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -3274,11 +3238,9 @@ type UninterpretedOption struct {
func (x *UninterpretedOption) Reset() {
*x = UninterpretedOption{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[18]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[18]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *UninterpretedOption) String() string {
@@ -3289,7 +3251,7 @@ func (*UninterpretedOption) ProtoMessage() {}
func (x *UninterpretedOption) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[18]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -3375,11 +3337,9 @@ type FeatureSet struct {
func (x *FeatureSet) Reset() {
*x = FeatureSet{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[19]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[19]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *FeatureSet) String() string {
@@ -3390,7 +3350,7 @@ func (*FeatureSet) ProtoMessage() {}
func (x *FeatureSet) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[19]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -3467,11 +3427,9 @@ type FeatureSetDefaults struct {
func (x *FeatureSetDefaults) Reset() {
*x = FeatureSetDefaults{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[20]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[20]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *FeatureSetDefaults) String() string {
@@ -3482,7 +3440,7 @@ func (*FeatureSetDefaults) ProtoMessage() {}
func (x *FeatureSetDefaults) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[20]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -3578,11 +3536,9 @@ type SourceCodeInfo struct {
func (x *SourceCodeInfo) Reset() {
*x = SourceCodeInfo{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[21]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[21]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *SourceCodeInfo) String() string {
@@ -3593,7 +3549,7 @@ func (*SourceCodeInfo) ProtoMessage() {}
func (x *SourceCodeInfo) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[21]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -3630,11 +3586,9 @@ type GeneratedCodeInfo struct {
func (x *GeneratedCodeInfo) Reset() {
*x = GeneratedCodeInfo{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[22]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[22]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *GeneratedCodeInfo) String() string {
@@ -3645,7 +3599,7 @@ func (*GeneratedCodeInfo) ProtoMessage() {}
func (x *GeneratedCodeInfo) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[22]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -3679,11 +3633,9 @@ type DescriptorProto_ExtensionRange struct {
func (x *DescriptorProto_ExtensionRange) Reset() {
*x = DescriptorProto_ExtensionRange{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[23]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[23]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *DescriptorProto_ExtensionRange) String() string {
@@ -3694,7 +3646,7 @@ func (*DescriptorProto_ExtensionRange) ProtoMessage() {}
func (x *DescriptorProto_ExtensionRange) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[23]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -3744,11 +3696,9 @@ type DescriptorProto_ReservedRange struct {
func (x *DescriptorProto_ReservedRange) Reset() {
*x = DescriptorProto_ReservedRange{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[24]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[24]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *DescriptorProto_ReservedRange) String() string {
@@ -3759,7 +3709,7 @@ func (*DescriptorProto_ReservedRange) ProtoMessage() {}
func (x *DescriptorProto_ReservedRange) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[24]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -3813,11 +3763,9 @@ type ExtensionRangeOptions_Declaration struct {
func (x *ExtensionRangeOptions_Declaration) Reset() {
*x = ExtensionRangeOptions_Declaration{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[25]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[25]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *ExtensionRangeOptions_Declaration) String() string {
@@ -3828,7 +3776,7 @@ func (*ExtensionRangeOptions_Declaration) ProtoMessage() {}
func (x *ExtensionRangeOptions_Declaration) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[25]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -3895,11 +3843,9 @@ type EnumDescriptorProto_EnumReservedRange struct {
func (x *EnumDescriptorProto_EnumReservedRange) Reset() {
*x = EnumDescriptorProto_EnumReservedRange{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[26]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[26]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *EnumDescriptorProto_EnumReservedRange) String() string {
@@ -3910,7 +3856,7 @@ func (*EnumDescriptorProto_EnumReservedRange) ProtoMessage() {}
func (x *EnumDescriptorProto_EnumReservedRange) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[26]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -3950,11 +3896,9 @@ type FieldOptions_EditionDefault struct {
func (x *FieldOptions_EditionDefault) Reset() {
*x = FieldOptions_EditionDefault{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[27]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[27]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *FieldOptions_EditionDefault) String() string {
@@ -3965,7 +3909,7 @@ func (*FieldOptions_EditionDefault) ProtoMessage() {}
func (x *FieldOptions_EditionDefault) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[27]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -4018,11 +3962,9 @@ type FieldOptions_FeatureSupport struct {
func (x *FieldOptions_FeatureSupport) Reset() {
*x = FieldOptions_FeatureSupport{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[28]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[28]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *FieldOptions_FeatureSupport) String() string {
@@ -4033,7 +3975,7 @@ func (*FieldOptions_FeatureSupport) ProtoMessage() {}
func (x *FieldOptions_FeatureSupport) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[28]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -4092,11 +4034,9 @@ type UninterpretedOption_NamePart struct {
func (x *UninterpretedOption_NamePart) Reset() {
*x = UninterpretedOption_NamePart{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[29]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[29]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *UninterpretedOption_NamePart) String() string {
@@ -4107,7 +4047,7 @@ func (*UninterpretedOption_NamePart) ProtoMessage() {}
func (x *UninterpretedOption_NamePart) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[29]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -4154,11 +4094,9 @@ type FeatureSetDefaults_FeatureSetEditionDefault struct {
func (x *FeatureSetDefaults_FeatureSetEditionDefault) Reset() {
*x = FeatureSetDefaults_FeatureSetEditionDefault{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[30]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[30]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *FeatureSetDefaults_FeatureSetEditionDefault) String() string {
@@ -4169,7 +4107,7 @@ func (*FeatureSetDefaults_FeatureSetEditionDefault) ProtoMessage() {}
func (x *FeatureSetDefaults_FeatureSetEditionDefault) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[30]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -4305,11 +4243,9 @@ type SourceCodeInfo_Location struct {
func (x *SourceCodeInfo_Location) Reset() {
*x = SourceCodeInfo_Location{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[31]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[31]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *SourceCodeInfo_Location) String() string {
@@ -4320,7 +4256,7 @@ func (*SourceCodeInfo_Location) ProtoMessage() {}
func (x *SourceCodeInfo_Location) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[31]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -4392,11 +4328,9 @@ type GeneratedCodeInfo_Annotation struct {
func (x *GeneratedCodeInfo_Annotation) Reset() {
*x = GeneratedCodeInfo_Annotation{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[32]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[32]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *GeneratedCodeInfo_Annotation) String() string {
@@ -4407,7 +4341,7 @@ func (*GeneratedCodeInfo_Annotation) ProtoMessage() {}
func (x *GeneratedCodeInfo_Annotation) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[32]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -5385,424 +5319,6 @@ func file_google_protobuf_descriptor_proto_init() {
if File_google_protobuf_descriptor_proto != nil {
return
}
- if !protoimpl.UnsafeEnabled {
- file_google_protobuf_descriptor_proto_msgTypes[0].Exporter = func(v any, i int) any {
- switch v := v.(*FileDescriptorSet); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[1].Exporter = func(v any, i int) any {
- switch v := v.(*FileDescriptorProto); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[2].Exporter = func(v any, i int) any {
- switch v := v.(*DescriptorProto); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[3].Exporter = func(v any, i int) any {
- switch v := v.(*ExtensionRangeOptions); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[4].Exporter = func(v any, i int) any {
- switch v := v.(*FieldDescriptorProto); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[5].Exporter = func(v any, i int) any {
- switch v := v.(*OneofDescriptorProto); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[6].Exporter = func(v any, i int) any {
- switch v := v.(*EnumDescriptorProto); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[7].Exporter = func(v any, i int) any {
- switch v := v.(*EnumValueDescriptorProto); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[8].Exporter = func(v any, i int) any {
- switch v := v.(*ServiceDescriptorProto); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[9].Exporter = func(v any, i int) any {
- switch v := v.(*MethodDescriptorProto); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[10].Exporter = func(v any, i int) any {
- switch v := v.(*FileOptions); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[11].Exporter = func(v any, i int) any {
- switch v := v.(*MessageOptions); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[12].Exporter = func(v any, i int) any {
- switch v := v.(*FieldOptions); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[13].Exporter = func(v any, i int) any {
- switch v := v.(*OneofOptions); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[14].Exporter = func(v any, i int) any {
- switch v := v.(*EnumOptions); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[15].Exporter = func(v any, i int) any {
- switch v := v.(*EnumValueOptions); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[16].Exporter = func(v any, i int) any {
- switch v := v.(*ServiceOptions); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[17].Exporter = func(v any, i int) any {
- switch v := v.(*MethodOptions); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[18].Exporter = func(v any, i int) any {
- switch v := v.(*UninterpretedOption); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[19].Exporter = func(v any, i int) any {
- switch v := v.(*FeatureSet); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[20].Exporter = func(v any, i int) any {
- switch v := v.(*FeatureSetDefaults); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[21].Exporter = func(v any, i int) any {
- switch v := v.(*SourceCodeInfo); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[22].Exporter = func(v any, i int) any {
- switch v := v.(*GeneratedCodeInfo); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[23].Exporter = func(v any, i int) any {
- switch v := v.(*DescriptorProto_ExtensionRange); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[24].Exporter = func(v any, i int) any {
- switch v := v.(*DescriptorProto_ReservedRange); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[25].Exporter = func(v any, i int) any {
- switch v := v.(*ExtensionRangeOptions_Declaration); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[26].Exporter = func(v any, i int) any {
- switch v := v.(*EnumDescriptorProto_EnumReservedRange); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[27].Exporter = func(v any, i int) any {
- switch v := v.(*FieldOptions_EditionDefault); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[28].Exporter = func(v any, i int) any {
- switch v := v.(*FieldOptions_FeatureSupport); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[29].Exporter = func(v any, i int) any {
- switch v := v.(*UninterpretedOption_NamePart); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[30].Exporter = func(v any, i int) any {
- switch v := v.(*FeatureSetDefaults_FeatureSetEditionDefault); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[31].Exporter = func(v any, i int) any {
- switch v := v.(*SourceCodeInfo_Location); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[32].Exporter = func(v any, i int) any {
- switch v := v.(*GeneratedCodeInfo_Annotation); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- }
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
diff --git a/vendor/google.golang.org/protobuf/types/gofeaturespb/go_features.pb.go b/vendor/google.golang.org/protobuf/types/gofeaturespb/go_features.pb.go
index a2ca940c50..c7e860fcd6 100644
--- a/vendor/google.golang.org/protobuf/types/gofeaturespb/go_features.pb.go
+++ b/vendor/google.golang.org/protobuf/types/gofeaturespb/go_features.pb.go
@@ -29,11 +29,9 @@ type GoFeatures struct {
func (x *GoFeatures) Reset() {
*x = GoFeatures{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_go_features_proto_msgTypes[0]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_go_features_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *GoFeatures) String() string {
@@ -44,7 +42,7 @@ func (*GoFeatures) ProtoMessage() {}
func (x *GoFeatures) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_go_features_proto_msgTypes[0]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -145,20 +143,6 @@ func file_google_protobuf_go_features_proto_init() {
if File_google_protobuf_go_features_proto != nil {
return
}
- if !protoimpl.UnsafeEnabled {
- file_google_protobuf_go_features_proto_msgTypes[0].Exporter = func(v any, i int) any {
- switch v := v.(*GoFeatures); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- }
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
diff --git a/vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go b/vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go
index 7172b43d38..87da199a38 100644
--- a/vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go
+++ b/vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go
@@ -368,11 +368,9 @@ func (x *Any) UnmarshalNew() (proto.Message, error) {
func (x *Any) Reset() {
*x = Any{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_any_proto_msgTypes[0]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_any_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *Any) String() string {
@@ -383,7 +381,7 @@ func (*Any) ProtoMessage() {}
func (x *Any) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_any_proto_msgTypes[0]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -461,20 +459,6 @@ func file_google_protobuf_any_proto_init() {
if File_google_protobuf_any_proto != nil {
return
}
- if !protoimpl.UnsafeEnabled {
- file_google_protobuf_any_proto_msgTypes[0].Exporter = func(v any, i int) any {
- switch v := v.(*Any); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- }
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
diff --git a/vendor/google.golang.org/protobuf/types/known/durationpb/duration.pb.go b/vendor/google.golang.org/protobuf/types/known/durationpb/duration.pb.go
index 1b71bcd910..b99d4d2410 100644
--- a/vendor/google.golang.org/protobuf/types/known/durationpb/duration.pb.go
+++ b/vendor/google.golang.org/protobuf/types/known/durationpb/duration.pb.go
@@ -245,11 +245,9 @@ func (x *Duration) check() uint {
func (x *Duration) Reset() {
*x = Duration{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_duration_proto_msgTypes[0]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_duration_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *Duration) String() string {
@@ -260,7 +258,7 @@ func (*Duration) ProtoMessage() {}
func (x *Duration) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_duration_proto_msgTypes[0]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -339,20 +337,6 @@ func file_google_protobuf_duration_proto_init() {
if File_google_protobuf_duration_proto != nil {
return
}
- if !protoimpl.UnsafeEnabled {
- file_google_protobuf_duration_proto_msgTypes[0].Exporter = func(v any, i int) any {
- switch v := v.(*Duration); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- }
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
diff --git a/vendor/google.golang.org/protobuf/types/known/emptypb/empty.pb.go b/vendor/google.golang.org/protobuf/types/known/emptypb/empty.pb.go
index d87b4fb828..1761bc9c69 100644
--- a/vendor/google.golang.org/protobuf/types/known/emptypb/empty.pb.go
+++ b/vendor/google.golang.org/protobuf/types/known/emptypb/empty.pb.go
@@ -55,11 +55,9 @@ type Empty struct {
func (x *Empty) Reset() {
*x = Empty{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_empty_proto_msgTypes[0]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_empty_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *Empty) String() string {
@@ -70,7 +68,7 @@ func (*Empty) ProtoMessage() {}
func (x *Empty) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_empty_proto_msgTypes[0]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -131,20 +129,6 @@ func file_google_protobuf_empty_proto_init() {
if File_google_protobuf_empty_proto != nil {
return
}
- if !protoimpl.UnsafeEnabled {
- file_google_protobuf_empty_proto_msgTypes[0].Exporter = func(v any, i int) any {
- switch v := v.(*Empty); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- }
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
diff --git a/vendor/google.golang.org/protobuf/types/known/fieldmaskpb/field_mask.pb.go b/vendor/google.golang.org/protobuf/types/known/fieldmaskpb/field_mask.pb.go
index ac1e91bb6d..19de8d371f 100644
--- a/vendor/google.golang.org/protobuf/types/known/fieldmaskpb/field_mask.pb.go
+++ b/vendor/google.golang.org/protobuf/types/known/fieldmaskpb/field_mask.pb.go
@@ -467,11 +467,9 @@ func rangeFields(path string, f func(field string) bool) bool {
func (x *FieldMask) Reset() {
*x = FieldMask{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_field_mask_proto_msgTypes[0]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_field_mask_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *FieldMask) String() string {
@@ -482,7 +480,7 @@ func (*FieldMask) ProtoMessage() {}
func (x *FieldMask) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_field_mask_proto_msgTypes[0]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -553,20 +551,6 @@ func file_google_protobuf_field_mask_proto_init() {
if File_google_protobuf_field_mask_proto != nil {
return
}
- if !protoimpl.UnsafeEnabled {
- file_google_protobuf_field_mask_proto_msgTypes[0].Exporter = func(v any, i int) any {
- switch v := v.(*FieldMask); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- }
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
diff --git a/vendor/google.golang.org/protobuf/types/known/structpb/struct.pb.go b/vendor/google.golang.org/protobuf/types/known/structpb/struct.pb.go
index d45361cbc7..8f206a6611 100644
--- a/vendor/google.golang.org/protobuf/types/known/structpb/struct.pb.go
+++ b/vendor/google.golang.org/protobuf/types/known/structpb/struct.pb.go
@@ -120,6 +120,7 @@ package structpb
import (
base64 "encoding/base64"
+ json "encoding/json"
protojson "google.golang.org/protobuf/encoding/protojson"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
@@ -233,11 +234,9 @@ func (x *Struct) UnmarshalJSON(b []byte) error {
func (x *Struct) Reset() {
*x = Struct{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_struct_proto_msgTypes[0]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_struct_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *Struct) String() string {
@@ -248,7 +247,7 @@ func (*Struct) ProtoMessage() {}
func (x *Struct) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_struct_proto_msgTypes[0]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -296,19 +295,20 @@ type Value struct {
// NewValue constructs a Value from a general-purpose Go interface.
//
-// ╔════════════════════════╤════════════════════════════════════════════╗
-// ║ Go type │ Conversion ║
-// ╠════════════════════════╪════════════════════════════════════════════╣
-// ║ nil │ stored as NullValue ║
-// ║ bool │ stored as BoolValue ║
-// ║ int, int32, int64 │ stored as NumberValue ║
-// ║ uint, uint32, uint64 │ stored as NumberValue ║
-// ║ float32, float64 │ stored as NumberValue ║
-// ║ string │ stored as StringValue; must be valid UTF-8 ║
-// ║ []byte │ stored as StringValue; base64-encoded ║
-// ║ map[string]any │ stored as StructValue ║
-// ║ []any │ stored as ListValue ║
-// ╚════════════════════════╧════════════════════════════════════════════╝
+// ╔═══════════════════════════════════════╤════════════════════════════════════════════╗
+// ║ Go type │ Conversion ║
+// ╠═══════════════════════════════════════╪════════════════════════════════════════════╣
+// ║ nil │ stored as NullValue ║
+// ║ bool │ stored as BoolValue ║
+// ║ int, int8, int16, int32, int64 │ stored as NumberValue ║
+// ║ uint, uint8, uint16, uint32, uint64 │ stored as NumberValue ║
+// ║ float32, float64 │ stored as NumberValue ║
+// ║ json.Number │ stored as NumberValue ║
+// ║ string │ stored as StringValue; must be valid UTF-8 ║
+// ║ []byte │ stored as StringValue; base64-encoded ║
+// ║ map[string]any │ stored as StructValue ║
+// ║ []any │ stored as ListValue ║
+// ╚═══════════════════════════════════════╧════════════════════════════════════════════╝
//
// When converting an int64 or uint64 to a NumberValue, numeric precision loss
// is possible since they are stored as a float64.
@@ -320,12 +320,20 @@ func NewValue(v any) (*Value, error) {
return NewBoolValue(v), nil
case int:
return NewNumberValue(float64(v)), nil
+ case int8:
+ return NewNumberValue(float64(v)), nil
+ case int16:
+ return NewNumberValue(float64(v)), nil
case int32:
return NewNumberValue(float64(v)), nil
case int64:
return NewNumberValue(float64(v)), nil
case uint:
return NewNumberValue(float64(v)), nil
+ case uint8:
+ return NewNumberValue(float64(v)), nil
+ case uint16:
+ return NewNumberValue(float64(v)), nil
case uint32:
return NewNumberValue(float64(v)), nil
case uint64:
@@ -334,6 +342,12 @@ func NewValue(v any) (*Value, error) {
return NewNumberValue(float64(v)), nil
case float64:
return NewNumberValue(float64(v)), nil
+ case json.Number:
+ n, err := v.Float64()
+ if err != nil {
+ return nil, protoimpl.X.NewError("invalid number format %q, expected a float64: %v", v, err)
+ }
+ return NewNumberValue(n), nil
case string:
if !utf8.ValidString(v) {
return nil, protoimpl.X.NewError("invalid UTF-8 in string: %q", v)
@@ -441,11 +455,9 @@ func (x *Value) UnmarshalJSON(b []byte) error {
func (x *Value) Reset() {
*x = Value{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_struct_proto_msgTypes[1]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_struct_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *Value) String() string {
@@ -456,7 +468,7 @@ func (*Value) ProtoMessage() {}
func (x *Value) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_struct_proto_msgTypes[1]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -613,11 +625,9 @@ func (x *ListValue) UnmarshalJSON(b []byte) error {
func (x *ListValue) Reset() {
*x = ListValue{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_struct_proto_msgTypes[2]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_struct_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *ListValue) String() string {
@@ -628,7 +638,7 @@ func (*ListValue) ProtoMessage() {}
func (x *ListValue) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_struct_proto_msgTypes[2]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -742,44 +752,6 @@ func file_google_protobuf_struct_proto_init() {
if File_google_protobuf_struct_proto != nil {
return
}
- if !protoimpl.UnsafeEnabled {
- file_google_protobuf_struct_proto_msgTypes[0].Exporter = func(v any, i int) any {
- switch v := v.(*Struct); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_struct_proto_msgTypes[1].Exporter = func(v any, i int) any {
- switch v := v.(*Value); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_struct_proto_msgTypes[2].Exporter = func(v any, i int) any {
- switch v := v.(*ListValue); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- }
file_google_protobuf_struct_proto_msgTypes[1].OneofWrappers = []any{
(*Value_NullValue)(nil),
(*Value_NumberValue)(nil),
diff --git a/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go b/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go
index 83a5a645b0..0d20722d70 100644
--- a/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go
+++ b/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go
@@ -254,11 +254,9 @@ func (x *Timestamp) check() uint {
func (x *Timestamp) Reset() {
*x = Timestamp{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_timestamp_proto_msgTypes[0]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_timestamp_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *Timestamp) String() string {
@@ -269,7 +267,7 @@ func (*Timestamp) ProtoMessage() {}
func (x *Timestamp) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_timestamp_proto_msgTypes[0]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -348,20 +346,6 @@ func file_google_protobuf_timestamp_proto_init() {
if File_google_protobuf_timestamp_proto != nil {
return
}
- if !protoimpl.UnsafeEnabled {
- file_google_protobuf_timestamp_proto_msgTypes[0].Exporter = func(v any, i int) any {
- switch v := v.(*Timestamp); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- }
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
diff --git a/vendor/google.golang.org/protobuf/types/known/wrapperspb/wrappers.pb.go b/vendor/google.golang.org/protobuf/types/known/wrapperspb/wrappers.pb.go
index e473f826aa..006060e569 100644
--- a/vendor/google.golang.org/protobuf/types/known/wrapperspb/wrappers.pb.go
+++ b/vendor/google.golang.org/protobuf/types/known/wrapperspb/wrappers.pb.go
@@ -69,11 +69,9 @@ func Double(v float64) *DoubleValue {
func (x *DoubleValue) Reset() {
*x = DoubleValue{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_wrappers_proto_msgTypes[0]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_wrappers_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *DoubleValue) String() string {
@@ -84,7 +82,7 @@ func (*DoubleValue) ProtoMessage() {}
func (x *DoubleValue) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_wrappers_proto_msgTypes[0]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -125,11 +123,9 @@ func Float(v float32) *FloatValue {
func (x *FloatValue) Reset() {
*x = FloatValue{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_wrappers_proto_msgTypes[1]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_wrappers_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *FloatValue) String() string {
@@ -140,7 +136,7 @@ func (*FloatValue) ProtoMessage() {}
func (x *FloatValue) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_wrappers_proto_msgTypes[1]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -181,11 +177,9 @@ func Int64(v int64) *Int64Value {
func (x *Int64Value) Reset() {
*x = Int64Value{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_wrappers_proto_msgTypes[2]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_wrappers_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *Int64Value) String() string {
@@ -196,7 +190,7 @@ func (*Int64Value) ProtoMessage() {}
func (x *Int64Value) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_wrappers_proto_msgTypes[2]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -237,11 +231,9 @@ func UInt64(v uint64) *UInt64Value {
func (x *UInt64Value) Reset() {
*x = UInt64Value{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_wrappers_proto_msgTypes[3]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_wrappers_proto_msgTypes[3]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *UInt64Value) String() string {
@@ -252,7 +244,7 @@ func (*UInt64Value) ProtoMessage() {}
func (x *UInt64Value) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_wrappers_proto_msgTypes[3]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -293,11 +285,9 @@ func Int32(v int32) *Int32Value {
func (x *Int32Value) Reset() {
*x = Int32Value{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_wrappers_proto_msgTypes[4]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_wrappers_proto_msgTypes[4]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *Int32Value) String() string {
@@ -308,7 +298,7 @@ func (*Int32Value) ProtoMessage() {}
func (x *Int32Value) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_wrappers_proto_msgTypes[4]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -349,11 +339,9 @@ func UInt32(v uint32) *UInt32Value {
func (x *UInt32Value) Reset() {
*x = UInt32Value{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_wrappers_proto_msgTypes[5]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_wrappers_proto_msgTypes[5]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *UInt32Value) String() string {
@@ -364,7 +352,7 @@ func (*UInt32Value) ProtoMessage() {}
func (x *UInt32Value) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_wrappers_proto_msgTypes[5]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -405,11 +393,9 @@ func Bool(v bool) *BoolValue {
func (x *BoolValue) Reset() {
*x = BoolValue{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_wrappers_proto_msgTypes[6]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_wrappers_proto_msgTypes[6]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *BoolValue) String() string {
@@ -420,7 +406,7 @@ func (*BoolValue) ProtoMessage() {}
func (x *BoolValue) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_wrappers_proto_msgTypes[6]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -461,11 +447,9 @@ func String(v string) *StringValue {
func (x *StringValue) Reset() {
*x = StringValue{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_wrappers_proto_msgTypes[7]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_wrappers_proto_msgTypes[7]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *StringValue) String() string {
@@ -476,7 +460,7 @@ func (*StringValue) ProtoMessage() {}
func (x *StringValue) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_wrappers_proto_msgTypes[7]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -517,11 +501,9 @@ func Bytes(v []byte) *BytesValue {
func (x *BytesValue) Reset() {
*x = BytesValue{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_wrappers_proto_msgTypes[8]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
+ mi := &file_google_protobuf_wrappers_proto_msgTypes[8]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
}
func (x *BytesValue) String() string {
@@ -532,7 +514,7 @@ func (*BytesValue) ProtoMessage() {}
func (x *BytesValue) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_wrappers_proto_msgTypes[8]
- if protoimpl.UnsafeEnabled && x != nil {
+ if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
@@ -629,116 +611,6 @@ func file_google_protobuf_wrappers_proto_init() {
if File_google_protobuf_wrappers_proto != nil {
return
}
- if !protoimpl.UnsafeEnabled {
- file_google_protobuf_wrappers_proto_msgTypes[0].Exporter = func(v any, i int) any {
- switch v := v.(*DoubleValue); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_wrappers_proto_msgTypes[1].Exporter = func(v any, i int) any {
- switch v := v.(*FloatValue); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_wrappers_proto_msgTypes[2].Exporter = func(v any, i int) any {
- switch v := v.(*Int64Value); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_wrappers_proto_msgTypes[3].Exporter = func(v any, i int) any {
- switch v := v.(*UInt64Value); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_wrappers_proto_msgTypes[4].Exporter = func(v any, i int) any {
- switch v := v.(*Int32Value); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_wrappers_proto_msgTypes[5].Exporter = func(v any, i int) any {
- switch v := v.(*UInt32Value); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_wrappers_proto_msgTypes[6].Exporter = func(v any, i int) any {
- switch v := v.(*BoolValue); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_wrappers_proto_msgTypes[7].Exporter = func(v any, i int) any {
- switch v := v.(*StringValue); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_wrappers_proto_msgTypes[8].Exporter = func(v any, i int) any {
- switch v := v.(*BytesValue); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- }
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
diff --git a/vendor/k8s.io/klog/v2/klog.go b/vendor/k8s.io/klog/v2/klog.go
index 026be9e3b1..47ec9466a6 100644
--- a/vendor/k8s.io/klog/v2/klog.go
+++ b/vendor/k8s.io/klog/v2/klog.go
@@ -404,13 +404,6 @@ func (t *traceLocation) Set(value string) error {
return nil
}
-// flushSyncWriter is the interface satisfied by logging destinations.
-type flushSyncWriter interface {
- Flush() error
- Sync() error
- io.Writer
-}
-
var logging loggingT
var commandLine flag.FlagSet
@@ -486,7 +479,7 @@ type settings struct {
// Access to all of the following fields must be protected via a mutex.
// file holds writer for each of the log types.
- file [severity.NumSeverity]flushSyncWriter
+ file [severity.NumSeverity]io.Writer
// flushInterval is the interval for periodic flushing. If zero,
// the global default will be used.
flushInterval time.Duration
@@ -831,32 +824,12 @@ func (l *loggingT) printS(err error, s severity.Severity, depth int, msg string,
buffer.PutBuffer(b)
}
-// redirectBuffer is used to set an alternate destination for the logs
-type redirectBuffer struct {
- w io.Writer
-}
-
-func (rb *redirectBuffer) Sync() error {
- return nil
-}
-
-func (rb *redirectBuffer) Flush() error {
- return nil
-}
-
-func (rb *redirectBuffer) Write(bytes []byte) (n int, err error) {
- return rb.w.Write(bytes)
-}
-
// SetOutput sets the output destination for all severities
func SetOutput(w io.Writer) {
logging.mu.Lock()
defer logging.mu.Unlock()
for s := severity.FatalLog; s >= severity.InfoLog; s-- {
- rb := &redirectBuffer{
- w: w,
- }
- logging.file[s] = rb
+ logging.file[s] = w
}
}
@@ -868,10 +841,7 @@ func SetOutputBySeverity(name string, w io.Writer) {
if !ok {
panic(fmt.Sprintf("SetOutputBySeverity(%q): unrecognized severity name", name))
}
- rb := &redirectBuffer{
- w: w,
- }
- logging.file[sev] = rb
+ logging.file[sev] = w
}
// LogToStderr sets whether to log exclusively to stderr, bypassing outputs
@@ -1011,7 +981,8 @@ func (l *loggingT) exit(err error) {
logExitFunc(err)
return
}
- l.flushAll()
+ needToSync := l.flushAll()
+ l.syncAll(needToSync)
OsExit(2)
}
@@ -1028,10 +999,6 @@ type syncBuffer struct {
maxbytes uint64 // The max number of bytes this syncBuffer.file can hold before cleaning up.
}
-func (sb *syncBuffer) Sync() error {
- return sb.file.Sync()
-}
-
// CalculateMaxSize returns the real max size in bytes after considering the default max size and the flag options.
func CalculateMaxSize() uint64 {
if logging.logFile != "" {
@@ -1223,24 +1190,45 @@ func StartFlushDaemon(interval time.Duration) {
// lockAndFlushAll is like flushAll but locks l.mu first.
func (l *loggingT) lockAndFlushAll() {
l.mu.Lock()
- l.flushAll()
+ needToSync := l.flushAll()
l.mu.Unlock()
+ // Some environments are slow when syncing and holding the lock might cause contention.
+ l.syncAll(needToSync)
}
-// flushAll flushes all the logs and attempts to "sync" their data to disk.
+// flushAll flushes all the logs
// l.mu is held.
-func (l *loggingT) flushAll() {
+//
+// The result is the number of files which need to be synced and the pointers to them.
+func (l *loggingT) flushAll() fileArray {
+ var needToSync fileArray
+
// Flush from fatal down, in case there's trouble flushing.
for s := severity.FatalLog; s >= severity.InfoLog; s-- {
file := l.file[s]
- if file != nil {
- _ = file.Flush() // ignore error
- _ = file.Sync() // ignore error
+ if sb, ok := file.(*syncBuffer); ok && sb.file != nil {
+ _ = sb.Flush() // ignore error
+ needToSync.files[needToSync.num] = sb.file
+ needToSync.num++
}
}
if logging.loggerOptions.flush != nil {
logging.loggerOptions.flush()
}
+ return needToSync
+}
+
+type fileArray struct {
+ num int
+ files [severity.NumSeverity]*os.File
+}
+
+// syncAll attempts to "sync" their data to disk.
+func (l *loggingT) syncAll(needToSync fileArray) {
+ // Flush from fatal down, in case there's trouble flushing.
+ for i := 0; i < needToSync.num; i++ {
+ _ = needToSync.files[i].Sync() // ignore error
+ }
}
// CopyStandardLogTo arranges for messages written to the Go "log" package's
diff --git a/vendor/k8s.io/kube-openapi/pkg/builder3/openapi.go b/vendor/k8s.io/kube-openapi/pkg/builder3/openapi.go
index 3a8d765f11..081dae306f 100644
--- a/vendor/k8s.io/kube-openapi/pkg/builder3/openapi.go
+++ b/vendor/k8s.io/kube-openapi/pkg/builder3/openapi.go
@@ -156,7 +156,9 @@ func (o *openAPI) buildRequestBody(parameters []common.Parameter, consumes []str
}
r := &spec3.RequestBody{
RequestBodyProps: spec3.RequestBodyProps{
- Content: map[string]*spec3.MediaType{},
+ Content: map[string]*spec3.MediaType{},
+ Description: param.Description(),
+ Required: param.Required(),
},
}
for _, consume := range consumes {
@@ -172,9 +174,9 @@ func (o *openAPI) buildRequestBody(parameters []common.Parameter, consumes []str
return nil, nil
}
-func newOpenAPI(config *common.Config) openAPI {
+func newOpenAPI(config *common.OpenAPIV3Config) openAPI {
o := openAPI{
- config: common.ConvertConfigToV3(config),
+ config: config,
spec: &spec3.OpenAPI{
Version: "3.0.0",
Info: config.Info,
@@ -313,24 +315,27 @@ func (o *openAPI) buildOpenAPISpec(webServices []common.RouteContainer) error {
// BuildOpenAPISpec builds OpenAPI v3 spec given a list of route containers and common.Config to customize it.
//
// Deprecated: BuildOpenAPISpecFromRoutes should be used instead.
-func BuildOpenAPISpec(webServices []*restful.WebService, config *common.Config) (*spec3.OpenAPI, error) {
+func BuildOpenAPISpec(webServices []*restful.WebService, config *common.OpenAPIV3Config) (*spec3.OpenAPI, error) {
return BuildOpenAPISpecFromRoutes(restfuladapter.AdaptWebServices(webServices), config)
}
// BuildOpenAPISpecFromRoutes builds OpenAPI v3 spec given a list of route containers and common.Config to customize it.
-func BuildOpenAPISpecFromRoutes(webServices []common.RouteContainer, config *common.Config) (*spec3.OpenAPI, error) {
+func BuildOpenAPISpecFromRoutes(webServices []common.RouteContainer, config *common.OpenAPIV3Config) (*spec3.OpenAPI, error) {
a := newOpenAPI(config)
err := a.buildOpenAPISpec(webServices)
if err != nil {
return nil, err
}
+ if config.PostProcessSpec != nil {
+ return config.PostProcessSpec(a.spec)
+ }
return a.spec, nil
}
// BuildOpenAPIDefinitionsForResource builds a partial OpenAPI spec given a sample object and common.Config to customize it.
// BuildOpenAPIDefinitionsForResources returns the OpenAPI spec which includes the definitions for the
// passed type names.
-func BuildOpenAPIDefinitionsForResources(config *common.Config, names ...string) (map[string]*spec.Schema, error) {
+func BuildOpenAPIDefinitionsForResources(config *common.OpenAPIV3Config, names ...string) (map[string]*spec.Schema, error) {
o := newOpenAPI(config)
// We can discard the return value of toSchema because all we care about is the side effect of calling it.
// All the models created for this resource get added to o.swagger.Definitions
diff --git a/vendor/k8s.io/kube-openapi/pkg/cached/cache.go b/vendor/k8s.io/kube-openapi/pkg/cached/cache.go
index 76415b7830..a66fe8a095 100644
--- a/vendor/k8s.io/kube-openapi/pkg/cached/cache.go
+++ b/vendor/k8s.io/kube-openapi/pkg/cached/cache.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-// Package cache provides a cache mechanism based on etags to lazily
+// Package cached provides a cache mechanism based on etags to lazily
// build, and/or cache results from expensive operation such that those
// operations are not repeated unnecessarily. The operations can be
// created as a tree, and replaced dynamically as needed.
@@ -25,16 +25,18 @@ limitations under the License.
//
// This package uses a source/transform/sink model of caches to build
// the dependency tree, and can be used as follows:
-// - [NewSource]: A source cache that recomputes the content every time.
-// - [NewStaticSource]: A source cache that always produces the
+// - [Func]: A source cache that recomputes the content every time.
+// - [Once]: A source cache that always produces the
// same content, it is only called once.
-// - [NewTransformer]: A cache that transforms data from one format to
+// - [Transform]: A cache that transforms data from one format to
// another. It's only refreshed when the source changes.
-// - [NewMerger]: A cache that aggregates multiple caches into one.
+// - [Merge]: A cache that aggregates multiple caches in a map into one.
// It's only refreshed when the source changes.
-// - [Replaceable]: A cache adapter that can be atomically
-// replaced with a new one, and saves the previous results in case an
-// error pops-up.
+// - [MergeList]: A cache that aggregates multiple caches in a list into one.
+// It's only refreshed when the source changes.
+// - [Atomic]: A cache adapter that atomically replaces the source with a new one.
+// - [LastSuccess]: A cache adapter that caches the last successful and returns
+// it if the next call fails. It extends [Atomic].
//
// # Etags
//
@@ -54,61 +56,45 @@ import (
"sync/atomic"
)
-// Result is the content returned from a call to a cache. It can either
-// be created with [NewResultOK] if the call was a success, or
-// [NewResultErr] if the call resulted in an error.
+// Value is wrapping a value behind a getter for lazy evaluation.
+type Value[T any] interface {
+ Get() (value T, etag string, err error)
+}
+
+// Result is wrapping T and error into a struct for cases where a tuple is more
+// convenient or necessary in Golang.
type Result[T any] struct {
- Data T
- Etag string
- Err error
+ Value T
+ Etag string
+ Err error
}
-// NewResultOK creates a new [Result] for a successful operation.
-func NewResultOK[T any](data T, etag string) Result[T] {
- return Result[T]{
- Data: data,
- Etag: etag,
- }
+func (r Result[T]) Get() (T, string, error) {
+ return r.Value, r.Etag, r.Err
}
-// NewResultErr creates a new [Result] when an error has happened.
-func NewResultErr[T any](err error) Result[T] {
- return Result[T]{
- Err: err,
- }
+// Func wraps a (thread-safe) function as a Value[T].
+func Func[T any](fn func() (T, string, error)) Value[T] {
+ return valueFunc[T](fn)
}
-// Result can be treated as a [Data] if necessary.
-func (r Result[T]) Get() Result[T] {
- return r
+type valueFunc[T any] func() (T, string, error)
+
+func (c valueFunc[T]) Get() (T, string, error) {
+ return c()
}
-// Data is a cache that performs an action whose result data will be
-// cached. It also returns an "etag" identifier to version the cache, so
-// that the caller can know if they have the most recent version of the
-// cache (and can decide to cache some operation based on that).
-//
-// The [NewMerger] and [NewTransformer] automatically handle
-// that for you by checking if the etag is updated before calling the
-// merging or transforming function.
-type Data[T any] interface {
- // Returns the cached data, as well as an "etag" to identify the
- // version of the cache, or an error if something happened.
- Get() Result[T]
+// Static returns constant values.
+func Static[T any](value T, etag string) Value[T] {
+ return Result[T]{Value: value, Etag: etag}
}
-// NewMerger creates a new merge cache, a cache that merges the result
-// of other caches. The function only gets called if any of the
-// dependency has changed.
+// Merge merges a of cached values. The merge function only gets called if any of
+// the dependency has changed.
//
// If any of the dependency returned an error before, or any of the
// dependency returned an error this time, or if the mergeFn failed
-// before, then the function is reran.
-//
-// The caches and results are mapped by K so that associated data can be
-// retrieved. The map of dependencies can not be modified after
-// creation, and a new merger should be created (and probably replaced
-// using a [Replaceable]).
+// before, then the function is run again.
//
// Note that this assumes there is no "partial" merge, the merge
// function will remerge all the dependencies together everytime. Since
@@ -118,18 +104,19 @@ type Data[T any] interface {
// Also note that Golang map iteration is not stable. If the mergeFn
// depends on the order iteration to be stable, it will need to
// implement its own sorting or iteration order.
-func NewMerger[K comparable, T, V any](mergeFn func(results map[K]Result[T]) Result[V], caches map[K]Data[T]) Data[V] {
- listCaches := make([]Data[T], 0, len(caches))
- // maps from index to key
+func Merge[K comparable, T, V any](mergeFn func(results map[K]Result[T]) (V, string, error), caches map[K]Value[T]) Value[V] {
+ list := make([]Value[T], 0, len(caches))
+
+ // map from index to key
indexes := make(map[int]K, len(caches))
i := 0
for k := range caches {
- listCaches = append(listCaches, caches[k])
+ list = append(list, caches[k])
indexes[i] = k
i++
}
- return NewListMerger(func(results []Result[T]) Result[V] {
+ return MergeList(func(results []Result[T]) (V, string, error) {
if len(results) != len(indexes) {
panic(fmt.Errorf("invalid result length %d, expected %d", len(results), len(indexes)))
}
@@ -138,20 +125,11 @@ func NewMerger[K comparable, T, V any](mergeFn func(results map[K]Result[T]) Res
m[indexes[i]] = results[i]
}
return mergeFn(m)
- }, listCaches)
-}
-
-type listMerger[T, V any] struct {
- lock sync.Mutex
- mergeFn func([]Result[T]) Result[V]
- caches []Data[T]
- cacheResults []Result[T]
- result Result[V]
+ }, list)
}
-// NewListMerger creates a new merge cache that merges the results of
-// other caches in list form. The function only gets called if any of
-// the dependency has changed.
+// MergeList merges a list of cached values. The function only gets called if
+// any of the dependency has changed.
//
// The benefit of ListMerger over the basic Merger is that caches are
// stored in an ordered list so the order of the cache will be
@@ -165,31 +143,37 @@ type listMerger[T, V any] struct {
// function will remerge all the dependencies together everytime. Since
// the list of dependencies is constant, there is no way to save some
// partial merge information either.
-func NewListMerger[T, V any](mergeFn func(results []Result[T]) Result[V], caches []Data[T]) Data[V] {
+func MergeList[T, V any](mergeFn func(results []Result[T]) (V, string, error), delegates []Value[T]) Value[V] {
return &listMerger[T, V]{
- mergeFn: mergeFn,
- caches: caches,
+ mergeFn: mergeFn,
+ delegates: delegates,
}
}
+type listMerger[T, V any] struct {
+ lock sync.Mutex
+ mergeFn func([]Result[T]) (V, string, error)
+ delegates []Value[T]
+ cache []Result[T]
+ result Result[V]
+}
+
func (c *listMerger[T, V]) prepareResultsLocked() []Result[T] {
- cacheResults := make([]Result[T], len(c.caches))
+ cacheResults := make([]Result[T], len(c.delegates))
ch := make(chan struct {
int
Result[T]
- }, len(c.caches))
- for i := range c.caches {
+ }, len(c.delegates))
+ for i := range c.delegates {
go func(index int) {
+ value, etag, err := c.delegates[index].Get()
ch <- struct {
int
Result[T]
- }{
- index,
- c.caches[index].Get(),
- }
+ }{index, Result[T]{Value: value, Etag: etag, Err: err}}
}(i)
}
- for i := 0; i < len(c.caches); i++ {
+ for i := 0; i < len(c.delegates); i++ {
res := <-ch
cacheResults[res.int] = res.Result
}
@@ -197,16 +181,16 @@ func (c *listMerger[T, V]) prepareResultsLocked() []Result[T] {
}
func (c *listMerger[T, V]) needsRunningLocked(results []Result[T]) bool {
- if c.cacheResults == nil {
+ if c.cache == nil {
return true
}
if c.result.Err != nil {
return true
}
- if len(results) != len(c.cacheResults) {
- panic(fmt.Errorf("invalid number of results: %v (expected %v)", len(results), len(c.cacheResults)))
+ if len(results) != len(c.cache) {
+ panic(fmt.Errorf("invalid number of results: %v (expected %v)", len(results), len(c.cache)))
}
- for i, oldResult := range c.cacheResults {
+ for i, oldResult := range c.cache {
newResult := results[i]
if newResult.Etag != oldResult.Etag || newResult.Err != nil || oldResult.Err != nil {
return true
@@ -215,98 +199,92 @@ func (c *listMerger[T, V]) needsRunningLocked(results []Result[T]) bool {
return false
}
-func (c *listMerger[T, V]) Get() Result[V] {
+func (c *listMerger[T, V]) Get() (V, string, error) {
c.lock.Lock()
defer c.lock.Unlock()
cacheResults := c.prepareResultsLocked()
if c.needsRunningLocked(cacheResults) {
- c.cacheResults = cacheResults
- c.result = c.mergeFn(c.cacheResults)
+ c.cache = cacheResults
+ c.result.Value, c.result.Etag, c.result.Err = c.mergeFn(c.cache)
}
- return c.result
+ return c.result.Value, c.result.Etag, c.result.Err
}
-// NewTransformer creates a new cache that transforms the result of
-// another cache. The transformFn will only be called if the source
-// cache has updated the output, otherwise, the cached result will be
-// returned.
+// Transform the result of another cached value. The transformFn will only be called
+// if the source has updated, otherwise, the result will be returned.
//
// If the dependency returned an error before, or it returns an error
// this time, or if the transformerFn failed before, the function is
// reran.
-func NewTransformer[T, V any](transformerFn func(Result[T]) Result[V], source Data[T]) Data[V] {
- return NewListMerger(func(caches []Result[T]) Result[V] {
- if len(caches) != 1 {
- panic(fmt.Errorf("invalid cache for transformer cache: %v", caches))
+func Transform[T, V any](transformerFn func(T, string, error) (V, string, error), source Value[T]) Value[V] {
+ return MergeList(func(delegates []Result[T]) (V, string, error) {
+ if len(delegates) != 1 {
+ panic(fmt.Errorf("invalid cache for transformer cache: %v", delegates))
}
- return transformerFn(caches[0])
- }, []Data[T]{source})
-}
-
-// NewSource creates a new cache that generates some data. This
-// will always be called since we don't know the origin of the data and
-// if it needs to be updated or not. sourceFn MUST be thread-safe.
-func NewSource[T any](sourceFn func() Result[T]) Data[T] {
- c := source[T](sourceFn)
- return &c
+ return transformerFn(delegates[0].Value, delegates[0].Etag, delegates[0].Err)
+ }, []Value[T]{source})
}
-type source[T any] func() Result[T]
-
-func (c *source[T]) Get() Result[T] {
- return (*c)()
-}
-
-// NewStaticSource creates a new cache that always generates the
-// same data. This will only be called once (lazily).
-func NewStaticSource[T any](staticFn func() Result[T]) Data[T] {
- return &static[T]{
- fn: staticFn,
+// Once calls Value[T].Get() lazily and only once, even in case of an error result.
+func Once[T any](d Value[T]) Value[T] {
+ return &once[T]{
+ data: d,
}
}
-type static[T any] struct {
+type once[T any] struct {
once sync.Once
- fn func() Result[T]
+ data Value[T]
result Result[T]
}
-func (c *static[T]) Get() Result[T] {
+func (c *once[T]) Get() (T, string, error) {
c.once.Do(func() {
- c.result = c.fn()
+ c.result.Value, c.result.Etag, c.result.Err = c.data.Get()
})
- return c.result
+ return c.result.Value, c.result.Etag, c.result.Err
}
-// Replaceable is a cache that carries the result even when the cache is
-// replaced. This is the type that should typically be stored in
-// structs.
-type Replaceable[T any] struct {
- cache atomic.Pointer[Data[T]]
- result atomic.Pointer[Result[T]]
+// Replaceable extends the Value[T] interface with the ability to change the
+// underlying Value[T] after construction.
+type Replaceable[T any] interface {
+ Value[T]
+ Store(Value[T])
}
-// Get retrieves the data from the underlying source. [Replaceable]
-// implements the [Data] interface itself. This is a pass-through
-// that calls the most recent underlying cache. If the cache fails but
-// previously had returned a success, that success will be returned
-// instead. If the cache fails but we never returned a success, that
-// failure is returned.
-func (c *Replaceable[T]) Get() Result[T] {
- result := (*c.cache.Load()).Get()
-
- for {
- cResult := c.result.Load()
- if result.Err != nil && cResult != nil && cResult.Err == nil {
- return *cResult
- }
- if c.result.CompareAndSwap(cResult, &result) {
- return result
+// Atomic wraps a Value[T] as an atomic value that can be replaced. It implements
+// Replaceable[T].
+type Atomic[T any] struct {
+ value atomic.Pointer[Value[T]]
+}
+
+var _ Replaceable[[]byte] = &Atomic[[]byte]{}
+
+func (x *Atomic[T]) Store(val Value[T]) { x.value.Store(&val) }
+func (x *Atomic[T]) Get() (T, string, error) { return (*x.value.Load()).Get() }
+
+// LastSuccess calls Value[T].Get(), but hides errors by returning the last
+// success if there has been any.
+type LastSuccess[T any] struct {
+ Atomic[T]
+ success atomic.Pointer[Result[T]]
+}
+
+var _ Replaceable[[]byte] = &LastSuccess[[]byte]{}
+
+func (c *LastSuccess[T]) Get() (T, string, error) {
+ success := c.success.Load()
+ value, etag, err := c.Atomic.Get()
+ if err == nil {
+ if success == nil {
+ c.success.CompareAndSwap(nil, &Result[T]{Value: value, Etag: etag, Err: err})
}
+ return value, etag, err
+ }
+
+ if success != nil {
+ return success.Value, success.Etag, success.Err
}
-}
-// Replace changes the cache.
-func (c *Replaceable[T]) Replace(cache Data[T]) {
- c.cache.Swap(&cache)
+ return value, etag, err
}
diff --git a/vendor/k8s.io/kube-openapi/pkg/common/common.go b/vendor/k8s.io/kube-openapi/pkg/common/common.go
index 1a6c12e17a..e4ce843b0c 100644
--- a/vendor/k8s.io/kube-openapi/pkg/common/common.go
+++ b/vendor/k8s.io/kube-openapi/pkg/common/common.go
@@ -22,7 +22,6 @@ import (
"github.com/emicklei/go-restful/v3"
- "k8s.io/kube-openapi/pkg/openapiconv"
"k8s.io/kube-openapi/pkg/spec3"
"k8s.io/kube-openapi/pkg/validation/spec"
)
@@ -165,6 +164,9 @@ type OpenAPIV3Config struct {
// It is an optional function to customize model names.
GetDefinitionName func(name string) (string, spec.Extensions)
+ // PostProcessSpec runs after the spec is ready to serve. It allows a final modification to the spec before serving.
+ PostProcessSpec func(*spec3.OpenAPI) (*spec3.OpenAPI, error)
+
// SecuritySchemes is list of all security schemes for OpenAPI service.
SecuritySchemes spec3.SecuritySchemes
@@ -172,43 +174,6 @@ type OpenAPIV3Config struct {
DefaultSecurity []map[string][]string
}
-// ConvertConfigToV3 converts a Config object to an OpenAPIV3Config object
-func ConvertConfigToV3(config *Config) *OpenAPIV3Config {
- if config == nil {
- return nil
- }
-
- v3Config := &OpenAPIV3Config{
- Info: config.Info,
- IgnorePrefixes: config.IgnorePrefixes,
- GetDefinitions: config.GetDefinitions,
- GetOperationIDAndTags: config.GetOperationIDAndTags,
- GetOperationIDAndTagsFromRoute: config.GetOperationIDAndTagsFromRoute,
- GetDefinitionName: config.GetDefinitionName,
- Definitions: config.Definitions,
- SecuritySchemes: make(spec3.SecuritySchemes),
- DefaultSecurity: config.DefaultSecurity,
- DefaultResponse: openapiconv.ConvertResponse(config.DefaultResponse, []string{"application/json"}),
-
- CommonResponses: make(map[int]*spec3.Response),
- ResponseDefinitions: make(map[string]*spec3.Response),
- }
-
- if config.SecurityDefinitions != nil {
- for s, securityScheme := range *config.SecurityDefinitions {
- v3Config.SecuritySchemes[s] = openapiconv.ConvertSecurityScheme(securityScheme)
- }
- }
- for k, commonResponse := range config.CommonResponses {
- v3Config.CommonResponses[k] = openapiconv.ConvertResponse(&commonResponse, []string{"application/json"})
- }
-
- for k, responseDefinition := range config.ResponseDefinitions {
- v3Config.ResponseDefinitions[k] = openapiconv.ConvertResponse(&responseDefinition, []string{"application/json"})
- }
- return v3Config
-}
-
type typeInfo struct {
name string
format string
diff --git a/vendor/k8s.io/kube-openapi/pkg/handler/handler.go b/vendor/k8s.io/kube-openapi/pkg/handler/handler.go
index 0eb3f2360d..5fc6297734 100644
--- a/vendor/k8s.io/kube-openapi/pkg/handler/handler.go
+++ b/vendor/k8s.io/kube-openapi/pkg/handler/handler.go
@@ -30,6 +30,7 @@ import (
openapi_v2 "github.com/google/gnostic-models/openapiv2"
"github.com/google/uuid"
"github.com/munnerz/goautoneg"
+
klog "k8s.io/klog/v2"
"k8s.io/kube-openapi/pkg/builder"
"k8s.io/kube-openapi/pkg/cached"
@@ -59,52 +60,52 @@ type timedSpec struct {
// OpenAPIService is the service responsible for serving OpenAPI spec. It has
// the ability to safely change the spec while serving it.
type OpenAPIService struct {
- specCache cached.Replaceable[*spec.Swagger]
- jsonCache cached.Data[timedSpec]
- protoCache cached.Data[timedSpec]
+ specCache cached.LastSuccess[*spec.Swagger]
+ jsonCache cached.Value[timedSpec]
+ protoCache cached.Value[timedSpec]
}
// NewOpenAPIService builds an OpenAPIService starting with the given spec.
func NewOpenAPIService(swagger *spec.Swagger) *OpenAPIService {
- return NewOpenAPIServiceLazy(cached.NewResultOK(swagger, uuid.New().String()))
+ return NewOpenAPIServiceLazy(cached.Static(swagger, uuid.New().String()))
}
// NewOpenAPIServiceLazy builds an OpenAPIService from lazy spec.
-func NewOpenAPIServiceLazy(swagger cached.Data[*spec.Swagger]) *OpenAPIService {
+func NewOpenAPIServiceLazy(swagger cached.Value[*spec.Swagger]) *OpenAPIService {
o := &OpenAPIService{}
o.UpdateSpecLazy(swagger)
- o.jsonCache = cached.NewTransformer[*spec.Swagger](func(result cached.Result[*spec.Swagger]) cached.Result[timedSpec] {
- if result.Err != nil {
- return cached.NewResultErr[timedSpec](result.Err)
+ o.jsonCache = cached.Transform[*spec.Swagger](func(spec *spec.Swagger, etag string, err error) (timedSpec, string, error) {
+ if err != nil {
+ return timedSpec{}, "", err
}
- json, err := result.Data.MarshalJSON()
+ json, err := spec.MarshalJSON()
if err != nil {
- return cached.NewResultErr[timedSpec](err)
+ return timedSpec{}, "", err
}
- return cached.NewResultOK(timedSpec{spec: json, lastModified: time.Now()}, computeETag(json))
+ return timedSpec{spec: json, lastModified: time.Now()}, computeETag(json), nil
}, &o.specCache)
- o.protoCache = cached.NewTransformer(func(result cached.Result[timedSpec]) cached.Result[timedSpec] {
- if result.Err != nil {
- return cached.NewResultErr[timedSpec](result.Err)
+ o.protoCache = cached.Transform(func(ts timedSpec, etag string, err error) (timedSpec, string, error) {
+ if err != nil {
+ return timedSpec{}, "", err
}
- proto, err := ToProtoBinary(result.Data.spec)
+ proto, err := ToProtoBinary(ts.spec)
if err != nil {
- return cached.NewResultErr[timedSpec](err)
+ return timedSpec{}, "", err
}
// We can re-use the same etag as json because of the Vary header.
- return cached.NewResultOK(timedSpec{spec: proto, lastModified: result.Data.lastModified}, result.Etag)
+ return timedSpec{spec: proto, lastModified: ts.lastModified}, etag, nil
}, o.jsonCache)
return o
}
func (o *OpenAPIService) UpdateSpec(swagger *spec.Swagger) error {
- o.UpdateSpecLazy(cached.NewResultOK(swagger, uuid.New().String()))
+ o.UpdateSpecLazy(cached.Static(swagger, uuid.New().String()))
return nil
}
-func (o *OpenAPIService) UpdateSpecLazy(swagger cached.Data[*spec.Swagger]) {
- o.specCache.Replace(swagger)
+func (o *OpenAPIService) UpdateSpecLazy(swagger cached.Value[*spec.Swagger]) {
+ o.specCache.Store(swagger)
}
func ToProtoBinary(json []byte) ([]byte, error) {
@@ -130,7 +131,7 @@ func (o *OpenAPIService) RegisterOpenAPIVersionedService(servePath string, handl
Type string
SubType string
ReturnedContentType string
- GetDataAndEtag cached.Data[timedSpec]
+ GetDataAndEtag cached.Value[timedSpec]
}{
{"application", subTypeJSON, "application/" + subTypeJSON, o.jsonCache},
{"application", subTypeProtobufDeprecated, "application/" + subTypeProtobuf, o.protoCache},
@@ -154,11 +155,11 @@ func (o *OpenAPIService) RegisterOpenAPIVersionedService(servePath string, handl
continue
}
// serve the first matching media type in the sorted clause list
- result := accepts.GetDataAndEtag.Get()
- if result.Err != nil {
- klog.Errorf("Error in OpenAPI handler: %s", result.Err)
+ ts, etag, err := accepts.GetDataAndEtag.Get()
+ if err != nil {
+ klog.Errorf("Error in OpenAPI handler: %s", err)
// only return a 503 if we have no older cache data to serve
- if result.Data.spec == nil {
+ if ts.spec == nil {
w.WriteHeader(http.StatusServiceUnavailable)
return
}
@@ -167,9 +168,9 @@ func (o *OpenAPIService) RegisterOpenAPIVersionedService(servePath string, handl
w.Header().Set("Content-Type", accepts.ReturnedContentType)
// ETag must be enclosed in double quotes: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag
- w.Header().Set("Etag", strconv.Quote(result.Etag))
+ w.Header().Set("Etag", strconv.Quote(etag))
// ServeContent will take care of caching using eTag.
- http.ServeContent(w, r, servePath, result.Data.lastModified, bytes.NewReader(result.Data.spec))
+ http.ServeContent(w, r, servePath, ts.lastModified, bytes.NewReader(ts.spec))
return
}
}
diff --git a/vendor/k8s.io/kube-openapi/pkg/handler3/handler.go b/vendor/k8s.io/kube-openapi/pkg/handler3/handler.go
index 2263e2f32b..fc45634887 100644
--- a/vendor/k8s.io/kube-openapi/pkg/handler3/handler.go
+++ b/vendor/k8s.io/kube-openapi/pkg/handler3/handler.go
@@ -33,6 +33,7 @@ import (
openapi_v3 "github.com/google/gnostic-models/openapiv3"
"github.com/google/uuid"
"github.com/munnerz/goautoneg"
+
"k8s.io/klog/v2"
"k8s.io/kube-openapi/pkg/cached"
"k8s.io/kube-openapi/pkg/common"
@@ -73,38 +74,38 @@ type timedSpec struct {
// This type is protected by the lock on OpenAPIService.
type openAPIV3Group struct {
- specCache cached.Replaceable[*spec3.OpenAPI]
- pbCache cached.Data[timedSpec]
- jsonCache cached.Data[timedSpec]
+ specCache cached.LastSuccess[*spec3.OpenAPI]
+ pbCache cached.Value[timedSpec]
+ jsonCache cached.Value[timedSpec]
}
func newOpenAPIV3Group() *openAPIV3Group {
o := &openAPIV3Group{}
- o.jsonCache = cached.NewTransformer[*spec3.OpenAPI](func(result cached.Result[*spec3.OpenAPI]) cached.Result[timedSpec] {
- if result.Err != nil {
- return cached.NewResultErr[timedSpec](result.Err)
+ o.jsonCache = cached.Transform[*spec3.OpenAPI](func(spec *spec3.OpenAPI, etag string, err error) (timedSpec, string, error) {
+ if err != nil {
+ return timedSpec{}, "", err
}
- json, err := json.Marshal(result.Data)
+ json, err := json.Marshal(spec)
if err != nil {
- return cached.NewResultErr[timedSpec](err)
+ return timedSpec{}, "", err
}
- return cached.NewResultOK(timedSpec{spec: json, lastModified: time.Now()}, computeETag(json))
+ return timedSpec{spec: json, lastModified: time.Now()}, computeETag(json), nil
}, &o.specCache)
- o.pbCache = cached.NewTransformer(func(result cached.Result[timedSpec]) cached.Result[timedSpec] {
- if result.Err != nil {
- return cached.NewResultErr[timedSpec](result.Err)
+ o.pbCache = cached.Transform(func(ts timedSpec, etag string, err error) (timedSpec, string, error) {
+ if err != nil {
+ return timedSpec{}, "", err
}
- proto, err := ToV3ProtoBinary(result.Data.spec)
+ proto, err := ToV3ProtoBinary(ts.spec)
if err != nil {
- return cached.NewResultErr[timedSpec](err)
+ return timedSpec{}, "", err
}
- return cached.NewResultOK(timedSpec{spec: proto, lastModified: result.Data.lastModified}, result.Etag)
+ return timedSpec{spec: proto, lastModified: ts.lastModified}, etag, nil
}, o.jsonCache)
return o
}
-func (o *openAPIV3Group) UpdateSpec(openapi cached.Data[*spec3.OpenAPI]) {
- o.specCache.Replace(openapi)
+func (o *openAPIV3Group) UpdateSpec(openapi cached.Value[*spec3.OpenAPI]) {
+ o.specCache.Store(openapi)
}
// OpenAPIService is the service responsible for serving OpenAPI spec. It has
@@ -114,7 +115,7 @@ type OpenAPIService struct {
mutex sync.Mutex
v3Schema map[string]*openAPIV3Group
- discoveryCache cached.Replaceable[timedSpec]
+ discoveryCache cached.LastSuccess[timedSpec]
}
func computeETag(data []byte) string {
@@ -137,20 +138,20 @@ func NewOpenAPIService() *OpenAPIService {
o := &OpenAPIService{}
o.v3Schema = make(map[string]*openAPIV3Group)
// We're not locked because we haven't shared the structure yet.
- o.discoveryCache.Replace(o.buildDiscoveryCacheLocked())
+ o.discoveryCache.Store(o.buildDiscoveryCacheLocked())
return o
}
-func (o *OpenAPIService) buildDiscoveryCacheLocked() cached.Data[timedSpec] {
- caches := make(map[string]cached.Data[timedSpec], len(o.v3Schema))
+func (o *OpenAPIService) buildDiscoveryCacheLocked() cached.Value[timedSpec] {
+ caches := make(map[string]cached.Value[timedSpec], len(o.v3Schema))
for gvName, group := range o.v3Schema {
caches[gvName] = group.jsonCache
}
- return cached.NewMerger(func(results map[string]cached.Result[timedSpec]) cached.Result[timedSpec] {
+ return cached.Merge(func(results map[string]cached.Result[timedSpec]) (timedSpec, string, error) {
discovery := &OpenAPIV3Discovery{Paths: make(map[string]OpenAPIV3DiscoveryGroupVersion)}
for gvName, result := range results {
if result.Err != nil {
- return cached.NewResultErr[timedSpec](result.Err)
+ return timedSpec{}, "", result.Err
}
discovery.Paths[gvName] = OpenAPIV3DiscoveryGroupVersion{
ServerRelativeURL: constructServerRelativeURL(gvName, result.Etag),
@@ -158,9 +159,9 @@ func (o *OpenAPIService) buildDiscoveryCacheLocked() cached.Data[timedSpec] {
}
j, err := json.Marshal(discovery)
if err != nil {
- return cached.NewResultErr[timedSpec](err)
+ return timedSpec{}, "", err
}
- return cached.NewResultOK(timedSpec{spec: j, lastModified: time.Now()}, computeETag(j))
+ return timedSpec{spec: j, lastModified: time.Now()}, computeETag(j), nil
}, caches)
}
@@ -171,32 +172,32 @@ func (o *OpenAPIService) getSingleGroupBytes(getType string, group string) ([]by
if !ok {
return nil, "", time.Now(), fmt.Errorf("Cannot find CRD group %s", group)
}
- result := cached.Result[timedSpec]{}
switch getType {
case subTypeJSON:
- result = v.jsonCache.Get()
+ ts, etag, err := v.jsonCache.Get()
+ return ts.spec, etag, ts.lastModified, err
case subTypeProtobuf, subTypeProtobufDeprecated:
- result = v.pbCache.Get()
+ ts, etag, err := v.pbCache.Get()
+ return ts.spec, etag, ts.lastModified, err
default:
return nil, "", time.Now(), fmt.Errorf("Invalid accept clause %s", getType)
}
- return result.Data.spec, result.Etag, result.Data.lastModified, result.Err
}
// UpdateGroupVersionLazy adds or updates an existing group with the new cached.
-func (o *OpenAPIService) UpdateGroupVersionLazy(group string, openapi cached.Data[*spec3.OpenAPI]) {
+func (o *OpenAPIService) UpdateGroupVersionLazy(group string, openapi cached.Value[*spec3.OpenAPI]) {
o.mutex.Lock()
defer o.mutex.Unlock()
if _, ok := o.v3Schema[group]; !ok {
o.v3Schema[group] = newOpenAPIV3Group()
// Since there is a new item, we need to re-build the cache map.
- o.discoveryCache.Replace(o.buildDiscoveryCacheLocked())
+ o.discoveryCache.Store(o.buildDiscoveryCacheLocked())
}
o.v3Schema[group].UpdateSpec(openapi)
}
func (o *OpenAPIService) UpdateGroupVersion(group string, openapi *spec3.OpenAPI) {
- o.UpdateGroupVersionLazy(group, cached.NewResultOK(openapi, uuid.New().String()))
+ o.UpdateGroupVersionLazy(group, cached.Static(openapi, uuid.New().String()))
}
func (o *OpenAPIService) DeleteGroupVersion(group string) {
@@ -204,19 +205,19 @@ func (o *OpenAPIService) DeleteGroupVersion(group string) {
defer o.mutex.Unlock()
delete(o.v3Schema, group)
// Rebuild the merge cache map since the items have changed.
- o.discoveryCache.Replace(o.buildDiscoveryCacheLocked())
+ o.discoveryCache.Store(o.buildDiscoveryCacheLocked())
}
func (o *OpenAPIService) HandleDiscovery(w http.ResponseWriter, r *http.Request) {
- result := o.discoveryCache.Get()
- if result.Err != nil {
- klog.Errorf("Error serving discovery: %s", result.Err)
+ ts, etag, err := o.discoveryCache.Get()
+ if err != nil {
+ klog.Errorf("Error serving discovery: %s", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
- w.Header().Set("Etag", strconv.Quote(result.Etag))
+ w.Header().Set("Etag", strconv.Quote(etag))
w.Header().Set("Content-Type", "application/json")
- http.ServeContent(w, r, "/openapi/v3", result.Data.lastModified, bytes.NewReader(result.Data.spec))
+ http.ServeContent(w, r, "/openapi/v3", ts.lastModified, bytes.NewReader(ts.spec))
}
func (o *OpenAPIService) HandleGroupVersion(w http.ResponseWriter, r *http.Request) {
diff --git a/vendor/k8s.io/kube-openapi/pkg/internal/flags.go b/vendor/k8s.io/kube-openapi/pkg/internal/flags.go
index bef6037823..da5485f6a6 100644
--- a/vendor/k8s.io/kube-openapi/pkg/internal/flags.go
+++ b/vendor/k8s.io/kube-openapi/pkg/internal/flags.go
@@ -22,3 +22,4 @@ var UseOptimizedJSONUnmarshalingV3 bool = true
// Used by tests to selectively disable experimental JSON marshaler
var UseOptimizedJSONMarshaling bool = true
+var UseOptimizedJSONMarshalingV3 bool = true
diff --git a/vendor/k8s.io/kube-openapi/pkg/openapiconv/convert.go b/vendor/k8s.io/kube-openapi/pkg/openapiconv/convert.go
deleted file mode 100644
index e993fe23d5..0000000000
--- a/vendor/k8s.io/kube-openapi/pkg/openapiconv/convert.go
+++ /dev/null
@@ -1,322 +0,0 @@
-/*
-Copyright 2022 The Kubernetes 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 openapiconv
-
-import (
- "strings"
-
- klog "k8s.io/klog/v2"
- builderutil "k8s.io/kube-openapi/pkg/builder3/util"
- "k8s.io/kube-openapi/pkg/spec3"
- "k8s.io/kube-openapi/pkg/validation/spec"
-)
-
-var OpenAPIV2DefPrefix = "#/definitions/"
-var OpenAPIV3DefPrefix = "#/components/schemas/"
-
-// ConvertV2ToV3 converts an OpenAPI V2 object into V3.
-// Certain references may be shared between the V2 and V3 objects in the conversion.
-func ConvertV2ToV3(v2Spec *spec.Swagger) *spec3.OpenAPI {
- v3Spec := &spec3.OpenAPI{
- Version: "3.0.0",
- Info: v2Spec.Info,
- ExternalDocs: ConvertExternalDocumentation(v2Spec.ExternalDocs),
- Paths: ConvertPaths(v2Spec.Paths),
- Components: ConvertComponents(v2Spec.SecurityDefinitions, v2Spec.Definitions, v2Spec.Responses, v2Spec.Produces),
- }
-
- return v3Spec
-}
-
-func ConvertExternalDocumentation(v2ED *spec.ExternalDocumentation) *spec3.ExternalDocumentation {
- if v2ED == nil {
- return nil
- }
- return &spec3.ExternalDocumentation{
- ExternalDocumentationProps: spec3.ExternalDocumentationProps{
- Description: v2ED.Description,
- URL: v2ED.URL,
- },
- }
-}
-
-func ConvertComponents(v2SecurityDefinitions spec.SecurityDefinitions, v2Definitions spec.Definitions, v2Responses map[string]spec.Response, produces []string) *spec3.Components {
- components := &spec3.Components{}
-
- if v2Definitions != nil {
- components.Schemas = make(map[string]*spec.Schema)
- }
- for s, schema := range v2Definitions {
- components.Schemas[s] = ConvertSchema(&schema)
- }
- if v2SecurityDefinitions != nil {
- components.SecuritySchemes = make(spec3.SecuritySchemes)
- }
- for s, securityScheme := range v2SecurityDefinitions {
- components.SecuritySchemes[s] = ConvertSecurityScheme(securityScheme)
- }
- if v2Responses != nil {
- components.Responses = make(map[string]*spec3.Response)
- }
- for r, response := range v2Responses {
- components.Responses[r] = ConvertResponse(&response, produces)
- }
-
- return components
-}
-
-func ConvertSchema(v2Schema *spec.Schema) *spec.Schema {
- if v2Schema == nil {
- return nil
- }
- v3Schema := spec.Schema{
- VendorExtensible: v2Schema.VendorExtensible,
- SchemaProps: v2Schema.SchemaProps,
- SwaggerSchemaProps: v2Schema.SwaggerSchemaProps,
- ExtraProps: v2Schema.ExtraProps,
- }
-
- if refString := v2Schema.Ref.String(); refString != "" {
- if idx := strings.Index(refString, OpenAPIV2DefPrefix); idx != -1 {
- v3Schema.Ref = spec.MustCreateRef(OpenAPIV3DefPrefix + refString[idx+len(OpenAPIV2DefPrefix):])
- } else {
- klog.Errorf("Error: Swagger V2 Ref %s does not contain #/definitions\n", refString)
- }
- }
-
- if v2Schema.Properties != nil {
- v3Schema.Properties = make(map[string]spec.Schema)
- for key, property := range v2Schema.Properties {
- v3Schema.Properties[key] = *ConvertSchema(&property)
- }
- }
- if v2Schema.Items != nil {
- v3Schema.Items = &spec.SchemaOrArray{
- Schema: ConvertSchema(v2Schema.Items.Schema),
- Schemas: ConvertSchemaList(v2Schema.Items.Schemas),
- }
- }
-
- if v2Schema.AdditionalProperties != nil {
- v3Schema.AdditionalProperties = &spec.SchemaOrBool{
- Schema: ConvertSchema(v2Schema.AdditionalProperties.Schema),
- Allows: v2Schema.AdditionalProperties.Allows,
- }
- }
- if v2Schema.AdditionalItems != nil {
- v3Schema.AdditionalItems = &spec.SchemaOrBool{
- Schema: ConvertSchema(v2Schema.AdditionalItems.Schema),
- Allows: v2Schema.AdditionalItems.Allows,
- }
- }
-
- return builderutil.WrapRefs(&v3Schema)
-}
-
-func ConvertSchemaList(v2SchemaList []spec.Schema) []spec.Schema {
- if v2SchemaList == nil {
- return nil
- }
- v3SchemaList := []spec.Schema{}
- for _, s := range v2SchemaList {
- v3SchemaList = append(v3SchemaList, *ConvertSchema(&s))
- }
- return v3SchemaList
-}
-
-func ConvertSecurityScheme(v2securityScheme *spec.SecurityScheme) *spec3.SecurityScheme {
- if v2securityScheme == nil {
- return nil
- }
- securityScheme := &spec3.SecurityScheme{
- VendorExtensible: v2securityScheme.VendorExtensible,
- SecuritySchemeProps: spec3.SecuritySchemeProps{
- Description: v2securityScheme.Description,
- Type: v2securityScheme.Type,
- Name: v2securityScheme.Name,
- In: v2securityScheme.In,
- },
- }
-
- if v2securityScheme.Flow != "" {
- securityScheme.Flows = make(map[string]*spec3.OAuthFlow)
- securityScheme.Flows[v2securityScheme.Flow] = &spec3.OAuthFlow{
- OAuthFlowProps: spec3.OAuthFlowProps{
- AuthorizationUrl: v2securityScheme.AuthorizationURL,
- TokenUrl: v2securityScheme.TokenURL,
- Scopes: v2securityScheme.Scopes,
- },
- }
- }
- return securityScheme
-}
-
-func ConvertPaths(v2Paths *spec.Paths) *spec3.Paths {
- if v2Paths == nil {
- return nil
- }
- paths := &spec3.Paths{
- VendorExtensible: v2Paths.VendorExtensible,
- }
-
- if v2Paths.Paths != nil {
- paths.Paths = make(map[string]*spec3.Path)
- }
- for k, v := range v2Paths.Paths {
- paths.Paths[k] = ConvertPathItem(v)
- }
- return paths
-}
-
-func ConvertPathItem(v2pathItem spec.PathItem) *spec3.Path {
- path := &spec3.Path{
- Refable: v2pathItem.Refable,
- PathProps: spec3.PathProps{
- Get: ConvertOperation(v2pathItem.Get),
- Put: ConvertOperation(v2pathItem.Put),
- Post: ConvertOperation(v2pathItem.Post),
- Delete: ConvertOperation(v2pathItem.Delete),
- Options: ConvertOperation(v2pathItem.Options),
- Head: ConvertOperation(v2pathItem.Head),
- Patch: ConvertOperation(v2pathItem.Patch),
- },
- VendorExtensible: v2pathItem.VendorExtensible,
- }
- for _, param := range v2pathItem.Parameters {
- path.Parameters = append(path.Parameters, ConvertParameter(param))
- }
- return path
-}
-
-func ConvertOperation(v2Operation *spec.Operation) *spec3.Operation {
- if v2Operation == nil {
- return nil
- }
- operation := &spec3.Operation{
- VendorExtensible: v2Operation.VendorExtensible,
- OperationProps: spec3.OperationProps{
- Description: v2Operation.Description,
- ExternalDocs: ConvertExternalDocumentation(v2Operation.OperationProps.ExternalDocs),
- Tags: v2Operation.Tags,
- Summary: v2Operation.Summary,
- Deprecated: v2Operation.Deprecated,
- OperationId: v2Operation.ID,
- },
- }
-
- for _, param := range v2Operation.Parameters {
- if param.ParamProps.Name == "body" && param.ParamProps.Schema != nil {
- operation.OperationProps.RequestBody = &spec3.RequestBody{
- RequestBodyProps: spec3.RequestBodyProps{},
- }
- if v2Operation.Consumes != nil {
- operation.RequestBody.Content = make(map[string]*spec3.MediaType)
- }
- for _, consumer := range v2Operation.Consumes {
- operation.RequestBody.Content[consumer] = &spec3.MediaType{
- MediaTypeProps: spec3.MediaTypeProps{
- Schema: ConvertSchema(param.ParamProps.Schema),
- },
- }
- }
- } else {
- operation.Parameters = append(operation.Parameters, ConvertParameter(param))
- }
- }
-
- operation.Responses = &spec3.Responses{ResponsesProps: spec3.ResponsesProps{
- Default: ConvertResponse(v2Operation.Responses.Default, v2Operation.Produces),
- },
- VendorExtensible: v2Operation.Responses.VendorExtensible,
- }
-
- if v2Operation.Responses.StatusCodeResponses != nil {
- operation.Responses.StatusCodeResponses = make(map[int]*spec3.Response)
- }
- for k, v := range v2Operation.Responses.StatusCodeResponses {
- operation.Responses.StatusCodeResponses[k] = ConvertResponse(&v, v2Operation.Produces)
- }
- return operation
-}
-
-func ConvertResponse(v2Response *spec.Response, produces []string) *spec3.Response {
- if v2Response == nil {
- return nil
- }
- response := &spec3.Response{
- Refable: ConvertRefableResponse(v2Response.Refable),
- VendorExtensible: v2Response.VendorExtensible,
- ResponseProps: spec3.ResponseProps{
- Description: v2Response.Description,
- },
- }
-
- if v2Response.Schema != nil {
- if produces != nil {
- response.Content = make(map[string]*spec3.MediaType)
- }
- for _, producer := range produces {
- response.ResponseProps.Content[producer] = &spec3.MediaType{
- MediaTypeProps: spec3.MediaTypeProps{
- Schema: ConvertSchema(v2Response.Schema),
- },
- }
- }
- }
- return response
-}
-
-func ConvertParameter(v2Param spec.Parameter) *spec3.Parameter {
- param := &spec3.Parameter{
- Refable: ConvertRefableParameter(v2Param.Refable),
- VendorExtensible: v2Param.VendorExtensible,
- ParameterProps: spec3.ParameterProps{
- Name: v2Param.Name,
- Description: v2Param.Description,
- In: v2Param.In,
- Required: v2Param.Required,
- Schema: ConvertSchema(v2Param.Schema),
- AllowEmptyValue: v2Param.AllowEmptyValue,
- },
- }
- // Convert SimpleSchema into Schema
- if param.Schema == nil {
- param.Schema = &spec.Schema{
- SchemaProps: spec.SchemaProps{
- Type: []string{v2Param.Type},
- Format: v2Param.Format,
- UniqueItems: v2Param.UniqueItems,
- },
- }
- }
-
- return param
-}
-
-func ConvertRefableParameter(refable spec.Refable) spec.Refable {
- if refable.Ref.String() != "" {
- return spec.Refable{Ref: spec.MustCreateRef(strings.Replace(refable.Ref.String(), "#/parameters/", "#/components/parameters/", 1))}
- }
- return refable
-}
-
-func ConvertRefableResponse(refable spec.Refable) spec.Refable {
- if refable.Ref.String() != "" {
- return spec.Refable{Ref: spec.MustCreateRef(strings.Replace(refable.Ref.String(), "#/responses/", "#/components/responses/", 1))}
- }
- return refable
-}
diff --git a/vendor/k8s.io/kube-openapi/pkg/schemaconv/smd.go b/vendor/k8s.io/kube-openapi/pkg/schemaconv/smd.go
index 799d866d51..9887d185b2 100644
--- a/vendor/k8s.io/kube-openapi/pkg/schemaconv/smd.go
+++ b/vendor/k8s.io/kube-openapi/pkg/schemaconv/smd.go
@@ -214,9 +214,6 @@ func makeUnion(extensions map[string]interface{}) (schema.Union, error) {
}
}
- if union.Discriminator != nil && len(union.Fields) == 0 {
- return schema.Union{}, fmt.Errorf("discriminator set to %v, but no fields in union", *union.Discriminator)
- }
return union, nil
}
diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/encoding.go b/vendor/k8s.io/kube-openapi/pkg/spec3/encoding.go
index 699291f1d8..1f62c6e772 100644
--- a/vendor/k8s.io/kube-openapi/pkg/spec3/encoding.go
+++ b/vendor/k8s.io/kube-openapi/pkg/spec3/encoding.go
@@ -32,6 +32,9 @@ type Encoding struct {
// MarshalJSON is a custom marshal function that knows how to encode Encoding as JSON
func (e *Encoding) MarshalJSON() ([]byte, error) {
+ if internal.UseOptimizedJSONMarshalingV3 {
+ return internal.DeterministicMarshal(e)
+ }
b1, err := json.Marshal(e.EncodingProps)
if err != nil {
return nil, err
@@ -43,6 +46,16 @@ func (e *Encoding) MarshalJSON() ([]byte, error) {
return swag.ConcatJSON(b1, b2), nil
}
+func (e *Encoding) MarshalNextJSON(opts jsonv2.MarshalOptions, enc *jsonv2.Encoder) error {
+ var x struct {
+ EncodingProps encodingPropsOmitZero `json:",inline"`
+ spec.Extensions
+ }
+ x.Extensions = internal.SanitizeExtensions(e.Extensions)
+ x.EncodingProps = encodingPropsOmitZero(e.EncodingProps)
+ return opts.MarshalNext(enc, x)
+}
+
func (e *Encoding) UnmarshalJSON(data []byte) error {
if internal.UseOptimizedJSONUnmarshalingV3 {
return jsonv2.Unmarshal(data, e)
@@ -82,3 +95,11 @@ type EncodingProps struct {
// AllowReserved determines whether the parameter value SHOULD allow reserved characters, as defined by RFC3986
AllowReserved bool `json:"allowReserved,omitempty"`
}
+
+type encodingPropsOmitZero struct {
+ ContentType string `json:"contentType,omitempty"`
+ Headers map[string]*Header `json:"headers,omitempty"`
+ Style string `json:"style,omitempty"`
+ Explode bool `json:"explode,omitzero"`
+ AllowReserved bool `json:"allowReserved,omitzero"`
+}
diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/example.go b/vendor/k8s.io/kube-openapi/pkg/spec3/example.go
index 03b8727170..8834a92e6d 100644
--- a/vendor/k8s.io/kube-openapi/pkg/spec3/example.go
+++ b/vendor/k8s.io/kube-openapi/pkg/spec3/example.go
@@ -36,6 +36,9 @@ type Example struct {
// MarshalJSON is a custom marshal function that knows how to encode RequestBody as JSON
func (e *Example) MarshalJSON() ([]byte, error) {
+ if internal.UseOptimizedJSONMarshalingV3 {
+ return internal.DeterministicMarshal(e)
+ }
b1, err := json.Marshal(e.Refable)
if err != nil {
return nil, err
@@ -50,6 +53,17 @@ func (e *Example) MarshalJSON() ([]byte, error) {
}
return swag.ConcatJSON(b1, b2, b3), nil
}
+func (e *Example) MarshalNextJSON(opts jsonv2.MarshalOptions, enc *jsonv2.Encoder) error {
+ var x struct {
+ Ref string `json:"$ref,omitempty"`
+ ExampleProps `json:",inline"`
+ spec.Extensions
+ }
+ x.Ref = e.Refable.Ref.String()
+ x.Extensions = internal.SanitizeExtensions(e.Extensions)
+ x.ExampleProps = e.ExampleProps
+ return opts.MarshalNext(enc, x)
+}
func (e *Example) UnmarshalJSON(data []byte) error {
if internal.UseOptimizedJSONUnmarshalingV3 {
diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/external_documentation.go b/vendor/k8s.io/kube-openapi/pkg/spec3/external_documentation.go
index e79956721a..f0515496e4 100644
--- a/vendor/k8s.io/kube-openapi/pkg/spec3/external_documentation.go
+++ b/vendor/k8s.io/kube-openapi/pkg/spec3/external_documentation.go
@@ -39,6 +39,9 @@ type ExternalDocumentationProps struct {
// MarshalJSON is a custom marshal function that knows how to encode Responses as JSON
func (e *ExternalDocumentation) MarshalJSON() ([]byte, error) {
+ if internal.UseOptimizedJSONMarshalingV3 {
+ return internal.DeterministicMarshal(e)
+ }
b1, err := json.Marshal(e.ExternalDocumentationProps)
if err != nil {
return nil, err
@@ -50,6 +53,16 @@ func (e *ExternalDocumentation) MarshalJSON() ([]byte, error) {
return swag.ConcatJSON(b1, b2), nil
}
+func (e *ExternalDocumentation) MarshalNextJSON(opts jsonv2.MarshalOptions, enc *jsonv2.Encoder) error {
+ var x struct {
+ ExternalDocumentationProps `json:",inline"`
+ spec.Extensions
+ }
+ x.Extensions = internal.SanitizeExtensions(e.Extensions)
+ x.ExternalDocumentationProps = e.ExternalDocumentationProps
+ return opts.MarshalNext(enc, x)
+}
+
func (e *ExternalDocumentation) UnmarshalJSON(data []byte) error {
if internal.UseOptimizedJSONUnmarshalingV3 {
return jsonv2.Unmarshal(data, e)
diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/fuzz.go b/vendor/k8s.io/kube-openapi/pkg/spec3/fuzz.go
index bc19dd48ed..08b6246ceb 100644
--- a/vendor/k8s.io/kube-openapi/pkg/spec3/fuzz.go
+++ b/vendor/k8s.io/kube-openapi/pkg/spec3/fuzz.go
@@ -35,6 +35,18 @@ var OpenAPIV3FuzzFuncs []interface{} = []interface{}{
func(o *OpenAPI, c fuzz.Continue) {
c.FuzzNoCustom(o)
o.Version = "3.0.0"
+ for i, val := range o.SecurityRequirement {
+ if val == nil {
+ o.SecurityRequirement[i] = make(map[string][]string)
+ }
+
+ for k, v := range val {
+ if v == nil {
+ val[k] = make([]string, 0)
+ }
+ }
+ }
+
},
func(r *interface{}, c fuzz.Continue) {
switch c.Intn(3) {
@@ -169,6 +181,21 @@ var OpenAPIV3FuzzFuncs []interface{} = []interface{}{
c.Fuzz(&v.ResponseProps)
c.Fuzz(&v.VendorExtensible)
},
+ func(v *Operation, c fuzz.Continue) {
+ c.FuzzNoCustom(v)
+ // Do not fuzz null values into the array.
+ for i, val := range v.SecurityRequirement {
+ if val == nil {
+ v.SecurityRequirement[i] = make(map[string][]string)
+ }
+
+ for k, v := range val {
+ if v == nil {
+ val[k] = make([]string, 0)
+ }
+ }
+ }
+ },
func(v *spec.Extensions, c fuzz.Continue) {
numChildren := c.Intn(5)
for i := 0; i < numChildren; i++ {
diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/header.go b/vendor/k8s.io/kube-openapi/pkg/spec3/header.go
index ee5a30f797..9ea30628ce 100644
--- a/vendor/k8s.io/kube-openapi/pkg/spec3/header.go
+++ b/vendor/k8s.io/kube-openapi/pkg/spec3/header.go
@@ -36,6 +36,9 @@ type Header struct {
// MarshalJSON is a custom marshal function that knows how to encode Header as JSON
func (h *Header) MarshalJSON() ([]byte, error) {
+ if internal.UseOptimizedJSONMarshalingV3 {
+ return internal.DeterministicMarshal(h)
+ }
b1, err := json.Marshal(h.Refable)
if err != nil {
return nil, err
@@ -51,6 +54,18 @@ func (h *Header) MarshalJSON() ([]byte, error) {
return swag.ConcatJSON(b1, b2, b3), nil
}
+func (h *Header) MarshalNextJSON(opts jsonv2.MarshalOptions, enc *jsonv2.Encoder) error {
+ var x struct {
+ Ref string `json:"$ref,omitempty"`
+ HeaderProps headerPropsOmitZero `json:",inline"`
+ spec.Extensions
+ }
+ x.Ref = h.Refable.Ref.String()
+ x.Extensions = internal.SanitizeExtensions(h.Extensions)
+ x.HeaderProps = headerPropsOmitZero(h.HeaderProps)
+ return opts.MarshalNext(enc, x)
+}
+
func (h *Header) UnmarshalJSON(data []byte) error {
if internal.UseOptimizedJSONUnmarshalingV3 {
return jsonv2.Unmarshal(data, h)
@@ -109,3 +124,19 @@ type HeaderProps struct {
// Examples of the header
Examples map[string]*Example `json:"examples,omitempty"`
}
+
+// Marshaling structure only, always edit along with corresponding
+// struct (or compilation will fail).
+type headerPropsOmitZero struct {
+ Description string `json:"description,omitempty"`
+ Required bool `json:"required,omitzero"`
+ Deprecated bool `json:"deprecated,omitzero"`
+ AllowEmptyValue bool `json:"allowEmptyValue,omitzero"`
+ Style string `json:"style,omitempty"`
+ Explode bool `json:"explode,omitzero"`
+ AllowReserved bool `json:"allowReserved,omitzero"`
+ Schema *spec.Schema `json:"schema,omitzero"`
+ Content map[string]*MediaType `json:"content,omitempty"`
+ Example interface{} `json:"example,omitempty"`
+ Examples map[string]*Example `json:"examples,omitempty"`
+}
diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/media_type.go b/vendor/k8s.io/kube-openapi/pkg/spec3/media_type.go
index d390e69bcf..47eef1edb0 100644
--- a/vendor/k8s.io/kube-openapi/pkg/spec3/media_type.go
+++ b/vendor/k8s.io/kube-openapi/pkg/spec3/media_type.go
@@ -35,6 +35,9 @@ type MediaType struct {
// MarshalJSON is a custom marshal function that knows how to encode MediaType as JSON
func (m *MediaType) MarshalJSON() ([]byte, error) {
+ if internal.UseOptimizedJSONMarshalingV3 {
+ return internal.DeterministicMarshal(m)
+ }
b1, err := json.Marshal(m.MediaTypeProps)
if err != nil {
return nil, err
@@ -46,6 +49,16 @@ func (m *MediaType) MarshalJSON() ([]byte, error) {
return swag.ConcatJSON(b1, b2), nil
}
+func (e *MediaType) MarshalNextJSON(opts jsonv2.MarshalOptions, enc *jsonv2.Encoder) error {
+ var x struct {
+ MediaTypeProps mediaTypePropsOmitZero `json:",inline"`
+ spec.Extensions
+ }
+ x.Extensions = internal.SanitizeExtensions(e.Extensions)
+ x.MediaTypeProps = mediaTypePropsOmitZero(e.MediaTypeProps)
+ return opts.MarshalNext(enc, x)
+}
+
func (m *MediaType) UnmarshalJSON(data []byte) error {
if internal.UseOptimizedJSONUnmarshalingV3 {
return jsonv2.Unmarshal(data, m)
@@ -84,3 +97,10 @@ type MediaTypeProps struct {
// A map between a property name and its encoding information. The key, being the property name, MUST exist in the schema as a property. The encoding object SHALL only apply to requestBody objects when the media type is multipart or application/x-www-form-urlencoded
Encoding map[string]*Encoding `json:"encoding,omitempty"`
}
+
+type mediaTypePropsOmitZero struct {
+ Schema *spec.Schema `json:"schema,omitzero"`
+ Example interface{} `json:"example,omitempty"`
+ Examples map[string]*Example `json:"examples,omitempty"`
+ Encoding map[string]*Encoding `json:"encoding,omitempty"`
+}
diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/operation.go b/vendor/k8s.io/kube-openapi/pkg/spec3/operation.go
index 28230610bd..f1e1025479 100644
--- a/vendor/k8s.io/kube-openapi/pkg/spec3/operation.go
+++ b/vendor/k8s.io/kube-openapi/pkg/spec3/operation.go
@@ -35,6 +35,9 @@ type Operation struct {
// MarshalJSON is a custom marshal function that knows how to encode Operation as JSON
func (o *Operation) MarshalJSON() ([]byte, error) {
+ if internal.UseOptimizedJSONMarshalingV3 {
+ return internal.DeterministicMarshal(o)
+ }
b1, err := json.Marshal(o.OperationProps)
if err != nil {
return nil, err
@@ -46,6 +49,16 @@ func (o *Operation) MarshalJSON() ([]byte, error) {
return swag.ConcatJSON(b1, b2), nil
}
+func (o *Operation) MarshalNextJSON(opts jsonv2.MarshalOptions, enc *jsonv2.Encoder) error {
+ var x struct {
+ spec.Extensions
+ OperationProps operationPropsOmitZero `json:",inline"`
+ }
+ x.Extensions = internal.SanitizeExtensions(o.Extensions)
+ x.OperationProps = operationPropsOmitZero(o.OperationProps)
+ return opts.MarshalNext(enc, x)
+}
+
// UnmarshalJSON hydrates this items instance with the data from JSON
func (o *Operation) UnmarshalJSON(data []byte) error {
if internal.UseOptimizedJSONUnmarshalingV3 {
@@ -95,3 +108,17 @@ type OperationProps struct {
// Servers contains an alternative server array to service this operation
Servers []*Server `json:"servers,omitempty"`
}
+
+type operationPropsOmitZero struct {
+ Tags []string `json:"tags,omitempty"`
+ Summary string `json:"summary,omitempty"`
+ Description string `json:"description,omitempty"`
+ ExternalDocs *ExternalDocumentation `json:"externalDocs,omitzero"`
+ OperationId string `json:"operationId,omitempty"`
+ Parameters []*Parameter `json:"parameters,omitempty"`
+ RequestBody *RequestBody `json:"requestBody,omitzero"`
+ Responses *Responses `json:"responses,omitzero"`
+ Deprecated bool `json:"deprecated,omitzero"`
+ SecurityRequirement []map[string][]string `json:"security,omitempty"`
+ Servers []*Server `json:"servers,omitempty"`
+}
diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/parameter.go b/vendor/k8s.io/kube-openapi/pkg/spec3/parameter.go
index 613da71a6d..ada7edb637 100644
--- a/vendor/k8s.io/kube-openapi/pkg/spec3/parameter.go
+++ b/vendor/k8s.io/kube-openapi/pkg/spec3/parameter.go
@@ -36,6 +36,9 @@ type Parameter struct {
// MarshalJSON is a custom marshal function that knows how to encode Parameter as JSON
func (p *Parameter) MarshalJSON() ([]byte, error) {
+ if internal.UseOptimizedJSONMarshalingV3 {
+ return internal.DeterministicMarshal(p)
+ }
b1, err := json.Marshal(p.Refable)
if err != nil {
return nil, err
@@ -51,6 +54,18 @@ func (p *Parameter) MarshalJSON() ([]byte, error) {
return swag.ConcatJSON(b1, b2, b3), nil
}
+func (p *Parameter) MarshalNextJSON(opts jsonv2.MarshalOptions, enc *jsonv2.Encoder) error {
+ var x struct {
+ Ref string `json:"$ref,omitempty"`
+ ParameterProps parameterPropsOmitZero `json:",inline"`
+ spec.Extensions
+ }
+ x.Ref = p.Refable.Ref.String()
+ x.Extensions = internal.SanitizeExtensions(p.Extensions)
+ x.ParameterProps = parameterPropsOmitZero(p.ParameterProps)
+ return opts.MarshalNext(enc, x)
+}
+
func (p *Parameter) UnmarshalJSON(data []byte) error {
if internal.UseOptimizedJSONUnmarshalingV3 {
return jsonv2.Unmarshal(data, p)
@@ -114,3 +129,19 @@ type ParameterProps struct {
// Examples of the parameter's potential value. Each example SHOULD contain a value in the correct format as specified in the parameter encoding
Examples map[string]*Example `json:"examples,omitempty"`
}
+
+type parameterPropsOmitZero struct {
+ Name string `json:"name,omitempty"`
+ In string `json:"in,omitempty"`
+ Description string `json:"description,omitempty"`
+ Required bool `json:"required,omitzero"`
+ Deprecated bool `json:"deprecated,omitzero"`
+ AllowEmptyValue bool `json:"allowEmptyValue,omitzero"`
+ Style string `json:"style,omitempty"`
+ Explode bool `json:"explode,omitzero"`
+ AllowReserved bool `json:"allowReserved,omitzero"`
+ Schema *spec.Schema `json:"schema,omitzero"`
+ Content map[string]*MediaType `json:"content,omitempty"`
+ Example interface{} `json:"example,omitempty"`
+ Examples map[string]*Example `json:"examples,omitempty"`
+}
diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/path.go b/vendor/k8s.io/kube-openapi/pkg/spec3/path.go
index 40d9061ace..16fbbb4dd9 100644
--- a/vendor/k8s.io/kube-openapi/pkg/spec3/path.go
+++ b/vendor/k8s.io/kube-openapi/pkg/spec3/path.go
@@ -35,15 +35,41 @@ type Paths struct {
// MarshalJSON is a custom marshal function that knows how to encode Paths as JSON
func (p *Paths) MarshalJSON() ([]byte, error) {
- b1, err := json.Marshal(p.Paths)
+ if internal.UseOptimizedJSONMarshalingV3 {
+ return internal.DeterministicMarshal(p)
+ }
+ b1, err := json.Marshal(p.VendorExtensible)
if err != nil {
return nil, err
}
- b2, err := json.Marshal(p.VendorExtensible)
+
+ pths := make(map[string]*Path)
+ for k, v := range p.Paths {
+ if strings.HasPrefix(k, "/") {
+ pths[k] = v
+ }
+ }
+ b2, err := json.Marshal(pths)
if err != nil {
return nil, err
}
- return swag.ConcatJSON(b1, b2), nil
+ concated := swag.ConcatJSON(b1, b2)
+ return concated, nil
+}
+
+func (p *Paths) MarshalNextJSON(opts jsonv2.MarshalOptions, enc *jsonv2.Encoder) error {
+ m := make(map[string]any, len(p.Extensions)+len(p.Paths))
+ for k, v := range p.Extensions {
+ if internal.IsExtensionKey(k) {
+ m[k] = v
+ }
+ }
+ for k, v := range p.Paths {
+ if strings.HasPrefix(k, "/") {
+ m[k] = v
+ }
+ }
+ return opts.MarshalNext(enc, m)
}
// UnmarshalJSON hydrates this items instance with the data from JSON
@@ -144,6 +170,9 @@ type Path struct {
// MarshalJSON is a custom marshal function that knows how to encode Path as JSON
func (p *Path) MarshalJSON() ([]byte, error) {
+ if internal.UseOptimizedJSONMarshalingV3 {
+ return internal.DeterministicMarshal(p)
+ }
b1, err := json.Marshal(p.Refable)
if err != nil {
return nil, err
@@ -159,6 +188,18 @@ func (p *Path) MarshalJSON() ([]byte, error) {
return swag.ConcatJSON(b1, b2, b3), nil
}
+func (p *Path) MarshalNextJSON(opts jsonv2.MarshalOptions, enc *jsonv2.Encoder) error {
+ var x struct {
+ Ref string `json:"$ref,omitempty"`
+ spec.Extensions
+ PathProps
+ }
+ x.Ref = p.Refable.Ref.String()
+ x.Extensions = internal.SanitizeExtensions(p.Extensions)
+ x.PathProps = p.PathProps
+ return opts.MarshalNext(enc, x)
+}
+
func (p *Path) UnmarshalJSON(data []byte) error {
if internal.UseOptimizedJSONUnmarshalingV3 {
return jsonv2.Unmarshal(data, p)
diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/request_body.go b/vendor/k8s.io/kube-openapi/pkg/spec3/request_body.go
index 33267ce675..6f8607e400 100644
--- a/vendor/k8s.io/kube-openapi/pkg/spec3/request_body.go
+++ b/vendor/k8s.io/kube-openapi/pkg/spec3/request_body.go
@@ -36,6 +36,9 @@ type RequestBody struct {
// MarshalJSON is a custom marshal function that knows how to encode RequestBody as JSON
func (r *RequestBody) MarshalJSON() ([]byte, error) {
+ if internal.UseOptimizedJSONMarshalingV3 {
+ return internal.DeterministicMarshal(r)
+ }
b1, err := json.Marshal(r.Refable)
if err != nil {
return nil, err
@@ -51,6 +54,18 @@ func (r *RequestBody) MarshalJSON() ([]byte, error) {
return swag.ConcatJSON(b1, b2, b3), nil
}
+func (r *RequestBody) MarshalNextJSON(opts jsonv2.MarshalOptions, enc *jsonv2.Encoder) error {
+ var x struct {
+ Ref string `json:"$ref,omitempty"`
+ RequestBodyProps requestBodyPropsOmitZero `json:",inline"`
+ spec.Extensions
+ }
+ x.Ref = r.Refable.Ref.String()
+ x.Extensions = internal.SanitizeExtensions(r.Extensions)
+ x.RequestBodyProps = requestBodyPropsOmitZero(r.RequestBodyProps)
+ return opts.MarshalNext(enc, x)
+}
+
func (r *RequestBody) UnmarshalJSON(data []byte) error {
if internal.UseOptimizedJSONUnmarshalingV3 {
return jsonv2.Unmarshal(data, r)
@@ -77,6 +92,12 @@ type RequestBodyProps struct {
Required bool `json:"required,omitempty"`
}
+type requestBodyPropsOmitZero struct {
+ Description string `json:"description,omitempty"`
+ Content map[string]*MediaType `json:"content,omitempty"`
+ Required bool `json:"required,omitzero"`
+}
+
func (r *RequestBody) UnmarshalNextJSON(opts jsonv2.UnmarshalOptions, dec *jsonv2.Decoder) error {
var x struct {
spec.Extensions
diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/response.go b/vendor/k8s.io/kube-openapi/pkg/spec3/response.go
index 95b388e6c6..73e241fdc9 100644
--- a/vendor/k8s.io/kube-openapi/pkg/spec3/response.go
+++ b/vendor/k8s.io/kube-openapi/pkg/spec3/response.go
@@ -37,6 +37,9 @@ type Responses struct {
// MarshalJSON is a custom marshal function that knows how to encode Responses as JSON
func (r *Responses) MarshalJSON() ([]byte, error) {
+ if internal.UseOptimizedJSONMarshalingV3 {
+ return internal.DeterministicMarshal(r)
+ }
b1, err := json.Marshal(r.ResponsesProps)
if err != nil {
return nil, err
@@ -48,6 +51,25 @@ func (r *Responses) MarshalJSON() ([]byte, error) {
return swag.ConcatJSON(b1, b2), nil
}
+func (r Responses) MarshalNextJSON(opts jsonv2.MarshalOptions, enc *jsonv2.Encoder) error {
+ type ArbitraryKeys map[string]interface{}
+ var x struct {
+ ArbitraryKeys
+ Default *Response `json:"default,omitzero"`
+ }
+ x.ArbitraryKeys = make(map[string]any, len(r.Extensions)+len(r.StatusCodeResponses))
+ for k, v := range r.Extensions {
+ if internal.IsExtensionKey(k) {
+ x.ArbitraryKeys[k] = v
+ }
+ }
+ for k, v := range r.StatusCodeResponses {
+ x.ArbitraryKeys[strconv.Itoa(k)] = v
+ }
+ x.Default = r.Default
+ return opts.MarshalNext(enc, x)
+}
+
func (r *Responses) UnmarshalJSON(data []byte) error {
if internal.UseOptimizedJSONUnmarshalingV3 {
return jsonv2.Unmarshal(data, r)
@@ -179,6 +201,9 @@ type Response struct {
// MarshalJSON is a custom marshal function that knows how to encode Response as JSON
func (r *Response) MarshalJSON() ([]byte, error) {
+ if internal.UseOptimizedJSONMarshalingV3 {
+ return internal.DeterministicMarshal(r)
+ }
b1, err := json.Marshal(r.Refable)
if err != nil {
return nil, err
@@ -194,6 +219,18 @@ func (r *Response) MarshalJSON() ([]byte, error) {
return swag.ConcatJSON(b1, b2, b3), nil
}
+func (r Response) MarshalNextJSON(opts jsonv2.MarshalOptions, enc *jsonv2.Encoder) error {
+ var x struct {
+ Ref string `json:"$ref,omitempty"`
+ spec.Extensions
+ ResponseProps `json:",inline"`
+ }
+ x.Ref = r.Refable.Ref.String()
+ x.Extensions = internal.SanitizeExtensions(r.Extensions)
+ x.ResponseProps = r.ResponseProps
+ return opts.MarshalNext(enc, x)
+}
+
func (r *Response) UnmarshalJSON(data []byte) error {
if internal.UseOptimizedJSONUnmarshalingV3 {
return jsonv2.Unmarshal(data, r)
@@ -247,6 +284,9 @@ type Link struct {
// MarshalJSON is a custom marshal function that knows how to encode Link as JSON
func (r *Link) MarshalJSON() ([]byte, error) {
+ if internal.UseOptimizedJSONMarshalingV3 {
+ return internal.DeterministicMarshal(r)
+ }
b1, err := json.Marshal(r.Refable)
if err != nil {
return nil, err
@@ -262,6 +302,18 @@ func (r *Link) MarshalJSON() ([]byte, error) {
return swag.ConcatJSON(b1, b2, b3), nil
}
+func (r *Link) MarshalNextJSON(opts jsonv2.MarshalOptions, enc *jsonv2.Encoder) error {
+ var x struct {
+ Ref string `json:"$ref,omitempty"`
+ spec.Extensions
+ LinkProps `json:",inline"`
+ }
+ x.Ref = r.Refable.Ref.String()
+ x.Extensions = internal.SanitizeExtensions(r.Extensions)
+ x.LinkProps = r.LinkProps
+ return opts.MarshalNext(enc, x)
+}
+
func (r *Link) UnmarshalJSON(data []byte) error {
if internal.UseOptimizedJSONUnmarshalingV3 {
return jsonv2.Unmarshal(data, r)
diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/security_scheme.go b/vendor/k8s.io/kube-openapi/pkg/spec3/security_scheme.go
index edf7e6de3f..dd1e98ed88 100644
--- a/vendor/k8s.io/kube-openapi/pkg/spec3/security_scheme.go
+++ b/vendor/k8s.io/kube-openapi/pkg/spec3/security_scheme.go
@@ -20,6 +20,8 @@ import (
"encoding/json"
"github.com/go-openapi/swag"
+ "k8s.io/kube-openapi/pkg/internal"
+ jsonv2 "k8s.io/kube-openapi/pkg/internal/third_party/go-json-experiment/json"
"k8s.io/kube-openapi/pkg/validation/spec"
)
@@ -32,6 +34,9 @@ type SecurityScheme struct {
// MarshalJSON is a custom marshal function that knows how to encode SecurityScheme as JSON
func (s *SecurityScheme) MarshalJSON() ([]byte, error) {
+ if internal.UseOptimizedJSONMarshalingV3 {
+ return internal.DeterministicMarshal(s)
+ }
b1, err := json.Marshal(s.SecuritySchemeProps)
if err != nil {
return nil, err
@@ -47,6 +52,18 @@ func (s *SecurityScheme) MarshalJSON() ([]byte, error) {
return swag.ConcatJSON(b1, b2, b3), nil
}
+func (s *SecurityScheme) MarshalNextJSON(opts jsonv2.MarshalOptions, enc *jsonv2.Encoder) error {
+ var x struct {
+ Ref string `json:"$ref,omitempty"`
+ SecuritySchemeProps `json:",inline"`
+ spec.Extensions
+ }
+ x.Ref = s.Refable.Ref.String()
+ x.Extensions = internal.SanitizeExtensions(s.Extensions)
+ x.SecuritySchemeProps = s.SecuritySchemeProps
+ return opts.MarshalNext(enc, x)
+}
+
// UnmarshalJSON hydrates this items instance with the data from JSON
func (s *SecurityScheme) UnmarshalJSON(data []byte) error {
if err := json.Unmarshal(data, &s.SecuritySchemeProps); err != nil {
diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/server.go b/vendor/k8s.io/kube-openapi/pkg/spec3/server.go
index d5df0a7811..654a42c06e 100644
--- a/vendor/k8s.io/kube-openapi/pkg/spec3/server.go
+++ b/vendor/k8s.io/kube-openapi/pkg/spec3/server.go
@@ -41,6 +41,9 @@ type ServerProps struct {
// MarshalJSON is a custom marshal function that knows how to encode Responses as JSON
func (s *Server) MarshalJSON() ([]byte, error) {
+ if internal.UseOptimizedJSONMarshalingV3 {
+ return internal.DeterministicMarshal(s)
+ }
b1, err := json.Marshal(s.ServerProps)
if err != nil {
return nil, err
@@ -52,6 +55,16 @@ func (s *Server) MarshalJSON() ([]byte, error) {
return swag.ConcatJSON(b1, b2), nil
}
+func (s *Server) MarshalNextJSON(opts jsonv2.MarshalOptions, enc *jsonv2.Encoder) error {
+ var x struct {
+ ServerProps `json:",inline"`
+ spec.Extensions
+ }
+ x.Extensions = internal.SanitizeExtensions(s.Extensions)
+ x.ServerProps = s.ServerProps
+ return opts.MarshalNext(enc, x)
+}
+
func (s *Server) UnmarshalJSON(data []byte) error {
if internal.UseOptimizedJSONUnmarshalingV3 {
return jsonv2.Unmarshal(data, s)
@@ -96,6 +109,9 @@ type ServerVariableProps struct {
// MarshalJSON is a custom marshal function that knows how to encode Responses as JSON
func (s *ServerVariable) MarshalJSON() ([]byte, error) {
+ if internal.UseOptimizedJSONMarshalingV3 {
+ return internal.DeterministicMarshal(s)
+ }
b1, err := json.Marshal(s.ServerVariableProps)
if err != nil {
return nil, err
@@ -107,6 +123,16 @@ func (s *ServerVariable) MarshalJSON() ([]byte, error) {
return swag.ConcatJSON(b1, b2), nil
}
+func (s *ServerVariable) MarshalNextJSON(opts jsonv2.MarshalOptions, enc *jsonv2.Encoder) error {
+ var x struct {
+ ServerVariableProps `json:",inline"`
+ spec.Extensions
+ }
+ x.Extensions = internal.SanitizeExtensions(s.Extensions)
+ x.ServerVariableProps = s.ServerVariableProps
+ return opts.MarshalNext(enc, x)
+}
+
func (s *ServerVariable) UnmarshalJSON(data []byte) error {
if internal.UseOptimizedJSONUnmarshalingV3 {
return jsonv2.Unmarshal(data, s)
diff --git a/vendor/k8s.io/kube-openapi/pkg/spec3/spec.go b/vendor/k8s.io/kube-openapi/pkg/spec3/spec.go
index bed096fb76..5db819c7f0 100644
--- a/vendor/k8s.io/kube-openapi/pkg/spec3/spec.go
+++ b/vendor/k8s.io/kube-openapi/pkg/spec3/spec.go
@@ -36,6 +36,8 @@ type OpenAPI struct {
Servers []*Server `json:"servers,omitempty"`
// Components hold various schemas for the specification
Components *Components `json:"components,omitempty"`
+ // SecurityRequirement holds a declaration of which security mechanisms can be used across the API
+ SecurityRequirement []map[string][]string `json:"security,omitempty"`
// ExternalDocs holds additional external documentation
ExternalDocs *ExternalDocumentation `json:"externalDocs,omitempty"`
}
@@ -48,3 +50,26 @@ func (o *OpenAPI) UnmarshalJSON(data []byte) error {
}
return json.Unmarshal(data, &p)
}
+
+func (o *OpenAPI) MarshalJSON() ([]byte, error) {
+ if internal.UseOptimizedJSONMarshalingV3 {
+ return internal.DeterministicMarshal(o)
+ }
+ type OpenAPIWithNoFunctions OpenAPI
+ p := (*OpenAPIWithNoFunctions)(o)
+ return json.Marshal(&p)
+}
+
+func (o *OpenAPI) MarshalNextJSON(opts jsonv2.MarshalOptions, enc *jsonv2.Encoder) error {
+ type OpenAPIOmitZero struct {
+ Version string `json:"openapi"`
+ Info *spec.Info `json:"info"`
+ Paths *Paths `json:"paths,omitzero"`
+ Servers []*Server `json:"servers,omitempty"`
+ Components *Components `json:"components,omitzero"`
+ SecurityRequirement []map[string][]string `json:"security,omitempty"`
+ ExternalDocs *ExternalDocumentation `json:"externalDocs,omitzero"`
+ }
+ x := (*OpenAPIOmitZero)(o)
+ return opts.MarshalNext(enc, x)
+}
diff --git a/vendor/k8s.io/kube-openapi/pkg/validation/spec/fuzz.go b/vendor/k8s.io/kube-openapi/pkg/validation/spec/fuzz.go
deleted file mode 100644
index c66f998f51..0000000000
--- a/vendor/k8s.io/kube-openapi/pkg/validation/spec/fuzz.go
+++ /dev/null
@@ -1,502 +0,0 @@
-/*
-Copyright 2022 The Kubernetes 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 spec
-
-import (
- "github.com/go-openapi/jsonreference"
- "github.com/google/go-cmp/cmp"
- fuzz "github.com/google/gofuzz"
-)
-
-var SwaggerFuzzFuncs []interface{} = []interface{}{
- func(v *Responses, c fuzz.Continue) {
- c.FuzzNoCustom(v)
- if v.Default != nil {
- // Check if we hit maxDepth and left an incomplete value
- if v.Default.Description == "" {
- v.Default = nil
- v.StatusCodeResponses = nil
- }
- }
-
- // conversion has no way to discern empty statusCodeResponses from
- // nil, since "default" is always included in the map.
- // So avoid empty responses list
- if len(v.StatusCodeResponses) == 0 {
- v.StatusCodeResponses = nil
- }
- },
- func(v *Operation, c fuzz.Continue) {
- c.FuzzNoCustom(v)
-
- if v != nil {
- // force non-nil
- v.Responses = &Responses{}
- c.Fuzz(v.Responses)
-
- v.Schemes = nil
- if c.RandBool() {
- v.Schemes = append(v.Schemes, "http")
- }
-
- if c.RandBool() {
- v.Schemes = append(v.Schemes, "https")
- }
-
- if c.RandBool() {
- v.Schemes = append(v.Schemes, "ws")
- }
-
- if c.RandBool() {
- v.Schemes = append(v.Schemes, "wss")
- }
-
- // Gnostic unconditionally makes security values non-null
- // So do not fuzz null values into the array.
- for i, val := range v.Security {
- if val == nil {
- v.Security[i] = make(map[string][]string)
- }
-
- for k, v := range val {
- if v == nil {
- val[k] = make([]string, 0)
- }
- }
- }
- }
- },
- func(v map[int]Response, c fuzz.Continue) {
- n := 0
- c.Fuzz(&n)
- if n == 0 {
- // Test that fuzzer is not at maxDepth so we do not
- // end up with empty elements
- return
- }
-
- // Prevent negative numbers
- num := c.Intn(4)
- for i := 0; i < num+2; i++ {
- val := Response{}
- c.Fuzz(&val)
-
- val.Description = c.RandString() + "x"
- v[100*(i+1)+c.Intn(100)] = val
- }
- },
- func(v map[string]PathItem, c fuzz.Continue) {
- n := 0
- c.Fuzz(&n)
- if n == 0 {
- // Test that fuzzer is not at maxDepth so we do not
- // end up with empty elements
- return
- }
-
- num := c.Intn(5)
- for i := 0; i < num+2; i++ {
- val := PathItem{}
- c.Fuzz(&val)
-
- // Ref params are only allowed in certain locations, so
- // possibly add a few to PathItems
- numRefsToAdd := c.Intn(5)
- for i := 0; i < numRefsToAdd; i++ {
- theRef := Parameter{}
- c.Fuzz(&theRef.Refable)
-
- val.Parameters = append(val.Parameters, theRef)
- }
-
- v["/"+c.RandString()] = val
- }
- },
- func(v *SchemaOrArray, c fuzz.Continue) {
- *v = SchemaOrArray{}
- // gnostic parser just doesn't support more
- // than one Schema here
- v.Schema = &Schema{}
- c.Fuzz(&v.Schema)
-
- },
- func(v *SchemaOrBool, c fuzz.Continue) {
- *v = SchemaOrBool{}
-
- if c.RandBool() {
- v.Allows = c.RandBool()
- } else {
- v.Schema = &Schema{}
- v.Allows = true
- c.Fuzz(&v.Schema)
- }
- },
- func(v map[string]Response, c fuzz.Continue) {
- n := 0
- c.Fuzz(&n)
- if n == 0 {
- // Test that fuzzer is not at maxDepth so we do not
- // end up with empty elements
- return
- }
-
- // Response definitions are not allowed to
- // be refs
- for i := 0; i < c.Intn(5)+1; i++ {
- resp := &Response{}
-
- c.Fuzz(resp)
- resp.Ref = Ref{}
- resp.Description = c.RandString() + "x"
-
- // Response refs are not vendor extensible by gnostic
- resp.VendorExtensible.Extensions = nil
- v[c.RandString()+"x"] = *resp
- }
- },
- func(v *Header, c fuzz.Continue) {
- if v != nil {
- c.FuzzNoCustom(v)
-
- // descendant Items of Header may not be refs
- cur := v.Items
- for cur != nil {
- cur.Ref = Ref{}
- cur = cur.Items
- }
- }
- },
- func(v *Ref, c fuzz.Continue) {
- *v = Ref{}
- v.Ref, _ = jsonreference.New("http://asd.com/" + c.RandString())
- },
- func(v *Response, c fuzz.Continue) {
- *v = Response{}
- if c.RandBool() {
- v.Ref = Ref{}
- v.Ref.Ref, _ = jsonreference.New("http://asd.com/" + c.RandString())
- } else {
- c.Fuzz(&v.VendorExtensible)
- c.Fuzz(&v.Schema)
- c.Fuzz(&v.ResponseProps)
-
- v.Headers = nil
- v.Ref = Ref{}
-
- n := 0
- c.Fuzz(&n)
- if n != 0 {
- // Test that fuzzer is not at maxDepth so we do not
- // end up with empty elements
- num := c.Intn(4)
- for i := 0; i < num; i++ {
- if v.Headers == nil {
- v.Headers = make(map[string]Header)
- }
- hdr := Header{}
- c.Fuzz(&hdr)
- if hdr.Type == "" {
- // hit maxDepth, just abort trying to make haders
- v.Headers = nil
- break
- }
- v.Headers[c.RandString()+"x"] = hdr
- }
- } else {
- v.Headers = nil
- }
- }
-
- v.Description = c.RandString() + "x"
-
- // Gnostic parses empty as nil, so to keep avoid putting empty
- if len(v.Headers) == 0 {
- v.Headers = nil
- }
- },
- func(v **Info, c fuzz.Continue) {
- // Info is never nil
- *v = &Info{}
- c.FuzzNoCustom(*v)
-
- (*v).Title = c.RandString() + "x"
- },
- func(v *Extensions, c fuzz.Continue) {
- // gnostic parser only picks up x- vendor extensions
- numChildren := c.Intn(5)
- for i := 0; i < numChildren; i++ {
- if *v == nil {
- *v = Extensions{}
- }
- (*v)["x-"+c.RandString()] = c.RandString()
- }
- },
- func(v *Swagger, c fuzz.Continue) {
- c.FuzzNoCustom(v)
-
- if v.Paths == nil {
- // Force paths non-nil since it does not have omitempty in json tag.
- // This means a perfect roundtrip (via json) is impossible,
- // since we can't tell the difference between empty/unspecified paths
- v.Paths = &Paths{}
- c.Fuzz(v.Paths)
- }
-
- v.Swagger = "2.0"
-
- // Gnostic support serializing ID at all
- // unavoidable data loss
- v.ID = ""
-
- v.Schemes = nil
- if c.RandUint64()%2 == 1 {
- v.Schemes = append(v.Schemes, "http")
- }
-
- if c.RandUint64()%2 == 1 {
- v.Schemes = append(v.Schemes, "https")
- }
-
- if c.RandUint64()%2 == 1 {
- v.Schemes = append(v.Schemes, "ws")
- }
-
- if c.RandUint64()%2 == 1 {
- v.Schemes = append(v.Schemes, "wss")
- }
-
- // Gnostic unconditionally makes security values non-null
- // So do not fuzz null values into the array.
- for i, val := range v.Security {
- if val == nil {
- v.Security[i] = make(map[string][]string)
- }
-
- for k, v := range val {
- if v == nil {
- val[k] = make([]string, 0)
- }
- }
- }
- },
- func(v *SecurityScheme, c fuzz.Continue) {
- v.Description = c.RandString() + "x"
- c.Fuzz(&v.VendorExtensible)
-
- switch c.Intn(3) {
- case 0:
- v.Type = "basic"
- case 1:
- v.Type = "apiKey"
- switch c.Intn(2) {
- case 0:
- v.In = "header"
- case 1:
- v.In = "query"
- default:
- panic("unreachable")
- }
- v.Name = "x" + c.RandString()
- case 2:
- v.Type = "oauth2"
-
- switch c.Intn(4) {
- case 0:
- v.Flow = "accessCode"
- v.TokenURL = "https://" + c.RandString()
- v.AuthorizationURL = "https://" + c.RandString()
- case 1:
- v.Flow = "application"
- v.TokenURL = "https://" + c.RandString()
- case 2:
- v.Flow = "implicit"
- v.AuthorizationURL = "https://" + c.RandString()
- case 3:
- v.Flow = "password"
- v.TokenURL = "https://" + c.RandString()
- default:
- panic("unreachable")
- }
- c.Fuzz(&v.Scopes)
- default:
- panic("unreachable")
- }
- },
- func(v *interface{}, c fuzz.Continue) {
- *v = c.RandString() + "x"
- },
- func(v *string, c fuzz.Continue) {
- *v = c.RandString() + "x"
- },
- func(v *ExternalDocumentation, c fuzz.Continue) {
- v.Description = c.RandString() + "x"
- v.URL = c.RandString() + "x"
- },
- func(v *SimpleSchema, c fuzz.Continue) {
- c.FuzzNoCustom(v)
-
- switch c.Intn(5) {
- case 0:
- v.Type = "string"
- case 1:
- v.Type = "number"
- case 2:
- v.Type = "boolean"
- case 3:
- v.Type = "integer"
- case 4:
- v.Type = "array"
- default:
- panic("unreachable")
- }
-
- switch c.Intn(5) {
- case 0:
- v.CollectionFormat = "csv"
- case 1:
- v.CollectionFormat = "ssv"
- case 2:
- v.CollectionFormat = "tsv"
- case 3:
- v.CollectionFormat = "pipes"
- case 4:
- v.CollectionFormat = ""
- default:
- panic("unreachable")
- }
-
- // None of the types which include SimpleSchema in our definitions
- // actually support "example" in the official spec
- v.Example = nil
-
- // unsupported by openapi
- v.Nullable = false
- },
- func(v *int64, c fuzz.Continue) {
- c.Fuzz(v)
-
- // Gnostic does not differentiate between 0 and non-specified
- // so avoid using 0 for fuzzer
- if *v == 0 {
- *v = 1
- }
- },
- func(v *float64, c fuzz.Continue) {
- c.Fuzz(v)
-
- // Gnostic does not differentiate between 0 and non-specified
- // so avoid using 0 for fuzzer
- if *v == 0.0 {
- *v = 1.0
- }
- },
- func(v *Parameter, c fuzz.Continue) {
- if v == nil {
- return
- }
- c.Fuzz(&v.VendorExtensible)
- if c.RandBool() {
- // body param
- v.Description = c.RandString() + "x"
- v.Name = c.RandString() + "x"
- v.In = "body"
- c.Fuzz(&v.Description)
- c.Fuzz(&v.Required)
-
- v.Schema = &Schema{}
- c.Fuzz(&v.Schema)
-
- } else {
- c.Fuzz(&v.SimpleSchema)
- c.Fuzz(&v.CommonValidations)
- v.AllowEmptyValue = false
- v.Description = c.RandString() + "x"
- v.Name = c.RandString() + "x"
-
- switch c.Intn(4) {
- case 0:
- // Header param
- v.In = "header"
- case 1:
- // Form data param
- v.In = "formData"
- v.AllowEmptyValue = c.RandBool()
- case 2:
- // Query param
- v.In = "query"
- v.AllowEmptyValue = c.RandBool()
- case 3:
- // Path param
- v.In = "path"
- v.Required = true
- default:
- panic("unreachable")
- }
-
- // descendant Items of Parameter may not be refs
- cur := v.Items
- for cur != nil {
- cur.Ref = Ref{}
- cur = cur.Items
- }
- }
- },
- func(v *Schema, c fuzz.Continue) {
- if c.RandBool() {
- // file schema
- c.Fuzz(&v.Default)
- c.Fuzz(&v.Description)
- c.Fuzz(&v.Example)
- c.Fuzz(&v.ExternalDocs)
-
- c.Fuzz(&v.Format)
- c.Fuzz(&v.ReadOnly)
- c.Fuzz(&v.Required)
- c.Fuzz(&v.Title)
- v.Type = StringOrArray{"file"}
-
- } else {
- // normal schema
- c.Fuzz(&v.SchemaProps)
- c.Fuzz(&v.SwaggerSchemaProps)
- c.Fuzz(&v.VendorExtensible)
- // c.Fuzz(&v.ExtraProps)
- // ExtraProps will not roundtrip - gnostic throws out
- // unrecognized keys
- }
-
- // Not supported by official openapi v2 spec
- // and stripped by k8s apiserver
- v.ID = ""
- v.AnyOf = nil
- v.OneOf = nil
- v.Not = nil
- v.Nullable = false
- v.AdditionalItems = nil
- v.Schema = ""
- v.PatternProperties = nil
- v.Definitions = nil
- v.Dependencies = nil
- },
-}
-
-var SwaggerDiffOptions = []cmp.Option{
- // cmp.Diff panics on Ref since jsonreference.Ref uses unexported fields
- cmp.Comparer(func(a Ref, b Ref) bool {
- return a.String() == b.String()
- }),
-}
diff --git a/vendor/k8s.io/utils/integer/integer.go b/vendor/k8s.io/utils/integer/integer.go
index e0811e8344..f64d64955b 100644
--- a/vendor/k8s.io/utils/integer/integer.go
+++ b/vendor/k8s.io/utils/integer/integer.go
@@ -18,7 +18,8 @@ package integer
import "math"
-// IntMax returns the maximum of the params
+// IntMax returns the maximum of the params.
+// Deprecated: for new code, use the max() builtin instead.
func IntMax(a, b int) int {
if b > a {
return b
@@ -26,7 +27,8 @@ func IntMax(a, b int) int {
return a
}
-// IntMin returns the minimum of the params
+// IntMin returns the minimum of the params.
+// Deprecated: for new code, use the min() builtin instead.
func IntMin(a, b int) int {
if b < a {
return b
@@ -34,7 +36,8 @@ func IntMin(a, b int) int {
return a
}
-// Int32Max returns the maximum of the params
+// Int32Max returns the maximum of the params.
+// Deprecated: for new code, use the max() builtin instead.
func Int32Max(a, b int32) int32 {
if b > a {
return b
@@ -42,7 +45,8 @@ func Int32Max(a, b int32) int32 {
return a
}
-// Int32Min returns the minimum of the params
+// Int32Min returns the minimum of the params.
+// Deprecated: for new code, use the min() builtin instead.
func Int32Min(a, b int32) int32 {
if b < a {
return b
@@ -50,7 +54,8 @@ func Int32Min(a, b int32) int32 {
return a
}
-// Int64Max returns the maximum of the params
+// Int64Max returns the maximum of the params.
+// Deprecated: for new code, use the max() builtin instead.
func Int64Max(a, b int64) int64 {
if b > a {
return b
@@ -58,7 +63,8 @@ func Int64Max(a, b int64) int64 {
return a
}
-// Int64Min returns the minimum of the params
+// Int64Min returns the minimum of the params.
+// Deprecated: for new code, use the min() builtin instead.
func Int64Min(a, b int64) int64 {
if b < a {
return b
diff --git a/vendor/k8s.io/utils/lru/lru.go b/vendor/k8s.io/utils/lru/lru.go
index 47f1352813..40c22ece13 100644
--- a/vendor/k8s.io/utils/lru/lru.go
+++ b/vendor/k8s.io/utils/lru/lru.go
@@ -16,6 +16,7 @@ limitations under the License.
package lru
import (
+ "fmt"
"sync"
groupcache "k8s.io/utils/internal/third_party/forked/golang/golang-lru"
@@ -44,6 +45,17 @@ func NewWithEvictionFunc(size int, f EvictionFunc) *Cache {
return c
}
+// SetEvictionFunc updates the eviction func
+func (c *Cache) SetEvictionFunc(f EvictionFunc) error {
+ c.lock.Lock()
+ defer c.lock.Unlock()
+ if c.cache.OnEvicted != nil {
+ return fmt.Errorf("lru cache eviction function is already set")
+ }
+ c.cache.OnEvicted = f
+ return nil
+}
+
// Add adds a value to the cache.
func (c *Cache) Add(key Key, value interface{}) {
c.lock.Lock()
diff --git a/vendor/k8s.io/utils/net/multi_listen.go b/vendor/k8s.io/utils/net/multi_listen.go
new file mode 100644
index 0000000000..7cb7795bec
--- /dev/null
+++ b/vendor/k8s.io/utils/net/multi_listen.go
@@ -0,0 +1,195 @@
+/*
+Copyright 2024 The Kubernetes 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 net
+
+import (
+ "context"
+ "fmt"
+ "net"
+ "sync"
+)
+
+// connErrPair pairs conn and error which is returned by accept on sub-listeners.
+type connErrPair struct {
+ conn net.Conn
+ err error
+}
+
+// multiListener implements net.Listener
+type multiListener struct {
+ listeners []net.Listener
+ wg sync.WaitGroup
+
+ // connCh passes accepted connections, from child listeners to parent.
+ connCh chan connErrPair
+ // stopCh communicates from parent to child listeners.
+ stopCh chan struct{}
+}
+
+// compile time check to ensure *multiListener implements net.Listener
+var _ net.Listener = &multiListener{}
+
+// MultiListen returns net.Listener which can listen on and accept connections for
+// the given network on multiple addresses. Internally it uses stdlib to create
+// sub-listener and multiplexes connection requests using go-routines.
+// The network must be "tcp", "tcp4" or "tcp6".
+// It follows the semantics of net.Listen that primarily means:
+// 1. If the host is an unspecified/zero IP address with "tcp" network, MultiListen
+// listens on all available unicast and anycast IP addresses of the local system.
+// 2. Use "tcp4" or "tcp6" to exclusively listen on IPv4 or IPv6 family, respectively.
+// 3. The host can accept names (e.g, localhost) and it will create a listener for at
+// most one of the host's IP.
+func MultiListen(ctx context.Context, network string, addrs ...string) (net.Listener, error) {
+ var lc net.ListenConfig
+ return multiListen(
+ ctx,
+ network,
+ addrs,
+ func(ctx context.Context, network, address string) (net.Listener, error) {
+ return lc.Listen(ctx, network, address)
+ })
+}
+
+// multiListen implements MultiListen by consuming stdlib functions as dependency allowing
+// mocking for unit-testing.
+func multiListen(
+ ctx context.Context,
+ network string,
+ addrs []string,
+ listenFunc func(ctx context.Context, network, address string) (net.Listener, error),
+) (net.Listener, error) {
+ if !(network == "tcp" || network == "tcp4" || network == "tcp6") {
+ return nil, fmt.Errorf("network %q not supported", network)
+ }
+ if len(addrs) == 0 {
+ return nil, fmt.Errorf("no address provided to listen on")
+ }
+
+ ml := &multiListener{
+ connCh: make(chan connErrPair),
+ stopCh: make(chan struct{}),
+ }
+ for _, addr := range addrs {
+ l, err := listenFunc(ctx, network, addr)
+ if err != nil {
+ // close all the sub-listeners and exit
+ _ = ml.Close()
+ return nil, err
+ }
+ ml.listeners = append(ml.listeners, l)
+ }
+
+ for _, l := range ml.listeners {
+ ml.wg.Add(1)
+ go func(l net.Listener) {
+ defer ml.wg.Done()
+ for {
+ // Accept() is blocking, unless ml.Close() is called, in which
+ // case it will return immediately with an error.
+ conn, err := l.Accept()
+ // This assumes that ANY error from Accept() will terminate the
+ // sub-listener. We could maybe be more precise, but it
+ // doesn't seem necessary.
+ terminate := err != nil
+
+ select {
+ case ml.connCh <- connErrPair{conn: conn, err: err}:
+ case <-ml.stopCh:
+ // In case we accepted a connection AND were stopped, and
+ // this select-case was chosen, just throw away the
+ // connection. This avoids potentially blocking on connCh
+ // or leaking a connection.
+ if conn != nil {
+ _ = conn.Close()
+ }
+ terminate = true
+ }
+ // Make sure we don't loop on Accept() returning an error and
+ // the select choosing the channel case.
+ if terminate {
+ return
+ }
+ }
+ }(l)
+ }
+ return ml, nil
+}
+
+// Accept implements net.Listener. It waits for and returns a connection from
+// any of the sub-listener.
+func (ml *multiListener) Accept() (net.Conn, error) {
+ // wait for any sub-listener to enqueue an accepted connection
+ connErr, ok := <-ml.connCh
+ if !ok {
+ // The channel will be closed only when Close() is called on the
+ // multiListener. Closing of this channel implies that all
+ // sub-listeners are also closed, which causes a "use of closed
+ // network connection" error on their Accept() calls. We return the
+ // same error for multiListener.Accept() if multiListener.Close()
+ // has already been called.
+ return nil, fmt.Errorf("use of closed network connection")
+ }
+ return connErr.conn, connErr.err
+}
+
+// Close implements net.Listener. It will close all sub-listeners and wait for
+// the go-routines to exit.
+func (ml *multiListener) Close() error {
+ // Make sure this can be called repeatedly without explosions.
+ select {
+ case <-ml.stopCh:
+ return fmt.Errorf("use of closed network connection")
+ default:
+ }
+
+ // Tell all sub-listeners to stop.
+ close(ml.stopCh)
+
+ // Closing the listeners causes Accept() to immediately return an error in
+ // the sub-listener go-routines.
+ for _, l := range ml.listeners {
+ _ = l.Close()
+ }
+
+ // Wait for all the sub-listener go-routines to exit.
+ ml.wg.Wait()
+ close(ml.connCh)
+
+ // Drain any already-queued connections.
+ for connErr := range ml.connCh {
+ if connErr.conn != nil {
+ _ = connErr.conn.Close()
+ }
+ }
+ return nil
+}
+
+// Addr is an implementation of the net.Listener interface. It always returns
+// the address of the first listener. Callers should use conn.LocalAddr() to
+// obtain the actual local address of the sub-listener.
+func (ml *multiListener) Addr() net.Addr {
+ return ml.listeners[0].Addr()
+}
+
+// Addrs is like Addr, but returns the address for all registered listeners.
+func (ml *multiListener) Addrs() []net.Addr {
+ var ret []net.Addr
+ for _, l := range ml.listeners {
+ ret = append(ret, l.Addr())
+ }
+ return ret
+}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index b9b2382e0a..c6b43dc1ff 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -6,7 +6,7 @@ github.com/Microsoft/go-winio/pkg/guid
# github.com/NYTimes/gziphandler v1.1.1
## explicit; go 1.11
github.com/NYTimes/gziphandler
-# github.com/RoaringBitmap/roaring v1.2.3
+# github.com/RoaringBitmap/roaring v1.9.4
## explicit; go 1.14
github.com/RoaringBitmap/roaring
github.com/RoaringBitmap/roaring/internal
@@ -22,8 +22,8 @@ github.com/avast/retry-go
# github.com/beorn7/perks v1.0.1
## explicit; go 1.11
github.com/beorn7/perks/quantile
-# github.com/bits-and-blooms/bitset v1.7.0
-## explicit; go 1.14
+# github.com/bits-and-blooms/bitset v1.12.0
+## explicit; go 1.16
github.com/bits-and-blooms/bitset
# github.com/blang/semver/v4 v4.0.0
## explicit; go 1.14
@@ -34,7 +34,7 @@ github.com/c9s/goprocinfo/linux
# github.com/cenkalti/backoff/v4 v4.2.1
## explicit; go 1.18
github.com/cenkalti/backoff/v4
-# github.com/cespare/xxhash/v2 v2.2.0
+# github.com/cespare/xxhash/v2 v2.3.0
## explicit; go 1.11
github.com/cespare/xxhash/v2
# github.com/container-storage-interface/spec v1.8.0
@@ -47,10 +47,10 @@ github.com/coreos/go-semver/semver
## explicit; go 1.12
github.com/coreos/go-systemd/v22/daemon
github.com/coreos/go-systemd/v22/journal
-# github.com/cpuguy83/go-md2man/v2 v2.0.4
+# github.com/cpuguy83/go-md2man/v2 v2.0.5
## explicit; go 1.11
github.com/cpuguy83/go-md2man/v2/md2man
-# github.com/davecgh/go-spew v1.1.1
+# github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc
## explicit
github.com/davecgh/go-spew/spew
# github.com/docker/distribution v2.8.2+incompatible
@@ -60,7 +60,7 @@ github.com/docker/distribution/reference
# github.com/docker/go-connections v0.4.0
## explicit
github.com/docker/go-connections/sockets
-# github.com/emicklei/go-restful/v3 v3.9.0
+# github.com/emicklei/go-restful/v3 v3.11.0
## explicit; go 1.13
github.com/emicklei/go-restful/v3
github.com/emicklei/go-restful/v3/log
@@ -82,7 +82,7 @@ github.com/gammazero/workerpool
# github.com/go-co-op/gocron v1.18.0
## explicit; go 1.19
github.com/go-co-op/gocron
-# github.com/go-logr/logr v1.4.1
+# github.com/go-logr/logr v1.4.2
## explicit; go 1.18
github.com/go-logr/logr
github.com/go-logr/logr/funcr
@@ -100,7 +100,7 @@ github.com/go-openapi/jsonpointer
## explicit; go 1.13
github.com/go-openapi/jsonreference
github.com/go-openapi/jsonreference/internal
-# github.com/go-openapi/swag v0.22.3
+# github.com/go-openapi/swag v0.22.4
## explicit; go 1.18
github.com/go-openapi/swag
# github.com/gogo/protobuf v1.3.2
@@ -224,15 +224,16 @@ github.com/longhorn/backing-image-manager/pkg/meta
github.com/longhorn/backing-image-manager/pkg/rpc
github.com/longhorn/backing-image-manager/pkg/types
github.com/longhorn/backing-image-manager/pkg/util
-# github.com/longhorn/backupstore v0.0.0-20240616091913-84428641a11d
-## explicit; go 1.21
+# github.com/longhorn/backupstore v0.0.0-20241112162019-b405e8f77dc3
+## explicit; go 1.22.7
github.com/longhorn/backupstore
github.com/longhorn/backupstore/logging
github.com/longhorn/backupstore/systembackup
github.com/longhorn/backupstore/types
github.com/longhorn/backupstore/util
-# github.com/longhorn/go-common-libs v0.0.0-20240616051056-103c7d62a0d5
-## explicit; go 1.22.0
+# github.com/longhorn/go-common-libs v0.0.0-20241109101504-614ae31d2212
+## explicit; go 1.22.7
+github.com/longhorn/go-common-libs/backup
github.com/longhorn/go-common-libs/exec
github.com/longhorn/go-common-libs/io
github.com/longhorn/go-common-libs/ns
@@ -242,13 +243,13 @@ github.com/longhorn/go-common-libs/sys
github.com/longhorn/go-common-libs/test/fake
github.com/longhorn/go-common-libs/types
github.com/longhorn/go-common-libs/utils
-# github.com/longhorn/go-iscsi-helper v0.0.0-20240617011911-febe418a1b19
-## explicit; go 1.22.0
+# github.com/longhorn/go-iscsi-helper v0.0.0-20241110033836-dd4b01aa15b8
+## explicit; go 1.22.7
github.com/longhorn/go-iscsi-helper/iscsi
github.com/longhorn/go-iscsi-helper/types
github.com/longhorn/go-iscsi-helper/util
-# github.com/longhorn/go-spdk-helper v0.0.0-20240616091844-5afd86a1d892
-## explicit; go 1.22.0
+# github.com/longhorn/go-spdk-helper v0.0.0-20241110033706-a878ed0191b2
+## explicit; go 1.22.7
github.com/longhorn/go-spdk-helper/pkg/types
# github.com/longhorn/longhorn-engine v1.5.5-rc2.0.20240418040645-8f85db1d1393
## explicit; go 1.21
@@ -296,7 +297,7 @@ github.com/mitchellh/go-ps
# github.com/mitchellh/reflectwalk v1.0.2
## explicit
github.com/mitchellh/reflectwalk
-# github.com/moby/sys/mountinfo v0.6.2
+# github.com/moby/sys/mountinfo v0.7.1
## explicit; go 1.16
github.com/moby/sys/mountinfo
# github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd
@@ -329,7 +330,7 @@ github.com/pierrec/lz4/v4/internal/xxh32
# github.com/pkg/errors v0.9.1
## explicit
github.com/pkg/errors
-# github.com/pmezard/go-difflib v1.0.0
+# github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2
## explicit
github.com/pmezard/go-difflib/difflib
# github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c
@@ -420,8 +421,8 @@ github.com/robfig/cron
# github.com/robfig/cron/v3 v3.0.1
## explicit; go 1.12
github.com/robfig/cron/v3
-# github.com/rogpeppe/go-internal v1.11.0
-## explicit; go 1.19
+# github.com/rogpeppe/go-internal v1.12.0
+## explicit; go 1.20
github.com/rogpeppe/go-internal/fmtsort
# github.com/russross/blackfriday/v2 v2.1.0
## explicit
@@ -453,7 +454,7 @@ github.com/stoewer/go-strcase
## explicit; go 1.17
github.com/stretchr/testify/assert
github.com/stretchr/testify/require
-# github.com/urfave/cli v1.22.15
+# github.com/urfave/cli v1.22.16
## explicit; go 1.11
github.com/urfave/cli
# github.com/yusufpapurcu/wmi v1.2.4
@@ -555,8 +556,8 @@ go.uber.org/zap/internal/color
go.uber.org/zap/internal/exit
go.uber.org/zap/zapcore
go.uber.org/zap/zapgrpc
-# golang.org/x/crypto v0.21.0
-## explicit; go 1.18
+# golang.org/x/crypto v0.29.0
+## explicit; go 1.20
golang.org/x/crypto/acme
golang.org/x/crypto/acme/autocert
golang.org/x/crypto/cryptobyte
@@ -566,14 +567,14 @@ golang.org/x/crypto/internal/alias
golang.org/x/crypto/internal/poly1305
golang.org/x/crypto/nacl/secretbox
golang.org/x/crypto/salsa20/salsa
-# golang.org/x/exp v0.0.0-20220827204233-334a2380cb91
-## explicit; go 1.18
+# golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f
+## explicit; go 1.22.0
golang.org/x/exp/constraints
golang.org/x/exp/slices
-# golang.org/x/mod v0.12.0
-## explicit; go 1.17
+# golang.org/x/mod v0.22.0
+## explicit; go 1.22.0
golang.org/x/mod/semver
-# golang.org/x/net v0.23.0
+# golang.org/x/net v0.31.0
## explicit; go 1.18
golang.org/x/net/context
golang.org/x/net/http/httpguts
@@ -585,27 +586,26 @@ golang.org/x/net/internal/timeseries
golang.org/x/net/proxy
golang.org/x/net/trace
golang.org/x/net/websocket
-# golang.org/x/oauth2 v0.18.0
+# golang.org/x/oauth2 v0.23.0
## explicit; go 1.18
golang.org/x/oauth2
golang.org/x/oauth2/internal
-# golang.org/x/sync v0.6.0
+# golang.org/x/sync v0.9.0
## explicit; go 1.18
golang.org/x/sync/errgroup
golang.org/x/sync/semaphore
golang.org/x/sync/singleflight
-# golang.org/x/sys v0.21.0
+# golang.org/x/sys v0.27.0
## explicit; go 1.18
golang.org/x/sys/cpu
-golang.org/x/sys/execabs
golang.org/x/sys/plan9
golang.org/x/sys/unix
golang.org/x/sys/windows
golang.org/x/sys/windows/registry
-# golang.org/x/term v0.18.0
+# golang.org/x/term v0.26.0
## explicit; go 1.18
golang.org/x/term
-# golang.org/x/text v0.14.0
+# golang.org/x/text v0.20.0
## explicit; go 1.18
golang.org/x/text/cases
golang.org/x/text/feature/plural
@@ -628,55 +628,50 @@ golang.org/x/text/width
# golang.org/x/time v0.3.0
## explicit
golang.org/x/time/rate
-# golang.org/x/tools v0.13.0
-## explicit; go 1.18
+# golang.org/x/tools v0.27.0
+## explicit; go 1.22.0
golang.org/x/tools/cmd/stringer
golang.org/x/tools/go/gcexportdata
-golang.org/x/tools/go/internal/packagesdriver
golang.org/x/tools/go/packages
golang.org/x/tools/go/types/objectpath
+golang.org/x/tools/go/types/typeutil
+golang.org/x/tools/internal/aliases
golang.org/x/tools/internal/event
golang.org/x/tools/internal/event/core
golang.org/x/tools/internal/event/keys
golang.org/x/tools/internal/event/label
-golang.org/x/tools/internal/event/tag
golang.org/x/tools/internal/gcimporter
golang.org/x/tools/internal/gocommand
golang.org/x/tools/internal/packagesinternal
golang.org/x/tools/internal/pkgbits
-golang.org/x/tools/internal/tokeninternal
+golang.org/x/tools/internal/stdlib
golang.org/x/tools/internal/typeparams
golang.org/x/tools/internal/typesinternal
-# google.golang.org/appengine v1.6.8
-## explicit; go 1.11
-google.golang.org/appengine/internal
-google.golang.org/appengine/internal/base
-google.golang.org/appengine/internal/datastore
-google.golang.org/appengine/internal/log
-google.golang.org/appengine/internal/remote_api
-google.golang.org/appengine/internal/urlfetch
-google.golang.org/appengine/urlfetch
+golang.org/x/tools/internal/versions
# google.golang.org/genproto v0.0.0-20240227224415-6ceb2ff114de
## explicit; go 1.19
google.golang.org/genproto/protobuf/field_mask
-# google.golang.org/genproto/googleapis/api v0.0.0-20240318140521-94a12d6c2237
-## explicit; go 1.19
+# google.golang.org/genproto/googleapis/api v0.0.0-20240903143218-8af14fe29dc1
+## explicit; go 1.21
google.golang.org/genproto/googleapis/api
google.golang.org/genproto/googleapis/api/annotations
google.golang.org/genproto/googleapis/api/expr/v1alpha1
google.golang.org/genproto/googleapis/api/httpbody
-# google.golang.org/genproto/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237
-## explicit; go 1.19
+# google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1
+## explicit; go 1.21
google.golang.org/genproto/googleapis/rpc/errdetails
google.golang.org/genproto/googleapis/rpc/status
-# google.golang.org/grpc v1.64.0
-## explicit; go 1.19
+# google.golang.org/grpc v1.68.0
+## explicit; go 1.22.7
google.golang.org/grpc
google.golang.org/grpc/attributes
google.golang.org/grpc/backoff
google.golang.org/grpc/balancer
google.golang.org/grpc/balancer/base
google.golang.org/grpc/balancer/grpclb/state
+google.golang.org/grpc/balancer/pickfirst
+google.golang.org/grpc/balancer/pickfirst/internal
+google.golang.org/grpc/balancer/pickfirst/pickfirstleaf
google.golang.org/grpc/balancer/roundrobin
google.golang.org/grpc/binarylog/grpc_binarylog_v1
google.golang.org/grpc/channelz
@@ -687,7 +682,9 @@ google.golang.org/grpc/credentials/insecure
google.golang.org/grpc/encoding
google.golang.org/grpc/encoding/gzip
google.golang.org/grpc/encoding/proto
+google.golang.org/grpc/experimental/stats
google.golang.org/grpc/grpclog
+google.golang.org/grpc/grpclog/internal
google.golang.org/grpc/health/grpc_health_v1
google.golang.org/grpc/internal
google.golang.org/grpc/internal/backoff
@@ -699,7 +696,6 @@ google.golang.org/grpc/internal/channelz
google.golang.org/grpc/internal/credentials
google.golang.org/grpc/internal/envconfig
google.golang.org/grpc/internal/grpclog
-google.golang.org/grpc/internal/grpcrand
google.golang.org/grpc/internal/grpcsync
google.golang.org/grpc/internal/grpcutil
google.golang.org/grpc/internal/idle
@@ -711,11 +707,13 @@ google.golang.org/grpc/internal/resolver/dns/internal
google.golang.org/grpc/internal/resolver/passthrough
google.golang.org/grpc/internal/resolver/unix
google.golang.org/grpc/internal/serviceconfig
+google.golang.org/grpc/internal/stats
google.golang.org/grpc/internal/status
google.golang.org/grpc/internal/syscall
google.golang.org/grpc/internal/transport
google.golang.org/grpc/internal/transport/networktype
google.golang.org/grpc/keepalive
+google.golang.org/grpc/mem
google.golang.org/grpc/metadata
google.golang.org/grpc/peer
google.golang.org/grpc/resolver
@@ -725,8 +723,8 @@ google.golang.org/grpc/serviceconfig
google.golang.org/grpc/stats
google.golang.org/grpc/status
google.golang.org/grpc/tap
-# google.golang.org/protobuf v1.34.2
-## explicit; go 1.20
+# google.golang.org/protobuf v1.35.1
+## explicit; go 1.21
google.golang.org/protobuf/encoding/protojson
google.golang.org/protobuf/encoding/prototext
google.golang.org/protobuf/encoding/protowire
@@ -783,7 +781,7 @@ gopkg.in/yaml.v2
# gopkg.in/yaml.v3 v3.0.1
## explicit
gopkg.in/yaml.v3
-# k8s.io/api v0.28.6 => k8s.io/api v0.28.2
+# k8s.io/api v0.31.2 => k8s.io/api v0.28.2
## explicit; go 1.20
k8s.io/api/admission/v1
k8s.io/api/admission/v1beta1
@@ -861,7 +859,7 @@ k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/internalint
k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1
k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1beta1
k8s.io/apiextensions-apiserver/pkg/features
-# k8s.io/apimachinery v0.28.6 => k8s.io/apimachinery v0.28.2
+# k8s.io/apimachinery v0.31.2 => k8s.io/apimachinery v0.28.2
## explicit; go 1.20
k8s.io/apimachinery/pkg/api/equality
k8s.io/apimachinery/pkg/api/errors
@@ -1069,7 +1067,7 @@ k8s.io/apiserver/plugin/pkg/authorizer/webhook
# k8s.io/cli-runtime v0.28.2 => k8s.io/cli-runtime v0.28.2
## explicit; go 1.20
k8s.io/cli-runtime/pkg/printers
-# k8s.io/client-go v0.28.6 => k8s.io/client-go v0.28.2
+# k8s.io/client-go v0.31.2 => k8s.io/client-go v0.28.2
## explicit; go 1.20
k8s.io/client-go/applyconfigurations/admissionregistration/v1
k8s.io/client-go/applyconfigurations/admissionregistration/v1alpha1
@@ -1435,7 +1433,7 @@ k8s.io/controller-manager/pkg/leadermigration/options
# k8s.io/klog v1.0.0
## explicit; go 1.12
k8s.io/klog
-# k8s.io/klog/v2 v2.120.1
+# k8s.io/klog/v2 v2.130.1
## explicit; go 1.18
k8s.io/klog/v2
k8s.io/klog/v2/internal/buffer
@@ -1454,8 +1452,8 @@ k8s.io/kms/pkg/util
## explicit; go 1.20
k8s.io/kube-aggregator/pkg/apis/apiregistration
k8s.io/kube-aggregator/pkg/apis/apiregistration/v1
-# k8s.io/kube-openapi v0.0.0-20230717233707-2695361300d9
-## explicit; go 1.19
+# k8s.io/kube-openapi v0.0.0-20240228011516-70dd3763d340
+## explicit; go 1.20
k8s.io/kube-openapi/pkg/builder
k8s.io/kube-openapi/pkg/builder3
k8s.io/kube-openapi/pkg/builder3/util
@@ -1466,7 +1464,6 @@ k8s.io/kube-openapi/pkg/handler
k8s.io/kube-openapi/pkg/handler3
k8s.io/kube-openapi/pkg/internal
k8s.io/kube-openapi/pkg/internal/third_party/go-json-experiment/json
-k8s.io/kube-openapi/pkg/openapiconv
k8s.io/kube-openapi/pkg/schemaconv
k8s.io/kube-openapi/pkg/schemamutation
k8s.io/kube-openapi/pkg/spec3
@@ -1511,10 +1508,10 @@ k8s.io/metrics/pkg/client/clientset/versioned
k8s.io/metrics/pkg/client/clientset/versioned/scheme
k8s.io/metrics/pkg/client/clientset/versioned/typed/metrics/v1alpha1
k8s.io/metrics/pkg/client/clientset/versioned/typed/metrics/v1beta1
-# k8s.io/mount-utils v0.30.2 => k8s.io/mount-utils v0.28.2
+# k8s.io/mount-utils v0.31.2 => k8s.io/mount-utils v0.28.2
## explicit; go 1.20
k8s.io/mount-utils
-# k8s.io/utils v0.0.0-20240502163921-fe8a2dddb1d0
+# k8s.io/utils v0.0.0-20241104163129-6fe5fd82f078
## explicit; go 1.18
k8s.io/utils/buffer
k8s.io/utils/clock
@@ -1545,16 +1542,17 @@ sigs.k8s.io/controller-runtime/pkg/conversion
## explicit; go 1.18
sigs.k8s.io/json
sigs.k8s.io/json/internal/golang/encoding/json
-# sigs.k8s.io/structured-merge-diff/v4 v4.2.3
+# sigs.k8s.io/structured-merge-diff/v4 v4.4.1
## explicit; go 1.13
sigs.k8s.io/structured-merge-diff/v4/fieldpath
sigs.k8s.io/structured-merge-diff/v4/merge
sigs.k8s.io/structured-merge-diff/v4/schema
sigs.k8s.io/structured-merge-diff/v4/typed
sigs.k8s.io/structured-merge-diff/v4/value
-# sigs.k8s.io/yaml v1.3.0
+# sigs.k8s.io/yaml v1.4.0
## explicit; go 1.12
sigs.k8s.io/yaml
+sigs.k8s.io/yaml/goyaml.v2
# k8s.io/api => k8s.io/api v0.28.2
# k8s.io/apiextensions-apiserver => k8s.io/apiextensions-apiserver v0.28.2
# k8s.io/apimachinery => k8s.io/apimachinery v0.28.2
diff --git a/vendor/sigs.k8s.io/structured-merge-diff/v4/fieldpath/pathelementmap.go b/vendor/sigs.k8s.io/structured-merge-diff/v4/fieldpath/pathelementmap.go
index 9b14ca581b..41fc2474a4 100644
--- a/vendor/sigs.k8s.io/structured-merge-diff/v4/fieldpath/pathelementmap.go
+++ b/vendor/sigs.k8s.io/structured-merge-diff/v4/fieldpath/pathelementmap.go
@@ -28,20 +28,15 @@ import (
// for PathElementSet and SetNodeMap, so we could probably share the
// code.
type PathElementValueMap struct {
- members sortedPathElementValues
+ valueMap PathElementMap
}
func MakePathElementValueMap(size int) PathElementValueMap {
return PathElementValueMap{
- members: make(sortedPathElementValues, 0, size),
+ valueMap: MakePathElementMap(size),
}
}
-type pathElementValue struct {
- PathElement PathElement
- Value value.Value
-}
-
type sortedPathElementValues []pathElementValue
// Implement the sort interface; this would permit bulk creation, which would
@@ -53,7 +48,40 @@ func (spev sortedPathElementValues) Less(i, j int) bool {
func (spev sortedPathElementValues) Swap(i, j int) { spev[i], spev[j] = spev[j], spev[i] }
// Insert adds the pathelement and associated value in the map.
+// If insert is called twice with the same PathElement, the value is replaced.
func (s *PathElementValueMap) Insert(pe PathElement, v value.Value) {
+ s.valueMap.Insert(pe, v)
+}
+
+// Get retrieves the value associated with the given PathElement from the map.
+// (nil, false) is returned if there is no such PathElement.
+func (s *PathElementValueMap) Get(pe PathElement) (value.Value, bool) {
+ v, ok := s.valueMap.Get(pe)
+ if !ok {
+ return nil, false
+ }
+ return v.(value.Value), true
+}
+
+// PathElementValueMap is a map from PathElement to interface{}.
+type PathElementMap struct {
+ members sortedPathElementValues
+}
+
+type pathElementValue struct {
+ PathElement PathElement
+ Value interface{}
+}
+
+func MakePathElementMap(size int) PathElementMap {
+ return PathElementMap{
+ members: make(sortedPathElementValues, 0, size),
+ }
+}
+
+// Insert adds the pathelement and associated value in the map.
+// If insert is called twice with the same PathElement, the value is replaced.
+func (s *PathElementMap) Insert(pe PathElement, v interface{}) {
loc := sort.Search(len(s.members), func(i int) bool {
return !s.members[i].PathElement.Less(pe)
})
@@ -62,6 +90,7 @@ func (s *PathElementValueMap) Insert(pe PathElement, v value.Value) {
return
}
if s.members[loc].PathElement.Equals(pe) {
+ s.members[loc].Value = v
return
}
s.members = append(s.members, pathElementValue{})
@@ -71,7 +100,7 @@ func (s *PathElementValueMap) Insert(pe PathElement, v value.Value) {
// Get retrieves the value associated with the given PathElement from the map.
// (nil, false) is returned if there is no such PathElement.
-func (s *PathElementValueMap) Get(pe PathElement) (value.Value, bool) {
+func (s *PathElementMap) Get(pe PathElement) (interface{}, bool) {
loc := sort.Search(len(s.members), func(i int) bool {
return !s.members[i].PathElement.Less(pe)
})
diff --git a/vendor/sigs.k8s.io/structured-merge-diff/v4/merge/conflict.go b/vendor/sigs.k8s.io/structured-merge-diff/v4/merge/conflict.go
index 75a492d8ea..f1aa258609 100644
--- a/vendor/sigs.k8s.io/structured-merge-diff/v4/merge/conflict.go
+++ b/vendor/sigs.k8s.io/structured-merge-diff/v4/merge/conflict.go
@@ -112,7 +112,7 @@ func ConflictsFromManagers(sets fieldpath.ManagedFields) Conflicts {
set.Set().Iterate(func(p fieldpath.Path) {
conflicts = append(conflicts, Conflict{
Manager: manager,
- Path: p,
+ Path: p.Copy(),
})
})
}
diff --git a/vendor/sigs.k8s.io/structured-merge-diff/v4/merge/update.go b/vendor/sigs.k8s.io/structured-merge-diff/v4/merge/update.go
index 1b23dcbd5e..d5a977d607 100644
--- a/vendor/sigs.k8s.io/structured-merge-diff/v4/merge/update.go
+++ b/vendor/sigs.k8s.io/structured-merge-diff/v4/merge/update.go
@@ -18,6 +18,7 @@ import (
"sigs.k8s.io/structured-merge-diff/v4/fieldpath"
"sigs.k8s.io/structured-merge-diff/v4/typed"
+ "sigs.k8s.io/structured-merge-diff/v4/value"
)
// Converter is an interface to the conversion logic. The converter
@@ -27,19 +28,39 @@ type Converter interface {
IsMissingVersionError(error) bool
}
-// Updater is the object used to compute updated FieldSets and also
-// merge the object on Apply.
-type Updater struct {
+// UpdateBuilder allows you to create a new Updater by exposing all of
+// the options and setting them once.
+type UpdaterBuilder struct {
Converter Converter
IgnoredFields map[fieldpath.APIVersion]*fieldpath.Set
- enableUnions bool
+ // Stop comparing the new object with old object after applying.
+ // This was initially used to avoid spurious etcd update, but
+ // since that's vastly inefficient, we've come-up with a better
+ // way of doing that. Create this flag to stop it.
+ // Comparing has become more expensive too now that we're not using
+ // `Compare` but `value.Equals` so this gives an option to avoid it.
+ ReturnInputOnNoop bool
}
-// EnableUnionFeature turns on union handling. It is disabled by default until the
-// feature is complete.
-func (s *Updater) EnableUnionFeature() {
- s.enableUnions = true
+func (u *UpdaterBuilder) BuildUpdater() *Updater {
+ return &Updater{
+ Converter: u.Converter,
+ IgnoredFields: u.IgnoredFields,
+ returnInputOnNoop: u.ReturnInputOnNoop,
+ }
+}
+
+// Updater is the object used to compute updated FieldSets and also
+// merge the object on Apply.
+type Updater struct {
+ // Deprecated: This will eventually become private.
+ Converter Converter
+
+ // Deprecated: This will eventually become private.
+ IgnoredFields map[fieldpath.APIVersion]*fieldpath.Set
+
+ returnInputOnNoop bool
}
func (s *Updater) update(oldObject, newObject *typed.TypedValue, version fieldpath.APIVersion, managers fieldpath.ManagedFields, workflow string, force bool) (fieldpath.ManagedFields, *typed.Comparison, error) {
@@ -126,12 +147,6 @@ func (s *Updater) Update(liveObject, newObject *typed.TypedValue, version fieldp
if err != nil {
return nil, fieldpath.ManagedFields{}, err
}
- if s.enableUnions {
- newObject, err = liveObject.NormalizeUnions(newObject)
- if err != nil {
- return nil, fieldpath.ManagedFields{}, err
- }
- }
managers, compare, err := s.update(liveObject, newObject, version, managers, manager, true)
if err != nil {
return nil, fieldpath.ManagedFields{}, err
@@ -145,7 +160,7 @@ func (s *Updater) Update(liveObject, newObject *typed.TypedValue, version fieldp
ignored = fieldpath.NewSet()
}
managers[manager] = fieldpath.NewVersionedSet(
- managers[manager].Set().Union(compare.Modified).Union(compare.Added).Difference(compare.Removed).RecursiveDifference(ignored),
+ managers[manager].Set().Difference(compare.Removed).Union(compare.Modified).Union(compare.Added).RecursiveDifference(ignored),
version,
false,
)
@@ -157,30 +172,17 @@ func (s *Updater) Update(liveObject, newObject *typed.TypedValue, version fieldp
// Apply should be called when Apply is run, given the current object as
// well as the configuration that is applied. This will merge the object
-// and return it. If the object hasn't changed, nil is returned (the
-// managers can still have changed though).
+// and return it.
func (s *Updater) Apply(liveObject, configObject *typed.TypedValue, version fieldpath.APIVersion, managers fieldpath.ManagedFields, manager string, force bool) (*typed.TypedValue, fieldpath.ManagedFields, error) {
var err error
managers, err = s.reconcileManagedFieldsWithSchemaChanges(liveObject, managers)
if err != nil {
return nil, fieldpath.ManagedFields{}, err
}
- if s.enableUnions {
- configObject, err = configObject.NormalizeUnionsApply(configObject)
- if err != nil {
- return nil, fieldpath.ManagedFields{}, err
- }
- }
newObject, err := liveObject.Merge(configObject)
if err != nil {
return nil, fieldpath.ManagedFields{}, fmt.Errorf("failed to merge config: %v", err)
}
- if s.enableUnions {
- newObject, err = configObject.NormalizeUnionsApply(newObject)
- if err != nil {
- return nil, fieldpath.ManagedFields{}, err
- }
- }
lastSet := managers[manager]
set, err := configObject.ToFieldSet()
if err != nil {
@@ -200,11 +202,11 @@ func (s *Updater) Apply(liveObject, configObject *typed.TypedValue, version fiel
if err != nil {
return nil, fieldpath.ManagedFields{}, fmt.Errorf("failed to prune fields: %v", err)
}
- managers, compare, err := s.update(liveObject, newObject, version, managers, manager, force)
+ managers, _, err = s.update(liveObject, newObject, version, managers, manager, force)
if err != nil {
return nil, fieldpath.ManagedFields{}, err
}
- if compare.IsSame() {
+ if !s.returnInputOnNoop && value.EqualsUsing(value.NewFreelistAllocator(), liveObject.AsValue(), newObject.AsValue()) {
newObject = nil
}
return newObject, managers, nil
@@ -218,7 +220,8 @@ func (s *Updater) prune(merged *typed.TypedValue, managers fieldpath.ManagedFiel
if lastSet == nil || lastSet.Set().Empty() {
return merged, nil
}
- convertedMerged, err := s.Converter.Convert(merged, lastSet.APIVersion())
+ version := lastSet.APIVersion()
+ convertedMerged, err := s.Converter.Convert(merged, version)
if err != nil {
if s.Converter.IsMissingVersionError(err) {
return merged, nil
@@ -228,7 +231,7 @@ func (s *Updater) prune(merged *typed.TypedValue, managers fieldpath.ManagedFiel
sc, tr := convertedMerged.Schema(), convertedMerged.TypeRef()
pruned := convertedMerged.RemoveItems(lastSet.Set().EnsureNamedFieldsAreMembers(sc, tr))
- pruned, err = s.addBackOwnedItems(convertedMerged, pruned, managers, applyingManager)
+ pruned, err = s.addBackOwnedItems(convertedMerged, pruned, version, managers, applyingManager)
if err != nil {
return nil, fmt.Errorf("failed add back owned items: %v", err)
}
@@ -241,7 +244,7 @@ func (s *Updater) prune(merged *typed.TypedValue, managers fieldpath.ManagedFiel
// addBackOwnedItems adds back any fields, list and map items that were removed by prune,
// but other appliers or updaters (or the current applier's new config) claim to own.
-func (s *Updater) addBackOwnedItems(merged, pruned *typed.TypedValue, managedFields fieldpath.ManagedFields, applyingManager string) (*typed.TypedValue, error) {
+func (s *Updater) addBackOwnedItems(merged, pruned *typed.TypedValue, prunedVersion fieldpath.APIVersion, managedFields fieldpath.ManagedFields, applyingManager string) (*typed.TypedValue, error) {
var err error
managedAtVersion := map[fieldpath.APIVersion]*fieldpath.Set{}
for _, managerSet := range managedFields {
@@ -252,7 +255,6 @@ func (s *Updater) addBackOwnedItems(merged, pruned *typed.TypedValue, managedFie
}
// Add back owned items at pruned version first to avoid conversion failure
// caused by pruned fields which are required for conversion.
- prunedVersion := fieldpath.APIVersion(*pruned.TypeRef().NamedType)
if managed, ok := managedAtVersion[prunedVersion]; ok {
merged, pruned, err = s.addBackOwnedItemsForVersion(merged, pruned, prunedVersion, managed)
if err != nil {
diff --git a/vendor/sigs.k8s.io/structured-merge-diff/v4/schema/elements.go b/vendor/sigs.k8s.io/structured-merge-diff/v4/schema/elements.go
index 7e5dc75827..5d3707a5b5 100644
--- a/vendor/sigs.k8s.io/structured-merge-diff/v4/schema/elements.go
+++ b/vendor/sigs.k8s.io/structured-merge-diff/v4/schema/elements.go
@@ -73,7 +73,7 @@ type Atom struct {
}
// Scalar (AKA "primitive") represents a type which has a single value which is
-// either numeric, string, or boolean.
+// either numeric, string, or boolean, or untyped for any of them.
//
// TODO: split numeric into float/int? Something even more fine-grained?
type Scalar string
@@ -82,6 +82,7 @@ const (
Numeric = Scalar("numeric")
String = Scalar("string")
Boolean = Scalar("boolean")
+ Untyped = Scalar("untyped")
)
// ElementRelationship is an enum of the different possible relationships
diff --git a/vendor/sigs.k8s.io/structured-merge-diff/v4/schema/schemaschema.go b/vendor/sigs.k8s.io/structured-merge-diff/v4/schema/schemaschema.go
index 7d64d1308c..6eb6c36df3 100644
--- a/vendor/sigs.k8s.io/structured-merge-diff/v4/schema/schemaschema.go
+++ b/vendor/sigs.k8s.io/structured-merge-diff/v4/schema/schemaschema.go
@@ -110,7 +110,7 @@ var SchemaSchemaYAML = `types:
scalar: string
- name: deduceInvalidDiscriminator
type:
- scalar: bool
+ scalar: boolean
- name: fields
type:
list:
@@ -145,6 +145,7 @@ var SchemaSchemaYAML = `types:
list:
elementType:
scalar: string
+ elementRelationship: atomic
- name: untyped
map:
fields:
diff --git a/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/compare.go b/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/compare.go
new file mode 100644
index 0000000000..ed483cbbc4
--- /dev/null
+++ b/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/compare.go
@@ -0,0 +1,460 @@
+/*
+Copyright 2018 The Kubernetes 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 typed
+
+import (
+ "fmt"
+ "strings"
+
+ "sigs.k8s.io/structured-merge-diff/v4/fieldpath"
+ "sigs.k8s.io/structured-merge-diff/v4/schema"
+ "sigs.k8s.io/structured-merge-diff/v4/value"
+)
+
+// Comparison is the return value of a TypedValue.Compare() operation.
+//
+// No field will appear in more than one of the three fieldsets. If all of the
+// fieldsets are empty, then the objects must have been equal.
+type Comparison struct {
+ // Removed contains any fields removed by rhs (the right-hand-side
+ // object in the comparison).
+ Removed *fieldpath.Set
+ // Modified contains fields present in both objects but different.
+ Modified *fieldpath.Set
+ // Added contains any fields added by rhs.
+ Added *fieldpath.Set
+}
+
+// IsSame returns true if the comparison returned no changes (the two
+// compared objects are similar).
+func (c *Comparison) IsSame() bool {
+ return c.Removed.Empty() && c.Modified.Empty() && c.Added.Empty()
+}
+
+// String returns a human readable version of the comparison.
+func (c *Comparison) String() string {
+ bld := strings.Builder{}
+ if !c.Modified.Empty() {
+ bld.WriteString(fmt.Sprintf("- Modified Fields:\n%v\n", c.Modified))
+ }
+ if !c.Added.Empty() {
+ bld.WriteString(fmt.Sprintf("- Added Fields:\n%v\n", c.Added))
+ }
+ if !c.Removed.Empty() {
+ bld.WriteString(fmt.Sprintf("- Removed Fields:\n%v\n", c.Removed))
+ }
+ return bld.String()
+}
+
+// ExcludeFields fields from the compare recursively removes the fields
+// from the entire comparison
+func (c *Comparison) ExcludeFields(fields *fieldpath.Set) *Comparison {
+ if fields == nil || fields.Empty() {
+ return c
+ }
+ c.Removed = c.Removed.RecursiveDifference(fields)
+ c.Modified = c.Modified.RecursiveDifference(fields)
+ c.Added = c.Added.RecursiveDifference(fields)
+ return c
+}
+
+type compareWalker struct {
+ lhs value.Value
+ rhs value.Value
+ schema *schema.Schema
+ typeRef schema.TypeRef
+
+ // Current path that we are comparing
+ path fieldpath.Path
+
+ // Resulting comparison.
+ comparison *Comparison
+
+ // internal housekeeping--don't set when constructing.
+ inLeaf bool // Set to true if we're in a "big leaf"--atomic map/list
+
+ // Allocate only as many walkers as needed for the depth by storing them here.
+ spareWalkers *[]*compareWalker
+
+ allocator value.Allocator
+}
+
+// compare compares stuff.
+func (w *compareWalker) compare(prefixFn func() string) (errs ValidationErrors) {
+ if w.lhs == nil && w.rhs == nil {
+ // check this condidition here instead of everywhere below.
+ return errorf("at least one of lhs and rhs must be provided")
+ }
+ a, ok := w.schema.Resolve(w.typeRef)
+ if !ok {
+ return errorf("schema error: no type found matching: %v", *w.typeRef.NamedType)
+ }
+
+ alhs := deduceAtom(a, w.lhs)
+ arhs := deduceAtom(a, w.rhs)
+
+ // deduceAtom does not fix the type for nil values
+ // nil is a wildcard and will accept whatever form the other operand takes
+ if w.rhs == nil {
+ errs = append(errs, handleAtom(alhs, w.typeRef, w)...)
+ } else if w.lhs == nil || alhs.Equals(&arhs) {
+ errs = append(errs, handleAtom(arhs, w.typeRef, w)...)
+ } else {
+ w2 := *w
+ errs = append(errs, handleAtom(alhs, w.typeRef, &w2)...)
+ errs = append(errs, handleAtom(arhs, w.typeRef, w)...)
+ }
+
+ if !w.inLeaf {
+ if w.lhs == nil {
+ w.comparison.Added.Insert(w.path)
+ } else if w.rhs == nil {
+ w.comparison.Removed.Insert(w.path)
+ }
+ }
+ return errs.WithLazyPrefix(prefixFn)
+}
+
+// doLeaf should be called on leaves before descending into children, if there
+// will be a descent. It modifies w.inLeaf.
+func (w *compareWalker) doLeaf() {
+ if w.inLeaf {
+ // We're in a "big leaf", an atomic map or list. Ignore
+ // subsequent leaves.
+ return
+ }
+ w.inLeaf = true
+
+ // We don't recurse into leaf fields for merging.
+ if w.lhs == nil {
+ w.comparison.Added.Insert(w.path)
+ } else if w.rhs == nil {
+ w.comparison.Removed.Insert(w.path)
+ } else if !value.EqualsUsing(w.allocator, w.rhs, w.lhs) {
+ // TODO: Equality is not sufficient for this.
+ // Need to implement equality check on the value type.
+ w.comparison.Modified.Insert(w.path)
+ }
+}
+
+func (w *compareWalker) doScalar(t *schema.Scalar) ValidationErrors {
+ // Make sure at least one side is a valid scalar.
+ lerrs := validateScalar(t, w.lhs, "lhs: ")
+ rerrs := validateScalar(t, w.rhs, "rhs: ")
+ if len(lerrs) > 0 && len(rerrs) > 0 {
+ return append(lerrs, rerrs...)
+ }
+
+ // All scalars are leaf fields.
+ w.doLeaf()
+
+ return nil
+}
+
+func (w *compareWalker) prepareDescent(pe fieldpath.PathElement, tr schema.TypeRef, cmp *Comparison) *compareWalker {
+ if w.spareWalkers == nil {
+ // first descent.
+ w.spareWalkers = &[]*compareWalker{}
+ }
+ var w2 *compareWalker
+ if n := len(*w.spareWalkers); n > 0 {
+ w2, *w.spareWalkers = (*w.spareWalkers)[n-1], (*w.spareWalkers)[:n-1]
+ } else {
+ w2 = &compareWalker{}
+ }
+ *w2 = *w
+ w2.typeRef = tr
+ w2.path = append(w2.path, pe)
+ w2.lhs = nil
+ w2.rhs = nil
+ w2.comparison = cmp
+ return w2
+}
+
+func (w *compareWalker) finishDescent(w2 *compareWalker) {
+ // if the descent caused a realloc, ensure that we reuse the buffer
+ // for the next sibling.
+ w.path = w2.path[:len(w2.path)-1]
+ *w.spareWalkers = append(*w.spareWalkers, w2)
+}
+
+func (w *compareWalker) derefMap(prefix string, v value.Value) (value.Map, ValidationErrors) {
+ if v == nil {
+ return nil, nil
+ }
+ m, err := mapValue(w.allocator, v)
+ if err != nil {
+ return nil, errorf("%v: %v", prefix, err)
+ }
+ return m, nil
+}
+
+func (w *compareWalker) visitListItems(t *schema.List, lhs, rhs value.List) (errs ValidationErrors) {
+ rLen := 0
+ if rhs != nil {
+ rLen = rhs.Length()
+ }
+ lLen := 0
+ if lhs != nil {
+ lLen = lhs.Length()
+ }
+
+ maxLength := rLen
+ if lLen > maxLength {
+ maxLength = lLen
+ }
+ // Contains all the unique PEs between lhs and rhs, exactly once.
+ // Order doesn't matter since we're just tracking ownership in a set.
+ allPEs := make([]fieldpath.PathElement, 0, maxLength)
+
+ // Gather all the elements from lhs, indexed by PE, in a list for duplicates.
+ lValues := fieldpath.MakePathElementMap(lLen)
+ for i := 0; i < lLen; i++ {
+ child := lhs.At(i)
+ pe, err := listItemToPathElement(w.allocator, w.schema, t, child)
+ if err != nil {
+ errs = append(errs, errorf("element %v: %v", i, err.Error())...)
+ // If we can't construct the path element, we can't
+ // even report errors deeper in the schema, so bail on
+ // this element.
+ continue
+ }
+
+ if v, found := lValues.Get(pe); found {
+ list := v.([]value.Value)
+ lValues.Insert(pe, append(list, child))
+ } else {
+ lValues.Insert(pe, []value.Value{child})
+ allPEs = append(allPEs, pe)
+ }
+ }
+
+ // Gather all the elements from rhs, indexed by PE, in a list for duplicates.
+ rValues := fieldpath.MakePathElementMap(rLen)
+ for i := 0; i < rLen; i++ {
+ rValue := rhs.At(i)
+ pe, err := listItemToPathElement(w.allocator, w.schema, t, rValue)
+ if err != nil {
+ errs = append(errs, errorf("element %v: %v", i, err.Error())...)
+ // If we can't construct the path element, we can't
+ // even report errors deeper in the schema, so bail on
+ // this element.
+ continue
+ }
+ if v, found := rValues.Get(pe); found {
+ list := v.([]value.Value)
+ rValues.Insert(pe, append(list, rValue))
+ } else {
+ rValues.Insert(pe, []value.Value{rValue})
+ if _, found := lValues.Get(pe); !found {
+ allPEs = append(allPEs, pe)
+ }
+ }
+ }
+
+ for _, pe := range allPEs {
+ lList := []value.Value(nil)
+ if l, ok := lValues.Get(pe); ok {
+ lList = l.([]value.Value)
+ }
+ rList := []value.Value(nil)
+ if l, ok := rValues.Get(pe); ok {
+ rList = l.([]value.Value)
+ }
+
+ switch {
+ case len(lList) == 0 && len(rList) == 0:
+ // We shouldn't be here anyway.
+ return
+ // Normal use-case:
+ // We have no duplicates for this PE, compare items one-to-one.
+ case len(lList) <= 1 && len(rList) <= 1:
+ lValue := value.Value(nil)
+ if len(lList) != 0 {
+ lValue = lList[0]
+ }
+ rValue := value.Value(nil)
+ if len(rList) != 0 {
+ rValue = rList[0]
+ }
+ errs = append(errs, w.compareListItem(t, pe, lValue, rValue)...)
+ // Duplicates before & after use-case:
+ // Compare the duplicates lists as if they were atomic, mark modified if they changed.
+ case len(lList) >= 2 && len(rList) >= 2:
+ listEqual := func(lList, rList []value.Value) bool {
+ if len(lList) != len(rList) {
+ return false
+ }
+ for i := range lList {
+ if !value.Equals(lList[i], rList[i]) {
+ return false
+ }
+ }
+ return true
+ }
+ if !listEqual(lList, rList) {
+ w.comparison.Modified.Insert(append(w.path, pe))
+ }
+ // Duplicates before & not anymore use-case:
+ // Rcursively add new non-duplicate items, Remove duplicate marker,
+ case len(lList) >= 2:
+ if len(rList) != 0 {
+ errs = append(errs, w.compareListItem(t, pe, nil, rList[0])...)
+ }
+ w.comparison.Removed.Insert(append(w.path, pe))
+ // New duplicates use-case:
+ // Recursively remove old non-duplicate items, add duplicate marker.
+ case len(rList) >= 2:
+ if len(lList) != 0 {
+ errs = append(errs, w.compareListItem(t, pe, lList[0], nil)...)
+ }
+ w.comparison.Added.Insert(append(w.path, pe))
+ }
+ }
+
+ return
+}
+
+func (w *compareWalker) indexListPathElements(t *schema.List, list value.List) ([]fieldpath.PathElement, fieldpath.PathElementValueMap, ValidationErrors) {
+ var errs ValidationErrors
+ length := 0
+ if list != nil {
+ length = list.Length()
+ }
+ observed := fieldpath.MakePathElementValueMap(length)
+ pes := make([]fieldpath.PathElement, 0, length)
+ for i := 0; i < length; i++ {
+ child := list.At(i)
+ pe, err := listItemToPathElement(w.allocator, w.schema, t, child)
+ if err != nil {
+ errs = append(errs, errorf("element %v: %v", i, err.Error())...)
+ // If we can't construct the path element, we can't
+ // even report errors deeper in the schema, so bail on
+ // this element.
+ continue
+ }
+ // Ignore repeated occurences of `pe`.
+ if _, found := observed.Get(pe); found {
+ continue
+ }
+ observed.Insert(pe, child)
+ pes = append(pes, pe)
+ }
+ return pes, observed, errs
+}
+
+func (w *compareWalker) compareListItem(t *schema.List, pe fieldpath.PathElement, lChild, rChild value.Value) ValidationErrors {
+ w2 := w.prepareDescent(pe, t.ElementType, w.comparison)
+ w2.lhs = lChild
+ w2.rhs = rChild
+ errs := w2.compare(pe.String)
+ w.finishDescent(w2)
+ return errs
+}
+
+func (w *compareWalker) derefList(prefix string, v value.Value) (value.List, ValidationErrors) {
+ if v == nil {
+ return nil, nil
+ }
+ l, err := listValue(w.allocator, v)
+ if err != nil {
+ return nil, errorf("%v: %v", prefix, err)
+ }
+ return l, nil
+}
+
+func (w *compareWalker) doList(t *schema.List) (errs ValidationErrors) {
+ lhs, _ := w.derefList("lhs: ", w.lhs)
+ if lhs != nil {
+ defer w.allocator.Free(lhs)
+ }
+ rhs, _ := w.derefList("rhs: ", w.rhs)
+ if rhs != nil {
+ defer w.allocator.Free(rhs)
+ }
+
+ // If both lhs and rhs are empty/null, treat it as a
+ // leaf: this helps preserve the empty/null
+ // distinction.
+ emptyPromoteToLeaf := (lhs == nil || lhs.Length() == 0) && (rhs == nil || rhs.Length() == 0)
+
+ if t.ElementRelationship == schema.Atomic || emptyPromoteToLeaf {
+ w.doLeaf()
+ return nil
+ }
+
+ if lhs == nil && rhs == nil {
+ return nil
+ }
+
+ errs = w.visitListItems(t, lhs, rhs)
+
+ return errs
+}
+
+func (w *compareWalker) visitMapItem(t *schema.Map, out map[string]interface{}, key string, lhs, rhs value.Value) (errs ValidationErrors) {
+ fieldType := t.ElementType
+ if sf, ok := t.FindField(key); ok {
+ fieldType = sf.Type
+ }
+ pe := fieldpath.PathElement{FieldName: &key}
+ w2 := w.prepareDescent(pe, fieldType, w.comparison)
+ w2.lhs = lhs
+ w2.rhs = rhs
+ errs = append(errs, w2.compare(pe.String)...)
+ w.finishDescent(w2)
+ return errs
+}
+
+func (w *compareWalker) visitMapItems(t *schema.Map, lhs, rhs value.Map) (errs ValidationErrors) {
+ out := map[string]interface{}{}
+
+ value.MapZipUsing(w.allocator, lhs, rhs, value.Unordered, func(key string, lhsValue, rhsValue value.Value) bool {
+ errs = append(errs, w.visitMapItem(t, out, key, lhsValue, rhsValue)...)
+ return true
+ })
+
+ return errs
+}
+
+func (w *compareWalker) doMap(t *schema.Map) (errs ValidationErrors) {
+ lhs, _ := w.derefMap("lhs: ", w.lhs)
+ if lhs != nil {
+ defer w.allocator.Free(lhs)
+ }
+ rhs, _ := w.derefMap("rhs: ", w.rhs)
+ if rhs != nil {
+ defer w.allocator.Free(rhs)
+ }
+ // If both lhs and rhs are empty/null, treat it as a
+ // leaf: this helps preserve the empty/null
+ // distinction.
+ emptyPromoteToLeaf := (lhs == nil || lhs.Empty()) && (rhs == nil || rhs.Empty())
+
+ if t.ElementRelationship == schema.Atomic || emptyPromoteToLeaf {
+ w.doLeaf()
+ return nil
+ }
+
+ if lhs == nil && rhs == nil {
+ return nil
+ }
+
+ errs = append(errs, w.visitMapItems(t, lhs, rhs)...)
+
+ return errs
+}
diff --git a/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/helpers.go b/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/helpers.go
index 19c77334f6..78fdb0e75f 100644
--- a/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/helpers.go
+++ b/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/helpers.go
@@ -197,7 +197,7 @@ func getAssociativeKeyDefault(s *schema.Schema, list *schema.List, fieldName str
return field.Default, nil
}
-func keyedAssociativeListItemToPathElement(a value.Allocator, s *schema.Schema, list *schema.List, index int, child value.Value) (fieldpath.PathElement, error) {
+func keyedAssociativeListItemToPathElement(a value.Allocator, s *schema.Schema, list *schema.List, child value.Value) (fieldpath.PathElement, error) {
pe := fieldpath.PathElement{}
if child.IsNull() {
// null entries are illegal.
@@ -225,7 +225,7 @@ func keyedAssociativeListItemToPathElement(a value.Allocator, s *schema.Schema,
return pe, nil
}
-func setItemToPathElement(list *schema.List, index int, child value.Value) (fieldpath.PathElement, error) {
+func setItemToPathElement(child value.Value) (fieldpath.PathElement, error) {
pe := fieldpath.PathElement{}
switch {
case child.IsMap():
@@ -245,16 +245,15 @@ func setItemToPathElement(list *schema.List, index int, child value.Value) (fiel
}
}
-func listItemToPathElement(a value.Allocator, s *schema.Schema, list *schema.List, index int, child value.Value) (fieldpath.PathElement, error) {
- if list.ElementRelationship == schema.Associative {
- if len(list.Keys) > 0 {
- return keyedAssociativeListItemToPathElement(a, s, list, index, child)
- }
+func listItemToPathElement(a value.Allocator, s *schema.Schema, list *schema.List, child value.Value) (fieldpath.PathElement, error) {
+ if list.ElementRelationship != schema.Associative {
+ return fieldpath.PathElement{}, errors.New("invalid indexing of non-associative list")
+ }
- // If there's no keys, then we must be a set of primitives.
- return setItemToPathElement(list, index, child)
+ if len(list.Keys) > 0 {
+ return keyedAssociativeListItemToPathElement(a, s, list, child)
}
- // Use the index as a key for atomic lists.
- return fieldpath.PathElement{Index: &index}, nil
+ // If there's no keys, then we must be a set of primitives.
+ return setItemToPathElement(child)
}
diff --git a/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/merge.go b/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/merge.go
index 9136440830..fa227ac405 100644
--- a/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/merge.go
+++ b/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/merge.go
@@ -113,11 +113,12 @@ func (w *mergingWalker) doLeaf() {
w.rule(w)
}
-func (w *mergingWalker) doScalar(t *schema.Scalar) (errs ValidationErrors) {
- errs = append(errs, validateScalar(t, w.lhs, "lhs: ")...)
- errs = append(errs, validateScalar(t, w.rhs, "rhs: ")...)
- if len(errs) > 0 {
- return errs
+func (w *mergingWalker) doScalar(t *schema.Scalar) ValidationErrors {
+ // Make sure at least one side is a valid scalar.
+ lerrs := validateScalar(t, w.lhs, "lhs: ")
+ rerrs := validateScalar(t, w.rhs, "rhs: ")
+ if len(lerrs) > 0 && len(rerrs) > 0 {
+ return append(lerrs, rerrs...)
}
// All scalars are leaf fields.
@@ -179,14 +180,18 @@ func (w *mergingWalker) visitListItems(t *schema.List, lhs, rhs value.List) (err
}
out := make([]interface{}, 0, outLen)
- rhsOrder, observedRHS, rhsErrs := w.indexListPathElements(t, rhs)
+ rhsPEs, observedRHS, rhsErrs := w.indexListPathElements(t, rhs, false)
errs = append(errs, rhsErrs...)
- lhsOrder, observedLHS, lhsErrs := w.indexListPathElements(t, lhs)
+ lhsPEs, observedLHS, lhsErrs := w.indexListPathElements(t, lhs, true)
errs = append(errs, lhsErrs...)
+ if len(errs) != 0 {
+ return errs
+ }
+
sharedOrder := make([]*fieldpath.PathElement, 0, rLen)
- for i := range rhsOrder {
- pe := &rhsOrder[i]
+ for i := range rhsPEs {
+ pe := &rhsPEs[i]
if _, ok := observedLHS.Get(*pe); ok {
sharedOrder = append(sharedOrder, pe)
}
@@ -198,13 +203,15 @@ func (w *mergingWalker) visitListItems(t *schema.List, lhs, rhs value.List) (err
sharedOrder = sharedOrder[1:]
}
- lLen, rLen = len(lhsOrder), len(rhsOrder)
+ mergedRHS := fieldpath.MakePathElementMap(len(rhsPEs))
+ lLen, rLen = len(lhsPEs), len(rhsPEs)
for lI, rI := 0, 0; lI < lLen || rI < rLen; {
if lI < lLen && rI < rLen {
- pe := lhsOrder[lI]
- if pe.Equals(rhsOrder[rI]) {
+ pe := lhsPEs[lI]
+ if pe.Equals(rhsPEs[rI]) {
// merge LHS & RHS items
- lChild, _ := observedLHS.Get(pe)
+ mergedRHS.Insert(pe, struct{}{})
+ lChild, _ := observedLHS.Get(pe) // may be nil if the PE is duplicaated.
rChild, _ := observedRHS.Get(pe)
mergeOut, errs := w.mergeListItem(t, pe, lChild, rChild)
errs = append(errs, errs...)
@@ -221,17 +228,17 @@ func (w *mergingWalker) visitListItems(t *schema.List, lhs, rhs value.List) (err
}
continue
}
- if _, ok := observedRHS.Get(pe); ok && nextShared != nil && !nextShared.Equals(lhsOrder[lI]) {
+ if _, ok := observedRHS.Get(pe); ok && nextShared != nil && !nextShared.Equals(lhsPEs[lI]) {
// shared item, but not the one we want in this round
lI++
continue
}
}
if lI < lLen {
- pe := lhsOrder[lI]
+ pe := lhsPEs[lI]
if _, ok := observedRHS.Get(pe); !ok {
- // take LHS item
- lChild, _ := observedLHS.Get(pe)
+ // take LHS item using At to make sure we get the right item (observed may not contain the right item).
+ lChild := lhs.AtUsing(w.allocator, lI)
mergeOut, errs := w.mergeListItem(t, pe, lChild, nil)
errs = append(errs, errs...)
if mergeOut != nil {
@@ -239,12 +246,16 @@ func (w *mergingWalker) visitListItems(t *schema.List, lhs, rhs value.List) (err
}
lI++
continue
+ } else if _, ok := mergedRHS.Get(pe); ok {
+ // we've already merged it with RHS, we don't want to duplicate it, skip it.
+ lI++
}
}
if rI < rLen {
// Take the RHS item, merge with matching LHS item if possible
- pe := rhsOrder[rI]
- lChild, _ := observedLHS.Get(pe) // may be nil
+ pe := rhsPEs[rI]
+ mergedRHS.Insert(pe, struct{}{})
+ lChild, _ := observedLHS.Get(pe) // may be nil if absent or duplicaated.
rChild, _ := observedRHS.Get(pe)
mergeOut, errs := w.mergeListItem(t, pe, lChild, rChild)
errs = append(errs, errs...)
@@ -271,7 +282,7 @@ func (w *mergingWalker) visitListItems(t *schema.List, lhs, rhs value.List) (err
return errs
}
-func (w *mergingWalker) indexListPathElements(t *schema.List, list value.List) ([]fieldpath.PathElement, fieldpath.PathElementValueMap, ValidationErrors) {
+func (w *mergingWalker) indexListPathElements(t *schema.List, list value.List, allowDuplicates bool) ([]fieldpath.PathElement, fieldpath.PathElementValueMap, ValidationErrors) {
var errs ValidationErrors
length := 0
if list != nil {
@@ -281,7 +292,7 @@ func (w *mergingWalker) indexListPathElements(t *schema.List, list value.List) (
pes := make([]fieldpath.PathElement, 0, length)
for i := 0; i < length; i++ {
child := list.At(i)
- pe, err := listItemToPathElement(w.allocator, w.schema, t, i, child)
+ pe, err := listItemToPathElement(w.allocator, w.schema, t, child)
if err != nil {
errs = append(errs, errorf("element %v: %v", i, err.Error())...)
// If we can't construct the path element, we can't
@@ -289,11 +300,15 @@ func (w *mergingWalker) indexListPathElements(t *schema.List, list value.List) (
// this element.
continue
}
- if _, found := observed.Get(pe); found {
+ if _, found := observed.Get(pe); found && !allowDuplicates {
errs = append(errs, errorf("duplicate entries for key %v", pe.String())...)
continue
+ } else if !found {
+ observed.Insert(pe, child)
+ } else {
+ // Duplicated items are not merged with the new value, make them nil.
+ observed.Insert(pe, value.NewValueInterface(nil))
}
- observed.Insert(pe, child)
pes = append(pes, pe)
}
return pes, observed, errs
diff --git a/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/parser.go b/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/parser.go
index 3949a78fc6..4258ee5bab 100644
--- a/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/parser.go
+++ b/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/parser.go
@@ -93,13 +93,13 @@ func (p ParseableType) IsValid() bool {
// FromYAML parses a yaml string into an object with the current schema
// and the type "typename" or an error if validation fails.
-func (p ParseableType) FromYAML(object YAMLObject) (*TypedValue, error) {
+func (p ParseableType) FromYAML(object YAMLObject, opts ...ValidationOptions) (*TypedValue, error) {
var v interface{}
err := yaml.Unmarshal([]byte(object), &v)
if err != nil {
return nil, err
}
- return AsTyped(value.NewValueInterface(v), p.Schema, p.TypeRef)
+ return AsTyped(value.NewValueInterface(v), p.Schema, p.TypeRef, opts...)
}
// FromUnstructured converts a go "interface{}" type, typically an
@@ -108,8 +108,8 @@ func (p ParseableType) FromYAML(object YAMLObject) (*TypedValue, error) {
// The provided interface{} must be one of: map[string]interface{},
// map[interface{}]interface{}, []interface{}, int types, float types,
// string or boolean. Nested interface{} must also be one of these types.
-func (p ParseableType) FromUnstructured(in interface{}) (*TypedValue, error) {
- return AsTyped(value.NewValueInterface(in), p.Schema, p.TypeRef)
+func (p ParseableType) FromUnstructured(in interface{}, opts ...ValidationOptions) (*TypedValue, error) {
+ return AsTyped(value.NewValueInterface(in), p.Schema, p.TypeRef, opts...)
}
// FromStructured converts a go "interface{}" type, typically an structured object in
@@ -117,12 +117,12 @@ func (p ParseableType) FromUnstructured(in interface{}) (*TypedValue, error) {
// schema validation. The provided "interface{}" value must be a pointer so that the
// value can be modified via reflection. The provided "interface{}" may contain structs
// and types that are converted to Values by the jsonMarshaler interface.
-func (p ParseableType) FromStructured(in interface{}) (*TypedValue, error) {
+func (p ParseableType) FromStructured(in interface{}, opts ...ValidationOptions) (*TypedValue, error) {
v, err := value.NewValueReflect(in)
if err != nil {
return nil, fmt.Errorf("error creating struct value reflector: %v", err)
}
- return AsTyped(v, p.Schema, p.TypeRef)
+ return AsTyped(v, p.Schema, p.TypeRef, opts...)
}
// DeducedParseableType is a ParseableType that deduces the type from
diff --git a/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/remove.go b/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/remove.go
index a338d761d4..ad071ee8f3 100644
--- a/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/remove.go
+++ b/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/remove.go
@@ -74,9 +74,9 @@ func (w *removingWalker) doList(t *schema.List) (errs ValidationErrors) {
iter := l.RangeUsing(w.allocator)
defer w.allocator.Free(iter)
for iter.Next() {
- i, item := iter.Item()
+ _, item := iter.Item()
// Ignore error because we have already validated this list
- pe, _ := listItemToPathElement(w.allocator, w.schema, t, i, item)
+ pe, _ := listItemToPathElement(w.allocator, w.schema, t, item)
path, _ := fieldpath.MakePath(pe)
// save items on the path when we shouldExtract
// but ignore them when we are removing (i.e. !w.shouldExtract)
diff --git a/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/tofieldset.go b/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/tofieldset.go
index 047efff053..d563a87ee6 100644
--- a/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/tofieldset.go
+++ b/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/tofieldset.go
@@ -94,9 +94,31 @@ func (v *toFieldSetWalker) doScalar(t *schema.Scalar) ValidationErrors {
}
func (v *toFieldSetWalker) visitListItems(t *schema.List, list value.List) (errs ValidationErrors) {
+ // Keeps track of the PEs we've seen
+ seen := fieldpath.MakePathElementSet(list.Length())
+ // Keeps tracks of the PEs we've counted as duplicates
+ duplicates := fieldpath.MakePathElementSet(list.Length())
for i := 0; i < list.Length(); i++ {
child := list.At(i)
- pe, _ := listItemToPathElement(v.allocator, v.schema, t, i, child)
+ pe, _ := listItemToPathElement(v.allocator, v.schema, t, child)
+ if seen.Has(pe) {
+ if duplicates.Has(pe) {
+ // do nothing
+ } else {
+ v.set.Insert(append(v.path, pe))
+ duplicates.Insert(pe)
+ }
+ } else {
+ seen.Insert(pe)
+ }
+ }
+
+ for i := 0; i < list.Length(); i++ {
+ child := list.At(i)
+ pe, _ := listItemToPathElement(v.allocator, v.schema, t, child)
+ if duplicates.Has(pe) {
+ continue
+ }
v2 := v.prepareDescent(pe, t.ElementType)
v2.value = child
errs = append(errs, v2.toFieldSet()...)
diff --git a/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/typed.go b/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/typed.go
index d63a97fe20..9be9028280 100644
--- a/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/typed.go
+++ b/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/typed.go
@@ -17,8 +17,6 @@ limitations under the License.
package typed
import (
- "fmt"
- "strings"
"sync"
"sigs.k8s.io/structured-merge-diff/v4/fieldpath"
@@ -26,16 +24,24 @@ import (
"sigs.k8s.io/structured-merge-diff/v4/value"
)
+// ValidationOptions is the list of all the options available when running the validation.
+type ValidationOptions int
+
+const (
+ // AllowDuplicates means that sets and associative lists can have duplicate similar items.
+ AllowDuplicates ValidationOptions = iota
+)
+
// AsTyped accepts a value and a type and returns a TypedValue. 'v' must have
// type 'typeName' in the schema. An error is returned if the v doesn't conform
// to the schema.
-func AsTyped(v value.Value, s *schema.Schema, typeRef schema.TypeRef) (*TypedValue, error) {
+func AsTyped(v value.Value, s *schema.Schema, typeRef schema.TypeRef, opts ...ValidationOptions) (*TypedValue, error) {
tv := &TypedValue{
value: v,
typeRef: typeRef,
schema: s,
}
- if err := tv.Validate(); err != nil {
+ if err := tv.Validate(opts...); err != nil {
return nil, err
}
return tv, nil
@@ -45,6 +51,10 @@ func AsTyped(v value.Value, s *schema.Schema, typeRef schema.TypeRef) (*TypedVal
// conforms to the schema, for cases where that has already been checked or
// where you're going to call a method that validates as a side-effect (like
// ToFieldSet).
+//
+// Deprecated: This function was initially created because validation
+// was expensive. Now that this has been solved, objects should always
+// be created as validated, using `AsTyped`.
func AsTypedUnvalidated(v value.Value, s *schema.Schema, typeRef schema.TypeRef) *TypedValue {
tv := &TypedValue{
value: v,
@@ -77,8 +87,14 @@ func (tv TypedValue) Schema() *schema.Schema {
}
// Validate returns an error with a list of every spec violation.
-func (tv TypedValue) Validate() error {
+func (tv TypedValue) Validate(opts ...ValidationOptions) error {
w := tv.walker()
+ for _, opt := range opts {
+ switch opt {
+ case AllowDuplicates:
+ w.allowDuplicates = true
+ }
+ }
defer w.finished()
if errs := w.validate(nil); len(errs) != 0 {
return errs
@@ -113,6 +129,10 @@ func (tv TypedValue) Merge(pso *TypedValue) (*TypedValue, error) {
return merge(&tv, pso, ruleKeepRHS, nil)
}
+var cmpwPool = sync.Pool{
+ New: func() interface{} { return &compareWalker{} },
+}
+
// Compare compares the two objects. See the comments on the `Comparison`
// struct for details on the return value.
//
@@ -120,33 +140,44 @@ func (tv TypedValue) Merge(pso *TypedValue) (*TypedValue, error) {
// match), or an error will be returned. Validation errors will be returned if
// the objects don't conform to the schema.
func (tv TypedValue) Compare(rhs *TypedValue) (c *Comparison, err error) {
- c = &Comparison{
+ lhs := tv
+ if lhs.schema != rhs.schema {
+ return nil, errorf("expected objects with types from the same schema")
+ }
+ if !lhs.typeRef.Equals(&rhs.typeRef) {
+ return nil, errorf("expected objects of the same type, but got %v and %v", lhs.typeRef, rhs.typeRef)
+ }
+
+ cmpw := cmpwPool.Get().(*compareWalker)
+ defer func() {
+ cmpw.lhs = nil
+ cmpw.rhs = nil
+ cmpw.schema = nil
+ cmpw.typeRef = schema.TypeRef{}
+ cmpw.comparison = nil
+ cmpw.inLeaf = false
+
+ cmpwPool.Put(cmpw)
+ }()
+
+ cmpw.lhs = lhs.value
+ cmpw.rhs = rhs.value
+ cmpw.schema = lhs.schema
+ cmpw.typeRef = lhs.typeRef
+ cmpw.comparison = &Comparison{
Removed: fieldpath.NewSet(),
Modified: fieldpath.NewSet(),
Added: fieldpath.NewSet(),
}
- _, err = merge(&tv, rhs, func(w *mergingWalker) {
- if w.lhs == nil {
- c.Added.Insert(w.path)
- } else if w.rhs == nil {
- c.Removed.Insert(w.path)
- } else if !value.Equals(w.rhs, w.lhs) {
- // TODO: Equality is not sufficient for this.
- // Need to implement equality check on the value type.
- c.Modified.Insert(w.path)
- }
- }, func(w *mergingWalker) {
- if w.lhs == nil {
- c.Added.Insert(w.path)
- } else if w.rhs == nil {
- c.Removed.Insert(w.path)
- }
- })
- if err != nil {
- return nil, err
+ if cmpw.allocator == nil {
+ cmpw.allocator = value.NewFreelistAllocator()
}
- return c, nil
+ errs := cmpw.compare(nil)
+ if len(errs) > 0 {
+ return nil, errs
+ }
+ return cmpw.comparison, nil
}
// RemoveItems removes each provided list or map item from the value.
@@ -161,63 +192,6 @@ func (tv TypedValue) ExtractItems(items *fieldpath.Set) *TypedValue {
return &tv
}
-// NormalizeUnions takes the new object and normalizes the union:
-// - If discriminator changed to non-nil, and a new field has been added
-// that doesn't match, an error is returned,
-// - If discriminator hasn't changed and two fields or more are set, an
-// error is returned,
-// - If discriminator changed to non-nil, all other fields but the
-// discriminated one will be cleared,
-// - Otherwise, If only one field is left, update discriminator to that value.
-//
-// Please note: union behavior isn't finalized yet and this is still experimental.
-func (tv TypedValue) NormalizeUnions(new *TypedValue) (*TypedValue, error) {
- var errs ValidationErrors
- var normalizeFn = func(w *mergingWalker) {
- if w.rhs != nil {
- v := w.rhs.Unstructured()
- w.out = &v
- }
- if err := normalizeUnions(w); err != nil {
- errs = append(errs, errorf(err.Error())...)
- }
- }
- out, mergeErrs := merge(&tv, new, func(w *mergingWalker) {}, normalizeFn)
- if mergeErrs != nil {
- errs = append(errs, mergeErrs.(ValidationErrors)...)
- }
- if len(errs) > 0 {
- return nil, errs
- }
- return out, nil
-}
-
-// NormalizeUnionsApply specifically normalize unions on apply. It
-// validates that the applied union is correct (there should be no
-// ambiguity there), and clear the fields according to the sent intent.
-//
-// Please note: union behavior isn't finalized yet and this is still experimental.
-func (tv TypedValue) NormalizeUnionsApply(new *TypedValue) (*TypedValue, error) {
- var errs ValidationErrors
- var normalizeFn = func(w *mergingWalker) {
- if w.rhs != nil {
- v := w.rhs.Unstructured()
- w.out = &v
- }
- if err := normalizeUnionsApply(w); err != nil {
- errs = append(errs, errorf(err.Error())...)
- }
- }
- out, mergeErrs := merge(&tv, new, func(w *mergingWalker) {}, normalizeFn)
- if mergeErrs != nil {
- errs = append(errs, mergeErrs.(ValidationErrors)...)
- }
- if len(errs) > 0 {
- return nil, errs
- }
- return out, nil
-}
-
func (tv TypedValue) Empty() *TypedValue {
tv.value = value.NewValueInterface(nil)
return &tv
@@ -273,50 +247,3 @@ func merge(lhs, rhs *TypedValue, rule, postRule mergeRule) (*TypedValue, error)
}
return out, nil
}
-
-// Comparison is the return value of a TypedValue.Compare() operation.
-//
-// No field will appear in more than one of the three fieldsets. If all of the
-// fieldsets are empty, then the objects must have been equal.
-type Comparison struct {
- // Removed contains any fields removed by rhs (the right-hand-side
- // object in the comparison).
- Removed *fieldpath.Set
- // Modified contains fields present in both objects but different.
- Modified *fieldpath.Set
- // Added contains any fields added by rhs.
- Added *fieldpath.Set
-}
-
-// IsSame returns true if the comparison returned no changes (the two
-// compared objects are similar).
-func (c *Comparison) IsSame() bool {
- return c.Removed.Empty() && c.Modified.Empty() && c.Added.Empty()
-}
-
-// String returns a human readable version of the comparison.
-func (c *Comparison) String() string {
- bld := strings.Builder{}
- if !c.Modified.Empty() {
- bld.WriteString(fmt.Sprintf("- Modified Fields:\n%v\n", c.Modified))
- }
- if !c.Added.Empty() {
- bld.WriteString(fmt.Sprintf("- Added Fields:\n%v\n", c.Added))
- }
- if !c.Removed.Empty() {
- bld.WriteString(fmt.Sprintf("- Removed Fields:\n%v\n", c.Removed))
- }
- return bld.String()
-}
-
-// ExcludeFields fields from the compare recursively removes the fields
-// from the entire comparison
-func (c *Comparison) ExcludeFields(fields *fieldpath.Set) *Comparison {
- if fields == nil || fields.Empty() {
- return c
- }
- c.Removed = c.Removed.RecursiveDifference(fields)
- c.Modified = c.Modified.RecursiveDifference(fields)
- c.Added = c.Added.RecursiveDifference(fields)
- return c
-}
diff --git a/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/union.go b/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/union.go
deleted file mode 100644
index 1fa5d88ae6..0000000000
--- a/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/union.go
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
-Copyright 2019 The Kubernetes 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 typed
-
-import (
- "fmt"
- "strings"
-
- "sigs.k8s.io/structured-merge-diff/v4/schema"
- "sigs.k8s.io/structured-merge-diff/v4/value"
-)
-
-func normalizeUnions(w *mergingWalker) error {
- atom, found := w.schema.Resolve(w.typeRef)
- if !found {
- panic(fmt.Sprintf("Unable to resolve schema in normalize union: %v/%v", w.schema, w.typeRef))
- }
- // Unions can only be in structures, and the struct must not have been removed
- if atom.Map == nil || w.out == nil {
- return nil
- }
-
- var old value.Map
- if w.lhs != nil && !w.lhs.IsNull() {
- old = w.lhs.AsMap()
- }
- for _, union := range atom.Map.Unions {
- if err := newUnion(&union).Normalize(old, w.rhs.AsMap(), value.NewValueInterface(*w.out).AsMap()); err != nil {
- return err
- }
- }
- return nil
-}
-
-func normalizeUnionsApply(w *mergingWalker) error {
- atom, found := w.schema.Resolve(w.typeRef)
- if !found {
- panic(fmt.Sprintf("Unable to resolve schema in normalize union: %v/%v", w.schema, w.typeRef))
- }
- // Unions can only be in structures, and the struct must not have been removed
- if atom.Map == nil || w.out == nil {
- return nil
- }
-
- var old value.Map
- if w.lhs != nil && !w.lhs.IsNull() {
- old = w.lhs.AsMap()
- }
-
- for _, union := range atom.Map.Unions {
- out := value.NewValueInterface(*w.out)
- if err := newUnion(&union).NormalizeApply(old, w.rhs.AsMap(), out.AsMap()); err != nil {
- return err
- }
- *w.out = out.Unstructured()
- }
- return nil
-}
-
-type discriminated string
-type field string
-
-type discriminatedNames struct {
- f2d map[field]discriminated
- d2f map[discriminated]field
-}
-
-func newDiscriminatedName(f2d map[field]discriminated) discriminatedNames {
- d2f := map[discriminated]field{}
- for key, value := range f2d {
- d2f[value] = key
- }
- return discriminatedNames{
- f2d: f2d,
- d2f: d2f,
- }
-}
-
-func (dn discriminatedNames) toField(d discriminated) field {
- if f, ok := dn.d2f[d]; ok {
- return f
- }
- return field(d)
-}
-
-func (dn discriminatedNames) toDiscriminated(f field) discriminated {
- if d, ok := dn.f2d[f]; ok {
- return d
- }
- return discriminated(f)
-}
-
-type discriminator struct {
- name string
-}
-
-func (d *discriminator) Set(m value.Map, v discriminated) {
- if d == nil {
- return
- }
- m.Set(d.name, value.NewValueInterface(string(v)))
-}
-
-func (d *discriminator) Get(m value.Map) discriminated {
- if d == nil || m == nil {
- return ""
- }
- val, ok := m.Get(d.name)
- if !ok {
- return ""
- }
- if !val.IsString() {
- return ""
- }
- return discriminated(val.AsString())
-}
-
-type fieldsSet map[field]struct{}
-
-// newFieldsSet returns a map of the fields that are part of the union and are set
-// in the given map.
-func newFieldsSet(m value.Map, fields []field) fieldsSet {
- if m == nil {
- return nil
- }
- set := fieldsSet{}
- for _, f := range fields {
- if subField, ok := m.Get(string(f)); ok && !subField.IsNull() {
- set.Add(f)
- }
- }
- return set
-}
-
-func (fs fieldsSet) Add(f field) {
- if fs == nil {
- fs = map[field]struct{}{}
- }
- fs[f] = struct{}{}
-}
-
-func (fs fieldsSet) One() *field {
- for f := range fs {
- return &f
- }
- return nil
-}
-
-func (fs fieldsSet) Has(f field) bool {
- _, ok := fs[f]
- return ok
-}
-
-func (fs fieldsSet) List() []field {
- fields := []field{}
- for f := range fs {
- fields = append(fields, f)
- }
- return fields
-}
-
-func (fs fieldsSet) Difference(o fieldsSet) fieldsSet {
- n := fieldsSet{}
- for f := range fs {
- if !o.Has(f) {
- n.Add(f)
- }
- }
- return n
-}
-
-func (fs fieldsSet) String() string {
- s := []string{}
- for k := range fs {
- s = append(s, string(k))
- }
- return strings.Join(s, ", ")
-}
-
-type union struct {
- deduceInvalidDiscriminator bool
- d *discriminator
- dn discriminatedNames
- f []field
-}
-
-func newUnion(su *schema.Union) *union {
- u := &union{}
- if su.Discriminator != nil {
- u.d = &discriminator{name: *su.Discriminator}
- }
- f2d := map[field]discriminated{}
- for _, f := range su.Fields {
- u.f = append(u.f, field(f.FieldName))
- f2d[field(f.FieldName)] = discriminated(f.DiscriminatorValue)
- }
- u.dn = newDiscriminatedName(f2d)
- u.deduceInvalidDiscriminator = su.DeduceInvalidDiscriminator
- return u
-}
-
-// clear removes all the fields in map that are part of the union, but
-// the one we decided to keep.
-func (u *union) clear(m value.Map, f field) {
- for _, fieldName := range u.f {
- if field(fieldName) != f {
- m.Delete(string(fieldName))
- }
- }
-}
-
-func (u *union) Normalize(old, new, out value.Map) error {
- os := newFieldsSet(old, u.f)
- ns := newFieldsSet(new, u.f)
- diff := ns.Difference(os)
-
- if u.d.Get(old) != u.d.Get(new) && u.d.Get(new) != "" {
- if len(diff) == 1 && u.d.Get(new) != u.dn.toDiscriminated(*diff.One()) {
- return fmt.Errorf("discriminator (%v) and field changed (%v) don't match", u.d.Get(new), diff.One())
- }
- if len(diff) > 1 {
- return fmt.Errorf("multiple new fields added: %v", diff)
- }
- u.clear(out, u.dn.toField(u.d.Get(new)))
- return nil
- }
-
- if len(ns) > 1 {
- return fmt.Errorf("multiple fields set without discriminator change: %v", ns)
- }
-
- // Set discriminiator if it needs to be deduced.
- if u.deduceInvalidDiscriminator && len(ns) == 1 {
- u.d.Set(out, u.dn.toDiscriminated(*ns.One()))
- }
-
- return nil
-}
-
-func (u *union) NormalizeApply(applied, merged, out value.Map) error {
- as := newFieldsSet(applied, u.f)
- if len(as) > 1 {
- return fmt.Errorf("more than one field of union applied: %v", as)
- }
- if len(as) == 0 {
- // None is set, just leave.
- return nil
- }
- // We have exactly one, discriminiator must match if set
- if u.d.Get(applied) != "" && u.d.Get(applied) != u.dn.toDiscriminated(*as.One()) {
- return fmt.Errorf("applied discriminator (%v) doesn't match applied field (%v)", u.d.Get(applied), *as.One())
- }
-
- // Update discriminiator if needed
- if u.deduceInvalidDiscriminator {
- u.d.Set(out, u.dn.toDiscriminated(*as.One()))
- }
- // Clear others fields.
- u.clear(out, *as.One())
-
- return nil
-}
diff --git a/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/validate.go b/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/validate.go
index 378d30219c..652e24c819 100644
--- a/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/validate.go
+++ b/vendor/sigs.k8s.io/structured-merge-diff/v4/typed/validate.go
@@ -33,6 +33,7 @@ func (tv TypedValue) walker() *validatingObjectWalker {
v.value = tv.value
v.schema = tv.schema
v.typeRef = tv.typeRef
+ v.allowDuplicates = false
if v.allocator == nil {
v.allocator = value.NewFreelistAllocator()
}
@@ -49,6 +50,9 @@ type validatingObjectWalker struct {
value value.Value
schema *schema.Schema
typeRef schema.TypeRef
+ // If set to true, duplicates will be allowed in
+ // associativeLists/sets.
+ allowDuplicates bool
// Allocate only as many walkers as needed for the depth by storing them here.
spareWalkers *[]*validatingObjectWalker
@@ -102,6 +106,12 @@ func validateScalar(t *schema.Scalar, v value.Value, prefix string) (errs Valida
if !v.IsBool() {
return errorf("%vexpected boolean, got %v", prefix, v)
}
+ case schema.Untyped:
+ if !v.IsFloat() && !v.IsInt() && !v.IsString() && !v.IsBool() {
+ return errorf("%vexpected any scalar, got %v", prefix, v)
+ }
+ default:
+ return errorf("%vunexpected scalar type in schema: %v", prefix, *t)
}
return nil
}
@@ -123,7 +133,7 @@ func (v *validatingObjectWalker) visitListItems(t *schema.List, list value.List)
pe.Index = &i
} else {
var err error
- pe, err = listItemToPathElement(v.allocator, v.schema, t, i, child)
+ pe, err = listItemToPathElement(v.allocator, v.schema, t, child)
if err != nil {
errs = append(errs, errorf("element %v: %v", i, err.Error())...)
// If we can't construct the path element, we can't
@@ -131,7 +141,7 @@ func (v *validatingObjectWalker) visitListItems(t *schema.List, list value.List)
// this element.
return
}
- if observedKeys.Has(pe) {
+ if observedKeys.Has(pe) && !v.allowDuplicates {
errs = append(errs, errorf("duplicate entries for key %v", pe.String())...)
}
observedKeys.Insert(pe)
diff --git a/vendor/sigs.k8s.io/structured-merge-diff/v4/value/mapreflect.go b/vendor/sigs.k8s.io/structured-merge-diff/v4/value/mapreflect.go
index dc8b8c7200..c38402b99a 100644
--- a/vendor/sigs.k8s.io/structured-merge-diff/v4/value/mapreflect.go
+++ b/vendor/sigs.k8s.io/structured-merge-diff/v4/value/mapreflect.go
@@ -136,7 +136,7 @@ func (r mapReflect) EqualsUsing(a Allocator, m Map) bool {
if !ok {
return false
}
- return Equals(vr.mustReuse(lhsVal, entry, nil, nil), value)
+ return EqualsUsing(a, vr.mustReuse(lhsVal, entry, nil, nil), value)
})
}
diff --git a/vendor/sigs.k8s.io/structured-merge-diff/v4/value/mapunstructured.go b/vendor/sigs.k8s.io/structured-merge-diff/v4/value/mapunstructured.go
index d8e208628d..c3ae00b180 100644
--- a/vendor/sigs.k8s.io/structured-merge-diff/v4/value/mapunstructured.go
+++ b/vendor/sigs.k8s.io/structured-merge-diff/v4/value/mapunstructured.go
@@ -88,12 +88,12 @@ func (m mapUnstructuredInterface) EqualsUsing(a Allocator, other Map) bool {
}
vv := a.allocValueUnstructured()
defer a.Free(vv)
- return other.Iterate(func(key string, value Value) bool {
+ return other.IterateUsing(a, func(key string, value Value) bool {
lhsVal, ok := m[key]
if !ok {
return false
}
- return Equals(vv.reuse(lhsVal), value)
+ return EqualsUsing(a, vv.reuse(lhsVal), value)
})
}
@@ -168,12 +168,12 @@ func (m mapUnstructuredString) EqualsUsing(a Allocator, other Map) bool {
}
vv := a.allocValueUnstructured()
defer a.Free(vv)
- return other.Iterate(func(key string, value Value) bool {
+ return other.IterateUsing(a, func(key string, value Value) bool {
lhsVal, ok := m[key]
if !ok {
return false
}
- return Equals(vv.reuse(lhsVal), value)
+ return EqualsUsing(a, vv.reuse(lhsVal), value)
})
}
diff --git a/vendor/sigs.k8s.io/structured-merge-diff/v4/value/reflectcache.go b/vendor/sigs.k8s.io/structured-merge-diff/v4/value/reflectcache.go
index a5a467c0f0..f0d58d42cb 100644
--- a/vendor/sigs.k8s.io/structured-merge-diff/v4/value/reflectcache.go
+++ b/vendor/sigs.k8s.io/structured-merge-diff/v4/value/reflectcache.go
@@ -154,7 +154,9 @@ func buildStructCacheEntry(t reflect.Type, infos map[string]*FieldCacheEntry, fi
if field.Type.Kind() == reflect.Ptr {
e = field.Type.Elem()
}
- buildStructCacheEntry(e, infos, append(fieldPath, field.Index))
+ if e.Kind() == reflect.Struct {
+ buildStructCacheEntry(e, infos, append(fieldPath, field.Index))
+ }
continue
}
info := &FieldCacheEntry{JsonName: jsonName, isOmitEmpty: isOmitempty, fieldPath: append(fieldPath, field.Index), fieldType: field.Type}
diff --git a/vendor/sigs.k8s.io/yaml/LICENSE b/vendor/sigs.k8s.io/yaml/LICENSE
index 7805d36de7..093d6d3edf 100644
--- a/vendor/sigs.k8s.io/yaml/LICENSE
+++ b/vendor/sigs.k8s.io/yaml/LICENSE
@@ -48,3 +48,259 @@ 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.
+
+# The forked go-yaml.v3 library under this project is covered by two
+different licenses (MIT and Apache):
+
+#### MIT License ####
+
+The following files were ported to Go from C files of libyaml, and thus
+are still covered by their original MIT license, with the additional
+copyright staring in 2011 when the project was ported over:
+
+ apic.go emitterc.go parserc.go readerc.go scannerc.go
+ writerc.go yamlh.go yamlprivateh.go
+
+Copyright (c) 2006-2010 Kirill Simonov
+Copyright (c) 2006-2011 Kirill Simonov
+
+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.
+
+### Apache License ###
+
+All the remaining project files are covered by the Apache license:
+
+Copyright (c) 2011-2019 Canonical Ltd
+
+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.
+
+# The forked go-yaml.v2 library under the project is covered by an
+Apache license:
+
+ 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/sigs.k8s.io/yaml/OWNERS b/vendor/sigs.k8s.io/yaml/OWNERS
index 325b40b076..003a149e15 100644
--- a/vendor/sigs.k8s.io/yaml/OWNERS
+++ b/vendor/sigs.k8s.io/yaml/OWNERS
@@ -2,26 +2,22 @@
approvers:
- dims
-- lavalamp
+- jpbetz
- smarterclayton
- deads2k
- sttts
- liggitt
-- caesarxuchao
reviewers:
- dims
- thockin
-- lavalamp
+- jpbetz
- smarterclayton
- wojtek-t
- deads2k
- derekwaynecarr
-- caesarxuchao
- mikedanese
- liggitt
-- gmarek
- sttts
-- ncdc
- tallclair
labels:
- sig/api-machinery
diff --git a/vendor/sigs.k8s.io/yaml/fields.go b/vendor/sigs.k8s.io/yaml/fields.go
index 235b7f2cf6..0ea28bd030 100644
--- a/vendor/sigs.k8s.io/yaml/fields.go
+++ b/vendor/sigs.k8s.io/yaml/fields.go
@@ -16,53 +16,53 @@ import (
"unicode/utf8"
)
-// indirect walks down v allocating pointers as needed,
+// indirect walks down 'value' 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 indirect(v reflect.Value, decodingNull bool) (json.Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
- // If v is a named type and is addressable,
+func indirect(value reflect.Value, decodingNull bool) (json.Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
+ // If 'value' 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()
+ if value.Kind() != reflect.Ptr && value.Type().Name() != "" && value.CanAddr() {
+ value = value.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
+ if value.Kind() == reflect.Interface && !value.IsNil() {
+ element := value.Elem()
+ if element.Kind() == reflect.Ptr && !element.IsNil() && (!decodingNull || element.Elem().Kind() == reflect.Ptr) {
+ value = element
continue
}
}
- if v.Kind() != reflect.Ptr {
+ if value.Kind() != reflect.Ptr {
break
}
- if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() {
+ if value.Elem().Kind() != reflect.Ptr && decodingNull && value.CanSet() {
break
}
- if v.IsNil() {
- if v.CanSet() {
- v.Set(reflect.New(v.Type().Elem()))
+ if value.IsNil() {
+ if value.CanSet() {
+ value.Set(reflect.New(value.Type().Elem()))
} else {
- v = reflect.New(v.Type().Elem())
+ value = reflect.New(value.Type().Elem())
}
}
- if v.Type().NumMethod() > 0 {
- if u, ok := v.Interface().(json.Unmarshaler); ok {
+ if value.Type().NumMethod() > 0 {
+ if u, ok := value.Interface().(json.Unmarshaler); ok {
return u, nil, reflect.Value{}
}
- if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {
+ if u, ok := value.Interface().(encoding.TextUnmarshaler); ok {
return nil, u, reflect.Value{}
}
}
- v = v.Elem()
+ value = value.Elem()
}
- return nil, nil, v
+ return nil, nil, value
}
// A field represents a single field found in a struct.
@@ -134,8 +134,8 @@ func typeFields(t reflect.Type) []field {
next := []field{{typ: t}}
// Count of queued names for current level and the next.
- count := map[reflect.Type]int{}
- nextCount := map[reflect.Type]int{}
+ var count map[reflect.Type]int
+ var nextCount map[reflect.Type]int
// Types already visited at an earlier level.
visited := map[reflect.Type]bool{}
@@ -348,8 +348,9 @@ const (
// 4) simpleLetterEqualFold, no specials, no non-letters.
//
// The letters S and K are special because they map to 3 runes, not just 2:
-// * S maps to s and to U+017F 'ſ' Latin small letter long s
-// * k maps to K and to U+212A 'K' Kelvin sign
+// - S maps to s and to U+017F 'ſ' Latin small letter long s
+// - k maps to K and to U+212A 'K' Kelvin sign
+//
// See http://play.golang.org/p/tTxjOc0OGo
//
// The returned function is specialized for matching against s and
@@ -420,10 +421,8 @@ func equalFoldRight(s, t []byte) bool {
t = t[size:]
}
- if len(t) > 0 {
- return false
- }
- return true
+
+ return len(t) <= 0
}
// asciiEqualFold is a specialization of bytes.EqualFold for use when
diff --git a/vendor/google.golang.org/appengine/LICENSE b/vendor/sigs.k8s.io/yaml/goyaml.v2/LICENSE
similarity index 99%
rename from vendor/google.golang.org/appengine/LICENSE
rename to vendor/sigs.k8s.io/yaml/goyaml.v2/LICENSE
index d645695673..8dada3edaf 100644
--- a/vendor/google.golang.org/appengine/LICENSE
+++ b/vendor/sigs.k8s.io/yaml/goyaml.v2/LICENSE
@@ -1,4 +1,3 @@
-
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
@@ -179,7 +178,7 @@
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 "[]"
+ 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
@@ -187,7 +186,7 @@
same "printed page" as the copyright notice for easier
identification within third-party archives.
- Copyright [yyyy] [name of copyright owner]
+ 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.
diff --git a/vendor/sigs.k8s.io/yaml/goyaml.v2/LICENSE.libyaml b/vendor/sigs.k8s.io/yaml/goyaml.v2/LICENSE.libyaml
new file mode 100644
index 0000000000..8da58fbf6f
--- /dev/null
+++ b/vendor/sigs.k8s.io/yaml/goyaml.v2/LICENSE.libyaml
@@ -0,0 +1,31 @@
+The following files were ported to Go from C files of libyaml, and thus
+are still covered by their original copyright and license:
+
+ apic.go
+ emitterc.go
+ parserc.go
+ readerc.go
+ scannerc.go
+ writerc.go
+ yamlh.go
+ yamlprivateh.go
+
+Copyright (c) 2006 Kirill Simonov
+
+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/sigs.k8s.io/yaml/goyaml.v2/NOTICE b/vendor/sigs.k8s.io/yaml/goyaml.v2/NOTICE
new file mode 100644
index 0000000000..866d74a7ad
--- /dev/null
+++ b/vendor/sigs.k8s.io/yaml/goyaml.v2/NOTICE
@@ -0,0 +1,13 @@
+Copyright 2011-2016 Canonical Ltd.
+
+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/sigs.k8s.io/yaml/goyaml.v2/OWNERS b/vendor/sigs.k8s.io/yaml/goyaml.v2/OWNERS
new file mode 100644
index 0000000000..73be0a3a9b
--- /dev/null
+++ b/vendor/sigs.k8s.io/yaml/goyaml.v2/OWNERS
@@ -0,0 +1,24 @@
+# See the OWNERS docs at https://go.k8s.io/owners
+
+approvers:
+- dims
+- jpbetz
+- smarterclayton
+- deads2k
+- sttts
+- liggitt
+- natasha41575
+- knverey
+reviewers:
+- dims
+- thockin
+- jpbetz
+- smarterclayton
+- deads2k
+- derekwaynecarr
+- mikedanese
+- liggitt
+- sttts
+- tallclair
+labels:
+- sig/api-machinery
diff --git a/vendor/sigs.k8s.io/yaml/goyaml.v2/README.md b/vendor/sigs.k8s.io/yaml/goyaml.v2/README.md
new file mode 100644
index 0000000000..53f4139dc3
--- /dev/null
+++ b/vendor/sigs.k8s.io/yaml/goyaml.v2/README.md
@@ -0,0 +1,143 @@
+# go-yaml fork
+
+This package is a fork of the go-yaml library and is intended solely for consumption
+by kubernetes projects. In this fork, we plan to support only critical changes required for
+kubernetes, such as small bug fixes and regressions. Larger, general-purpose feature requests
+should be made in the upstream go-yaml library, and we will reject such changes in this fork
+unless we are pulling them from upstream.
+
+This fork is based on v2.4.0: https://github.com/go-yaml/yaml/releases/tag/v2.4.0
+
+# YAML support for the Go language
+
+Introduction
+------------
+
+The yaml package enables Go programs to comfortably encode and decode YAML
+values. It was developed within [Canonical](https://www.canonical.com) as
+part of the [juju](https://juju.ubuntu.com) project, and is based on a
+pure Go port of the well-known [libyaml](http://pyyaml.org/wiki/LibYAML)
+C library to parse and generate YAML data quickly and reliably.
+
+Compatibility
+-------------
+
+The yaml package supports most of YAML 1.1 and 1.2, including support for
+anchors, tags, map merging, etc. Multi-document unmarshalling is not yet
+implemented, and base-60 floats from YAML 1.1 are purposefully not
+supported since they're a poor design and are gone in YAML 1.2.
+
+Installation and usage
+----------------------
+
+The import path for the package is *gopkg.in/yaml.v2*.
+
+To install it, run:
+
+ go get gopkg.in/yaml.v2
+
+API documentation
+-----------------
+
+If opened in a browser, the import path itself leads to the API documentation:
+
+ * [https://gopkg.in/yaml.v2](https://gopkg.in/yaml.v2)
+
+API stability
+-------------
+
+The package API for yaml v2 will remain stable as described in [gopkg.in](https://gopkg.in).
+
+
+License
+-------
+
+The yaml package is licensed under the Apache License 2.0. Please see the LICENSE file for details.
+
+
+Example
+-------
+
+```Go
+package main
+
+import (
+ "fmt"
+ "log"
+
+ "gopkg.in/yaml.v2"
+)
+
+var data = `
+a: Easy!
+b:
+ c: 2
+ d: [3, 4]
+`
+
+// Note: struct fields must be public in order for unmarshal to
+// correctly populate the data.
+type T struct {
+ A string
+ B struct {
+ RenamedC int `yaml:"c"`
+ D []int `yaml:",flow"`
+ }
+}
+
+func main() {
+ t := T{}
+
+ err := yaml.Unmarshal([]byte(data), &t)
+ if err != nil {
+ log.Fatalf("error: %v", err)
+ }
+ fmt.Printf("--- t:\n%v\n\n", t)
+
+ d, err := yaml.Marshal(&t)
+ if err != nil {
+ log.Fatalf("error: %v", err)
+ }
+ fmt.Printf("--- t dump:\n%s\n\n", string(d))
+
+ m := make(map[interface{}]interface{})
+
+ err = yaml.Unmarshal([]byte(data), &m)
+ if err != nil {
+ log.Fatalf("error: %v", err)
+ }
+ fmt.Printf("--- m:\n%v\n\n", m)
+
+ d, err = yaml.Marshal(&m)
+ if err != nil {
+ log.Fatalf("error: %v", err)
+ }
+ fmt.Printf("--- m dump:\n%s\n\n", string(d))
+}
+```
+
+This example will generate the following output:
+
+```
+--- t:
+{Easy! {2 [3 4]}}
+
+--- t dump:
+a: Easy!
+b:
+ c: 2
+ d: [3, 4]
+
+
+--- m:
+map[a:Easy! b:map[c:2 d:[3 4]]]
+
+--- m dump:
+a: Easy!
+b:
+ c: 2
+ d:
+ - 3
+ - 4
+```
+
diff --git a/vendor/sigs.k8s.io/yaml/goyaml.v2/apic.go b/vendor/sigs.k8s.io/yaml/goyaml.v2/apic.go
new file mode 100644
index 0000000000..acf71402cf
--- /dev/null
+++ b/vendor/sigs.k8s.io/yaml/goyaml.v2/apic.go
@@ -0,0 +1,744 @@
+package yaml
+
+import (
+ "io"
+)
+
+func yaml_insert_token(parser *yaml_parser_t, pos int, token *yaml_token_t) {
+ //fmt.Println("yaml_insert_token", "pos:", pos, "typ:", token.typ, "head:", parser.tokens_head, "len:", len(parser.tokens))
+
+ // Check if we can move the queue at the beginning of the buffer.
+ if parser.tokens_head > 0 && len(parser.tokens) == cap(parser.tokens) {
+ if parser.tokens_head != len(parser.tokens) {
+ copy(parser.tokens, parser.tokens[parser.tokens_head:])
+ }
+ parser.tokens = parser.tokens[:len(parser.tokens)-parser.tokens_head]
+ parser.tokens_head = 0
+ }
+ parser.tokens = append(parser.tokens, *token)
+ if pos < 0 {
+ return
+ }
+ copy(parser.tokens[parser.tokens_head+pos+1:], parser.tokens[parser.tokens_head+pos:])
+ parser.tokens[parser.tokens_head+pos] = *token
+}
+
+// Create a new parser object.
+func yaml_parser_initialize(parser *yaml_parser_t) bool {
+ *parser = yaml_parser_t{
+ raw_buffer: make([]byte, 0, input_raw_buffer_size),
+ buffer: make([]byte, 0, input_buffer_size),
+ }
+ return true
+}
+
+// Destroy a parser object.
+func yaml_parser_delete(parser *yaml_parser_t) {
+ *parser = yaml_parser_t{}
+}
+
+// String read handler.
+func yaml_string_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
+ if parser.input_pos == len(parser.input) {
+ return 0, io.EOF
+ }
+ n = copy(buffer, parser.input[parser.input_pos:])
+ parser.input_pos += n
+ return n, nil
+}
+
+// Reader read handler.
+func yaml_reader_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
+ return parser.input_reader.Read(buffer)
+}
+
+// Set a string input.
+func yaml_parser_set_input_string(parser *yaml_parser_t, input []byte) {
+ if parser.read_handler != nil {
+ panic("must set the input source only once")
+ }
+ parser.read_handler = yaml_string_read_handler
+ parser.input = input
+ parser.input_pos = 0
+}
+
+// Set a file input.
+func yaml_parser_set_input_reader(parser *yaml_parser_t, r io.Reader) {
+ if parser.read_handler != nil {
+ panic("must set the input source only once")
+ }
+ parser.read_handler = yaml_reader_read_handler
+ parser.input_reader = r
+}
+
+// Set the source encoding.
+func yaml_parser_set_encoding(parser *yaml_parser_t, encoding yaml_encoding_t) {
+ if parser.encoding != yaml_ANY_ENCODING {
+ panic("must set the encoding only once")
+ }
+ parser.encoding = encoding
+}
+
+var disableLineWrapping = false
+
+// Create a new emitter object.
+func yaml_emitter_initialize(emitter *yaml_emitter_t) {
+ *emitter = yaml_emitter_t{
+ buffer: make([]byte, output_buffer_size),
+ raw_buffer: make([]byte, 0, output_raw_buffer_size),
+ states: make([]yaml_emitter_state_t, 0, initial_stack_size),
+ events: make([]yaml_event_t, 0, initial_queue_size),
+ }
+ if disableLineWrapping {
+ emitter.best_width = -1
+ }
+}
+
+// Destroy an emitter object.
+func yaml_emitter_delete(emitter *yaml_emitter_t) {
+ *emitter = yaml_emitter_t{}
+}
+
+// String write handler.
+func yaml_string_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
+ *emitter.output_buffer = append(*emitter.output_buffer, buffer...)
+ return nil
+}
+
+// yaml_writer_write_handler uses emitter.output_writer to write the
+// emitted text.
+func yaml_writer_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
+ _, err := emitter.output_writer.Write(buffer)
+ return err
+}
+
+// Set a string output.
+func yaml_emitter_set_output_string(emitter *yaml_emitter_t, output_buffer *[]byte) {
+ if emitter.write_handler != nil {
+ panic("must set the output target only once")
+ }
+ emitter.write_handler = yaml_string_write_handler
+ emitter.output_buffer = output_buffer
+}
+
+// Set a file output.
+func yaml_emitter_set_output_writer(emitter *yaml_emitter_t, w io.Writer) {
+ if emitter.write_handler != nil {
+ panic("must set the output target only once")
+ }
+ emitter.write_handler = yaml_writer_write_handler
+ emitter.output_writer = w
+}
+
+// Set the output encoding.
+func yaml_emitter_set_encoding(emitter *yaml_emitter_t, encoding yaml_encoding_t) {
+ if emitter.encoding != yaml_ANY_ENCODING {
+ panic("must set the output encoding only once")
+ }
+ emitter.encoding = encoding
+}
+
+// Set the canonical output style.
+func yaml_emitter_set_canonical(emitter *yaml_emitter_t, canonical bool) {
+ emitter.canonical = canonical
+}
+
+//// Set the indentation increment.
+func yaml_emitter_set_indent(emitter *yaml_emitter_t, indent int) {
+ if indent < 2 || indent > 9 {
+ indent = 2
+ }
+ emitter.best_indent = indent
+}
+
+// Set the preferred line width.
+func yaml_emitter_set_width(emitter *yaml_emitter_t, width int) {
+ if width < 0 {
+ width = -1
+ }
+ emitter.best_width = width
+}
+
+// Set if unescaped non-ASCII characters are allowed.
+func yaml_emitter_set_unicode(emitter *yaml_emitter_t, unicode bool) {
+ emitter.unicode = unicode
+}
+
+// Set the preferred line break character.
+func yaml_emitter_set_break(emitter *yaml_emitter_t, line_break yaml_break_t) {
+ emitter.line_break = line_break
+}
+
+///*
+// * Destroy a token object.
+// */
+//
+//YAML_DECLARE(void)
+//yaml_token_delete(yaml_token_t *token)
+//{
+// assert(token); // Non-NULL token object expected.
+//
+// switch (token.type)
+// {
+// case YAML_TAG_DIRECTIVE_TOKEN:
+// yaml_free(token.data.tag_directive.handle);
+// yaml_free(token.data.tag_directive.prefix);
+// break;
+//
+// case YAML_ALIAS_TOKEN:
+// yaml_free(token.data.alias.value);
+// break;
+//
+// case YAML_ANCHOR_TOKEN:
+// yaml_free(token.data.anchor.value);
+// break;
+//
+// case YAML_TAG_TOKEN:
+// yaml_free(token.data.tag.handle);
+// yaml_free(token.data.tag.suffix);
+// break;
+//
+// case YAML_SCALAR_TOKEN:
+// yaml_free(token.data.scalar.value);
+// break;
+//
+// default:
+// break;
+// }
+//
+// memset(token, 0, sizeof(yaml_token_t));
+//}
+//
+///*
+// * Check if a string is a valid UTF-8 sequence.
+// *
+// * Check 'reader.c' for more details on UTF-8 encoding.
+// */
+//
+//static int
+//yaml_check_utf8(yaml_char_t *start, size_t length)
+//{
+// yaml_char_t *end = start+length;
+// yaml_char_t *pointer = start;
+//
+// while (pointer < end) {
+// unsigned char octet;
+// unsigned int width;
+// unsigned int value;
+// size_t k;
+//
+// octet = pointer[0];
+// width = (octet & 0x80) == 0x00 ? 1 :
+// (octet & 0xE0) == 0xC0 ? 2 :
+// (octet & 0xF0) == 0xE0 ? 3 :
+// (octet & 0xF8) == 0xF0 ? 4 : 0;
+// value = (octet & 0x80) == 0x00 ? octet & 0x7F :
+// (octet & 0xE0) == 0xC0 ? octet & 0x1F :
+// (octet & 0xF0) == 0xE0 ? octet & 0x0F :
+// (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
+// if (!width) return 0;
+// if (pointer+width > end) return 0;
+// for (k = 1; k < width; k ++) {
+// octet = pointer[k];
+// if ((octet & 0xC0) != 0x80) return 0;
+// value = (value << 6) + (octet & 0x3F);
+// }
+// if (!((width == 1) ||
+// (width == 2 && value >= 0x80) ||
+// (width == 3 && value >= 0x800) ||
+// (width == 4 && value >= 0x10000))) return 0;
+//
+// pointer += width;
+// }
+//
+// return 1;
+//}
+//
+
+// Create STREAM-START.
+func yaml_stream_start_event_initialize(event *yaml_event_t, encoding yaml_encoding_t) {
+ *event = yaml_event_t{
+ typ: yaml_STREAM_START_EVENT,
+ encoding: encoding,
+ }
+}
+
+// Create STREAM-END.
+func yaml_stream_end_event_initialize(event *yaml_event_t) {
+ *event = yaml_event_t{
+ typ: yaml_STREAM_END_EVENT,
+ }
+}
+
+// Create DOCUMENT-START.
+func yaml_document_start_event_initialize(
+ event *yaml_event_t,
+ version_directive *yaml_version_directive_t,
+ tag_directives []yaml_tag_directive_t,
+ implicit bool,
+) {
+ *event = yaml_event_t{
+ typ: yaml_DOCUMENT_START_EVENT,
+ version_directive: version_directive,
+ tag_directives: tag_directives,
+ implicit: implicit,
+ }
+}
+
+// Create DOCUMENT-END.
+func yaml_document_end_event_initialize(event *yaml_event_t, implicit bool) {
+ *event = yaml_event_t{
+ typ: yaml_DOCUMENT_END_EVENT,
+ implicit: implicit,
+ }
+}
+
+///*
+// * Create ALIAS.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_alias_event_initialize(event *yaml_event_t, anchor *yaml_char_t)
+//{
+// mark yaml_mark_t = { 0, 0, 0 }
+// anchor_copy *yaml_char_t = NULL
+//
+// assert(event) // Non-NULL event object is expected.
+// assert(anchor) // Non-NULL anchor is expected.
+//
+// if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0
+//
+// anchor_copy = yaml_strdup(anchor)
+// if (!anchor_copy)
+// return 0
+//
+// ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark)
+//
+// return 1
+//}
+
+// Create SCALAR.
+func yaml_scalar_event_initialize(event *yaml_event_t, anchor, tag, value []byte, plain_implicit, quoted_implicit bool, style yaml_scalar_style_t) bool {
+ *event = yaml_event_t{
+ typ: yaml_SCALAR_EVENT,
+ anchor: anchor,
+ tag: tag,
+ value: value,
+ implicit: plain_implicit,
+ quoted_implicit: quoted_implicit,
+ style: yaml_style_t(style),
+ }
+ return true
+}
+
+// Create SEQUENCE-START.
+func yaml_sequence_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_sequence_style_t) bool {
+ *event = yaml_event_t{
+ typ: yaml_SEQUENCE_START_EVENT,
+ anchor: anchor,
+ tag: tag,
+ implicit: implicit,
+ style: yaml_style_t(style),
+ }
+ return true
+}
+
+// Create SEQUENCE-END.
+func yaml_sequence_end_event_initialize(event *yaml_event_t) bool {
+ *event = yaml_event_t{
+ typ: yaml_SEQUENCE_END_EVENT,
+ }
+ return true
+}
+
+// Create MAPPING-START.
+func yaml_mapping_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_mapping_style_t) {
+ *event = yaml_event_t{
+ typ: yaml_MAPPING_START_EVENT,
+ anchor: anchor,
+ tag: tag,
+ implicit: implicit,
+ style: yaml_style_t(style),
+ }
+}
+
+// Create MAPPING-END.
+func yaml_mapping_end_event_initialize(event *yaml_event_t) {
+ *event = yaml_event_t{
+ typ: yaml_MAPPING_END_EVENT,
+ }
+}
+
+// Destroy an event object.
+func yaml_event_delete(event *yaml_event_t) {
+ *event = yaml_event_t{}
+}
+
+///*
+// * Create a document object.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_initialize(document *yaml_document_t,
+// version_directive *yaml_version_directive_t,
+// tag_directives_start *yaml_tag_directive_t,
+// tag_directives_end *yaml_tag_directive_t,
+// start_implicit int, end_implicit int)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+// struct {
+// start *yaml_node_t
+// end *yaml_node_t
+// top *yaml_node_t
+// } nodes = { NULL, NULL, NULL }
+// version_directive_copy *yaml_version_directive_t = NULL
+// struct {
+// start *yaml_tag_directive_t
+// end *yaml_tag_directive_t
+// top *yaml_tag_directive_t
+// } tag_directives_copy = { NULL, NULL, NULL }
+// value yaml_tag_directive_t = { NULL, NULL }
+// mark yaml_mark_t = { 0, 0, 0 }
+//
+// assert(document) // Non-NULL document object is expected.
+// assert((tag_directives_start && tag_directives_end) ||
+// (tag_directives_start == tag_directives_end))
+// // Valid tag directives are expected.
+//
+// if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error
+//
+// if (version_directive) {
+// version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t))
+// if (!version_directive_copy) goto error
+// version_directive_copy.major = version_directive.major
+// version_directive_copy.minor = version_directive.minor
+// }
+//
+// if (tag_directives_start != tag_directives_end) {
+// tag_directive *yaml_tag_directive_t
+// if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
+// goto error
+// for (tag_directive = tag_directives_start
+// tag_directive != tag_directives_end; tag_directive ++) {
+// assert(tag_directive.handle)
+// assert(tag_directive.prefix)
+// if (!yaml_check_utf8(tag_directive.handle,
+// strlen((char *)tag_directive.handle)))
+// goto error
+// if (!yaml_check_utf8(tag_directive.prefix,
+// strlen((char *)tag_directive.prefix)))
+// goto error
+// value.handle = yaml_strdup(tag_directive.handle)
+// value.prefix = yaml_strdup(tag_directive.prefix)
+// if (!value.handle || !value.prefix) goto error
+// if (!PUSH(&context, tag_directives_copy, value))
+// goto error
+// value.handle = NULL
+// value.prefix = NULL
+// }
+// }
+//
+// DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
+// tag_directives_copy.start, tag_directives_copy.top,
+// start_implicit, end_implicit, mark, mark)
+//
+// return 1
+//
+//error:
+// STACK_DEL(&context, nodes)
+// yaml_free(version_directive_copy)
+// while (!STACK_EMPTY(&context, tag_directives_copy)) {
+// value yaml_tag_directive_t = POP(&context, tag_directives_copy)
+// yaml_free(value.handle)
+// yaml_free(value.prefix)
+// }
+// STACK_DEL(&context, tag_directives_copy)
+// yaml_free(value.handle)
+// yaml_free(value.prefix)
+//
+// return 0
+//}
+//
+///*
+// * Destroy a document object.
+// */
+//
+//YAML_DECLARE(void)
+//yaml_document_delete(document *yaml_document_t)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+// tag_directive *yaml_tag_directive_t
+//
+// context.error = YAML_NO_ERROR // Eliminate a compiler warning.
+//
+// assert(document) // Non-NULL document object is expected.
+//
+// while (!STACK_EMPTY(&context, document.nodes)) {
+// node yaml_node_t = POP(&context, document.nodes)
+// yaml_free(node.tag)
+// switch (node.type) {
+// case YAML_SCALAR_NODE:
+// yaml_free(node.data.scalar.value)
+// break
+// case YAML_SEQUENCE_NODE:
+// STACK_DEL(&context, node.data.sequence.items)
+// break
+// case YAML_MAPPING_NODE:
+// STACK_DEL(&context, node.data.mapping.pairs)
+// break
+// default:
+// assert(0) // Should not happen.
+// }
+// }
+// STACK_DEL(&context, document.nodes)
+//
+// yaml_free(document.version_directive)
+// for (tag_directive = document.tag_directives.start
+// tag_directive != document.tag_directives.end
+// tag_directive++) {
+// yaml_free(tag_directive.handle)
+// yaml_free(tag_directive.prefix)
+// }
+// yaml_free(document.tag_directives.start)
+//
+// memset(document, 0, sizeof(yaml_document_t))
+//}
+//
+///**
+// * Get a document node.
+// */
+//
+//YAML_DECLARE(yaml_node_t *)
+//yaml_document_get_node(document *yaml_document_t, index int)
+//{
+// assert(document) // Non-NULL document object is expected.
+//
+// if (index > 0 && document.nodes.start + index <= document.nodes.top) {
+// return document.nodes.start + index - 1
+// }
+// return NULL
+//}
+//
+///**
+// * Get the root object.
+// */
+//
+//YAML_DECLARE(yaml_node_t *)
+//yaml_document_get_root_node(document *yaml_document_t)
+//{
+// assert(document) // Non-NULL document object is expected.
+//
+// if (document.nodes.top != document.nodes.start) {
+// return document.nodes.start
+// }
+// return NULL
+//}
+//
+///*
+// * Add a scalar node to a document.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_add_scalar(document *yaml_document_t,
+// tag *yaml_char_t, value *yaml_char_t, length int,
+// style yaml_scalar_style_t)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+// mark yaml_mark_t = { 0, 0, 0 }
+// tag_copy *yaml_char_t = NULL
+// value_copy *yaml_char_t = NULL
+// node yaml_node_t
+//
+// assert(document) // Non-NULL document object is expected.
+// assert(value) // Non-NULL value is expected.
+//
+// if (!tag) {
+// tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG
+// }
+//
+// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
+// tag_copy = yaml_strdup(tag)
+// if (!tag_copy) goto error
+//
+// if (length < 0) {
+// length = strlen((char *)value)
+// }
+//
+// if (!yaml_check_utf8(value, length)) goto error
+// value_copy = yaml_malloc(length+1)
+// if (!value_copy) goto error
+// memcpy(value_copy, value, length)
+// value_copy[length] = '\0'
+//
+// SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark)
+// if (!PUSH(&context, document.nodes, node)) goto error
+//
+// return document.nodes.top - document.nodes.start
+//
+//error:
+// yaml_free(tag_copy)
+// yaml_free(value_copy)
+//
+// return 0
+//}
+//
+///*
+// * Add a sequence node to a document.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_add_sequence(document *yaml_document_t,
+// tag *yaml_char_t, style yaml_sequence_style_t)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+// mark yaml_mark_t = { 0, 0, 0 }
+// tag_copy *yaml_char_t = NULL
+// struct {
+// start *yaml_node_item_t
+// end *yaml_node_item_t
+// top *yaml_node_item_t
+// } items = { NULL, NULL, NULL }
+// node yaml_node_t
+//
+// assert(document) // Non-NULL document object is expected.
+//
+// if (!tag) {
+// tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG
+// }
+//
+// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
+// tag_copy = yaml_strdup(tag)
+// if (!tag_copy) goto error
+//
+// if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error
+//
+// SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
+// style, mark, mark)
+// if (!PUSH(&context, document.nodes, node)) goto error
+//
+// return document.nodes.top - document.nodes.start
+//
+//error:
+// STACK_DEL(&context, items)
+// yaml_free(tag_copy)
+//
+// return 0
+//}
+//
+///*
+// * Add a mapping node to a document.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_add_mapping(document *yaml_document_t,
+// tag *yaml_char_t, style yaml_mapping_style_t)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+// mark yaml_mark_t = { 0, 0, 0 }
+// tag_copy *yaml_char_t = NULL
+// struct {
+// start *yaml_node_pair_t
+// end *yaml_node_pair_t
+// top *yaml_node_pair_t
+// } pairs = { NULL, NULL, NULL }
+// node yaml_node_t
+//
+// assert(document) // Non-NULL document object is expected.
+//
+// if (!tag) {
+// tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG
+// }
+//
+// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
+// tag_copy = yaml_strdup(tag)
+// if (!tag_copy) goto error
+//
+// if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error
+//
+// MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
+// style, mark, mark)
+// if (!PUSH(&context, document.nodes, node)) goto error
+//
+// return document.nodes.top - document.nodes.start
+//
+//error:
+// STACK_DEL(&context, pairs)
+// yaml_free(tag_copy)
+//
+// return 0
+//}
+//
+///*
+// * Append an item to a sequence node.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_append_sequence_item(document *yaml_document_t,
+// sequence int, item int)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+//
+// assert(document) // Non-NULL document is required.
+// assert(sequence > 0
+// && document.nodes.start + sequence <= document.nodes.top)
+// // Valid sequence id is required.
+// assert(document.nodes.start[sequence-1].type == YAML_SEQUENCE_NODE)
+// // A sequence node is required.
+// assert(item > 0 && document.nodes.start + item <= document.nodes.top)
+// // Valid item id is required.
+//
+// if (!PUSH(&context,
+// document.nodes.start[sequence-1].data.sequence.items, item))
+// return 0
+//
+// return 1
+//}
+//
+///*
+// * Append a pair of a key and a value to a mapping node.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_append_mapping_pair(document *yaml_document_t,
+// mapping int, key int, value int)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+//
+// pair yaml_node_pair_t
+//
+// assert(document) // Non-NULL document is required.
+// assert(mapping > 0
+// && document.nodes.start + mapping <= document.nodes.top)
+// // Valid mapping id is required.
+// assert(document.nodes.start[mapping-1].type == YAML_MAPPING_NODE)
+// // A mapping node is required.
+// assert(key > 0 && document.nodes.start + key <= document.nodes.top)
+// // Valid key id is required.
+// assert(value > 0 && document.nodes.start + value <= document.nodes.top)
+// // Valid value id is required.
+//
+// pair.key = key
+// pair.value = value
+//
+// if (!PUSH(&context,
+// document.nodes.start[mapping-1].data.mapping.pairs, pair))
+// return 0
+//
+// return 1
+//}
+//
+//
diff --git a/vendor/sigs.k8s.io/yaml/goyaml.v2/decode.go b/vendor/sigs.k8s.io/yaml/goyaml.v2/decode.go
new file mode 100644
index 0000000000..129bc2a97d
--- /dev/null
+++ b/vendor/sigs.k8s.io/yaml/goyaml.v2/decode.go
@@ -0,0 +1,815 @@
+package yaml
+
+import (
+ "encoding"
+ "encoding/base64"
+ "fmt"
+ "io"
+ "math"
+ "reflect"
+ "strconv"
+ "time"
+)
+
+const (
+ documentNode = 1 << iota
+ mappingNode
+ sequenceNode
+ scalarNode
+ aliasNode
+)
+
+type node struct {
+ kind int
+ line, column int
+ tag string
+ // For an alias node, alias holds the resolved alias.
+ alias *node
+ value string
+ implicit bool
+ children []*node
+ anchors map[string]*node
+}
+
+// ----------------------------------------------------------------------------
+// Parser, produces a node tree out of a libyaml event stream.
+
+type parser struct {
+ parser yaml_parser_t
+ event yaml_event_t
+ doc *node
+ doneInit bool
+}
+
+func newParser(b []byte) *parser {
+ p := parser{}
+ if !yaml_parser_initialize(&p.parser) {
+ panic("failed to initialize YAML emitter")
+ }
+ if len(b) == 0 {
+ b = []byte{'\n'}
+ }
+ yaml_parser_set_input_string(&p.parser, b)
+ return &p
+}
+
+func newParserFromReader(r io.Reader) *parser {
+ p := parser{}
+ if !yaml_parser_initialize(&p.parser) {
+ panic("failed to initialize YAML emitter")
+ }
+ yaml_parser_set_input_reader(&p.parser, r)
+ return &p
+}
+
+func (p *parser) init() {
+ if p.doneInit {
+ return
+ }
+ p.expect(yaml_STREAM_START_EVENT)
+ p.doneInit = true
+}
+
+func (p *parser) destroy() {
+ if p.event.typ != yaml_NO_EVENT {
+ yaml_event_delete(&p.event)
+ }
+ yaml_parser_delete(&p.parser)
+}
+
+// expect consumes an event from the event stream and
+// checks that it's of the expected type.
+func (p *parser) expect(e yaml_event_type_t) {
+ if p.event.typ == yaml_NO_EVENT {
+ if !yaml_parser_parse(&p.parser, &p.event) {
+ p.fail()
+ }
+ }
+ if p.event.typ == yaml_STREAM_END_EVENT {
+ failf("attempted to go past the end of stream; corrupted value?")
+ }
+ if p.event.typ != e {
+ p.parser.problem = fmt.Sprintf("expected %s event but got %s", e, p.event.typ)
+ p.fail()
+ }
+ yaml_event_delete(&p.event)
+ p.event.typ = yaml_NO_EVENT
+}
+
+// peek peeks at the next event in the event stream,
+// puts the results into p.event and returns the event type.
+func (p *parser) peek() yaml_event_type_t {
+ if p.event.typ != yaml_NO_EVENT {
+ return p.event.typ
+ }
+ if !yaml_parser_parse(&p.parser, &p.event) {
+ p.fail()
+ }
+ return p.event.typ
+}
+
+func (p *parser) fail() {
+ var where string
+ var line int
+ if p.parser.problem_mark.line != 0 {
+ line = p.parser.problem_mark.line
+ // Scanner errors don't iterate line before returning error
+ if p.parser.error == yaml_SCANNER_ERROR {
+ line++
+ }
+ } else if p.parser.context_mark.line != 0 {
+ line = p.parser.context_mark.line
+ }
+ if line != 0 {
+ where = "line " + strconv.Itoa(line) + ": "
+ }
+ var msg string
+ if len(p.parser.problem) > 0 {
+ msg = p.parser.problem
+ } else {
+ msg = "unknown problem parsing YAML content"
+ }
+ failf("%s%s", where, msg)
+}
+
+func (p *parser) anchor(n *node, anchor []byte) {
+ if anchor != nil {
+ p.doc.anchors[string(anchor)] = n
+ }
+}
+
+func (p *parser) parse() *node {
+ p.init()
+ switch p.peek() {
+ case yaml_SCALAR_EVENT:
+ return p.scalar()
+ case yaml_ALIAS_EVENT:
+ return p.alias()
+ case yaml_MAPPING_START_EVENT:
+ return p.mapping()
+ case yaml_SEQUENCE_START_EVENT:
+ return p.sequence()
+ case yaml_DOCUMENT_START_EVENT:
+ return p.document()
+ case yaml_STREAM_END_EVENT:
+ // Happens when attempting to decode an empty buffer.
+ return nil
+ default:
+ panic("attempted to parse unknown event: " + p.event.typ.String())
+ }
+}
+
+func (p *parser) node(kind int) *node {
+ return &node{
+ kind: kind,
+ line: p.event.start_mark.line,
+ column: p.event.start_mark.column,
+ }
+}
+
+func (p *parser) document() *node {
+ n := p.node(documentNode)
+ n.anchors = make(map[string]*node)
+ p.doc = n
+ p.expect(yaml_DOCUMENT_START_EVENT)
+ n.children = append(n.children, p.parse())
+ p.expect(yaml_DOCUMENT_END_EVENT)
+ return n
+}
+
+func (p *parser) alias() *node {
+ n := p.node(aliasNode)
+ n.value = string(p.event.anchor)
+ n.alias = p.doc.anchors[n.value]
+ if n.alias == nil {
+ failf("unknown anchor '%s' referenced", n.value)
+ }
+ p.expect(yaml_ALIAS_EVENT)
+ return n
+}
+
+func (p *parser) scalar() *node {
+ n := p.node(scalarNode)
+ n.value = string(p.event.value)
+ n.tag = string(p.event.tag)
+ n.implicit = p.event.implicit
+ p.anchor(n, p.event.anchor)
+ p.expect(yaml_SCALAR_EVENT)
+ return n
+}
+
+func (p *parser) sequence() *node {
+ n := p.node(sequenceNode)
+ p.anchor(n, p.event.anchor)
+ p.expect(yaml_SEQUENCE_START_EVENT)
+ for p.peek() != yaml_SEQUENCE_END_EVENT {
+ n.children = append(n.children, p.parse())
+ }
+ p.expect(yaml_SEQUENCE_END_EVENT)
+ return n
+}
+
+func (p *parser) mapping() *node {
+ n := p.node(mappingNode)
+ p.anchor(n, p.event.anchor)
+ p.expect(yaml_MAPPING_START_EVENT)
+ for p.peek() != yaml_MAPPING_END_EVENT {
+ n.children = append(n.children, p.parse(), p.parse())
+ }
+ p.expect(yaml_MAPPING_END_EVENT)
+ return n
+}
+
+// ----------------------------------------------------------------------------
+// Decoder, unmarshals a node into a provided value.
+
+type decoder struct {
+ doc *node
+ aliases map[*node]bool
+ mapType reflect.Type
+ terrors []string
+ strict bool
+
+ decodeCount int
+ aliasCount int
+ aliasDepth int
+}
+
+var (
+ mapItemType = reflect.TypeOf(MapItem{})
+ durationType = reflect.TypeOf(time.Duration(0))
+ defaultMapType = reflect.TypeOf(map[interface{}]interface{}{})
+ ifaceType = defaultMapType.Elem()
+ timeType = reflect.TypeOf(time.Time{})
+ ptrTimeType = reflect.TypeOf(&time.Time{})
+)
+
+func newDecoder(strict bool) *decoder {
+ d := &decoder{mapType: defaultMapType, strict: strict}
+ d.aliases = make(map[*node]bool)
+ return d
+}
+
+func (d *decoder) terror(n *node, tag string, out reflect.Value) {
+ if n.tag != "" {
+ tag = n.tag
+ }
+ value := n.value
+ if tag != yaml_SEQ_TAG && tag != yaml_MAP_TAG {
+ if len(value) > 10 {
+ value = " `" + value[:7] + "...`"
+ } else {
+ value = " `" + value + "`"
+ }
+ }
+ d.terrors = append(d.terrors, fmt.Sprintf("line %d: cannot unmarshal %s%s into %s", n.line+1, shortTag(tag), value, out.Type()))
+}
+
+func (d *decoder) callUnmarshaler(n *node, u Unmarshaler) (good bool) {
+ terrlen := len(d.terrors)
+ err := u.UnmarshalYAML(func(v interface{}) (err error) {
+ defer handleErr(&err)
+ d.unmarshal(n, reflect.ValueOf(v))
+ if len(d.terrors) > terrlen {
+ issues := d.terrors[terrlen:]
+ d.terrors = d.terrors[:terrlen]
+ return &TypeError{issues}
+ }
+ return nil
+ })
+ if e, ok := err.(*TypeError); ok {
+ d.terrors = append(d.terrors, e.Errors...)
+ return false
+ }
+ if err != nil {
+ fail(err)
+ }
+ return true
+}
+
+// d.prepare initializes and dereferences pointers and calls UnmarshalYAML
+// if a value is found to implement it.
+// It returns the initialized and dereferenced out value, whether
+// unmarshalling was already done by UnmarshalYAML, and if so whether
+// its types unmarshalled appropriately.
+//
+// If n holds a null value, prepare returns before doing anything.
+func (d *decoder) prepare(n *node, out reflect.Value) (newout reflect.Value, unmarshaled, good bool) {
+ if n.tag == yaml_NULL_TAG || n.kind == scalarNode && n.tag == "" && (n.value == "null" || n.value == "~" || n.value == "" && n.implicit) {
+ return out, false, false
+ }
+ again := true
+ for again {
+ again = false
+ if out.Kind() == reflect.Ptr {
+ if out.IsNil() {
+ out.Set(reflect.New(out.Type().Elem()))
+ }
+ out = out.Elem()
+ again = true
+ }
+ if out.CanAddr() {
+ if u, ok := out.Addr().Interface().(Unmarshaler); ok {
+ good = d.callUnmarshaler(n, u)
+ return out, true, good
+ }
+ }
+ }
+ return out, false, false
+}
+
+const (
+ // 400,000 decode operations is ~500kb of dense object declarations, or
+ // ~5kb of dense object declarations with 10000% alias expansion
+ alias_ratio_range_low = 400000
+
+ // 4,000,000 decode operations is ~5MB of dense object declarations, or
+ // ~4.5MB of dense object declarations with 10% alias expansion
+ alias_ratio_range_high = 4000000
+
+ // alias_ratio_range is the range over which we scale allowed alias ratios
+ alias_ratio_range = float64(alias_ratio_range_high - alias_ratio_range_low)
+)
+
+func allowedAliasRatio(decodeCount int) float64 {
+ switch {
+ case decodeCount <= alias_ratio_range_low:
+ // allow 99% to come from alias expansion for small-to-medium documents
+ return 0.99
+ case decodeCount >= alias_ratio_range_high:
+ // allow 10% to come from alias expansion for very large documents
+ return 0.10
+ default:
+ // scale smoothly from 99% down to 10% over the range.
+ // this maps to 396,000 - 400,000 allowed alias-driven decodes over the range.
+ // 400,000 decode operations is ~100MB of allocations in worst-case scenarios (single-item maps).
+ return 0.99 - 0.89*(float64(decodeCount-alias_ratio_range_low)/alias_ratio_range)
+ }
+}
+
+func (d *decoder) unmarshal(n *node, out reflect.Value) (good bool) {
+ d.decodeCount++
+ if d.aliasDepth > 0 {
+ d.aliasCount++
+ }
+ if d.aliasCount > 100 && d.decodeCount > 1000 && float64(d.aliasCount)/float64(d.decodeCount) > allowedAliasRatio(d.decodeCount) {
+ failf("document contains excessive aliasing")
+ }
+ switch n.kind {
+ case documentNode:
+ return d.document(n, out)
+ case aliasNode:
+ return d.alias(n, out)
+ }
+ out, unmarshaled, good := d.prepare(n, out)
+ if unmarshaled {
+ return good
+ }
+ switch n.kind {
+ case scalarNode:
+ good = d.scalar(n, out)
+ case mappingNode:
+ good = d.mapping(n, out)
+ case sequenceNode:
+ good = d.sequence(n, out)
+ default:
+ panic("internal error: unknown node kind: " + strconv.Itoa(n.kind))
+ }
+ return good
+}
+
+func (d *decoder) document(n *node, out reflect.Value) (good bool) {
+ if len(n.children) == 1 {
+ d.doc = n
+ d.unmarshal(n.children[0], out)
+ return true
+ }
+ return false
+}
+
+func (d *decoder) alias(n *node, out reflect.Value) (good bool) {
+ if d.aliases[n] {
+ // TODO this could actually be allowed in some circumstances.
+ failf("anchor '%s' value contains itself", n.value)
+ }
+ d.aliases[n] = true
+ d.aliasDepth++
+ good = d.unmarshal(n.alias, out)
+ d.aliasDepth--
+ delete(d.aliases, n)
+ return good
+}
+
+var zeroValue reflect.Value
+
+func resetMap(out reflect.Value) {
+ for _, k := range out.MapKeys() {
+ out.SetMapIndex(k, zeroValue)
+ }
+}
+
+func (d *decoder) scalar(n *node, out reflect.Value) bool {
+ var tag string
+ var resolved interface{}
+ if n.tag == "" && !n.implicit {
+ tag = yaml_STR_TAG
+ resolved = n.value
+ } else {
+ tag, resolved = resolve(n.tag, n.value)
+ if tag == yaml_BINARY_TAG {
+ data, err := base64.StdEncoding.DecodeString(resolved.(string))
+ if err != nil {
+ failf("!!binary value contains invalid base64 data")
+ }
+ resolved = string(data)
+ }
+ }
+ if resolved == nil {
+ if out.Kind() == reflect.Map && !out.CanAddr() {
+ resetMap(out)
+ } else {
+ out.Set(reflect.Zero(out.Type()))
+ }
+ return true
+ }
+ if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() {
+ // We've resolved to exactly the type we want, so use that.
+ out.Set(resolvedv)
+ return true
+ }
+ // Perhaps we can use the value as a TextUnmarshaler to
+ // set its value.
+ if out.CanAddr() {
+ u, ok := out.Addr().Interface().(encoding.TextUnmarshaler)
+ if ok {
+ var text []byte
+ if tag == yaml_BINARY_TAG {
+ text = []byte(resolved.(string))
+ } else {
+ // We let any value be unmarshaled into TextUnmarshaler.
+ // That might be more lax than we'd like, but the
+ // TextUnmarshaler itself should bowl out any dubious values.
+ text = []byte(n.value)
+ }
+ err := u.UnmarshalText(text)
+ if err != nil {
+ fail(err)
+ }
+ return true
+ }
+ }
+ switch out.Kind() {
+ case reflect.String:
+ if tag == yaml_BINARY_TAG {
+ out.SetString(resolved.(string))
+ return true
+ }
+ if resolved != nil {
+ out.SetString(n.value)
+ return true
+ }
+ case reflect.Interface:
+ if resolved == nil {
+ out.Set(reflect.Zero(out.Type()))
+ } else if tag == yaml_TIMESTAMP_TAG {
+ // It looks like a timestamp but for backward compatibility
+ // reasons we set it as a string, so that code that unmarshals
+ // timestamp-like values into interface{} will continue to
+ // see a string and not a time.Time.
+ // TODO(v3) Drop this.
+ out.Set(reflect.ValueOf(n.value))
+ } else {
+ out.Set(reflect.ValueOf(resolved))
+ }
+ return true
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ switch resolved := resolved.(type) {
+ case int:
+ if !out.OverflowInt(int64(resolved)) {
+ out.SetInt(int64(resolved))
+ return true
+ }
+ case int64:
+ if !out.OverflowInt(resolved) {
+ out.SetInt(resolved)
+ return true
+ }
+ case uint64:
+ if resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {
+ out.SetInt(int64(resolved))
+ return true
+ }
+ case float64:
+ if resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {
+ out.SetInt(int64(resolved))
+ return true
+ }
+ case string:
+ if out.Type() == durationType {
+ d, err := time.ParseDuration(resolved)
+ if err == nil {
+ out.SetInt(int64(d))
+ return true
+ }
+ }
+ }
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ switch resolved := resolved.(type) {
+ case int:
+ if resolved >= 0 && !out.OverflowUint(uint64(resolved)) {
+ out.SetUint(uint64(resolved))
+ return true
+ }
+ case int64:
+ if resolved >= 0 && !out.OverflowUint(uint64(resolved)) {
+ out.SetUint(uint64(resolved))
+ return true
+ }
+ case uint64:
+ if !out.OverflowUint(uint64(resolved)) {
+ out.SetUint(uint64(resolved))
+ return true
+ }
+ case float64:
+ if resolved <= math.MaxUint64 && !out.OverflowUint(uint64(resolved)) {
+ out.SetUint(uint64(resolved))
+ return true
+ }
+ }
+ case reflect.Bool:
+ switch resolved := resolved.(type) {
+ case bool:
+ out.SetBool(resolved)
+ return true
+ }
+ case reflect.Float32, reflect.Float64:
+ switch resolved := resolved.(type) {
+ case int:
+ out.SetFloat(float64(resolved))
+ return true
+ case int64:
+ out.SetFloat(float64(resolved))
+ return true
+ case uint64:
+ out.SetFloat(float64(resolved))
+ return true
+ case float64:
+ out.SetFloat(resolved)
+ return true
+ }
+ case reflect.Struct:
+ if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() {
+ out.Set(resolvedv)
+ return true
+ }
+ case reflect.Ptr:
+ if out.Type().Elem() == reflect.TypeOf(resolved) {
+ // TODO DOes this make sense? When is out a Ptr except when decoding a nil value?
+ elem := reflect.New(out.Type().Elem())
+ elem.Elem().Set(reflect.ValueOf(resolved))
+ out.Set(elem)
+ return true
+ }
+ }
+ d.terror(n, tag, out)
+ return false
+}
+
+func settableValueOf(i interface{}) reflect.Value {
+ v := reflect.ValueOf(i)
+ sv := reflect.New(v.Type()).Elem()
+ sv.Set(v)
+ return sv
+}
+
+func (d *decoder) sequence(n *node, out reflect.Value) (good bool) {
+ l := len(n.children)
+
+ var iface reflect.Value
+ switch out.Kind() {
+ case reflect.Slice:
+ out.Set(reflect.MakeSlice(out.Type(), l, l))
+ case reflect.Array:
+ if l != out.Len() {
+ failf("invalid array: want %d elements but got %d", out.Len(), l)
+ }
+ case reflect.Interface:
+ // No type hints. Will have to use a generic sequence.
+ iface = out
+ out = settableValueOf(make([]interface{}, l))
+ default:
+ d.terror(n, yaml_SEQ_TAG, out)
+ return false
+ }
+ et := out.Type().Elem()
+
+ j := 0
+ for i := 0; i < l; i++ {
+ e := reflect.New(et).Elem()
+ if ok := d.unmarshal(n.children[i], e); ok {
+ out.Index(j).Set(e)
+ j++
+ }
+ }
+ if out.Kind() != reflect.Array {
+ out.Set(out.Slice(0, j))
+ }
+ if iface.IsValid() {
+ iface.Set(out)
+ }
+ return true
+}
+
+func (d *decoder) mapping(n *node, out reflect.Value) (good bool) {
+ switch out.Kind() {
+ case reflect.Struct:
+ return d.mappingStruct(n, out)
+ case reflect.Slice:
+ return d.mappingSlice(n, out)
+ case reflect.Map:
+ // okay
+ case reflect.Interface:
+ if d.mapType.Kind() == reflect.Map {
+ iface := out
+ out = reflect.MakeMap(d.mapType)
+ iface.Set(out)
+ } else {
+ slicev := reflect.New(d.mapType).Elem()
+ if !d.mappingSlice(n, slicev) {
+ return false
+ }
+ out.Set(slicev)
+ return true
+ }
+ default:
+ d.terror(n, yaml_MAP_TAG, out)
+ return false
+ }
+ outt := out.Type()
+ kt := outt.Key()
+ et := outt.Elem()
+
+ mapType := d.mapType
+ if outt.Key() == ifaceType && outt.Elem() == ifaceType {
+ d.mapType = outt
+ }
+
+ if out.IsNil() {
+ out.Set(reflect.MakeMap(outt))
+ }
+ l := len(n.children)
+ for i := 0; i < l; i += 2 {
+ if isMerge(n.children[i]) {
+ d.merge(n.children[i+1], out)
+ continue
+ }
+ k := reflect.New(kt).Elem()
+ if d.unmarshal(n.children[i], k) {
+ kkind := k.Kind()
+ if kkind == reflect.Interface {
+ kkind = k.Elem().Kind()
+ }
+ if kkind == reflect.Map || kkind == reflect.Slice {
+ failf("invalid map key: %#v", k.Interface())
+ }
+ e := reflect.New(et).Elem()
+ if d.unmarshal(n.children[i+1], e) {
+ d.setMapIndex(n.children[i+1], out, k, e)
+ }
+ }
+ }
+ d.mapType = mapType
+ return true
+}
+
+func (d *decoder) setMapIndex(n *node, out, k, v reflect.Value) {
+ if d.strict && out.MapIndex(k) != zeroValue {
+ d.terrors = append(d.terrors, fmt.Sprintf("line %d: key %#v already set in map", n.line+1, k.Interface()))
+ return
+ }
+ out.SetMapIndex(k, v)
+}
+
+func (d *decoder) mappingSlice(n *node, out reflect.Value) (good bool) {
+ outt := out.Type()
+ if outt.Elem() != mapItemType {
+ d.terror(n, yaml_MAP_TAG, out)
+ return false
+ }
+
+ mapType := d.mapType
+ d.mapType = outt
+
+ var slice []MapItem
+ var l = len(n.children)
+ for i := 0; i < l; i += 2 {
+ if isMerge(n.children[i]) {
+ d.merge(n.children[i+1], out)
+ continue
+ }
+ item := MapItem{}
+ k := reflect.ValueOf(&item.Key).Elem()
+ if d.unmarshal(n.children[i], k) {
+ v := reflect.ValueOf(&item.Value).Elem()
+ if d.unmarshal(n.children[i+1], v) {
+ slice = append(slice, item)
+ }
+ }
+ }
+ out.Set(reflect.ValueOf(slice))
+ d.mapType = mapType
+ return true
+}
+
+func (d *decoder) mappingStruct(n *node, out reflect.Value) (good bool) {
+ sinfo, err := getStructInfo(out.Type())
+ if err != nil {
+ panic(err)
+ }
+ name := settableValueOf("")
+ l := len(n.children)
+
+ var inlineMap reflect.Value
+ var elemType reflect.Type
+ if sinfo.InlineMap != -1 {
+ inlineMap = out.Field(sinfo.InlineMap)
+ inlineMap.Set(reflect.New(inlineMap.Type()).Elem())
+ elemType = inlineMap.Type().Elem()
+ }
+
+ var doneFields []bool
+ if d.strict {
+ doneFields = make([]bool, len(sinfo.FieldsList))
+ }
+ for i := 0; i < l; i += 2 {
+ ni := n.children[i]
+ if isMerge(ni) {
+ d.merge(n.children[i+1], out)
+ continue
+ }
+ if !d.unmarshal(ni, name) {
+ continue
+ }
+ if info, ok := sinfo.FieldsMap[name.String()]; ok {
+ if d.strict {
+ if doneFields[info.Id] {
+ d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s already set in type %s", ni.line+1, name.String(), out.Type()))
+ continue
+ }
+ doneFields[info.Id] = true
+ }
+ var field reflect.Value
+ if info.Inline == nil {
+ field = out.Field(info.Num)
+ } else {
+ field = out.FieldByIndex(info.Inline)
+ }
+ d.unmarshal(n.children[i+1], field)
+ } else if sinfo.InlineMap != -1 {
+ if inlineMap.IsNil() {
+ inlineMap.Set(reflect.MakeMap(inlineMap.Type()))
+ }
+ value := reflect.New(elemType).Elem()
+ d.unmarshal(n.children[i+1], value)
+ d.setMapIndex(n.children[i+1], inlineMap, name, value)
+ } else if d.strict {
+ d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s not found in type %s", ni.line+1, name.String(), out.Type()))
+ }
+ }
+ return true
+}
+
+func failWantMap() {
+ failf("map merge requires map or sequence of maps as the value")
+}
+
+func (d *decoder) merge(n *node, out reflect.Value) {
+ switch n.kind {
+ case mappingNode:
+ d.unmarshal(n, out)
+ case aliasNode:
+ if n.alias != nil && n.alias.kind != mappingNode {
+ failWantMap()
+ }
+ d.unmarshal(n, out)
+ case sequenceNode:
+ // Step backwards as earlier nodes take precedence.
+ for i := len(n.children) - 1; i >= 0; i-- {
+ ni := n.children[i]
+ if ni.kind == aliasNode {
+ if ni.alias != nil && ni.alias.kind != mappingNode {
+ failWantMap()
+ }
+ } else if ni.kind != mappingNode {
+ failWantMap()
+ }
+ d.unmarshal(ni, out)
+ }
+ default:
+ failWantMap()
+ }
+}
+
+func isMerge(n *node) bool {
+ return n.kind == scalarNode && n.value == "<<" && (n.implicit == true || n.tag == yaml_MERGE_TAG)
+}
diff --git a/vendor/sigs.k8s.io/yaml/goyaml.v2/emitterc.go b/vendor/sigs.k8s.io/yaml/goyaml.v2/emitterc.go
new file mode 100644
index 0000000000..a1c2cc5262
--- /dev/null
+++ b/vendor/sigs.k8s.io/yaml/goyaml.v2/emitterc.go
@@ -0,0 +1,1685 @@
+package yaml
+
+import (
+ "bytes"
+ "fmt"
+)
+
+// Flush the buffer if needed.
+func flush(emitter *yaml_emitter_t) bool {
+ if emitter.buffer_pos+5 >= len(emitter.buffer) {
+ return yaml_emitter_flush(emitter)
+ }
+ return true
+}
+
+// Put a character to the output buffer.
+func put(emitter *yaml_emitter_t, value byte) bool {
+ if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
+ return false
+ }
+ emitter.buffer[emitter.buffer_pos] = value
+ emitter.buffer_pos++
+ emitter.column++
+ return true
+}
+
+// Put a line break to the output buffer.
+func put_break(emitter *yaml_emitter_t) bool {
+ if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
+ return false
+ }
+ switch emitter.line_break {
+ case yaml_CR_BREAK:
+ emitter.buffer[emitter.buffer_pos] = '\r'
+ emitter.buffer_pos += 1
+ case yaml_LN_BREAK:
+ emitter.buffer[emitter.buffer_pos] = '\n'
+ emitter.buffer_pos += 1
+ case yaml_CRLN_BREAK:
+ emitter.buffer[emitter.buffer_pos+0] = '\r'
+ emitter.buffer[emitter.buffer_pos+1] = '\n'
+ emitter.buffer_pos += 2
+ default:
+ panic("unknown line break setting")
+ }
+ emitter.column = 0
+ emitter.line++
+ return true
+}
+
+// Copy a character from a string into buffer.
+func write(emitter *yaml_emitter_t, s []byte, i *int) bool {
+ if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
+ return false
+ }
+ p := emitter.buffer_pos
+ w := width(s[*i])
+ switch w {
+ case 4:
+ emitter.buffer[p+3] = s[*i+3]
+ fallthrough
+ case 3:
+ emitter.buffer[p+2] = s[*i+2]
+ fallthrough
+ case 2:
+ emitter.buffer[p+1] = s[*i+1]
+ fallthrough
+ case 1:
+ emitter.buffer[p+0] = s[*i+0]
+ default:
+ panic("unknown character width")
+ }
+ emitter.column++
+ emitter.buffer_pos += w
+ *i += w
+ return true
+}
+
+// Write a whole string into buffer.
+func write_all(emitter *yaml_emitter_t, s []byte) bool {
+ for i := 0; i < len(s); {
+ if !write(emitter, s, &i) {
+ return false
+ }
+ }
+ return true
+}
+
+// Copy a line break character from a string into buffer.
+func write_break(emitter *yaml_emitter_t, s []byte, i *int) bool {
+ if s[*i] == '\n' {
+ if !put_break(emitter) {
+ return false
+ }
+ *i++
+ } else {
+ if !write(emitter, s, i) {
+ return false
+ }
+ emitter.column = 0
+ emitter.line++
+ }
+ return true
+}
+
+// Set an emitter error and return false.
+func yaml_emitter_set_emitter_error(emitter *yaml_emitter_t, problem string) bool {
+ emitter.error = yaml_EMITTER_ERROR
+ emitter.problem = problem
+ return false
+}
+
+// Emit an event.
+func yaml_emitter_emit(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ emitter.events = append(emitter.events, *event)
+ for !yaml_emitter_need_more_events(emitter) {
+ event := &emitter.events[emitter.events_head]
+ if !yaml_emitter_analyze_event(emitter, event) {
+ return false
+ }
+ if !yaml_emitter_state_machine(emitter, event) {
+ return false
+ }
+ yaml_event_delete(event)
+ emitter.events_head++
+ }
+ return true
+}
+
+// Check if we need to accumulate more events before emitting.
+//
+// We accumulate extra
+// - 1 event for DOCUMENT-START
+// - 2 events for SEQUENCE-START
+// - 3 events for MAPPING-START
+//
+func yaml_emitter_need_more_events(emitter *yaml_emitter_t) bool {
+ if emitter.events_head == len(emitter.events) {
+ return true
+ }
+ var accumulate int
+ switch emitter.events[emitter.events_head].typ {
+ case yaml_DOCUMENT_START_EVENT:
+ accumulate = 1
+ break
+ case yaml_SEQUENCE_START_EVENT:
+ accumulate = 2
+ break
+ case yaml_MAPPING_START_EVENT:
+ accumulate = 3
+ break
+ default:
+ return false
+ }
+ if len(emitter.events)-emitter.events_head > accumulate {
+ return false
+ }
+ var level int
+ for i := emitter.events_head; i < len(emitter.events); i++ {
+ switch emitter.events[i].typ {
+ case yaml_STREAM_START_EVENT, yaml_DOCUMENT_START_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT:
+ level++
+ case yaml_STREAM_END_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_END_EVENT, yaml_MAPPING_END_EVENT:
+ level--
+ }
+ if level == 0 {
+ return false
+ }
+ }
+ return true
+}
+
+// Append a directive to the directives stack.
+func yaml_emitter_append_tag_directive(emitter *yaml_emitter_t, value *yaml_tag_directive_t, allow_duplicates bool) bool {
+ for i := 0; i < len(emitter.tag_directives); i++ {
+ if bytes.Equal(value.handle, emitter.tag_directives[i].handle) {
+ if allow_duplicates {
+ return true
+ }
+ return yaml_emitter_set_emitter_error(emitter, "duplicate %TAG directive")
+ }
+ }
+
+ // [Go] Do we actually need to copy this given garbage collection
+ // and the lack of deallocating destructors?
+ tag_copy := yaml_tag_directive_t{
+ handle: make([]byte, len(value.handle)),
+ prefix: make([]byte, len(value.prefix)),
+ }
+ copy(tag_copy.handle, value.handle)
+ copy(tag_copy.prefix, value.prefix)
+ emitter.tag_directives = append(emitter.tag_directives, tag_copy)
+ return true
+}
+
+// Increase the indentation level.
+func yaml_emitter_increase_indent(emitter *yaml_emitter_t, flow, indentless bool) bool {
+ emitter.indents = append(emitter.indents, emitter.indent)
+ if emitter.indent < 0 {
+ if flow {
+ emitter.indent = emitter.best_indent
+ } else {
+ emitter.indent = 0
+ }
+ } else if !indentless {
+ emitter.indent += emitter.best_indent
+ }
+ return true
+}
+
+// State dispatcher.
+func yaml_emitter_state_machine(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ switch emitter.state {
+ default:
+ case yaml_EMIT_STREAM_START_STATE:
+ return yaml_emitter_emit_stream_start(emitter, event)
+
+ case yaml_EMIT_FIRST_DOCUMENT_START_STATE:
+ return yaml_emitter_emit_document_start(emitter, event, true)
+
+ case yaml_EMIT_DOCUMENT_START_STATE:
+ return yaml_emitter_emit_document_start(emitter, event, false)
+
+ case yaml_EMIT_DOCUMENT_CONTENT_STATE:
+ return yaml_emitter_emit_document_content(emitter, event)
+
+ case yaml_EMIT_DOCUMENT_END_STATE:
+ return yaml_emitter_emit_document_end(emitter, event)
+
+ case yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:
+ return yaml_emitter_emit_flow_sequence_item(emitter, event, true)
+
+ case yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE:
+ return yaml_emitter_emit_flow_sequence_item(emitter, event, false)
+
+ case yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:
+ return yaml_emitter_emit_flow_mapping_key(emitter, event, true)
+
+ case yaml_EMIT_FLOW_MAPPING_KEY_STATE:
+ return yaml_emitter_emit_flow_mapping_key(emitter, event, false)
+
+ case yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:
+ return yaml_emitter_emit_flow_mapping_value(emitter, event, true)
+
+ case yaml_EMIT_FLOW_MAPPING_VALUE_STATE:
+ return yaml_emitter_emit_flow_mapping_value(emitter, event, false)
+
+ case yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE:
+ return yaml_emitter_emit_block_sequence_item(emitter, event, true)
+
+ case yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE:
+ return yaml_emitter_emit_block_sequence_item(emitter, event, false)
+
+ case yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE:
+ return yaml_emitter_emit_block_mapping_key(emitter, event, true)
+
+ case yaml_EMIT_BLOCK_MAPPING_KEY_STATE:
+ return yaml_emitter_emit_block_mapping_key(emitter, event, false)
+
+ case yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE:
+ return yaml_emitter_emit_block_mapping_value(emitter, event, true)
+
+ case yaml_EMIT_BLOCK_MAPPING_VALUE_STATE:
+ return yaml_emitter_emit_block_mapping_value(emitter, event, false)
+
+ case yaml_EMIT_END_STATE:
+ return yaml_emitter_set_emitter_error(emitter, "expected nothing after STREAM-END")
+ }
+ panic("invalid emitter state")
+}
+
+// Expect STREAM-START.
+func yaml_emitter_emit_stream_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ if event.typ != yaml_STREAM_START_EVENT {
+ return yaml_emitter_set_emitter_error(emitter, "expected STREAM-START")
+ }
+ if emitter.encoding == yaml_ANY_ENCODING {
+ emitter.encoding = event.encoding
+ if emitter.encoding == yaml_ANY_ENCODING {
+ emitter.encoding = yaml_UTF8_ENCODING
+ }
+ }
+ if emitter.best_indent < 2 || emitter.best_indent > 9 {
+ emitter.best_indent = 2
+ }
+ if emitter.best_width >= 0 && emitter.best_width <= emitter.best_indent*2 {
+ emitter.best_width = 80
+ }
+ if emitter.best_width < 0 {
+ emitter.best_width = 1<<31 - 1
+ }
+ if emitter.line_break == yaml_ANY_BREAK {
+ emitter.line_break = yaml_LN_BREAK
+ }
+
+ emitter.indent = -1
+ emitter.line = 0
+ emitter.column = 0
+ emitter.whitespace = true
+ emitter.indention = true
+
+ if emitter.encoding != yaml_UTF8_ENCODING {
+ if !yaml_emitter_write_bom(emitter) {
+ return false
+ }
+ }
+ emitter.state = yaml_EMIT_FIRST_DOCUMENT_START_STATE
+ return true
+}
+
+// Expect DOCUMENT-START or STREAM-END.
+func yaml_emitter_emit_document_start(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
+
+ if event.typ == yaml_DOCUMENT_START_EVENT {
+
+ if event.version_directive != nil {
+ if !yaml_emitter_analyze_version_directive(emitter, event.version_directive) {
+ return false
+ }
+ }
+
+ for i := 0; i < len(event.tag_directives); i++ {
+ tag_directive := &event.tag_directives[i]
+ if !yaml_emitter_analyze_tag_directive(emitter, tag_directive) {
+ return false
+ }
+ if !yaml_emitter_append_tag_directive(emitter, tag_directive, false) {
+ return false
+ }
+ }
+
+ for i := 0; i < len(default_tag_directives); i++ {
+ tag_directive := &default_tag_directives[i]
+ if !yaml_emitter_append_tag_directive(emitter, tag_directive, true) {
+ return false
+ }
+ }
+
+ implicit := event.implicit
+ if !first || emitter.canonical {
+ implicit = false
+ }
+
+ if emitter.open_ended && (event.version_directive != nil || len(event.tag_directives) > 0) {
+ if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+
+ if event.version_directive != nil {
+ implicit = false
+ if !yaml_emitter_write_indicator(emitter, []byte("%YAML"), true, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte("1.1"), true, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+
+ if len(event.tag_directives) > 0 {
+ implicit = false
+ for i := 0; i < len(event.tag_directives); i++ {
+ tag_directive := &event.tag_directives[i]
+ if !yaml_emitter_write_indicator(emitter, []byte("%TAG"), true, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_tag_handle(emitter, tag_directive.handle) {
+ return false
+ }
+ if !yaml_emitter_write_tag_content(emitter, tag_directive.prefix, true) {
+ return false
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ }
+
+ if yaml_emitter_check_empty_document(emitter) {
+ implicit = false
+ }
+ if !implicit {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte("---"), true, false, false) {
+ return false
+ }
+ if emitter.canonical {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ }
+
+ emitter.state = yaml_EMIT_DOCUMENT_CONTENT_STATE
+ return true
+ }
+
+ if event.typ == yaml_STREAM_END_EVENT {
+ if emitter.open_ended {
+ if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ if !yaml_emitter_flush(emitter) {
+ return false
+ }
+ emitter.state = yaml_EMIT_END_STATE
+ return true
+ }
+
+ return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-START or STREAM-END")
+}
+
+// Expect the root node.
+func yaml_emitter_emit_document_content(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ emitter.states = append(emitter.states, yaml_EMIT_DOCUMENT_END_STATE)
+ return yaml_emitter_emit_node(emitter, event, true, false, false, false)
+}
+
+// Expect DOCUMENT-END.
+func yaml_emitter_emit_document_end(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ if event.typ != yaml_DOCUMENT_END_EVENT {
+ return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-END")
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ if !event.implicit {
+ // [Go] Allocate the slice elsewhere.
+ if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ if !yaml_emitter_flush(emitter) {
+ return false
+ }
+ emitter.state = yaml_EMIT_DOCUMENT_START_STATE
+ emitter.tag_directives = emitter.tag_directives[:0]
+ return true
+}
+
+// Expect a flow item node.
+func yaml_emitter_emit_flow_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
+ if first {
+ if !yaml_emitter_write_indicator(emitter, []byte{'['}, true, true, false) {
+ return false
+ }
+ if !yaml_emitter_increase_indent(emitter, true, false) {
+ return false
+ }
+ emitter.flow_level++
+ }
+
+ if event.typ == yaml_SEQUENCE_END_EVENT {
+ emitter.flow_level--
+ emitter.indent = emitter.indents[len(emitter.indents)-1]
+ emitter.indents = emitter.indents[:len(emitter.indents)-1]
+ if emitter.canonical && !first {
+ if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{']'}, false, false, false) {
+ return false
+ }
+ emitter.state = emitter.states[len(emitter.states)-1]
+ emitter.states = emitter.states[:len(emitter.states)-1]
+
+ return true
+ }
+
+ if !first {
+ if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
+ return false
+ }
+ }
+
+ if emitter.canonical || emitter.column > emitter.best_width {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE)
+ return yaml_emitter_emit_node(emitter, event, false, true, false, false)
+}
+
+// Expect a flow key node.
+func yaml_emitter_emit_flow_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
+ if first {
+ if !yaml_emitter_write_indicator(emitter, []byte{'{'}, true, true, false) {
+ return false
+ }
+ if !yaml_emitter_increase_indent(emitter, true, false) {
+ return false
+ }
+ emitter.flow_level++
+ }
+
+ if event.typ == yaml_MAPPING_END_EVENT {
+ emitter.flow_level--
+ emitter.indent = emitter.indents[len(emitter.indents)-1]
+ emitter.indents = emitter.indents[:len(emitter.indents)-1]
+ if emitter.canonical && !first {
+ if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{'}'}, false, false, false) {
+ return false
+ }
+ emitter.state = emitter.states[len(emitter.states)-1]
+ emitter.states = emitter.states[:len(emitter.states)-1]
+ return true
+ }
+
+ if !first {
+ if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
+ return false
+ }
+ }
+ if emitter.canonical || emitter.column > emitter.best_width {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+
+ if !emitter.canonical && yaml_emitter_check_simple_key(emitter) {
+ emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE)
+ return yaml_emitter_emit_node(emitter, event, false, false, true, true)
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, false) {
+ return false
+ }
+ emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_VALUE_STATE)
+ return yaml_emitter_emit_node(emitter, event, false, false, true, false)
+}
+
+// Expect a flow value node.
+func yaml_emitter_emit_flow_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool {
+ if simple {
+ if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) {
+ return false
+ }
+ } else {
+ if emitter.canonical || emitter.column > emitter.best_width {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, false) {
+ return false
+ }
+ }
+ emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_KEY_STATE)
+ return yaml_emitter_emit_node(emitter, event, false, false, true, false)
+}
+
+// Expect a block item node.
+func yaml_emitter_emit_block_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
+ if first {
+ if !yaml_emitter_increase_indent(emitter, false, emitter.mapping_context && !emitter.indention) {
+ return false
+ }
+ }
+ if event.typ == yaml_SEQUENCE_END_EVENT {
+ emitter.indent = emitter.indents[len(emitter.indents)-1]
+ emitter.indents = emitter.indents[:len(emitter.indents)-1]
+ emitter.state = emitter.states[len(emitter.states)-1]
+ emitter.states = emitter.states[:len(emitter.states)-1]
+ return true
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{'-'}, true, false, true) {
+ return false
+ }
+ emitter.states = append(emitter.states, yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE)
+ return yaml_emitter_emit_node(emitter, event, false, true, false, false)
+}
+
+// Expect a block key node.
+func yaml_emitter_emit_block_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
+ if first {
+ if !yaml_emitter_increase_indent(emitter, false, false) {
+ return false
+ }
+ }
+ if event.typ == yaml_MAPPING_END_EVENT {
+ emitter.indent = emitter.indents[len(emitter.indents)-1]
+ emitter.indents = emitter.indents[:len(emitter.indents)-1]
+ emitter.state = emitter.states[len(emitter.states)-1]
+ emitter.states = emitter.states[:len(emitter.states)-1]
+ return true
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ if yaml_emitter_check_simple_key(emitter) {
+ emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE)
+ return yaml_emitter_emit_node(emitter, event, false, false, true, true)
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, true) {
+ return false
+ }
+ emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_VALUE_STATE)
+ return yaml_emitter_emit_node(emitter, event, false, false, true, false)
+}
+
+// Expect a block value node.
+func yaml_emitter_emit_block_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool {
+ if simple {
+ if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) {
+ return false
+ }
+ } else {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, true) {
+ return false
+ }
+ }
+ emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_KEY_STATE)
+ return yaml_emitter_emit_node(emitter, event, false, false, true, false)
+}
+
+// Expect a node.
+func yaml_emitter_emit_node(emitter *yaml_emitter_t, event *yaml_event_t,
+ root bool, sequence bool, mapping bool, simple_key bool) bool {
+
+ emitter.root_context = root
+ emitter.sequence_context = sequence
+ emitter.mapping_context = mapping
+ emitter.simple_key_context = simple_key
+
+ switch event.typ {
+ case yaml_ALIAS_EVENT:
+ return yaml_emitter_emit_alias(emitter, event)
+ case yaml_SCALAR_EVENT:
+ return yaml_emitter_emit_scalar(emitter, event)
+ case yaml_SEQUENCE_START_EVENT:
+ return yaml_emitter_emit_sequence_start(emitter, event)
+ case yaml_MAPPING_START_EVENT:
+ return yaml_emitter_emit_mapping_start(emitter, event)
+ default:
+ return yaml_emitter_set_emitter_error(emitter,
+ fmt.Sprintf("expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS, but got %v", event.typ))
+ }
+}
+
+// Expect ALIAS.
+func yaml_emitter_emit_alias(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ if !yaml_emitter_process_anchor(emitter) {
+ return false
+ }
+ emitter.state = emitter.states[len(emitter.states)-1]
+ emitter.states = emitter.states[:len(emitter.states)-1]
+ return true
+}
+
+// Expect SCALAR.
+func yaml_emitter_emit_scalar(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ if !yaml_emitter_select_scalar_style(emitter, event) {
+ return false
+ }
+ if !yaml_emitter_process_anchor(emitter) {
+ return false
+ }
+ if !yaml_emitter_process_tag(emitter) {
+ return false
+ }
+ if !yaml_emitter_increase_indent(emitter, true, false) {
+ return false
+ }
+ if !yaml_emitter_process_scalar(emitter) {
+ return false
+ }
+ emitter.indent = emitter.indents[len(emitter.indents)-1]
+ emitter.indents = emitter.indents[:len(emitter.indents)-1]
+ emitter.state = emitter.states[len(emitter.states)-1]
+ emitter.states = emitter.states[:len(emitter.states)-1]
+ return true
+}
+
+// Expect SEQUENCE-START.
+func yaml_emitter_emit_sequence_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ if !yaml_emitter_process_anchor(emitter) {
+ return false
+ }
+ if !yaml_emitter_process_tag(emitter) {
+ return false
+ }
+ if emitter.flow_level > 0 || emitter.canonical || event.sequence_style() == yaml_FLOW_SEQUENCE_STYLE ||
+ yaml_emitter_check_empty_sequence(emitter) {
+ emitter.state = yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE
+ } else {
+ emitter.state = yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE
+ }
+ return true
+}
+
+// Expect MAPPING-START.
+func yaml_emitter_emit_mapping_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ if !yaml_emitter_process_anchor(emitter) {
+ return false
+ }
+ if !yaml_emitter_process_tag(emitter) {
+ return false
+ }
+ if emitter.flow_level > 0 || emitter.canonical || event.mapping_style() == yaml_FLOW_MAPPING_STYLE ||
+ yaml_emitter_check_empty_mapping(emitter) {
+ emitter.state = yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE
+ } else {
+ emitter.state = yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE
+ }
+ return true
+}
+
+// Check if the document content is an empty scalar.
+func yaml_emitter_check_empty_document(emitter *yaml_emitter_t) bool {
+ return false // [Go] Huh?
+}
+
+// Check if the next events represent an empty sequence.
+func yaml_emitter_check_empty_sequence(emitter *yaml_emitter_t) bool {
+ if len(emitter.events)-emitter.events_head < 2 {
+ return false
+ }
+ return emitter.events[emitter.events_head].typ == yaml_SEQUENCE_START_EVENT &&
+ emitter.events[emitter.events_head+1].typ == yaml_SEQUENCE_END_EVENT
+}
+
+// Check if the next events represent an empty mapping.
+func yaml_emitter_check_empty_mapping(emitter *yaml_emitter_t) bool {
+ if len(emitter.events)-emitter.events_head < 2 {
+ return false
+ }
+ return emitter.events[emitter.events_head].typ == yaml_MAPPING_START_EVENT &&
+ emitter.events[emitter.events_head+1].typ == yaml_MAPPING_END_EVENT
+}
+
+// Check if the next node can be expressed as a simple key.
+func yaml_emitter_check_simple_key(emitter *yaml_emitter_t) bool {
+ length := 0
+ switch emitter.events[emitter.events_head].typ {
+ case yaml_ALIAS_EVENT:
+ length += len(emitter.anchor_data.anchor)
+ case yaml_SCALAR_EVENT:
+ if emitter.scalar_data.multiline {
+ return false
+ }
+ length += len(emitter.anchor_data.anchor) +
+ len(emitter.tag_data.handle) +
+ len(emitter.tag_data.suffix) +
+ len(emitter.scalar_data.value)
+ case yaml_SEQUENCE_START_EVENT:
+ if !yaml_emitter_check_empty_sequence(emitter) {
+ return false
+ }
+ length += len(emitter.anchor_data.anchor) +
+ len(emitter.tag_data.handle) +
+ len(emitter.tag_data.suffix)
+ case yaml_MAPPING_START_EVENT:
+ if !yaml_emitter_check_empty_mapping(emitter) {
+ return false
+ }
+ length += len(emitter.anchor_data.anchor) +
+ len(emitter.tag_data.handle) +
+ len(emitter.tag_data.suffix)
+ default:
+ return false
+ }
+ return length <= 128
+}
+
+// Determine an acceptable scalar style.
+func yaml_emitter_select_scalar_style(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+
+ no_tag := len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0
+ if no_tag && !event.implicit && !event.quoted_implicit {
+ return yaml_emitter_set_emitter_error(emitter, "neither tag nor implicit flags are specified")
+ }
+
+ style := event.scalar_style()
+ if style == yaml_ANY_SCALAR_STYLE {
+ style = yaml_PLAIN_SCALAR_STYLE
+ }
+ if emitter.canonical {
+ style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
+ }
+ if emitter.simple_key_context && emitter.scalar_data.multiline {
+ style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
+ }
+
+ if style == yaml_PLAIN_SCALAR_STYLE {
+ if emitter.flow_level > 0 && !emitter.scalar_data.flow_plain_allowed ||
+ emitter.flow_level == 0 && !emitter.scalar_data.block_plain_allowed {
+ style = yaml_SINGLE_QUOTED_SCALAR_STYLE
+ }
+ if len(emitter.scalar_data.value) == 0 && (emitter.flow_level > 0 || emitter.simple_key_context) {
+ style = yaml_SINGLE_QUOTED_SCALAR_STYLE
+ }
+ if no_tag && !event.implicit {
+ style = yaml_SINGLE_QUOTED_SCALAR_STYLE
+ }
+ }
+ if style == yaml_SINGLE_QUOTED_SCALAR_STYLE {
+ if !emitter.scalar_data.single_quoted_allowed {
+ style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
+ }
+ }
+ if style == yaml_LITERAL_SCALAR_STYLE || style == yaml_FOLDED_SCALAR_STYLE {
+ if !emitter.scalar_data.block_allowed || emitter.flow_level > 0 || emitter.simple_key_context {
+ style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
+ }
+ }
+
+ if no_tag && !event.quoted_implicit && style != yaml_PLAIN_SCALAR_STYLE {
+ emitter.tag_data.handle = []byte{'!'}
+ }
+ emitter.scalar_data.style = style
+ return true
+}
+
+// Write an anchor.
+func yaml_emitter_process_anchor(emitter *yaml_emitter_t) bool {
+ if emitter.anchor_data.anchor == nil {
+ return true
+ }
+ c := []byte{'&'}
+ if emitter.anchor_data.alias {
+ c[0] = '*'
+ }
+ if !yaml_emitter_write_indicator(emitter, c, true, false, false) {
+ return false
+ }
+ return yaml_emitter_write_anchor(emitter, emitter.anchor_data.anchor)
+}
+
+// Write a tag.
+func yaml_emitter_process_tag(emitter *yaml_emitter_t) bool {
+ if len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0 {
+ return true
+ }
+ if len(emitter.tag_data.handle) > 0 {
+ if !yaml_emitter_write_tag_handle(emitter, emitter.tag_data.handle) {
+ return false
+ }
+ if len(emitter.tag_data.suffix) > 0 {
+ if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) {
+ return false
+ }
+ }
+ } else {
+ // [Go] Allocate these slices elsewhere.
+ if !yaml_emitter_write_indicator(emitter, []byte("!<"), true, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) {
+ return false
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{'>'}, false, false, false) {
+ return false
+ }
+ }
+ return true
+}
+
+// Write a scalar.
+func yaml_emitter_process_scalar(emitter *yaml_emitter_t) bool {
+ switch emitter.scalar_data.style {
+ case yaml_PLAIN_SCALAR_STYLE:
+ return yaml_emitter_write_plain_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
+
+ case yaml_SINGLE_QUOTED_SCALAR_STYLE:
+ return yaml_emitter_write_single_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
+
+ case yaml_DOUBLE_QUOTED_SCALAR_STYLE:
+ return yaml_emitter_write_double_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
+
+ case yaml_LITERAL_SCALAR_STYLE:
+ return yaml_emitter_write_literal_scalar(emitter, emitter.scalar_data.value)
+
+ case yaml_FOLDED_SCALAR_STYLE:
+ return yaml_emitter_write_folded_scalar(emitter, emitter.scalar_data.value)
+ }
+ panic("unknown scalar style")
+}
+
+// Check if a %YAML directive is valid.
+func yaml_emitter_analyze_version_directive(emitter *yaml_emitter_t, version_directive *yaml_version_directive_t) bool {
+ if version_directive.major != 1 || version_directive.minor != 1 {
+ return yaml_emitter_set_emitter_error(emitter, "incompatible %YAML directive")
+ }
+ return true
+}
+
+// Check if a %TAG directive is valid.
+func yaml_emitter_analyze_tag_directive(emitter *yaml_emitter_t, tag_directive *yaml_tag_directive_t) bool {
+ handle := tag_directive.handle
+ prefix := tag_directive.prefix
+ if len(handle) == 0 {
+ return yaml_emitter_set_emitter_error(emitter, "tag handle must not be empty")
+ }
+ if handle[0] != '!' {
+ return yaml_emitter_set_emitter_error(emitter, "tag handle must start with '!'")
+ }
+ if handle[len(handle)-1] != '!' {
+ return yaml_emitter_set_emitter_error(emitter, "tag handle must end with '!'")
+ }
+ for i := 1; i < len(handle)-1; i += width(handle[i]) {
+ if !is_alpha(handle, i) {
+ return yaml_emitter_set_emitter_error(emitter, "tag handle must contain alphanumerical characters only")
+ }
+ }
+ if len(prefix) == 0 {
+ return yaml_emitter_set_emitter_error(emitter, "tag prefix must not be empty")
+ }
+ return true
+}
+
+// Check if an anchor is valid.
+func yaml_emitter_analyze_anchor(emitter *yaml_emitter_t, anchor []byte, alias bool) bool {
+ if len(anchor) == 0 {
+ problem := "anchor value must not be empty"
+ if alias {
+ problem = "alias value must not be empty"
+ }
+ return yaml_emitter_set_emitter_error(emitter, problem)
+ }
+ for i := 0; i < len(anchor); i += width(anchor[i]) {
+ if !is_alpha(anchor, i) {
+ problem := "anchor value must contain alphanumerical characters only"
+ if alias {
+ problem = "alias value must contain alphanumerical characters only"
+ }
+ return yaml_emitter_set_emitter_error(emitter, problem)
+ }
+ }
+ emitter.anchor_data.anchor = anchor
+ emitter.anchor_data.alias = alias
+ return true
+}
+
+// Check if a tag is valid.
+func yaml_emitter_analyze_tag(emitter *yaml_emitter_t, tag []byte) bool {
+ if len(tag) == 0 {
+ return yaml_emitter_set_emitter_error(emitter, "tag value must not be empty")
+ }
+ for i := 0; i < len(emitter.tag_directives); i++ {
+ tag_directive := &emitter.tag_directives[i]
+ if bytes.HasPrefix(tag, tag_directive.prefix) {
+ emitter.tag_data.handle = tag_directive.handle
+ emitter.tag_data.suffix = tag[len(tag_directive.prefix):]
+ return true
+ }
+ }
+ emitter.tag_data.suffix = tag
+ return true
+}
+
+// Check if a scalar is valid.
+func yaml_emitter_analyze_scalar(emitter *yaml_emitter_t, value []byte) bool {
+ var (
+ block_indicators = false
+ flow_indicators = false
+ line_breaks = false
+ special_characters = false
+
+ leading_space = false
+ leading_break = false
+ trailing_space = false
+ trailing_break = false
+ break_space = false
+ space_break = false
+
+ preceded_by_whitespace = false
+ followed_by_whitespace = false
+ previous_space = false
+ previous_break = false
+ )
+
+ emitter.scalar_data.value = value
+
+ if len(value) == 0 {
+ emitter.scalar_data.multiline = false
+ emitter.scalar_data.flow_plain_allowed = false
+ emitter.scalar_data.block_plain_allowed = true
+ emitter.scalar_data.single_quoted_allowed = true
+ emitter.scalar_data.block_allowed = false
+ return true
+ }
+
+ if len(value) >= 3 && ((value[0] == '-' && value[1] == '-' && value[2] == '-') || (value[0] == '.' && value[1] == '.' && value[2] == '.')) {
+ block_indicators = true
+ flow_indicators = true
+ }
+
+ preceded_by_whitespace = true
+ for i, w := 0, 0; i < len(value); i += w {
+ w = width(value[i])
+ followed_by_whitespace = i+w >= len(value) || is_blank(value, i+w)
+
+ if i == 0 {
+ switch value[i] {
+ case '#', ',', '[', ']', '{', '}', '&', '*', '!', '|', '>', '\'', '"', '%', '@', '`':
+ flow_indicators = true
+ block_indicators = true
+ case '?', ':':
+ flow_indicators = true
+ if followed_by_whitespace {
+ block_indicators = true
+ }
+ case '-':
+ if followed_by_whitespace {
+ flow_indicators = true
+ block_indicators = true
+ }
+ }
+ } else {
+ switch value[i] {
+ case ',', '?', '[', ']', '{', '}':
+ flow_indicators = true
+ case ':':
+ flow_indicators = true
+ if followed_by_whitespace {
+ block_indicators = true
+ }
+ case '#':
+ if preceded_by_whitespace {
+ flow_indicators = true
+ block_indicators = true
+ }
+ }
+ }
+
+ if !is_printable(value, i) || !is_ascii(value, i) && !emitter.unicode {
+ special_characters = true
+ }
+ if is_space(value, i) {
+ if i == 0 {
+ leading_space = true
+ }
+ if i+width(value[i]) == len(value) {
+ trailing_space = true
+ }
+ if previous_break {
+ break_space = true
+ }
+ previous_space = true
+ previous_break = false
+ } else if is_break(value, i) {
+ line_breaks = true
+ if i == 0 {
+ leading_break = true
+ }
+ if i+width(value[i]) == len(value) {
+ trailing_break = true
+ }
+ if previous_space {
+ space_break = true
+ }
+ previous_space = false
+ previous_break = true
+ } else {
+ previous_space = false
+ previous_break = false
+ }
+
+ // [Go]: Why 'z'? Couldn't be the end of the string as that's the loop condition.
+ preceded_by_whitespace = is_blankz(value, i)
+ }
+
+ emitter.scalar_data.multiline = line_breaks
+ emitter.scalar_data.flow_plain_allowed = true
+ emitter.scalar_data.block_plain_allowed = true
+ emitter.scalar_data.single_quoted_allowed = true
+ emitter.scalar_data.block_allowed = true
+
+ if leading_space || leading_break || trailing_space || trailing_break {
+ emitter.scalar_data.flow_plain_allowed = false
+ emitter.scalar_data.block_plain_allowed = false
+ }
+ if trailing_space {
+ emitter.scalar_data.block_allowed = false
+ }
+ if break_space {
+ emitter.scalar_data.flow_plain_allowed = false
+ emitter.scalar_data.block_plain_allowed = false
+ emitter.scalar_data.single_quoted_allowed = false
+ }
+ if space_break || special_characters {
+ emitter.scalar_data.flow_plain_allowed = false
+ emitter.scalar_data.block_plain_allowed = false
+ emitter.scalar_data.single_quoted_allowed = false
+ emitter.scalar_data.block_allowed = false
+ }
+ if line_breaks {
+ emitter.scalar_data.flow_plain_allowed = false
+ emitter.scalar_data.block_plain_allowed = false
+ }
+ if flow_indicators {
+ emitter.scalar_data.flow_plain_allowed = false
+ }
+ if block_indicators {
+ emitter.scalar_data.block_plain_allowed = false
+ }
+ return true
+}
+
+// Check if the event data is valid.
+func yaml_emitter_analyze_event(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+
+ emitter.anchor_data.anchor = nil
+ emitter.tag_data.handle = nil
+ emitter.tag_data.suffix = nil
+ emitter.scalar_data.value = nil
+
+ switch event.typ {
+ case yaml_ALIAS_EVENT:
+ if !yaml_emitter_analyze_anchor(emitter, event.anchor, true) {
+ return false
+ }
+
+ case yaml_SCALAR_EVENT:
+ if len(event.anchor) > 0 {
+ if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
+ return false
+ }
+ }
+ if len(event.tag) > 0 && (emitter.canonical || (!event.implicit && !event.quoted_implicit)) {
+ if !yaml_emitter_analyze_tag(emitter, event.tag) {
+ return false
+ }
+ }
+ if !yaml_emitter_analyze_scalar(emitter, event.value) {
+ return false
+ }
+
+ case yaml_SEQUENCE_START_EVENT:
+ if len(event.anchor) > 0 {
+ if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
+ return false
+ }
+ }
+ if len(event.tag) > 0 && (emitter.canonical || !event.implicit) {
+ if !yaml_emitter_analyze_tag(emitter, event.tag) {
+ return false
+ }
+ }
+
+ case yaml_MAPPING_START_EVENT:
+ if len(event.anchor) > 0 {
+ if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
+ return false
+ }
+ }
+ if len(event.tag) > 0 && (emitter.canonical || !event.implicit) {
+ if !yaml_emitter_analyze_tag(emitter, event.tag) {
+ return false
+ }
+ }
+ }
+ return true
+}
+
+// Write the BOM character.
+func yaml_emitter_write_bom(emitter *yaml_emitter_t) bool {
+ if !flush(emitter) {
+ return false
+ }
+ pos := emitter.buffer_pos
+ emitter.buffer[pos+0] = '\xEF'
+ emitter.buffer[pos+1] = '\xBB'
+ emitter.buffer[pos+2] = '\xBF'
+ emitter.buffer_pos += 3
+ return true
+}
+
+func yaml_emitter_write_indent(emitter *yaml_emitter_t) bool {
+ indent := emitter.indent
+ if indent < 0 {
+ indent = 0
+ }
+ if !emitter.indention || emitter.column > indent || (emitter.column == indent && !emitter.whitespace) {
+ if !put_break(emitter) {
+ return false
+ }
+ }
+ for emitter.column < indent {
+ if !put(emitter, ' ') {
+ return false
+ }
+ }
+ emitter.whitespace = true
+ emitter.indention = true
+ return true
+}
+
+func yaml_emitter_write_indicator(emitter *yaml_emitter_t, indicator []byte, need_whitespace, is_whitespace, is_indention bool) bool {
+ if need_whitespace && !emitter.whitespace {
+ if !put(emitter, ' ') {
+ return false
+ }
+ }
+ if !write_all(emitter, indicator) {
+ return false
+ }
+ emitter.whitespace = is_whitespace
+ emitter.indention = (emitter.indention && is_indention)
+ emitter.open_ended = false
+ return true
+}
+
+func yaml_emitter_write_anchor(emitter *yaml_emitter_t, value []byte) bool {
+ if !write_all(emitter, value) {
+ return false
+ }
+ emitter.whitespace = false
+ emitter.indention = false
+ return true
+}
+
+func yaml_emitter_write_tag_handle(emitter *yaml_emitter_t, value []byte) bool {
+ if !emitter.whitespace {
+ if !put(emitter, ' ') {
+ return false
+ }
+ }
+ if !write_all(emitter, value) {
+ return false
+ }
+ emitter.whitespace = false
+ emitter.indention = false
+ return true
+}
+
+func yaml_emitter_write_tag_content(emitter *yaml_emitter_t, value []byte, need_whitespace bool) bool {
+ if need_whitespace && !emitter.whitespace {
+ if !put(emitter, ' ') {
+ return false
+ }
+ }
+ for i := 0; i < len(value); {
+ var must_write bool
+ switch value[i] {
+ case ';', '/', '?', ':', '@', '&', '=', '+', '$', ',', '_', '.', '~', '*', '\'', '(', ')', '[', ']':
+ must_write = true
+ default:
+ must_write = is_alpha(value, i)
+ }
+ if must_write {
+ if !write(emitter, value, &i) {
+ return false
+ }
+ } else {
+ w := width(value[i])
+ for k := 0; k < w; k++ {
+ octet := value[i]
+ i++
+ if !put(emitter, '%') {
+ return false
+ }
+
+ c := octet >> 4
+ if c < 10 {
+ c += '0'
+ } else {
+ c += 'A' - 10
+ }
+ if !put(emitter, c) {
+ return false
+ }
+
+ c = octet & 0x0f
+ if c < 10 {
+ c += '0'
+ } else {
+ c += 'A' - 10
+ }
+ if !put(emitter, c) {
+ return false
+ }
+ }
+ }
+ }
+ emitter.whitespace = false
+ emitter.indention = false
+ return true
+}
+
+func yaml_emitter_write_plain_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
+ if !emitter.whitespace {
+ if !put(emitter, ' ') {
+ return false
+ }
+ }
+
+ spaces := false
+ breaks := false
+ for i := 0; i < len(value); {
+ if is_space(value, i) {
+ if allow_breaks && !spaces && emitter.column > emitter.best_width && !is_space(value, i+1) {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ i += width(value[i])
+ } else {
+ if !write(emitter, value, &i) {
+ return false
+ }
+ }
+ spaces = true
+ } else if is_break(value, i) {
+ if !breaks && value[i] == '\n' {
+ if !put_break(emitter) {
+ return false
+ }
+ }
+ if !write_break(emitter, value, &i) {
+ return false
+ }
+ emitter.indention = true
+ breaks = true
+ } else {
+ if breaks {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ if !write(emitter, value, &i) {
+ return false
+ }
+ emitter.indention = false
+ spaces = false
+ breaks = false
+ }
+ }
+
+ emitter.whitespace = false
+ emitter.indention = false
+ if emitter.root_context {
+ emitter.open_ended = true
+ }
+
+ return true
+}
+
+func yaml_emitter_write_single_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
+
+ if !yaml_emitter_write_indicator(emitter, []byte{'\''}, true, false, false) {
+ return false
+ }
+
+ spaces := false
+ breaks := false
+ for i := 0; i < len(value); {
+ if is_space(value, i) {
+ if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 && !is_space(value, i+1) {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ i += width(value[i])
+ } else {
+ if !write(emitter, value, &i) {
+ return false
+ }
+ }
+ spaces = true
+ } else if is_break(value, i) {
+ if !breaks && value[i] == '\n' {
+ if !put_break(emitter) {
+ return false
+ }
+ }
+ if !write_break(emitter, value, &i) {
+ return false
+ }
+ emitter.indention = true
+ breaks = true
+ } else {
+ if breaks {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ if value[i] == '\'' {
+ if !put(emitter, '\'') {
+ return false
+ }
+ }
+ if !write(emitter, value, &i) {
+ return false
+ }
+ emitter.indention = false
+ spaces = false
+ breaks = false
+ }
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{'\''}, false, false, false) {
+ return false
+ }
+ emitter.whitespace = false
+ emitter.indention = false
+ return true
+}
+
+func yaml_emitter_write_double_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
+ spaces := false
+ if !yaml_emitter_write_indicator(emitter, []byte{'"'}, true, false, false) {
+ return false
+ }
+
+ for i := 0; i < len(value); {
+ if !is_printable(value, i) || (!emitter.unicode && !is_ascii(value, i)) ||
+ is_bom(value, i) || is_break(value, i) ||
+ value[i] == '"' || value[i] == '\\' {
+
+ octet := value[i]
+
+ var w int
+ var v rune
+ switch {
+ case octet&0x80 == 0x00:
+ w, v = 1, rune(octet&0x7F)
+ case octet&0xE0 == 0xC0:
+ w, v = 2, rune(octet&0x1F)
+ case octet&0xF0 == 0xE0:
+ w, v = 3, rune(octet&0x0F)
+ case octet&0xF8 == 0xF0:
+ w, v = 4, rune(octet&0x07)
+ }
+ for k := 1; k < w; k++ {
+ octet = value[i+k]
+ v = (v << 6) + (rune(octet) & 0x3F)
+ }
+ i += w
+
+ if !put(emitter, '\\') {
+ return false
+ }
+
+ var ok bool
+ switch v {
+ case 0x00:
+ ok = put(emitter, '0')
+ case 0x07:
+ ok = put(emitter, 'a')
+ case 0x08:
+ ok = put(emitter, 'b')
+ case 0x09:
+ ok = put(emitter, 't')
+ case 0x0A:
+ ok = put(emitter, 'n')
+ case 0x0b:
+ ok = put(emitter, 'v')
+ case 0x0c:
+ ok = put(emitter, 'f')
+ case 0x0d:
+ ok = put(emitter, 'r')
+ case 0x1b:
+ ok = put(emitter, 'e')
+ case 0x22:
+ ok = put(emitter, '"')
+ case 0x5c:
+ ok = put(emitter, '\\')
+ case 0x85:
+ ok = put(emitter, 'N')
+ case 0xA0:
+ ok = put(emitter, '_')
+ case 0x2028:
+ ok = put(emitter, 'L')
+ case 0x2029:
+ ok = put(emitter, 'P')
+ default:
+ if v <= 0xFF {
+ ok = put(emitter, 'x')
+ w = 2
+ } else if v <= 0xFFFF {
+ ok = put(emitter, 'u')
+ w = 4
+ } else {
+ ok = put(emitter, 'U')
+ w = 8
+ }
+ for k := (w - 1) * 4; ok && k >= 0; k -= 4 {
+ digit := byte((v >> uint(k)) & 0x0F)
+ if digit < 10 {
+ ok = put(emitter, digit+'0')
+ } else {
+ ok = put(emitter, digit+'A'-10)
+ }
+ }
+ }
+ if !ok {
+ return false
+ }
+ spaces = false
+ } else if is_space(value, i) {
+ if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ if is_space(value, i+1) {
+ if !put(emitter, '\\') {
+ return false
+ }
+ }
+ i += width(value[i])
+ } else if !write(emitter, value, &i) {
+ return false
+ }
+ spaces = true
+ } else {
+ if !write(emitter, value, &i) {
+ return false
+ }
+ spaces = false
+ }
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{'"'}, false, false, false) {
+ return false
+ }
+ emitter.whitespace = false
+ emitter.indention = false
+ return true
+}
+
+func yaml_emitter_write_block_scalar_hints(emitter *yaml_emitter_t, value []byte) bool {
+ if is_space(value, 0) || is_break(value, 0) {
+ indent_hint := []byte{'0' + byte(emitter.best_indent)}
+ if !yaml_emitter_write_indicator(emitter, indent_hint, false, false, false) {
+ return false
+ }
+ }
+
+ emitter.open_ended = false
+
+ var chomp_hint [1]byte
+ if len(value) == 0 {
+ chomp_hint[0] = '-'
+ } else {
+ i := len(value) - 1
+ for value[i]&0xC0 == 0x80 {
+ i--
+ }
+ if !is_break(value, i) {
+ chomp_hint[0] = '-'
+ } else if i == 0 {
+ chomp_hint[0] = '+'
+ emitter.open_ended = true
+ } else {
+ i--
+ for value[i]&0xC0 == 0x80 {
+ i--
+ }
+ if is_break(value, i) {
+ chomp_hint[0] = '+'
+ emitter.open_ended = true
+ }
+ }
+ }
+ if chomp_hint[0] != 0 {
+ if !yaml_emitter_write_indicator(emitter, chomp_hint[:], false, false, false) {
+ return false
+ }
+ }
+ return true
+}
+
+func yaml_emitter_write_literal_scalar(emitter *yaml_emitter_t, value []byte) bool {
+ if !yaml_emitter_write_indicator(emitter, []byte{'|'}, true, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_block_scalar_hints(emitter, value) {
+ return false
+ }
+ if !put_break(emitter) {
+ return false
+ }
+ emitter.indention = true
+ emitter.whitespace = true
+ breaks := true
+ for i := 0; i < len(value); {
+ if is_break(value, i) {
+ if !write_break(emitter, value, &i) {
+ return false
+ }
+ emitter.indention = true
+ breaks = true
+ } else {
+ if breaks {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ if !write(emitter, value, &i) {
+ return false
+ }
+ emitter.indention = false
+ breaks = false
+ }
+ }
+
+ return true
+}
+
+func yaml_emitter_write_folded_scalar(emitter *yaml_emitter_t, value []byte) bool {
+ if !yaml_emitter_write_indicator(emitter, []byte{'>'}, true, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_block_scalar_hints(emitter, value) {
+ return false
+ }
+
+ if !put_break(emitter) {
+ return false
+ }
+ emitter.indention = true
+ emitter.whitespace = true
+
+ breaks := true
+ leading_spaces := true
+ for i := 0; i < len(value); {
+ if is_break(value, i) {
+ if !breaks && !leading_spaces && value[i] == '\n' {
+ k := 0
+ for is_break(value, k) {
+ k += width(value[k])
+ }
+ if !is_blankz(value, k) {
+ if !put_break(emitter) {
+ return false
+ }
+ }
+ }
+ if !write_break(emitter, value, &i) {
+ return false
+ }
+ emitter.indention = true
+ breaks = true
+ } else {
+ if breaks {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ leading_spaces = is_blank(value, i)
+ }
+ if !breaks && is_space(value, i) && !is_space(value, i+1) && emitter.column > emitter.best_width {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ i += width(value[i])
+ } else {
+ if !write(emitter, value, &i) {
+ return false
+ }
+ }
+ emitter.indention = false
+ breaks = false
+ }
+ }
+ return true
+}
diff --git a/vendor/sigs.k8s.io/yaml/goyaml.v2/encode.go b/vendor/sigs.k8s.io/yaml/goyaml.v2/encode.go
new file mode 100644
index 0000000000..0ee738e11b
--- /dev/null
+++ b/vendor/sigs.k8s.io/yaml/goyaml.v2/encode.go
@@ -0,0 +1,390 @@
+package yaml
+
+import (
+ "encoding"
+ "fmt"
+ "io"
+ "reflect"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+ "time"
+ "unicode/utf8"
+)
+
+// jsonNumber is the interface of the encoding/json.Number datatype.
+// Repeating the interface here avoids a dependency on encoding/json, and also
+// supports other libraries like jsoniter, which use a similar datatype with
+// the same interface. Detecting this interface is useful when dealing with
+// structures containing json.Number, which is a string under the hood. The
+// encoder should prefer the use of Int64(), Float64() and string(), in that
+// order, when encoding this type.
+type jsonNumber interface {
+ Float64() (float64, error)
+ Int64() (int64, error)
+ String() string
+}
+
+type encoder struct {
+ emitter yaml_emitter_t
+ event yaml_event_t
+ out []byte
+ flow bool
+ // doneInit holds whether the initial stream_start_event has been
+ // emitted.
+ doneInit bool
+}
+
+func newEncoder() *encoder {
+ e := &encoder{}
+ yaml_emitter_initialize(&e.emitter)
+ yaml_emitter_set_output_string(&e.emitter, &e.out)
+ yaml_emitter_set_unicode(&e.emitter, true)
+ return e
+}
+
+func newEncoderWithWriter(w io.Writer) *encoder {
+ e := &encoder{}
+ yaml_emitter_initialize(&e.emitter)
+ yaml_emitter_set_output_writer(&e.emitter, w)
+ yaml_emitter_set_unicode(&e.emitter, true)
+ return e
+}
+
+func (e *encoder) init() {
+ if e.doneInit {
+ return
+ }
+ yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING)
+ e.emit()
+ e.doneInit = true
+}
+
+func (e *encoder) finish() {
+ e.emitter.open_ended = false
+ yaml_stream_end_event_initialize(&e.event)
+ e.emit()
+}
+
+func (e *encoder) destroy() {
+ yaml_emitter_delete(&e.emitter)
+}
+
+func (e *encoder) emit() {
+ // This will internally delete the e.event value.
+ e.must(yaml_emitter_emit(&e.emitter, &e.event))
+}
+
+func (e *encoder) must(ok bool) {
+ if !ok {
+ msg := e.emitter.problem
+ if msg == "" {
+ msg = "unknown problem generating YAML content"
+ }
+ failf("%s", msg)
+ }
+}
+
+func (e *encoder) marshalDoc(tag string, in reflect.Value) {
+ e.init()
+ yaml_document_start_event_initialize(&e.event, nil, nil, true)
+ e.emit()
+ e.marshal(tag, in)
+ yaml_document_end_event_initialize(&e.event, true)
+ e.emit()
+}
+
+func (e *encoder) marshal(tag string, in reflect.Value) {
+ if !in.IsValid() || in.Kind() == reflect.Ptr && in.IsNil() {
+ e.nilv()
+ return
+ }
+ iface := in.Interface()
+ switch m := iface.(type) {
+ case jsonNumber:
+ integer, err := m.Int64()
+ if err == nil {
+ // In this case the json.Number is a valid int64
+ in = reflect.ValueOf(integer)
+ break
+ }
+ float, err := m.Float64()
+ if err == nil {
+ // In this case the json.Number is a valid float64
+ in = reflect.ValueOf(float)
+ break
+ }
+ // fallback case - no number could be obtained
+ in = reflect.ValueOf(m.String())
+ case time.Time, *time.Time:
+ // Although time.Time implements TextMarshaler,
+ // we don't want to treat it as a string for YAML
+ // purposes because YAML has special support for
+ // timestamps.
+ case Marshaler:
+ v, err := m.MarshalYAML()
+ if err != nil {
+ fail(err)
+ }
+ if v == nil {
+ e.nilv()
+ return
+ }
+ in = reflect.ValueOf(v)
+ case encoding.TextMarshaler:
+ text, err := m.MarshalText()
+ if err != nil {
+ fail(err)
+ }
+ in = reflect.ValueOf(string(text))
+ case nil:
+ e.nilv()
+ return
+ }
+ switch in.Kind() {
+ case reflect.Interface:
+ e.marshal(tag, in.Elem())
+ case reflect.Map:
+ e.mapv(tag, in)
+ case reflect.Ptr:
+ if in.Type() == ptrTimeType {
+ e.timev(tag, in.Elem())
+ } else {
+ e.marshal(tag, in.Elem())
+ }
+ case reflect.Struct:
+ if in.Type() == timeType {
+ e.timev(tag, in)
+ } else {
+ e.structv(tag, in)
+ }
+ case reflect.Slice, reflect.Array:
+ if in.Type().Elem() == mapItemType {
+ e.itemsv(tag, in)
+ } else {
+ e.slicev(tag, in)
+ }
+ case reflect.String:
+ e.stringv(tag, in)
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ if in.Type() == durationType {
+ e.stringv(tag, reflect.ValueOf(iface.(time.Duration).String()))
+ } else {
+ e.intv(tag, in)
+ }
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ e.uintv(tag, in)
+ case reflect.Float32, reflect.Float64:
+ e.floatv(tag, in)
+ case reflect.Bool:
+ e.boolv(tag, in)
+ default:
+ panic("cannot marshal type: " + in.Type().String())
+ }
+}
+
+func (e *encoder) mapv(tag string, in reflect.Value) {
+ e.mappingv(tag, func() {
+ keys := keyList(in.MapKeys())
+ sort.Sort(keys)
+ for _, k := range keys {
+ e.marshal("", k)
+ e.marshal("", in.MapIndex(k))
+ }
+ })
+}
+
+func (e *encoder) itemsv(tag string, in reflect.Value) {
+ e.mappingv(tag, func() {
+ slice := in.Convert(reflect.TypeOf([]MapItem{})).Interface().([]MapItem)
+ for _, item := range slice {
+ e.marshal("", reflect.ValueOf(item.Key))
+ e.marshal("", reflect.ValueOf(item.Value))
+ }
+ })
+}
+
+func (e *encoder) structv(tag string, in reflect.Value) {
+ sinfo, err := getStructInfo(in.Type())
+ if err != nil {
+ panic(err)
+ }
+ e.mappingv(tag, func() {
+ for _, info := range sinfo.FieldsList {
+ var value reflect.Value
+ if info.Inline == nil {
+ value = in.Field(info.Num)
+ } else {
+ value = in.FieldByIndex(info.Inline)
+ }
+ if info.OmitEmpty && isZero(value) {
+ continue
+ }
+ e.marshal("", reflect.ValueOf(info.Key))
+ e.flow = info.Flow
+ e.marshal("", value)
+ }
+ if sinfo.InlineMap >= 0 {
+ m := in.Field(sinfo.InlineMap)
+ if m.Len() > 0 {
+ e.flow = false
+ keys := keyList(m.MapKeys())
+ sort.Sort(keys)
+ for _, k := range keys {
+ if _, found := sinfo.FieldsMap[k.String()]; found {
+ panic(fmt.Sprintf("Can't have key %q in inlined map; conflicts with struct field", k.String()))
+ }
+ e.marshal("", k)
+ e.flow = false
+ e.marshal("", m.MapIndex(k))
+ }
+ }
+ }
+ })
+}
+
+func (e *encoder) mappingv(tag string, f func()) {
+ implicit := tag == ""
+ style := yaml_BLOCK_MAPPING_STYLE
+ if e.flow {
+ e.flow = false
+ style = yaml_FLOW_MAPPING_STYLE
+ }
+ yaml_mapping_start_event_initialize(&e.event, nil, []byte(tag), implicit, style)
+ e.emit()
+ f()
+ yaml_mapping_end_event_initialize(&e.event)
+ e.emit()
+}
+
+func (e *encoder) slicev(tag string, in reflect.Value) {
+ implicit := tag == ""
+ style := yaml_BLOCK_SEQUENCE_STYLE
+ if e.flow {
+ e.flow = false
+ style = yaml_FLOW_SEQUENCE_STYLE
+ }
+ e.must(yaml_sequence_start_event_initialize(&e.event, nil, []byte(tag), implicit, style))
+ e.emit()
+ n := in.Len()
+ for i := 0; i < n; i++ {
+ e.marshal("", in.Index(i))
+ }
+ e.must(yaml_sequence_end_event_initialize(&e.event))
+ e.emit()
+}
+
+// isBase60 returns whether s is in base 60 notation as defined in YAML 1.1.
+//
+// The base 60 float notation in YAML 1.1 is a terrible idea and is unsupported
+// in YAML 1.2 and by this package, but these should be marshalled quoted for
+// the time being for compatibility with other parsers.
+func isBase60Float(s string) (result bool) {
+ // Fast path.
+ if s == "" {
+ return false
+ }
+ c := s[0]
+ if !(c == '+' || c == '-' || c >= '0' && c <= '9') || strings.IndexByte(s, ':') < 0 {
+ return false
+ }
+ // Do the full match.
+ return base60float.MatchString(s)
+}
+
+// From http://yaml.org/type/float.html, except the regular expression there
+// is bogus. In practice parsers do not enforce the "\.[0-9_]*" suffix.
+var base60float = regexp.MustCompile(`^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+(?:\.[0-9_]*)?$`)
+
+func (e *encoder) stringv(tag string, in reflect.Value) {
+ var style yaml_scalar_style_t
+ s := in.String()
+ canUsePlain := true
+ switch {
+ case !utf8.ValidString(s):
+ if tag == yaml_BINARY_TAG {
+ failf("explicitly tagged !!binary data must be base64-encoded")
+ }
+ if tag != "" {
+ failf("cannot marshal invalid UTF-8 data as %s", shortTag(tag))
+ }
+ // It can't be encoded directly as YAML so use a binary tag
+ // and encode it as base64.
+ tag = yaml_BINARY_TAG
+ s = encodeBase64(s)
+ case tag == "":
+ // Check to see if it would resolve to a specific
+ // tag when encoded unquoted. If it doesn't,
+ // there's no need to quote it.
+ rtag, _ := resolve("", s)
+ canUsePlain = rtag == yaml_STR_TAG && !isBase60Float(s)
+ }
+ // Note: it's possible for user code to emit invalid YAML
+ // if they explicitly specify a tag and a string containing
+ // text that's incompatible with that tag.
+ switch {
+ case strings.Contains(s, "\n"):
+ style = yaml_LITERAL_SCALAR_STYLE
+ case canUsePlain:
+ style = yaml_PLAIN_SCALAR_STYLE
+ default:
+ style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
+ }
+ e.emitScalar(s, "", tag, style)
+}
+
+func (e *encoder) boolv(tag string, in reflect.Value) {
+ var s string
+ if in.Bool() {
+ s = "true"
+ } else {
+ s = "false"
+ }
+ e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
+}
+
+func (e *encoder) intv(tag string, in reflect.Value) {
+ s := strconv.FormatInt(in.Int(), 10)
+ e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
+}
+
+func (e *encoder) uintv(tag string, in reflect.Value) {
+ s := strconv.FormatUint(in.Uint(), 10)
+ e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
+}
+
+func (e *encoder) timev(tag string, in reflect.Value) {
+ t := in.Interface().(time.Time)
+ s := t.Format(time.RFC3339Nano)
+ e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
+}
+
+func (e *encoder) floatv(tag string, in reflect.Value) {
+ // Issue #352: When formatting, use the precision of the underlying value
+ precision := 64
+ if in.Kind() == reflect.Float32 {
+ precision = 32
+ }
+
+ s := strconv.FormatFloat(in.Float(), 'g', -1, precision)
+ switch s {
+ case "+Inf":
+ s = ".inf"
+ case "-Inf":
+ s = "-.inf"
+ case "NaN":
+ s = ".nan"
+ }
+ e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
+}
+
+func (e *encoder) nilv() {
+ e.emitScalar("null", "", "", yaml_PLAIN_SCALAR_STYLE)
+}
+
+func (e *encoder) emitScalar(value, anchor, tag string, style yaml_scalar_style_t) {
+ implicit := tag == ""
+ e.must(yaml_scalar_event_initialize(&e.event, []byte(anchor), []byte(tag), []byte(value), implicit, implicit, style))
+ e.emit()
+}
diff --git a/vendor/sigs.k8s.io/yaml/goyaml.v2/parserc.go b/vendor/sigs.k8s.io/yaml/goyaml.v2/parserc.go
new file mode 100644
index 0000000000..81d05dfe57
--- /dev/null
+++ b/vendor/sigs.k8s.io/yaml/goyaml.v2/parserc.go
@@ -0,0 +1,1095 @@
+package yaml
+
+import (
+ "bytes"
+)
+
+// The parser implements the following grammar:
+//
+// stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
+// implicit_document ::= block_node DOCUMENT-END*
+// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+// block_node_or_indentless_sequence ::=
+// ALIAS
+// | properties (block_content | indentless_block_sequence)?
+// | block_content
+// | indentless_block_sequence
+// block_node ::= ALIAS
+// | properties block_content?
+// | block_content
+// flow_node ::= ALIAS
+// | properties flow_content?
+// | flow_content
+// properties ::= TAG ANCHOR? | ANCHOR TAG?
+// block_content ::= block_collection | flow_collection | SCALAR
+// flow_content ::= flow_collection | SCALAR
+// block_collection ::= block_sequence | block_mapping
+// flow_collection ::= flow_sequence | flow_mapping
+// block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
+// indentless_sequence ::= (BLOCK-ENTRY block_node?)+
+// block_mapping ::= BLOCK-MAPPING_START
+// ((KEY block_node_or_indentless_sequence?)?
+// (VALUE block_node_or_indentless_sequence?)?)*
+// BLOCK-END
+// flow_sequence ::= FLOW-SEQUENCE-START
+// (flow_sequence_entry FLOW-ENTRY)*
+// flow_sequence_entry?
+// FLOW-SEQUENCE-END
+// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+// flow_mapping ::= FLOW-MAPPING-START
+// (flow_mapping_entry FLOW-ENTRY)*
+// flow_mapping_entry?
+// FLOW-MAPPING-END
+// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+
+// Peek the next token in the token queue.
+func peek_token(parser *yaml_parser_t) *yaml_token_t {
+ if parser.token_available || yaml_parser_fetch_more_tokens(parser) {
+ return &parser.tokens[parser.tokens_head]
+ }
+ return nil
+}
+
+// Remove the next token from the queue (must be called after peek_token).
+func skip_token(parser *yaml_parser_t) {
+ parser.token_available = false
+ parser.tokens_parsed++
+ parser.stream_end_produced = parser.tokens[parser.tokens_head].typ == yaml_STREAM_END_TOKEN
+ parser.tokens_head++
+}
+
+// Get the next event.
+func yaml_parser_parse(parser *yaml_parser_t, event *yaml_event_t) bool {
+ // Erase the event object.
+ *event = yaml_event_t{}
+
+ // No events after the end of the stream or error.
+ if parser.stream_end_produced || parser.error != yaml_NO_ERROR || parser.state == yaml_PARSE_END_STATE {
+ return true
+ }
+
+ // Generate the next event.
+ return yaml_parser_state_machine(parser, event)
+}
+
+// Set parser error.
+func yaml_parser_set_parser_error(parser *yaml_parser_t, problem string, problem_mark yaml_mark_t) bool {
+ parser.error = yaml_PARSER_ERROR
+ parser.problem = problem
+ parser.problem_mark = problem_mark
+ return false
+}
+
+func yaml_parser_set_parser_error_context(parser *yaml_parser_t, context string, context_mark yaml_mark_t, problem string, problem_mark yaml_mark_t) bool {
+ parser.error = yaml_PARSER_ERROR
+ parser.context = context
+ parser.context_mark = context_mark
+ parser.problem = problem
+ parser.problem_mark = problem_mark
+ return false
+}
+
+// State dispatcher.
+func yaml_parser_state_machine(parser *yaml_parser_t, event *yaml_event_t) bool {
+ //trace("yaml_parser_state_machine", "state:", parser.state.String())
+
+ switch parser.state {
+ case yaml_PARSE_STREAM_START_STATE:
+ return yaml_parser_parse_stream_start(parser, event)
+
+ case yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE:
+ return yaml_parser_parse_document_start(parser, event, true)
+
+ case yaml_PARSE_DOCUMENT_START_STATE:
+ return yaml_parser_parse_document_start(parser, event, false)
+
+ case yaml_PARSE_DOCUMENT_CONTENT_STATE:
+ return yaml_parser_parse_document_content(parser, event)
+
+ case yaml_PARSE_DOCUMENT_END_STATE:
+ return yaml_parser_parse_document_end(parser, event)
+
+ case yaml_PARSE_BLOCK_NODE_STATE:
+ return yaml_parser_parse_node(parser, event, true, false)
+
+ case yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE:
+ return yaml_parser_parse_node(parser, event, true, true)
+
+ case yaml_PARSE_FLOW_NODE_STATE:
+ return yaml_parser_parse_node(parser, event, false, false)
+
+ case yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE:
+ return yaml_parser_parse_block_sequence_entry(parser, event, true)
+
+ case yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE:
+ return yaml_parser_parse_block_sequence_entry(parser, event, false)
+
+ case yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE:
+ return yaml_parser_parse_indentless_sequence_entry(parser, event)
+
+ case yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE:
+ return yaml_parser_parse_block_mapping_key(parser, event, true)
+
+ case yaml_PARSE_BLOCK_MAPPING_KEY_STATE:
+ return yaml_parser_parse_block_mapping_key(parser, event, false)
+
+ case yaml_PARSE_BLOCK_MAPPING_VALUE_STATE:
+ return yaml_parser_parse_block_mapping_value(parser, event)
+
+ case yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE:
+ return yaml_parser_parse_flow_sequence_entry(parser, event, true)
+
+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE:
+ return yaml_parser_parse_flow_sequence_entry(parser, event, false)
+
+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE:
+ return yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event)
+
+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE:
+ return yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event)
+
+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE:
+ return yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event)
+
+ case yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE:
+ return yaml_parser_parse_flow_mapping_key(parser, event, true)
+
+ case yaml_PARSE_FLOW_MAPPING_KEY_STATE:
+ return yaml_parser_parse_flow_mapping_key(parser, event, false)
+
+ case yaml_PARSE_FLOW_MAPPING_VALUE_STATE:
+ return yaml_parser_parse_flow_mapping_value(parser, event, false)
+
+ case yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE:
+ return yaml_parser_parse_flow_mapping_value(parser, event, true)
+
+ default:
+ panic("invalid parser state")
+ }
+}
+
+// Parse the production:
+// stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
+// ************
+func yaml_parser_parse_stream_start(parser *yaml_parser_t, event *yaml_event_t) bool {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_STREAM_START_TOKEN {
+ return yaml_parser_set_parser_error(parser, "did not find expected ", token.start_mark)
+ }
+ parser.state = yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE
+ *event = yaml_event_t{
+ typ: yaml_STREAM_START_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+ encoding: token.encoding,
+ }
+ skip_token(parser)
+ return true
+}
+
+// Parse the productions:
+// implicit_document ::= block_node DOCUMENT-END*
+// *
+// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+// *************************
+func yaml_parser_parse_document_start(parser *yaml_parser_t, event *yaml_event_t, implicit bool) bool {
+
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+
+ // Parse extra document end indicators.
+ if !implicit {
+ for token.typ == yaml_DOCUMENT_END_TOKEN {
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ }
+ }
+
+ if implicit && token.typ != yaml_VERSION_DIRECTIVE_TOKEN &&
+ token.typ != yaml_TAG_DIRECTIVE_TOKEN &&
+ token.typ != yaml_DOCUMENT_START_TOKEN &&
+ token.typ != yaml_STREAM_END_TOKEN {
+ // Parse an implicit document.
+ if !yaml_parser_process_directives(parser, nil, nil) {
+ return false
+ }
+ parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE)
+ parser.state = yaml_PARSE_BLOCK_NODE_STATE
+
+ *event = yaml_event_t{
+ typ: yaml_DOCUMENT_START_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+ }
+
+ } else if token.typ != yaml_STREAM_END_TOKEN {
+ // Parse an explicit document.
+ var version_directive *yaml_version_directive_t
+ var tag_directives []yaml_tag_directive_t
+ start_mark := token.start_mark
+ if !yaml_parser_process_directives(parser, &version_directive, &tag_directives) {
+ return false
+ }
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_DOCUMENT_START_TOKEN {
+ yaml_parser_set_parser_error(parser,
+ "did not find expected ", token.start_mark)
+ return false
+ }
+ parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE)
+ parser.state = yaml_PARSE_DOCUMENT_CONTENT_STATE
+ end_mark := token.end_mark
+
+ *event = yaml_event_t{
+ typ: yaml_DOCUMENT_START_EVENT,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ version_directive: version_directive,
+ tag_directives: tag_directives,
+ implicit: false,
+ }
+ skip_token(parser)
+
+ } else {
+ // Parse the stream end.
+ parser.state = yaml_PARSE_END_STATE
+ *event = yaml_event_t{
+ typ: yaml_STREAM_END_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+ }
+ skip_token(parser)
+ }
+
+ return true
+}
+
+// Parse the productions:
+// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+// ***********
+//
+func yaml_parser_parse_document_content(parser *yaml_parser_t, event *yaml_event_t) bool {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ == yaml_VERSION_DIRECTIVE_TOKEN ||
+ token.typ == yaml_TAG_DIRECTIVE_TOKEN ||
+ token.typ == yaml_DOCUMENT_START_TOKEN ||
+ token.typ == yaml_DOCUMENT_END_TOKEN ||
+ token.typ == yaml_STREAM_END_TOKEN {
+ parser.state = parser.states[len(parser.states)-1]
+ parser.states = parser.states[:len(parser.states)-1]
+ return yaml_parser_process_empty_scalar(parser, event,
+ token.start_mark)
+ }
+ return yaml_parser_parse_node(parser, event, true, false)
+}
+
+// Parse the productions:
+// implicit_document ::= block_node DOCUMENT-END*
+// *************
+// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+//
+func yaml_parser_parse_document_end(parser *yaml_parser_t, event *yaml_event_t) bool {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+
+ start_mark := token.start_mark
+ end_mark := token.start_mark
+
+ implicit := true
+ if token.typ == yaml_DOCUMENT_END_TOKEN {
+ end_mark = token.end_mark
+ skip_token(parser)
+ implicit = false
+ }
+
+ parser.tag_directives = parser.tag_directives[:0]
+
+ parser.state = yaml_PARSE_DOCUMENT_START_STATE
+ *event = yaml_event_t{
+ typ: yaml_DOCUMENT_END_EVENT,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ implicit: implicit,
+ }
+ return true
+}
+
+// Parse the productions:
+// block_node_or_indentless_sequence ::=
+// ALIAS
+// *****
+// | properties (block_content | indentless_block_sequence)?
+// ********** *
+// | block_content | indentless_block_sequence
+// *
+// block_node ::= ALIAS
+// *****
+// | properties block_content?
+// ********** *
+// | block_content
+// *
+// flow_node ::= ALIAS
+// *****
+// | properties flow_content?
+// ********** *
+// | flow_content
+// *
+// properties ::= TAG ANCHOR? | ANCHOR TAG?
+// *************************
+// block_content ::= block_collection | flow_collection | SCALAR
+// ******
+// flow_content ::= flow_collection | SCALAR
+// ******
+func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, indentless_sequence bool) bool {
+ //defer trace("yaml_parser_parse_node", "block:", block, "indentless_sequence:", indentless_sequence)()
+
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+
+ if token.typ == yaml_ALIAS_TOKEN {
+ parser.state = parser.states[len(parser.states)-1]
+ parser.states = parser.states[:len(parser.states)-1]
+ *event = yaml_event_t{
+ typ: yaml_ALIAS_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+ anchor: token.value,
+ }
+ skip_token(parser)
+ return true
+ }
+
+ start_mark := token.start_mark
+ end_mark := token.start_mark
+
+ var tag_token bool
+ var tag_handle, tag_suffix, anchor []byte
+ var tag_mark yaml_mark_t
+ if token.typ == yaml_ANCHOR_TOKEN {
+ anchor = token.value
+ start_mark = token.start_mark
+ end_mark = token.end_mark
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ == yaml_TAG_TOKEN {
+ tag_token = true
+ tag_handle = token.value
+ tag_suffix = token.suffix
+ tag_mark = token.start_mark
+ end_mark = token.end_mark
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ }
+ } else if token.typ == yaml_TAG_TOKEN {
+ tag_token = true
+ tag_handle = token.value
+ tag_suffix = token.suffix
+ start_mark = token.start_mark
+ tag_mark = token.start_mark
+ end_mark = token.end_mark
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ == yaml_ANCHOR_TOKEN {
+ anchor = token.value
+ end_mark = token.end_mark
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ }
+ }
+
+ var tag []byte
+ if tag_token {
+ if len(tag_handle) == 0 {
+ tag = tag_suffix
+ tag_suffix = nil
+ } else {
+ for i := range parser.tag_directives {
+ if bytes.Equal(parser.tag_directives[i].handle, tag_handle) {
+ tag = append([]byte(nil), parser.tag_directives[i].prefix...)
+ tag = append(tag, tag_suffix...)
+ break
+ }
+ }
+ if len(tag) == 0 {
+ yaml_parser_set_parser_error_context(parser,
+ "while parsing a node", start_mark,
+ "found undefined tag handle", tag_mark)
+ return false
+ }
+ }
+ }
+
+ implicit := len(tag) == 0
+ if indentless_sequence && token.typ == yaml_BLOCK_ENTRY_TOKEN {
+ end_mark = token.end_mark
+ parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE
+ *event = yaml_event_t{
+ typ: yaml_SEQUENCE_START_EVENT,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ anchor: anchor,
+ tag: tag,
+ implicit: implicit,
+ style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE),
+ }
+ return true
+ }
+ if token.typ == yaml_SCALAR_TOKEN {
+ var plain_implicit, quoted_implicit bool
+ end_mark = token.end_mark
+ if (len(tag) == 0 && token.style == yaml_PLAIN_SCALAR_STYLE) || (len(tag) == 1 && tag[0] == '!') {
+ plain_implicit = true
+ } else if len(tag) == 0 {
+ quoted_implicit = true
+ }
+ parser.state = parser.states[len(parser.states)-1]
+ parser.states = parser.states[:len(parser.states)-1]
+
+ *event = yaml_event_t{
+ typ: yaml_SCALAR_EVENT,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ anchor: anchor,
+ tag: tag,
+ value: token.value,
+ implicit: plain_implicit,
+ quoted_implicit: quoted_implicit,
+ style: yaml_style_t(token.style),
+ }
+ skip_token(parser)
+ return true
+ }
+ if token.typ == yaml_FLOW_SEQUENCE_START_TOKEN {
+ // [Go] Some of the events below can be merged as they differ only on style.
+ end_mark = token.end_mark
+ parser.state = yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE
+ *event = yaml_event_t{
+ typ: yaml_SEQUENCE_START_EVENT,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ anchor: anchor,
+ tag: tag,
+ implicit: implicit,
+ style: yaml_style_t(yaml_FLOW_SEQUENCE_STYLE),
+ }
+ return true
+ }
+ if token.typ == yaml_FLOW_MAPPING_START_TOKEN {
+ end_mark = token.end_mark
+ parser.state = yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE
+ *event = yaml_event_t{
+ typ: yaml_MAPPING_START_EVENT,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ anchor: anchor,
+ tag: tag,
+ implicit: implicit,
+ style: yaml_style_t(yaml_FLOW_MAPPING_STYLE),
+ }
+ return true
+ }
+ if block && token.typ == yaml_BLOCK_SEQUENCE_START_TOKEN {
+ end_mark = token.end_mark
+ parser.state = yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE
+ *event = yaml_event_t{
+ typ: yaml_SEQUENCE_START_EVENT,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ anchor: anchor,
+ tag: tag,
+ implicit: implicit,
+ style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE),
+ }
+ return true
+ }
+ if block && token.typ == yaml_BLOCK_MAPPING_START_TOKEN {
+ end_mark = token.end_mark
+ parser.state = yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE
+ *event = yaml_event_t{
+ typ: yaml_MAPPING_START_EVENT,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ anchor: anchor,
+ tag: tag,
+ implicit: implicit,
+ style: yaml_style_t(yaml_BLOCK_MAPPING_STYLE),
+ }
+ return true
+ }
+ if len(anchor) > 0 || len(tag) > 0 {
+ parser.state = parser.states[len(parser.states)-1]
+ parser.states = parser.states[:len(parser.states)-1]
+
+ *event = yaml_event_t{
+ typ: yaml_SCALAR_EVENT,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ anchor: anchor,
+ tag: tag,
+ implicit: implicit,
+ quoted_implicit: false,
+ style: yaml_style_t(yaml_PLAIN_SCALAR_STYLE),
+ }
+ return true
+ }
+
+ context := "while parsing a flow node"
+ if block {
+ context = "while parsing a block node"
+ }
+ yaml_parser_set_parser_error_context(parser, context, start_mark,
+ "did not find expected node content", token.start_mark)
+ return false
+}
+
+// Parse the productions:
+// block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
+// ******************** *********** * *********
+//
+func yaml_parser_parse_block_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
+ if first {
+ token := peek_token(parser)
+ parser.marks = append(parser.marks, token.start_mark)
+ skip_token(parser)
+ }
+
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+
+ if token.typ == yaml_BLOCK_ENTRY_TOKEN {
+ mark := token.end_mark
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_BLOCK_ENTRY_TOKEN && token.typ != yaml_BLOCK_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE)
+ return yaml_parser_parse_node(parser, event, true, false)
+ } else {
+ parser.state = yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE
+ return yaml_parser_process_empty_scalar(parser, event, mark)
+ }
+ }
+ if token.typ == yaml_BLOCK_END_TOKEN {
+ parser.state = parser.states[len(parser.states)-1]
+ parser.states = parser.states[:len(parser.states)-1]
+ parser.marks = parser.marks[:len(parser.marks)-1]
+
+ *event = yaml_event_t{
+ typ: yaml_SEQUENCE_END_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+ }
+
+ skip_token(parser)
+ return true
+ }
+
+ context_mark := parser.marks[len(parser.marks)-1]
+ parser.marks = parser.marks[:len(parser.marks)-1]
+ return yaml_parser_set_parser_error_context(parser,
+ "while parsing a block collection", context_mark,
+ "did not find expected '-' indicator", token.start_mark)
+}
+
+// Parse the productions:
+// indentless_sequence ::= (BLOCK-ENTRY block_node?)+
+// *********** *
+func yaml_parser_parse_indentless_sequence_entry(parser *yaml_parser_t, event *yaml_event_t) bool {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+
+ if token.typ == yaml_BLOCK_ENTRY_TOKEN {
+ mark := token.end_mark
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_BLOCK_ENTRY_TOKEN &&
+ token.typ != yaml_KEY_TOKEN &&
+ token.typ != yaml_VALUE_TOKEN &&
+ token.typ != yaml_BLOCK_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE)
+ return yaml_parser_parse_node(parser, event, true, false)
+ }
+ parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE
+ return yaml_parser_process_empty_scalar(parser, event, mark)
+ }
+ parser.state = parser.states[len(parser.states)-1]
+ parser.states = parser.states[:len(parser.states)-1]
+
+ *event = yaml_event_t{
+ typ: yaml_SEQUENCE_END_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.start_mark, // [Go] Shouldn't this be token.end_mark?
+ }
+ return true
+}
+
+// Parse the productions:
+// block_mapping ::= BLOCK-MAPPING_START
+// *******************
+// ((KEY block_node_or_indentless_sequence?)?
+// *** *
+// (VALUE block_node_or_indentless_sequence?)?)*
+//
+// BLOCK-END
+// *********
+//
+func yaml_parser_parse_block_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
+ if first {
+ token := peek_token(parser)
+ parser.marks = append(parser.marks, token.start_mark)
+ skip_token(parser)
+ }
+
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+
+ if token.typ == yaml_KEY_TOKEN {
+ mark := token.end_mark
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_KEY_TOKEN &&
+ token.typ != yaml_VALUE_TOKEN &&
+ token.typ != yaml_BLOCK_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_VALUE_STATE)
+ return yaml_parser_parse_node(parser, event, true, true)
+ } else {
+ parser.state = yaml_PARSE_BLOCK_MAPPING_VALUE_STATE
+ return yaml_parser_process_empty_scalar(parser, event, mark)
+ }
+ } else if token.typ == yaml_BLOCK_END_TOKEN {
+ parser.state = parser.states[len(parser.states)-1]
+ parser.states = parser.states[:len(parser.states)-1]
+ parser.marks = parser.marks[:len(parser.marks)-1]
+ *event = yaml_event_t{
+ typ: yaml_MAPPING_END_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+ }
+ skip_token(parser)
+ return true
+ }
+
+ context_mark := parser.marks[len(parser.marks)-1]
+ parser.marks = parser.marks[:len(parser.marks)-1]
+ return yaml_parser_set_parser_error_context(parser,
+ "while parsing a block mapping", context_mark,
+ "did not find expected key", token.start_mark)
+}
+
+// Parse the productions:
+// block_mapping ::= BLOCK-MAPPING_START
+//
+// ((KEY block_node_or_indentless_sequence?)?
+//
+// (VALUE block_node_or_indentless_sequence?)?)*
+// ***** *
+// BLOCK-END
+//
+//
+func yaml_parser_parse_block_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ == yaml_VALUE_TOKEN {
+ mark := token.end_mark
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_KEY_TOKEN &&
+ token.typ != yaml_VALUE_TOKEN &&
+ token.typ != yaml_BLOCK_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_KEY_STATE)
+ return yaml_parser_parse_node(parser, event, true, true)
+ }
+ parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE
+ return yaml_parser_process_empty_scalar(parser, event, mark)
+ }
+ parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE
+ return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
+}
+
+// Parse the productions:
+// flow_sequence ::= FLOW-SEQUENCE-START
+// *******************
+// (flow_sequence_entry FLOW-ENTRY)*
+// * **********
+// flow_sequence_entry?
+// *
+// FLOW-SEQUENCE-END
+// *****************
+// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+// *
+//
+func yaml_parser_parse_flow_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
+ if first {
+ token := peek_token(parser)
+ parser.marks = append(parser.marks, token.start_mark)
+ skip_token(parser)
+ }
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
+ if !first {
+ if token.typ == yaml_FLOW_ENTRY_TOKEN {
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ } else {
+ context_mark := parser.marks[len(parser.marks)-1]
+ parser.marks = parser.marks[:len(parser.marks)-1]
+ return yaml_parser_set_parser_error_context(parser,
+ "while parsing a flow sequence", context_mark,
+ "did not find expected ',' or ']'", token.start_mark)
+ }
+ }
+
+ if token.typ == yaml_KEY_TOKEN {
+ parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE
+ *event = yaml_event_t{
+ typ: yaml_MAPPING_START_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+ implicit: true,
+ style: yaml_style_t(yaml_FLOW_MAPPING_STYLE),
+ }
+ skip_token(parser)
+ return true
+ } else if token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE)
+ return yaml_parser_parse_node(parser, event, false, false)
+ }
+ }
+
+ parser.state = parser.states[len(parser.states)-1]
+ parser.states = parser.states[:len(parser.states)-1]
+ parser.marks = parser.marks[:len(parser.marks)-1]
+
+ *event = yaml_event_t{
+ typ: yaml_SEQUENCE_END_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+ }
+
+ skip_token(parser)
+ return true
+}
+
+//
+// Parse the productions:
+// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+// *** *
+//
+func yaml_parser_parse_flow_sequence_entry_mapping_key(parser *yaml_parser_t, event *yaml_event_t) bool {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_VALUE_TOKEN &&
+ token.typ != yaml_FLOW_ENTRY_TOKEN &&
+ token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE)
+ return yaml_parser_parse_node(parser, event, false, false)
+ }
+ mark := token.end_mark
+ skip_token(parser)
+ parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE
+ return yaml_parser_process_empty_scalar(parser, event, mark)
+}
+
+// Parse the productions:
+// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+// ***** *
+//
+func yaml_parser_parse_flow_sequence_entry_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ == yaml_VALUE_TOKEN {
+ skip_token(parser)
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_FLOW_ENTRY_TOKEN && token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE)
+ return yaml_parser_parse_node(parser, event, false, false)
+ }
+ }
+ parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE
+ return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
+}
+
+// Parse the productions:
+// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+// *
+//
+func yaml_parser_parse_flow_sequence_entry_mapping_end(parser *yaml_parser_t, event *yaml_event_t) bool {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE
+ *event = yaml_event_t{
+ typ: yaml_MAPPING_END_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.start_mark, // [Go] Shouldn't this be end_mark?
+ }
+ return true
+}
+
+// Parse the productions:
+// flow_mapping ::= FLOW-MAPPING-START
+// ******************
+// (flow_mapping_entry FLOW-ENTRY)*
+// * **********
+// flow_mapping_entry?
+// ******************
+// FLOW-MAPPING-END
+// ****************
+// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+// * *** *
+//
+func yaml_parser_parse_flow_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
+ if first {
+ token := peek_token(parser)
+ parser.marks = append(parser.marks, token.start_mark)
+ skip_token(parser)
+ }
+
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+
+ if token.typ != yaml_FLOW_MAPPING_END_TOKEN {
+ if !first {
+ if token.typ == yaml_FLOW_ENTRY_TOKEN {
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ } else {
+ context_mark := parser.marks[len(parser.marks)-1]
+ parser.marks = parser.marks[:len(parser.marks)-1]
+ return yaml_parser_set_parser_error_context(parser,
+ "while parsing a flow mapping", context_mark,
+ "did not find expected ',' or '}'", token.start_mark)
+ }
+ }
+
+ if token.typ == yaml_KEY_TOKEN {
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_VALUE_TOKEN &&
+ token.typ != yaml_FLOW_ENTRY_TOKEN &&
+ token.typ != yaml_FLOW_MAPPING_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_VALUE_STATE)
+ return yaml_parser_parse_node(parser, event, false, false)
+ } else {
+ parser.state = yaml_PARSE_FLOW_MAPPING_VALUE_STATE
+ return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
+ }
+ } else if token.typ != yaml_FLOW_MAPPING_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE)
+ return yaml_parser_parse_node(parser, event, false, false)
+ }
+ }
+
+ parser.state = parser.states[len(parser.states)-1]
+ parser.states = parser.states[:len(parser.states)-1]
+ parser.marks = parser.marks[:len(parser.marks)-1]
+ *event = yaml_event_t{
+ typ: yaml_MAPPING_END_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+ }
+ skip_token(parser)
+ return true
+}
+
+// Parse the productions:
+// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+// * ***** *
+//
+func yaml_parser_parse_flow_mapping_value(parser *yaml_parser_t, event *yaml_event_t, empty bool) bool {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if empty {
+ parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE
+ return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
+ }
+ if token.typ == yaml_VALUE_TOKEN {
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_FLOW_ENTRY_TOKEN && token.typ != yaml_FLOW_MAPPING_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_KEY_STATE)
+ return yaml_parser_parse_node(parser, event, false, false)
+ }
+ }
+ parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE
+ return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
+}
+
+// Generate an empty scalar event.
+func yaml_parser_process_empty_scalar(parser *yaml_parser_t, event *yaml_event_t, mark yaml_mark_t) bool {
+ *event = yaml_event_t{
+ typ: yaml_SCALAR_EVENT,
+ start_mark: mark,
+ end_mark: mark,
+ value: nil, // Empty
+ implicit: true,
+ style: yaml_style_t(yaml_PLAIN_SCALAR_STYLE),
+ }
+ return true
+}
+
+var default_tag_directives = []yaml_tag_directive_t{
+ {[]byte("!"), []byte("!")},
+ {[]byte("!!"), []byte("tag:yaml.org,2002:")},
+}
+
+// Parse directives.
+func yaml_parser_process_directives(parser *yaml_parser_t,
+ version_directive_ref **yaml_version_directive_t,
+ tag_directives_ref *[]yaml_tag_directive_t) bool {
+
+ var version_directive *yaml_version_directive_t
+ var tag_directives []yaml_tag_directive_t
+
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+
+ for token.typ == yaml_VERSION_DIRECTIVE_TOKEN || token.typ == yaml_TAG_DIRECTIVE_TOKEN {
+ if token.typ == yaml_VERSION_DIRECTIVE_TOKEN {
+ if version_directive != nil {
+ yaml_parser_set_parser_error(parser,
+ "found duplicate %YAML directive", token.start_mark)
+ return false
+ }
+ if token.major != 1 || token.minor != 1 {
+ yaml_parser_set_parser_error(parser,
+ "found incompatible YAML document", token.start_mark)
+ return false
+ }
+ version_directive = &yaml_version_directive_t{
+ major: token.major,
+ minor: token.minor,
+ }
+ } else if token.typ == yaml_TAG_DIRECTIVE_TOKEN {
+ value := yaml_tag_directive_t{
+ handle: token.value,
+ prefix: token.prefix,
+ }
+ if !yaml_parser_append_tag_directive(parser, value, false, token.start_mark) {
+ return false
+ }
+ tag_directives = append(tag_directives, value)
+ }
+
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ }
+
+ for i := range default_tag_directives {
+ if !yaml_parser_append_tag_directive(parser, default_tag_directives[i], true, token.start_mark) {
+ return false
+ }
+ }
+
+ if version_directive_ref != nil {
+ *version_directive_ref = version_directive
+ }
+ if tag_directives_ref != nil {
+ *tag_directives_ref = tag_directives
+ }
+ return true
+}
+
+// Append a tag directive to the directives stack.
+func yaml_parser_append_tag_directive(parser *yaml_parser_t, value yaml_tag_directive_t, allow_duplicates bool, mark yaml_mark_t) bool {
+ for i := range parser.tag_directives {
+ if bytes.Equal(value.handle, parser.tag_directives[i].handle) {
+ if allow_duplicates {
+ return true
+ }
+ return yaml_parser_set_parser_error(parser, "found duplicate %TAG directive", mark)
+ }
+ }
+
+ // [Go] I suspect the copy is unnecessary. This was likely done
+ // because there was no way to track ownership of the data.
+ value_copy := yaml_tag_directive_t{
+ handle: make([]byte, len(value.handle)),
+ prefix: make([]byte, len(value.prefix)),
+ }
+ copy(value_copy.handle, value.handle)
+ copy(value_copy.prefix, value.prefix)
+ parser.tag_directives = append(parser.tag_directives, value_copy)
+ return true
+}
diff --git a/vendor/sigs.k8s.io/yaml/goyaml.v2/readerc.go b/vendor/sigs.k8s.io/yaml/goyaml.v2/readerc.go
new file mode 100644
index 0000000000..7c1f5fac3d
--- /dev/null
+++ b/vendor/sigs.k8s.io/yaml/goyaml.v2/readerc.go
@@ -0,0 +1,412 @@
+package yaml
+
+import (
+ "io"
+)
+
+// Set the reader error and return 0.
+func yaml_parser_set_reader_error(parser *yaml_parser_t, problem string, offset int, value int) bool {
+ parser.error = yaml_READER_ERROR
+ parser.problem = problem
+ parser.problem_offset = offset
+ parser.problem_value = value
+ return false
+}
+
+// Byte order marks.
+const (
+ bom_UTF8 = "\xef\xbb\xbf"
+ bom_UTF16LE = "\xff\xfe"
+ bom_UTF16BE = "\xfe\xff"
+)
+
+// Determine the input stream encoding by checking the BOM symbol. If no BOM is
+// found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure.
+func yaml_parser_determine_encoding(parser *yaml_parser_t) bool {
+ // Ensure that we had enough bytes in the raw buffer.
+ for !parser.eof && len(parser.raw_buffer)-parser.raw_buffer_pos < 3 {
+ if !yaml_parser_update_raw_buffer(parser) {
+ return false
+ }
+ }
+
+ // Determine the encoding.
+ buf := parser.raw_buffer
+ pos := parser.raw_buffer_pos
+ avail := len(buf) - pos
+ if avail >= 2 && buf[pos] == bom_UTF16LE[0] && buf[pos+1] == bom_UTF16LE[1] {
+ parser.encoding = yaml_UTF16LE_ENCODING
+ parser.raw_buffer_pos += 2
+ parser.offset += 2
+ } else if avail >= 2 && buf[pos] == bom_UTF16BE[0] && buf[pos+1] == bom_UTF16BE[1] {
+ parser.encoding = yaml_UTF16BE_ENCODING
+ parser.raw_buffer_pos += 2
+ parser.offset += 2
+ } else if avail >= 3 && buf[pos] == bom_UTF8[0] && buf[pos+1] == bom_UTF8[1] && buf[pos+2] == bom_UTF8[2] {
+ parser.encoding = yaml_UTF8_ENCODING
+ parser.raw_buffer_pos += 3
+ parser.offset += 3
+ } else {
+ parser.encoding = yaml_UTF8_ENCODING
+ }
+ return true
+}
+
+// Update the raw buffer.
+func yaml_parser_update_raw_buffer(parser *yaml_parser_t) bool {
+ size_read := 0
+
+ // Return if the raw buffer is full.
+ if parser.raw_buffer_pos == 0 && len(parser.raw_buffer) == cap(parser.raw_buffer) {
+ return true
+ }
+
+ // Return on EOF.
+ if parser.eof {
+ return true
+ }
+
+ // Move the remaining bytes in the raw buffer to the beginning.
+ if parser.raw_buffer_pos > 0 && parser.raw_buffer_pos < len(parser.raw_buffer) {
+ copy(parser.raw_buffer, parser.raw_buffer[parser.raw_buffer_pos:])
+ }
+ parser.raw_buffer = parser.raw_buffer[:len(parser.raw_buffer)-parser.raw_buffer_pos]
+ parser.raw_buffer_pos = 0
+
+ // Call the read handler to fill the buffer.
+ size_read, err := parser.read_handler(parser, parser.raw_buffer[len(parser.raw_buffer):cap(parser.raw_buffer)])
+ parser.raw_buffer = parser.raw_buffer[:len(parser.raw_buffer)+size_read]
+ if err == io.EOF {
+ parser.eof = true
+ } else if err != nil {
+ return yaml_parser_set_reader_error(parser, "input error: "+err.Error(), parser.offset, -1)
+ }
+ return true
+}
+
+// Ensure that the buffer contains at least `length` characters.
+// Return true on success, false on failure.
+//
+// The length is supposed to be significantly less that the buffer size.
+func yaml_parser_update_buffer(parser *yaml_parser_t, length int) bool {
+ if parser.read_handler == nil {
+ panic("read handler must be set")
+ }
+
+ // [Go] This function was changed to guarantee the requested length size at EOF.
+ // The fact we need to do this is pretty awful, but the description above implies
+ // for that to be the case, and there are tests
+
+ // If the EOF flag is set and the raw buffer is empty, do nothing.
+ if parser.eof && parser.raw_buffer_pos == len(parser.raw_buffer) {
+ // [Go] ACTUALLY! Read the documentation of this function above.
+ // This is just broken. To return true, we need to have the
+ // given length in the buffer. Not doing that means every single
+ // check that calls this function to make sure the buffer has a
+ // given length is Go) panicking; or C) accessing invalid memory.
+ //return true
+ }
+
+ // Return if the buffer contains enough characters.
+ if parser.unread >= length {
+ return true
+ }
+
+ // Determine the input encoding if it is not known yet.
+ if parser.encoding == yaml_ANY_ENCODING {
+ if !yaml_parser_determine_encoding(parser) {
+ return false
+ }
+ }
+
+ // Move the unread characters to the beginning of the buffer.
+ buffer_len := len(parser.buffer)
+ if parser.buffer_pos > 0 && parser.buffer_pos < buffer_len {
+ copy(parser.buffer, parser.buffer[parser.buffer_pos:])
+ buffer_len -= parser.buffer_pos
+ parser.buffer_pos = 0
+ } else if parser.buffer_pos == buffer_len {
+ buffer_len = 0
+ parser.buffer_pos = 0
+ }
+
+ // Open the whole buffer for writing, and cut it before returning.
+ parser.buffer = parser.buffer[:cap(parser.buffer)]
+
+ // Fill the buffer until it has enough characters.
+ first := true
+ for parser.unread < length {
+
+ // Fill the raw buffer if necessary.
+ if !first || parser.raw_buffer_pos == len(parser.raw_buffer) {
+ if !yaml_parser_update_raw_buffer(parser) {
+ parser.buffer = parser.buffer[:buffer_len]
+ return false
+ }
+ }
+ first = false
+
+ // Decode the raw buffer.
+ inner:
+ for parser.raw_buffer_pos != len(parser.raw_buffer) {
+ var value rune
+ var width int
+
+ raw_unread := len(parser.raw_buffer) - parser.raw_buffer_pos
+
+ // Decode the next character.
+ switch parser.encoding {
+ case yaml_UTF8_ENCODING:
+ // Decode a UTF-8 character. Check RFC 3629
+ // (http://www.ietf.org/rfc/rfc3629.txt) for more details.
+ //
+ // The following table (taken from the RFC) is used for
+ // decoding.
+ //
+ // Char. number range | UTF-8 octet sequence
+ // (hexadecimal) | (binary)
+ // --------------------+------------------------------------
+ // 0000 0000-0000 007F | 0xxxxxxx
+ // 0000 0080-0000 07FF | 110xxxxx 10xxxxxx
+ // 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
+ // 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+ //
+ // Additionally, the characters in the range 0xD800-0xDFFF
+ // are prohibited as they are reserved for use with UTF-16
+ // surrogate pairs.
+
+ // Determine the length of the UTF-8 sequence.
+ octet := parser.raw_buffer[parser.raw_buffer_pos]
+ switch {
+ case octet&0x80 == 0x00:
+ width = 1
+ case octet&0xE0 == 0xC0:
+ width = 2
+ case octet&0xF0 == 0xE0:
+ width = 3
+ case octet&0xF8 == 0xF0:
+ width = 4
+ default:
+ // The leading octet is invalid.
+ return yaml_parser_set_reader_error(parser,
+ "invalid leading UTF-8 octet",
+ parser.offset, int(octet))
+ }
+
+ // Check if the raw buffer contains an incomplete character.
+ if width > raw_unread {
+ if parser.eof {
+ return yaml_parser_set_reader_error(parser,
+ "incomplete UTF-8 octet sequence",
+ parser.offset, -1)
+ }
+ break inner
+ }
+
+ // Decode the leading octet.
+ switch {
+ case octet&0x80 == 0x00:
+ value = rune(octet & 0x7F)
+ case octet&0xE0 == 0xC0:
+ value = rune(octet & 0x1F)
+ case octet&0xF0 == 0xE0:
+ value = rune(octet & 0x0F)
+ case octet&0xF8 == 0xF0:
+ value = rune(octet & 0x07)
+ default:
+ value = 0
+ }
+
+ // Check and decode the trailing octets.
+ for k := 1; k < width; k++ {
+ octet = parser.raw_buffer[parser.raw_buffer_pos+k]
+
+ // Check if the octet is valid.
+ if (octet & 0xC0) != 0x80 {
+ return yaml_parser_set_reader_error(parser,
+ "invalid trailing UTF-8 octet",
+ parser.offset+k, int(octet))
+ }
+
+ // Decode the octet.
+ value = (value << 6) + rune(octet&0x3F)
+ }
+
+ // Check the length of the sequence against the value.
+ switch {
+ case width == 1:
+ case width == 2 && value >= 0x80:
+ case width == 3 && value >= 0x800:
+ case width == 4 && value >= 0x10000:
+ default:
+ return yaml_parser_set_reader_error(parser,
+ "invalid length of a UTF-8 sequence",
+ parser.offset, -1)
+ }
+
+ // Check the range of the value.
+ if value >= 0xD800 && value <= 0xDFFF || value > 0x10FFFF {
+ return yaml_parser_set_reader_error(parser,
+ "invalid Unicode character",
+ parser.offset, int(value))
+ }
+
+ case yaml_UTF16LE_ENCODING, yaml_UTF16BE_ENCODING:
+ var low, high int
+ if parser.encoding == yaml_UTF16LE_ENCODING {
+ low, high = 0, 1
+ } else {
+ low, high = 1, 0
+ }
+
+ // The UTF-16 encoding is not as simple as one might
+ // naively think. Check RFC 2781
+ // (http://www.ietf.org/rfc/rfc2781.txt).
+ //
+ // Normally, two subsequent bytes describe a Unicode
+ // character. However a special technique (called a
+ // surrogate pair) is used for specifying character
+ // values larger than 0xFFFF.
+ //
+ // A surrogate pair consists of two pseudo-characters:
+ // high surrogate area (0xD800-0xDBFF)
+ // low surrogate area (0xDC00-0xDFFF)
+ //
+ // The following formulas are used for decoding
+ // and encoding characters using surrogate pairs:
+ //
+ // U = U' + 0x10000 (0x01 00 00 <= U <= 0x10 FF FF)
+ // U' = yyyyyyyyyyxxxxxxxxxx (0 <= U' <= 0x0F FF FF)
+ // W1 = 110110yyyyyyyyyy
+ // W2 = 110111xxxxxxxxxx
+ //
+ // where U is the character value, W1 is the high surrogate
+ // area, W2 is the low surrogate area.
+
+ // Check for incomplete UTF-16 character.
+ if raw_unread < 2 {
+ if parser.eof {
+ return yaml_parser_set_reader_error(parser,
+ "incomplete UTF-16 character",
+ parser.offset, -1)
+ }
+ break inner
+ }
+
+ // Get the character.
+ value = rune(parser.raw_buffer[parser.raw_buffer_pos+low]) +
+ (rune(parser.raw_buffer[parser.raw_buffer_pos+high]) << 8)
+
+ // Check for unexpected low surrogate area.
+ if value&0xFC00 == 0xDC00 {
+ return yaml_parser_set_reader_error(parser,
+ "unexpected low surrogate area",
+ parser.offset, int(value))
+ }
+
+ // Check for a high surrogate area.
+ if value&0xFC00 == 0xD800 {
+ width = 4
+
+ // Check for incomplete surrogate pair.
+ if raw_unread < 4 {
+ if parser.eof {
+ return yaml_parser_set_reader_error(parser,
+ "incomplete UTF-16 surrogate pair",
+ parser.offset, -1)
+ }
+ break inner
+ }
+
+ // Get the next character.
+ value2 := rune(parser.raw_buffer[parser.raw_buffer_pos+low+2]) +
+ (rune(parser.raw_buffer[parser.raw_buffer_pos+high+2]) << 8)
+
+ // Check for a low surrogate area.
+ if value2&0xFC00 != 0xDC00 {
+ return yaml_parser_set_reader_error(parser,
+ "expected low surrogate area",
+ parser.offset+2, int(value2))
+ }
+
+ // Generate the value of the surrogate pair.
+ value = 0x10000 + ((value & 0x3FF) << 10) + (value2 & 0x3FF)
+ } else {
+ width = 2
+ }
+
+ default:
+ panic("impossible")
+ }
+
+ // Check if the character is in the allowed range:
+ // #x9 | #xA | #xD | [#x20-#x7E] (8 bit)
+ // | #x85 | [#xA0-#xD7FF] | [#xE000-#xFFFD] (16 bit)
+ // | [#x10000-#x10FFFF] (32 bit)
+ switch {
+ case value == 0x09:
+ case value == 0x0A:
+ case value == 0x0D:
+ case value >= 0x20 && value <= 0x7E:
+ case value == 0x85:
+ case value >= 0xA0 && value <= 0xD7FF:
+ case value >= 0xE000 && value <= 0xFFFD:
+ case value >= 0x10000 && value <= 0x10FFFF:
+ default:
+ return yaml_parser_set_reader_error(parser,
+ "control characters are not allowed",
+ parser.offset, int(value))
+ }
+
+ // Move the raw pointers.
+ parser.raw_buffer_pos += width
+ parser.offset += width
+
+ // Finally put the character into the buffer.
+ if value <= 0x7F {
+ // 0000 0000-0000 007F . 0xxxxxxx
+ parser.buffer[buffer_len+0] = byte(value)
+ buffer_len += 1
+ } else if value <= 0x7FF {
+ // 0000 0080-0000 07FF . 110xxxxx 10xxxxxx
+ parser.buffer[buffer_len+0] = byte(0xC0 + (value >> 6))
+ parser.buffer[buffer_len+1] = byte(0x80 + (value & 0x3F))
+ buffer_len += 2
+ } else if value <= 0xFFFF {
+ // 0000 0800-0000 FFFF . 1110xxxx 10xxxxxx 10xxxxxx
+ parser.buffer[buffer_len+0] = byte(0xE0 + (value >> 12))
+ parser.buffer[buffer_len+1] = byte(0x80 + ((value >> 6) & 0x3F))
+ parser.buffer[buffer_len+2] = byte(0x80 + (value & 0x3F))
+ buffer_len += 3
+ } else {
+ // 0001 0000-0010 FFFF . 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+ parser.buffer[buffer_len+0] = byte(0xF0 + (value >> 18))
+ parser.buffer[buffer_len+1] = byte(0x80 + ((value >> 12) & 0x3F))
+ parser.buffer[buffer_len+2] = byte(0x80 + ((value >> 6) & 0x3F))
+ parser.buffer[buffer_len+3] = byte(0x80 + (value & 0x3F))
+ buffer_len += 4
+ }
+
+ parser.unread++
+ }
+
+ // On EOF, put NUL into the buffer and return.
+ if parser.eof {
+ parser.buffer[buffer_len] = 0
+ buffer_len++
+ parser.unread++
+ break
+ }
+ }
+ // [Go] Read the documentation of this function above. To return true,
+ // we need to have the given length in the buffer. Not doing that means
+ // every single check that calls this function to make sure the buffer
+ // has a given length is Go) panicking; or C) accessing invalid memory.
+ // This happens here due to the EOF above breaking early.
+ for buffer_len < length {
+ parser.buffer[buffer_len] = 0
+ buffer_len++
+ }
+ parser.buffer = parser.buffer[:buffer_len]
+ return true
+}
diff --git a/vendor/sigs.k8s.io/yaml/goyaml.v2/resolve.go b/vendor/sigs.k8s.io/yaml/goyaml.v2/resolve.go
new file mode 100644
index 0000000000..4120e0c916
--- /dev/null
+++ b/vendor/sigs.k8s.io/yaml/goyaml.v2/resolve.go
@@ -0,0 +1,258 @@
+package yaml
+
+import (
+ "encoding/base64"
+ "math"
+ "regexp"
+ "strconv"
+ "strings"
+ "time"
+)
+
+type resolveMapItem struct {
+ value interface{}
+ tag string
+}
+
+var resolveTable = make([]byte, 256)
+var resolveMap = make(map[string]resolveMapItem)
+
+func init() {
+ t := resolveTable
+ t[int('+')] = 'S' // Sign
+ t[int('-')] = 'S'
+ for _, c := range "0123456789" {
+ t[int(c)] = 'D' // Digit
+ }
+ for _, c := range "yYnNtTfFoO~" {
+ t[int(c)] = 'M' // In map
+ }
+ t[int('.')] = '.' // Float (potentially in map)
+
+ var resolveMapList = []struct {
+ v interface{}
+ tag string
+ l []string
+ }{
+ {true, yaml_BOOL_TAG, []string{"y", "Y", "yes", "Yes", "YES"}},
+ {true, yaml_BOOL_TAG, []string{"true", "True", "TRUE"}},
+ {true, yaml_BOOL_TAG, []string{"on", "On", "ON"}},
+ {false, yaml_BOOL_TAG, []string{"n", "N", "no", "No", "NO"}},
+ {false, yaml_BOOL_TAG, []string{"false", "False", "FALSE"}},
+ {false, yaml_BOOL_TAG, []string{"off", "Off", "OFF"}},
+ {nil, yaml_NULL_TAG, []string{"", "~", "null", "Null", "NULL"}},
+ {math.NaN(), yaml_FLOAT_TAG, []string{".nan", ".NaN", ".NAN"}},
+ {math.Inf(+1), yaml_FLOAT_TAG, []string{".inf", ".Inf", ".INF"}},
+ {math.Inf(+1), yaml_FLOAT_TAG, []string{"+.inf", "+.Inf", "+.INF"}},
+ {math.Inf(-1), yaml_FLOAT_TAG, []string{"-.inf", "-.Inf", "-.INF"}},
+ {"<<", yaml_MERGE_TAG, []string{"<<"}},
+ }
+
+ m := resolveMap
+ for _, item := range resolveMapList {
+ for _, s := range item.l {
+ m[s] = resolveMapItem{item.v, item.tag}
+ }
+ }
+}
+
+const longTagPrefix = "tag:yaml.org,2002:"
+
+func shortTag(tag string) string {
+ // TODO This can easily be made faster and produce less garbage.
+ if strings.HasPrefix(tag, longTagPrefix) {
+ return "!!" + tag[len(longTagPrefix):]
+ }
+ return tag
+}
+
+func longTag(tag string) string {
+ if strings.HasPrefix(tag, "!!") {
+ return longTagPrefix + tag[2:]
+ }
+ return tag
+}
+
+func resolvableTag(tag string) bool {
+ switch tag {
+ case "", yaml_STR_TAG, yaml_BOOL_TAG, yaml_INT_TAG, yaml_FLOAT_TAG, yaml_NULL_TAG, yaml_TIMESTAMP_TAG:
+ return true
+ }
+ return false
+}
+
+var yamlStyleFloat = regexp.MustCompile(`^[-+]?(\.[0-9]+|[0-9]+(\.[0-9]*)?)([eE][-+]?[0-9]+)?$`)
+
+func resolve(tag string, in string) (rtag string, out interface{}) {
+ if !resolvableTag(tag) {
+ return tag, in
+ }
+
+ defer func() {
+ switch tag {
+ case "", rtag, yaml_STR_TAG, yaml_BINARY_TAG:
+ return
+ case yaml_FLOAT_TAG:
+ if rtag == yaml_INT_TAG {
+ switch v := out.(type) {
+ case int64:
+ rtag = yaml_FLOAT_TAG
+ out = float64(v)
+ return
+ case int:
+ rtag = yaml_FLOAT_TAG
+ out = float64(v)
+ return
+ }
+ }
+ }
+ failf("cannot decode %s `%s` as a %s", shortTag(rtag), in, shortTag(tag))
+ }()
+
+ // Any data is accepted as a !!str or !!binary.
+ // Otherwise, the prefix is enough of a hint about what it might be.
+ hint := byte('N')
+ if in != "" {
+ hint = resolveTable[in[0]]
+ }
+ if hint != 0 && tag != yaml_STR_TAG && tag != yaml_BINARY_TAG {
+ // Handle things we can lookup in a map.
+ if item, ok := resolveMap[in]; ok {
+ return item.tag, item.value
+ }
+
+ // Base 60 floats are a bad idea, were dropped in YAML 1.2, and
+ // are purposefully unsupported here. They're still quoted on
+ // the way out for compatibility with other parser, though.
+
+ switch hint {
+ case 'M':
+ // We've already checked the map above.
+
+ case '.':
+ // Not in the map, so maybe a normal float.
+ floatv, err := strconv.ParseFloat(in, 64)
+ if err == nil {
+ return yaml_FLOAT_TAG, floatv
+ }
+
+ case 'D', 'S':
+ // Int, float, or timestamp.
+ // Only try values as a timestamp if the value is unquoted or there's an explicit
+ // !!timestamp tag.
+ if tag == "" || tag == yaml_TIMESTAMP_TAG {
+ t, ok := parseTimestamp(in)
+ if ok {
+ return yaml_TIMESTAMP_TAG, t
+ }
+ }
+
+ plain := strings.Replace(in, "_", "", -1)
+ intv, err := strconv.ParseInt(plain, 0, 64)
+ if err == nil {
+ if intv == int64(int(intv)) {
+ return yaml_INT_TAG, int(intv)
+ } else {
+ return yaml_INT_TAG, intv
+ }
+ }
+ uintv, err := strconv.ParseUint(plain, 0, 64)
+ if err == nil {
+ return yaml_INT_TAG, uintv
+ }
+ if yamlStyleFloat.MatchString(plain) {
+ floatv, err := strconv.ParseFloat(plain, 64)
+ if err == nil {
+ return yaml_FLOAT_TAG, floatv
+ }
+ }
+ if strings.HasPrefix(plain, "0b") {
+ intv, err := strconv.ParseInt(plain[2:], 2, 64)
+ if err == nil {
+ if intv == int64(int(intv)) {
+ return yaml_INT_TAG, int(intv)
+ } else {
+ return yaml_INT_TAG, intv
+ }
+ }
+ uintv, err := strconv.ParseUint(plain[2:], 2, 64)
+ if err == nil {
+ return yaml_INT_TAG, uintv
+ }
+ } else if strings.HasPrefix(plain, "-0b") {
+ intv, err := strconv.ParseInt("-" + plain[3:], 2, 64)
+ if err == nil {
+ if true || intv == int64(int(intv)) {
+ return yaml_INT_TAG, int(intv)
+ } else {
+ return yaml_INT_TAG, intv
+ }
+ }
+ }
+ default:
+ panic("resolveTable item not yet handled: " + string(rune(hint)) + " (with " + in + ")")
+ }
+ }
+ return yaml_STR_TAG, in
+}
+
+// encodeBase64 encodes s as base64 that is broken up into multiple lines
+// as appropriate for the resulting length.
+func encodeBase64(s string) string {
+ const lineLen = 70
+ encLen := base64.StdEncoding.EncodedLen(len(s))
+ lines := encLen/lineLen + 1
+ buf := make([]byte, encLen*2+lines)
+ in := buf[0:encLen]
+ out := buf[encLen:]
+ base64.StdEncoding.Encode(in, []byte(s))
+ k := 0
+ for i := 0; i < len(in); i += lineLen {
+ j := i + lineLen
+ if j > len(in) {
+ j = len(in)
+ }
+ k += copy(out[k:], in[i:j])
+ if lines > 1 {
+ out[k] = '\n'
+ k++
+ }
+ }
+ return string(out[:k])
+}
+
+// This is a subset of the formats allowed by the regular expression
+// defined at http://yaml.org/type/timestamp.html.
+var allowedTimestampFormats = []string{
+ "2006-1-2T15:4:5.999999999Z07:00", // RCF3339Nano with short date fields.
+ "2006-1-2t15:4:5.999999999Z07:00", // RFC3339Nano with short date fields and lower-case "t".
+ "2006-1-2 15:4:5.999999999", // space separated with no time zone
+ "2006-1-2", // date only
+ // Notable exception: time.Parse cannot handle: "2001-12-14 21:59:43.10 -5"
+ // from the set of examples.
+}
+
+// parseTimestamp parses s as a timestamp string and
+// returns the timestamp and reports whether it succeeded.
+// Timestamp formats are defined at http://yaml.org/type/timestamp.html
+func parseTimestamp(s string) (time.Time, bool) {
+ // TODO write code to check all the formats supported by
+ // http://yaml.org/type/timestamp.html instead of using time.Parse.
+
+ // Quick check: all date formats start with YYYY-.
+ i := 0
+ for ; i < len(s); i++ {
+ if c := s[i]; c < '0' || c > '9' {
+ break
+ }
+ }
+ if i != 4 || i == len(s) || s[i] != '-' {
+ return time.Time{}, false
+ }
+ for _, format := range allowedTimestampFormats {
+ if t, err := time.Parse(format, s); err == nil {
+ return t, true
+ }
+ }
+ return time.Time{}, false
+}
diff --git a/vendor/sigs.k8s.io/yaml/goyaml.v2/scannerc.go b/vendor/sigs.k8s.io/yaml/goyaml.v2/scannerc.go
new file mode 100644
index 0000000000..0b9bb6030a
--- /dev/null
+++ b/vendor/sigs.k8s.io/yaml/goyaml.v2/scannerc.go
@@ -0,0 +1,2711 @@
+package yaml
+
+import (
+ "bytes"
+ "fmt"
+)
+
+// Introduction
+// ************
+//
+// The following notes assume that you are familiar with the YAML specification
+// (http://yaml.org/spec/1.2/spec.html). We mostly follow it, although in
+// some cases we are less restrictive that it requires.
+//
+// The process of transforming a YAML stream into a sequence of events is
+// divided on two steps: Scanning and Parsing.
+//
+// The Scanner transforms the input stream into a sequence of tokens, while the
+// parser transform the sequence of tokens produced by the Scanner into a
+// sequence of parsing events.
+//
+// The Scanner is rather clever and complicated. The Parser, on the contrary,
+// is a straightforward implementation of a recursive-descendant parser (or,
+// LL(1) parser, as it is usually called).
+//
+// Actually there are two issues of Scanning that might be called "clever", the
+// rest is quite straightforward. The issues are "block collection start" and
+// "simple keys". Both issues are explained below in details.
+//
+// Here the Scanning step is explained and implemented. We start with the list
+// of all the tokens produced by the Scanner together with short descriptions.
+//
+// Now, tokens:
+//
+// STREAM-START(encoding) # The stream start.
+// STREAM-END # The stream end.
+// VERSION-DIRECTIVE(major,minor) # The '%YAML' directive.
+// TAG-DIRECTIVE(handle,prefix) # The '%TAG' directive.
+// DOCUMENT-START # '---'
+// DOCUMENT-END # '...'
+// BLOCK-SEQUENCE-START # Indentation increase denoting a block
+// BLOCK-MAPPING-START # sequence or a block mapping.
+// BLOCK-END # Indentation decrease.
+// FLOW-SEQUENCE-START # '['
+// FLOW-SEQUENCE-END # ']'
+// BLOCK-SEQUENCE-START # '{'
+// BLOCK-SEQUENCE-END # '}'
+// BLOCK-ENTRY # '-'
+// FLOW-ENTRY # ','
+// KEY # '?' or nothing (simple keys).
+// VALUE # ':'
+// ALIAS(anchor) # '*anchor'
+// ANCHOR(anchor) # '&anchor'
+// TAG(handle,suffix) # '!handle!suffix'
+// SCALAR(value,style) # A scalar.
+//
+// The following two tokens are "virtual" tokens denoting the beginning and the
+// end of the stream:
+//
+// STREAM-START(encoding)
+// STREAM-END
+//
+// We pass the information about the input stream encoding with the
+// STREAM-START token.
+//
+// The next two tokens are responsible for tags:
+//
+// VERSION-DIRECTIVE(major,minor)
+// TAG-DIRECTIVE(handle,prefix)
+//
+// Example:
+//
+// %YAML 1.1
+// %TAG ! !foo
+// %TAG !yaml! tag:yaml.org,2002:
+// ---
+//
+// The correspoding sequence of tokens:
+//
+// STREAM-START(utf-8)
+// VERSION-DIRECTIVE(1,1)
+// TAG-DIRECTIVE("!","!foo")
+// TAG-DIRECTIVE("!yaml","tag:yaml.org,2002:")
+// DOCUMENT-START
+// STREAM-END
+//
+// Note that the VERSION-DIRECTIVE and TAG-DIRECTIVE tokens occupy a whole
+// line.
+//
+// The document start and end indicators are represented by:
+//
+// DOCUMENT-START
+// DOCUMENT-END
+//
+// Note that if a YAML stream contains an implicit document (without '---'
+// and '...' indicators), no DOCUMENT-START and DOCUMENT-END tokens will be
+// produced.
+//
+// In the following examples, we present whole documents together with the
+// produced tokens.
+//
+// 1. An implicit document:
+//
+// 'a scalar'
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// SCALAR("a scalar",single-quoted)
+// STREAM-END
+//
+// 2. An explicit document:
+//
+// ---
+// 'a scalar'
+// ...
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// DOCUMENT-START
+// SCALAR("a scalar",single-quoted)
+// DOCUMENT-END
+// STREAM-END
+//
+// 3. Several documents in a stream:
+//
+// 'a scalar'
+// ---
+// 'another scalar'
+// ---
+// 'yet another scalar'
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// SCALAR("a scalar",single-quoted)
+// DOCUMENT-START
+// SCALAR("another scalar",single-quoted)
+// DOCUMENT-START
+// SCALAR("yet another scalar",single-quoted)
+// STREAM-END
+//
+// We have already introduced the SCALAR token above. The following tokens are
+// used to describe aliases, anchors, tag, and scalars:
+//
+// ALIAS(anchor)
+// ANCHOR(anchor)
+// TAG(handle,suffix)
+// SCALAR(value,style)
+//
+// The following series of examples illustrate the usage of these tokens:
+//
+// 1. A recursive sequence:
+//
+// &A [ *A ]
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// ANCHOR("A")
+// FLOW-SEQUENCE-START
+// ALIAS("A")
+// FLOW-SEQUENCE-END
+// STREAM-END
+//
+// 2. A tagged scalar:
+//
+// !!float "3.14" # A good approximation.
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// TAG("!!","float")
+// SCALAR("3.14",double-quoted)
+// STREAM-END
+//
+// 3. Various scalar styles:
+//
+// --- # Implicit empty plain scalars do not produce tokens.
+// --- a plain scalar
+// --- 'a single-quoted scalar'
+// --- "a double-quoted scalar"
+// --- |-
+// a literal scalar
+// --- >-
+// a folded
+// scalar
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// DOCUMENT-START
+// DOCUMENT-START
+// SCALAR("a plain scalar",plain)
+// DOCUMENT-START
+// SCALAR("a single-quoted scalar",single-quoted)
+// DOCUMENT-START
+// SCALAR("a double-quoted scalar",double-quoted)
+// DOCUMENT-START
+// SCALAR("a literal scalar",literal)
+// DOCUMENT-START
+// SCALAR("a folded scalar",folded)
+// STREAM-END
+//
+// Now it's time to review collection-related tokens. We will start with
+// flow collections:
+//
+// FLOW-SEQUENCE-START
+// FLOW-SEQUENCE-END
+// FLOW-MAPPING-START
+// FLOW-MAPPING-END
+// FLOW-ENTRY
+// KEY
+// VALUE
+//
+// The tokens FLOW-SEQUENCE-START, FLOW-SEQUENCE-END, FLOW-MAPPING-START, and
+// FLOW-MAPPING-END represent the indicators '[', ']', '{', and '}'
+// correspondingly. FLOW-ENTRY represent the ',' indicator. Finally the
+// indicators '?' and ':', which are used for denoting mapping keys and values,
+// are represented by the KEY and VALUE tokens.
+//
+// The following examples show flow collections:
+//
+// 1. A flow sequence:
+//
+// [item 1, item 2, item 3]
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// FLOW-SEQUENCE-START
+// SCALAR("item 1",plain)
+// FLOW-ENTRY
+// SCALAR("item 2",plain)
+// FLOW-ENTRY
+// SCALAR("item 3",plain)
+// FLOW-SEQUENCE-END
+// STREAM-END
+//
+// 2. A flow mapping:
+//
+// {
+// a simple key: a value, # Note that the KEY token is produced.
+// ? a complex key: another value,
+// }
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// FLOW-MAPPING-START
+// KEY
+// SCALAR("a simple key",plain)
+// VALUE
+// SCALAR("a value",plain)
+// FLOW-ENTRY
+// KEY
+// SCALAR("a complex key",plain)
+// VALUE
+// SCALAR("another value",plain)
+// FLOW-ENTRY
+// FLOW-MAPPING-END
+// STREAM-END
+//
+// A simple key is a key which is not denoted by the '?' indicator. Note that
+// the Scanner still produce the KEY token whenever it encounters a simple key.
+//
+// For scanning block collections, the following tokens are used (note that we
+// repeat KEY and VALUE here):
+//
+// BLOCK-SEQUENCE-START
+// BLOCK-MAPPING-START
+// BLOCK-END
+// BLOCK-ENTRY
+// KEY
+// VALUE
+//
+// The tokens BLOCK-SEQUENCE-START and BLOCK-MAPPING-START denote indentation
+// increase that precedes a block collection (cf. the INDENT token in Python).
+// The token BLOCK-END denote indentation decrease that ends a block collection
+// (cf. the DEDENT token in Python). However YAML has some syntax pecularities
+// that makes detections of these tokens more complex.
+//
+// The tokens BLOCK-ENTRY, KEY, and VALUE are used to represent the indicators
+// '-', '?', and ':' correspondingly.
+//
+// The following examples show how the tokens BLOCK-SEQUENCE-START,
+// BLOCK-MAPPING-START, and BLOCK-END are emitted by the Scanner:
+//
+// 1. Block sequences:
+//
+// - item 1
+// - item 2
+// -
+// - item 3.1
+// - item 3.2
+// -
+// key 1: value 1
+// key 2: value 2
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// BLOCK-SEQUENCE-START
+// BLOCK-ENTRY
+// SCALAR("item 1",plain)
+// BLOCK-ENTRY
+// SCALAR("item 2",plain)
+// BLOCK-ENTRY
+// BLOCK-SEQUENCE-START
+// BLOCK-ENTRY
+// SCALAR("item 3.1",plain)
+// BLOCK-ENTRY
+// SCALAR("item 3.2",plain)
+// BLOCK-END
+// BLOCK-ENTRY
+// BLOCK-MAPPING-START
+// KEY
+// SCALAR("key 1",plain)
+// VALUE
+// SCALAR("value 1",plain)
+// KEY
+// SCALAR("key 2",plain)
+// VALUE
+// SCALAR("value 2",plain)
+// BLOCK-END
+// BLOCK-END
+// STREAM-END
+//
+// 2. Block mappings:
+//
+// a simple key: a value # The KEY token is produced here.
+// ? a complex key
+// : another value
+// a mapping:
+// key 1: value 1
+// key 2: value 2
+// a sequence:
+// - item 1
+// - item 2
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// BLOCK-MAPPING-START
+// KEY
+// SCALAR("a simple key",plain)
+// VALUE
+// SCALAR("a value",plain)
+// KEY
+// SCALAR("a complex key",plain)
+// VALUE
+// SCALAR("another value",plain)
+// KEY
+// SCALAR("a mapping",plain)
+// BLOCK-MAPPING-START
+// KEY
+// SCALAR("key 1",plain)
+// VALUE
+// SCALAR("value 1",plain)
+// KEY
+// SCALAR("key 2",plain)
+// VALUE
+// SCALAR("value 2",plain)
+// BLOCK-END
+// KEY
+// SCALAR("a sequence",plain)
+// VALUE
+// BLOCK-SEQUENCE-START
+// BLOCK-ENTRY
+// SCALAR("item 1",plain)
+// BLOCK-ENTRY
+// SCALAR("item 2",plain)
+// BLOCK-END
+// BLOCK-END
+// STREAM-END
+//
+// YAML does not always require to start a new block collection from a new
+// line. If the current line contains only '-', '?', and ':' indicators, a new
+// block collection may start at the current line. The following examples
+// illustrate this case:
+//
+// 1. Collections in a sequence:
+//
+// - - item 1
+// - item 2
+// - key 1: value 1
+// key 2: value 2
+// - ? complex key
+// : complex value
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// BLOCK-SEQUENCE-START
+// BLOCK-ENTRY
+// BLOCK-SEQUENCE-START
+// BLOCK-ENTRY
+// SCALAR("item 1",plain)
+// BLOCK-ENTRY
+// SCALAR("item 2",plain)
+// BLOCK-END
+// BLOCK-ENTRY
+// BLOCK-MAPPING-START
+// KEY
+// SCALAR("key 1",plain)
+// VALUE
+// SCALAR("value 1",plain)
+// KEY
+// SCALAR("key 2",plain)
+// VALUE
+// SCALAR("value 2",plain)
+// BLOCK-END
+// BLOCK-ENTRY
+// BLOCK-MAPPING-START
+// KEY
+// SCALAR("complex key")
+// VALUE
+// SCALAR("complex value")
+// BLOCK-END
+// BLOCK-END
+// STREAM-END
+//
+// 2. Collections in a mapping:
+//
+// ? a sequence
+// : - item 1
+// - item 2
+// ? a mapping
+// : key 1: value 1
+// key 2: value 2
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// BLOCK-MAPPING-START
+// KEY
+// SCALAR("a sequence",plain)
+// VALUE
+// BLOCK-SEQUENCE-START
+// BLOCK-ENTRY
+// SCALAR("item 1",plain)
+// BLOCK-ENTRY
+// SCALAR("item 2",plain)
+// BLOCK-END
+// KEY
+// SCALAR("a mapping",plain)
+// VALUE
+// BLOCK-MAPPING-START
+// KEY
+// SCALAR("key 1",plain)
+// VALUE
+// SCALAR("value 1",plain)
+// KEY
+// SCALAR("key 2",plain)
+// VALUE
+// SCALAR("value 2",plain)
+// BLOCK-END
+// BLOCK-END
+// STREAM-END
+//
+// YAML also permits non-indented sequences if they are included into a block
+// mapping. In this case, the token BLOCK-SEQUENCE-START is not produced:
+//
+// key:
+// - item 1 # BLOCK-SEQUENCE-START is NOT produced here.
+// - item 2
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// BLOCK-MAPPING-START
+// KEY
+// SCALAR("key",plain)
+// VALUE
+// BLOCK-ENTRY
+// SCALAR("item 1",plain)
+// BLOCK-ENTRY
+// SCALAR("item 2",plain)
+// BLOCK-END
+//
+
+// Ensure that the buffer contains the required number of characters.
+// Return true on success, false on failure (reader error or memory error).
+func cache(parser *yaml_parser_t, length int) bool {
+ // [Go] This was inlined: !cache(A, B) -> unread < B && !update(A, B)
+ return parser.unread >= length || yaml_parser_update_buffer(parser, length)
+}
+
+// Advance the buffer pointer.
+func skip(parser *yaml_parser_t) {
+ parser.mark.index++
+ parser.mark.column++
+ parser.unread--
+ parser.buffer_pos += width(parser.buffer[parser.buffer_pos])
+}
+
+func skip_line(parser *yaml_parser_t) {
+ if is_crlf(parser.buffer, parser.buffer_pos) {
+ parser.mark.index += 2
+ parser.mark.column = 0
+ parser.mark.line++
+ parser.unread -= 2
+ parser.buffer_pos += 2
+ } else if is_break(parser.buffer, parser.buffer_pos) {
+ parser.mark.index++
+ parser.mark.column = 0
+ parser.mark.line++
+ parser.unread--
+ parser.buffer_pos += width(parser.buffer[parser.buffer_pos])
+ }
+}
+
+// Copy a character to a string buffer and advance pointers.
+func read(parser *yaml_parser_t, s []byte) []byte {
+ w := width(parser.buffer[parser.buffer_pos])
+ if w == 0 {
+ panic("invalid character sequence")
+ }
+ if len(s) == 0 {
+ s = make([]byte, 0, 32)
+ }
+ if w == 1 && len(s)+w <= cap(s) {
+ s = s[:len(s)+1]
+ s[len(s)-1] = parser.buffer[parser.buffer_pos]
+ parser.buffer_pos++
+ } else {
+ s = append(s, parser.buffer[parser.buffer_pos:parser.buffer_pos+w]...)
+ parser.buffer_pos += w
+ }
+ parser.mark.index++
+ parser.mark.column++
+ parser.unread--
+ return s
+}
+
+// Copy a line break character to a string buffer and advance pointers.
+func read_line(parser *yaml_parser_t, s []byte) []byte {
+ buf := parser.buffer
+ pos := parser.buffer_pos
+ switch {
+ case buf[pos] == '\r' && buf[pos+1] == '\n':
+ // CR LF . LF
+ s = append(s, '\n')
+ parser.buffer_pos += 2
+ parser.mark.index++
+ parser.unread--
+ case buf[pos] == '\r' || buf[pos] == '\n':
+ // CR|LF . LF
+ s = append(s, '\n')
+ parser.buffer_pos += 1
+ case buf[pos] == '\xC2' && buf[pos+1] == '\x85':
+ // NEL . LF
+ s = append(s, '\n')
+ parser.buffer_pos += 2
+ case buf[pos] == '\xE2' && buf[pos+1] == '\x80' && (buf[pos+2] == '\xA8' || buf[pos+2] == '\xA9'):
+ // LS|PS . LS|PS
+ s = append(s, buf[parser.buffer_pos:pos+3]...)
+ parser.buffer_pos += 3
+ default:
+ return s
+ }
+ parser.mark.index++
+ parser.mark.column = 0
+ parser.mark.line++
+ parser.unread--
+ return s
+}
+
+// Get the next token.
+func yaml_parser_scan(parser *yaml_parser_t, token *yaml_token_t) bool {
+ // Erase the token object.
+ *token = yaml_token_t{} // [Go] Is this necessary?
+
+ // No tokens after STREAM-END or error.
+ if parser.stream_end_produced || parser.error != yaml_NO_ERROR {
+ return true
+ }
+
+ // Ensure that the tokens queue contains enough tokens.
+ if !parser.token_available {
+ if !yaml_parser_fetch_more_tokens(parser) {
+ return false
+ }
+ }
+
+ // Fetch the next token from the queue.
+ *token = parser.tokens[parser.tokens_head]
+ parser.tokens_head++
+ parser.tokens_parsed++
+ parser.token_available = false
+
+ if token.typ == yaml_STREAM_END_TOKEN {
+ parser.stream_end_produced = true
+ }
+ return true
+}
+
+// Set the scanner error and return false.
+func yaml_parser_set_scanner_error(parser *yaml_parser_t, context string, context_mark yaml_mark_t, problem string) bool {
+ parser.error = yaml_SCANNER_ERROR
+ parser.context = context
+ parser.context_mark = context_mark
+ parser.problem = problem
+ parser.problem_mark = parser.mark
+ return false
+}
+
+func yaml_parser_set_scanner_tag_error(parser *yaml_parser_t, directive bool, context_mark yaml_mark_t, problem string) bool {
+ context := "while parsing a tag"
+ if directive {
+ context = "while parsing a %TAG directive"
+ }
+ return yaml_parser_set_scanner_error(parser, context, context_mark, problem)
+}
+
+func trace(args ...interface{}) func() {
+ pargs := append([]interface{}{"+++"}, args...)
+ fmt.Println(pargs...)
+ pargs = append([]interface{}{"---"}, args...)
+ return func() { fmt.Println(pargs...) }
+}
+
+// Ensure that the tokens queue contains at least one token which can be
+// returned to the Parser.
+func yaml_parser_fetch_more_tokens(parser *yaml_parser_t) bool {
+ // While we need more tokens to fetch, do it.
+ for {
+ if parser.tokens_head != len(parser.tokens) {
+ // If queue is non-empty, check if any potential simple key may
+ // occupy the head position.
+ head_tok_idx, ok := parser.simple_keys_by_tok[parser.tokens_parsed]
+ if !ok {
+ break
+ } else if valid, ok := yaml_simple_key_is_valid(parser, &parser.simple_keys[head_tok_idx]); !ok {
+ return false
+ } else if !valid {
+ break
+ }
+ }
+ // Fetch the next token.
+ if !yaml_parser_fetch_next_token(parser) {
+ return false
+ }
+ }
+
+ parser.token_available = true
+ return true
+}
+
+// The dispatcher for token fetchers.
+func yaml_parser_fetch_next_token(parser *yaml_parser_t) bool {
+ // Ensure that the buffer is initialized.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ // Check if we just started scanning. Fetch STREAM-START then.
+ if !parser.stream_start_produced {
+ return yaml_parser_fetch_stream_start(parser)
+ }
+
+ // Eat whitespaces and comments until we reach the next token.
+ if !yaml_parser_scan_to_next_token(parser) {
+ return false
+ }
+
+ // Check the indentation level against the current column.
+ if !yaml_parser_unroll_indent(parser, parser.mark.column) {
+ return false
+ }
+
+ // Ensure that the buffer contains at least 4 characters. 4 is the length
+ // of the longest indicators ('--- ' and '... ').
+ if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) {
+ return false
+ }
+
+ // Is it the end of the stream?
+ if is_z(parser.buffer, parser.buffer_pos) {
+ return yaml_parser_fetch_stream_end(parser)
+ }
+
+ // Is it a directive?
+ if parser.mark.column == 0 && parser.buffer[parser.buffer_pos] == '%' {
+ return yaml_parser_fetch_directive(parser)
+ }
+
+ buf := parser.buffer
+ pos := parser.buffer_pos
+
+ // Is it the document start indicator?
+ if parser.mark.column == 0 && buf[pos] == '-' && buf[pos+1] == '-' && buf[pos+2] == '-' && is_blankz(buf, pos+3) {
+ return yaml_parser_fetch_document_indicator(parser, yaml_DOCUMENT_START_TOKEN)
+ }
+
+ // Is it the document end indicator?
+ if parser.mark.column == 0 && buf[pos] == '.' && buf[pos+1] == '.' && buf[pos+2] == '.' && is_blankz(buf, pos+3) {
+ return yaml_parser_fetch_document_indicator(parser, yaml_DOCUMENT_END_TOKEN)
+ }
+
+ // Is it the flow sequence start indicator?
+ if buf[pos] == '[' {
+ return yaml_parser_fetch_flow_collection_start(parser, yaml_FLOW_SEQUENCE_START_TOKEN)
+ }
+
+ // Is it the flow mapping start indicator?
+ if parser.buffer[parser.buffer_pos] == '{' {
+ return yaml_parser_fetch_flow_collection_start(parser, yaml_FLOW_MAPPING_START_TOKEN)
+ }
+
+ // Is it the flow sequence end indicator?
+ if parser.buffer[parser.buffer_pos] == ']' {
+ return yaml_parser_fetch_flow_collection_end(parser,
+ yaml_FLOW_SEQUENCE_END_TOKEN)
+ }
+
+ // Is it the flow mapping end indicator?
+ if parser.buffer[parser.buffer_pos] == '}' {
+ return yaml_parser_fetch_flow_collection_end(parser,
+ yaml_FLOW_MAPPING_END_TOKEN)
+ }
+
+ // Is it the flow entry indicator?
+ if parser.buffer[parser.buffer_pos] == ',' {
+ return yaml_parser_fetch_flow_entry(parser)
+ }
+
+ // Is it the block entry indicator?
+ if parser.buffer[parser.buffer_pos] == '-' && is_blankz(parser.buffer, parser.buffer_pos+1) {
+ return yaml_parser_fetch_block_entry(parser)
+ }
+
+ // Is it the key indicator?
+ if parser.buffer[parser.buffer_pos] == '?' && (parser.flow_level > 0 || is_blankz(parser.buffer, parser.buffer_pos+1)) {
+ return yaml_parser_fetch_key(parser)
+ }
+
+ // Is it the value indicator?
+ if parser.buffer[parser.buffer_pos] == ':' && (parser.flow_level > 0 || is_blankz(parser.buffer, parser.buffer_pos+1)) {
+ return yaml_parser_fetch_value(parser)
+ }
+
+ // Is it an alias?
+ if parser.buffer[parser.buffer_pos] == '*' {
+ return yaml_parser_fetch_anchor(parser, yaml_ALIAS_TOKEN)
+ }
+
+ // Is it an anchor?
+ if parser.buffer[parser.buffer_pos] == '&' {
+ return yaml_parser_fetch_anchor(parser, yaml_ANCHOR_TOKEN)
+ }
+
+ // Is it a tag?
+ if parser.buffer[parser.buffer_pos] == '!' {
+ return yaml_parser_fetch_tag(parser)
+ }
+
+ // Is it a literal scalar?
+ if parser.buffer[parser.buffer_pos] == '|' && parser.flow_level == 0 {
+ return yaml_parser_fetch_block_scalar(parser, true)
+ }
+
+ // Is it a folded scalar?
+ if parser.buffer[parser.buffer_pos] == '>' && parser.flow_level == 0 {
+ return yaml_parser_fetch_block_scalar(parser, false)
+ }
+
+ // Is it a single-quoted scalar?
+ if parser.buffer[parser.buffer_pos] == '\'' {
+ return yaml_parser_fetch_flow_scalar(parser, true)
+ }
+
+ // Is it a double-quoted scalar?
+ if parser.buffer[parser.buffer_pos] == '"' {
+ return yaml_parser_fetch_flow_scalar(parser, false)
+ }
+
+ // Is it a plain scalar?
+ //
+ // A plain scalar may start with any non-blank characters except
+ //
+ // '-', '?', ':', ',', '[', ']', '{', '}',
+ // '#', '&', '*', '!', '|', '>', '\'', '\"',
+ // '%', '@', '`'.
+ //
+ // In the block context (and, for the '-' indicator, in the flow context
+ // too), it may also start with the characters
+ //
+ // '-', '?', ':'
+ //
+ // if it is followed by a non-space character.
+ //
+ // The last rule is more restrictive than the specification requires.
+ // [Go] Make this logic more reasonable.
+ //switch parser.buffer[parser.buffer_pos] {
+ //case '-', '?', ':', ',', '?', '-', ',', ':', ']', '[', '}', '{', '&', '#', '!', '*', '>', '|', '"', '\'', '@', '%', '-', '`':
+ //}
+ if !(is_blankz(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == '-' ||
+ parser.buffer[parser.buffer_pos] == '?' || parser.buffer[parser.buffer_pos] == ':' ||
+ parser.buffer[parser.buffer_pos] == ',' || parser.buffer[parser.buffer_pos] == '[' ||
+ parser.buffer[parser.buffer_pos] == ']' || parser.buffer[parser.buffer_pos] == '{' ||
+ parser.buffer[parser.buffer_pos] == '}' || parser.buffer[parser.buffer_pos] == '#' ||
+ parser.buffer[parser.buffer_pos] == '&' || parser.buffer[parser.buffer_pos] == '*' ||
+ parser.buffer[parser.buffer_pos] == '!' || parser.buffer[parser.buffer_pos] == '|' ||
+ parser.buffer[parser.buffer_pos] == '>' || parser.buffer[parser.buffer_pos] == '\'' ||
+ parser.buffer[parser.buffer_pos] == '"' || parser.buffer[parser.buffer_pos] == '%' ||
+ parser.buffer[parser.buffer_pos] == '@' || parser.buffer[parser.buffer_pos] == '`') ||
+ (parser.buffer[parser.buffer_pos] == '-' && !is_blank(parser.buffer, parser.buffer_pos+1)) ||
+ (parser.flow_level == 0 &&
+ (parser.buffer[parser.buffer_pos] == '?' || parser.buffer[parser.buffer_pos] == ':') &&
+ !is_blankz(parser.buffer, parser.buffer_pos+1)) {
+ return yaml_parser_fetch_plain_scalar(parser)
+ }
+
+ // If we don't determine the token type so far, it is an error.
+ return yaml_parser_set_scanner_error(parser,
+ "while scanning for the next token", parser.mark,
+ "found character that cannot start any token")
+}
+
+func yaml_simple_key_is_valid(parser *yaml_parser_t, simple_key *yaml_simple_key_t) (valid, ok bool) {
+ if !simple_key.possible {
+ return false, true
+ }
+
+ // The 1.2 specification says:
+ //
+ // "If the ? indicator is omitted, parsing needs to see past the
+ // implicit key to recognize it as such. To limit the amount of
+ // lookahead required, the “:” indicator must appear at most 1024
+ // Unicode characters beyond the start of the key. In addition, the key
+ // is restricted to a single line."
+ //
+ if simple_key.mark.line < parser.mark.line || simple_key.mark.index+1024 < parser.mark.index {
+ // Check if the potential simple key to be removed is required.
+ if simple_key.required {
+ return false, yaml_parser_set_scanner_error(parser,
+ "while scanning a simple key", simple_key.mark,
+ "could not find expected ':'")
+ }
+ simple_key.possible = false
+ return false, true
+ }
+ return true, true
+}
+
+// Check if a simple key may start at the current position and add it if
+// needed.
+func yaml_parser_save_simple_key(parser *yaml_parser_t) bool {
+ // A simple key is required at the current position if the scanner is in
+ // the block context and the current column coincides with the indentation
+ // level.
+
+ required := parser.flow_level == 0 && parser.indent == parser.mark.column
+
+ //
+ // If the current position may start a simple key, save it.
+ //
+ if parser.simple_key_allowed {
+ simple_key := yaml_simple_key_t{
+ possible: true,
+ required: required,
+ token_number: parser.tokens_parsed + (len(parser.tokens) - parser.tokens_head),
+ mark: parser.mark,
+ }
+
+ if !yaml_parser_remove_simple_key(parser) {
+ return false
+ }
+ parser.simple_keys[len(parser.simple_keys)-1] = simple_key
+ parser.simple_keys_by_tok[simple_key.token_number] = len(parser.simple_keys) - 1
+ }
+ return true
+}
+
+// Remove a potential simple key at the current flow level.
+func yaml_parser_remove_simple_key(parser *yaml_parser_t) bool {
+ i := len(parser.simple_keys) - 1
+ if parser.simple_keys[i].possible {
+ // If the key is required, it is an error.
+ if parser.simple_keys[i].required {
+ return yaml_parser_set_scanner_error(parser,
+ "while scanning a simple key", parser.simple_keys[i].mark,
+ "could not find expected ':'")
+ }
+ // Remove the key from the stack.
+ parser.simple_keys[i].possible = false
+ delete(parser.simple_keys_by_tok, parser.simple_keys[i].token_number)
+ }
+ return true
+}
+
+// max_flow_level limits the flow_level
+const max_flow_level = 10000
+
+// Increase the flow level and resize the simple key list if needed.
+func yaml_parser_increase_flow_level(parser *yaml_parser_t) bool {
+ // Reset the simple key on the next level.
+ parser.simple_keys = append(parser.simple_keys, yaml_simple_key_t{
+ possible: false,
+ required: false,
+ token_number: parser.tokens_parsed + (len(parser.tokens) - parser.tokens_head),
+ mark: parser.mark,
+ })
+
+ // Increase the flow level.
+ parser.flow_level++
+ if parser.flow_level > max_flow_level {
+ return yaml_parser_set_scanner_error(parser,
+ "while increasing flow level", parser.simple_keys[len(parser.simple_keys)-1].mark,
+ fmt.Sprintf("exceeded max depth of %d", max_flow_level))
+ }
+ return true
+}
+
+// Decrease the flow level.
+func yaml_parser_decrease_flow_level(parser *yaml_parser_t) bool {
+ if parser.flow_level > 0 {
+ parser.flow_level--
+ last := len(parser.simple_keys) - 1
+ delete(parser.simple_keys_by_tok, parser.simple_keys[last].token_number)
+ parser.simple_keys = parser.simple_keys[:last]
+ }
+ return true
+}
+
+// max_indents limits the indents stack size
+const max_indents = 10000
+
+// Push the current indentation level to the stack and set the new level
+// the current column is greater than the indentation level. In this case,
+// append or insert the specified token into the token queue.
+func yaml_parser_roll_indent(parser *yaml_parser_t, column, number int, typ yaml_token_type_t, mark yaml_mark_t) bool {
+ // In the flow context, do nothing.
+ if parser.flow_level > 0 {
+ return true
+ }
+
+ if parser.indent < column {
+ // Push the current indentation level to the stack and set the new
+ // indentation level.
+ parser.indents = append(parser.indents, parser.indent)
+ parser.indent = column
+ if len(parser.indents) > max_indents {
+ return yaml_parser_set_scanner_error(parser,
+ "while increasing indent level", parser.simple_keys[len(parser.simple_keys)-1].mark,
+ fmt.Sprintf("exceeded max depth of %d", max_indents))
+ }
+
+ // Create a token and insert it into the queue.
+ token := yaml_token_t{
+ typ: typ,
+ start_mark: mark,
+ end_mark: mark,
+ }
+ if number > -1 {
+ number -= parser.tokens_parsed
+ }
+ yaml_insert_token(parser, number, &token)
+ }
+ return true
+}
+
+// Pop indentation levels from the indents stack until the current level
+// becomes less or equal to the column. For each indentation level, append
+// the BLOCK-END token.
+func yaml_parser_unroll_indent(parser *yaml_parser_t, column int) bool {
+ // In the flow context, do nothing.
+ if parser.flow_level > 0 {
+ return true
+ }
+
+ // Loop through the indentation levels in the stack.
+ for parser.indent > column {
+ // Create a token and append it to the queue.
+ token := yaml_token_t{
+ typ: yaml_BLOCK_END_TOKEN,
+ start_mark: parser.mark,
+ end_mark: parser.mark,
+ }
+ yaml_insert_token(parser, -1, &token)
+
+ // Pop the indentation level.
+ parser.indent = parser.indents[len(parser.indents)-1]
+ parser.indents = parser.indents[:len(parser.indents)-1]
+ }
+ return true
+}
+
+// Initialize the scanner and produce the STREAM-START token.
+func yaml_parser_fetch_stream_start(parser *yaml_parser_t) bool {
+
+ // Set the initial indentation.
+ parser.indent = -1
+
+ // Initialize the simple key stack.
+ parser.simple_keys = append(parser.simple_keys, yaml_simple_key_t{})
+
+ parser.simple_keys_by_tok = make(map[int]int)
+
+ // A simple key is allowed at the beginning of the stream.
+ parser.simple_key_allowed = true
+
+ // We have started.
+ parser.stream_start_produced = true
+
+ // Create the STREAM-START token and append it to the queue.
+ token := yaml_token_t{
+ typ: yaml_STREAM_START_TOKEN,
+ start_mark: parser.mark,
+ end_mark: parser.mark,
+ encoding: parser.encoding,
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the STREAM-END token and shut down the scanner.
+func yaml_parser_fetch_stream_end(parser *yaml_parser_t) bool {
+
+ // Force new line.
+ if parser.mark.column != 0 {
+ parser.mark.column = 0
+ parser.mark.line++
+ }
+
+ // Reset the indentation level.
+ if !yaml_parser_unroll_indent(parser, -1) {
+ return false
+ }
+
+ // Reset simple keys.
+ if !yaml_parser_remove_simple_key(parser) {
+ return false
+ }
+
+ parser.simple_key_allowed = false
+
+ // Create the STREAM-END token and append it to the queue.
+ token := yaml_token_t{
+ typ: yaml_STREAM_END_TOKEN,
+ start_mark: parser.mark,
+ end_mark: parser.mark,
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce a VERSION-DIRECTIVE or TAG-DIRECTIVE token.
+func yaml_parser_fetch_directive(parser *yaml_parser_t) bool {
+ // Reset the indentation level.
+ if !yaml_parser_unroll_indent(parser, -1) {
+ return false
+ }
+
+ // Reset simple keys.
+ if !yaml_parser_remove_simple_key(parser) {
+ return false
+ }
+
+ parser.simple_key_allowed = false
+
+ // Create the YAML-DIRECTIVE or TAG-DIRECTIVE token.
+ token := yaml_token_t{}
+ if !yaml_parser_scan_directive(parser, &token) {
+ return false
+ }
+ // Append the token to the queue.
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the DOCUMENT-START or DOCUMENT-END token.
+func yaml_parser_fetch_document_indicator(parser *yaml_parser_t, typ yaml_token_type_t) bool {
+ // Reset the indentation level.
+ if !yaml_parser_unroll_indent(parser, -1) {
+ return false
+ }
+
+ // Reset simple keys.
+ if !yaml_parser_remove_simple_key(parser) {
+ return false
+ }
+
+ parser.simple_key_allowed = false
+
+ // Consume the token.
+ start_mark := parser.mark
+
+ skip(parser)
+ skip(parser)
+ skip(parser)
+
+ end_mark := parser.mark
+
+ // Create the DOCUMENT-START or DOCUMENT-END token.
+ token := yaml_token_t{
+ typ: typ,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ }
+ // Append the token to the queue.
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the FLOW-SEQUENCE-START or FLOW-MAPPING-START token.
+func yaml_parser_fetch_flow_collection_start(parser *yaml_parser_t, typ yaml_token_type_t) bool {
+ // The indicators '[' and '{' may start a simple key.
+ if !yaml_parser_save_simple_key(parser) {
+ return false
+ }
+
+ // Increase the flow level.
+ if !yaml_parser_increase_flow_level(parser) {
+ return false
+ }
+
+ // A simple key may follow the indicators '[' and '{'.
+ parser.simple_key_allowed = true
+
+ // Consume the token.
+ start_mark := parser.mark
+ skip(parser)
+ end_mark := parser.mark
+
+ // Create the FLOW-SEQUENCE-START of FLOW-MAPPING-START token.
+ token := yaml_token_t{
+ typ: typ,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ }
+ // Append the token to the queue.
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the FLOW-SEQUENCE-END or FLOW-MAPPING-END token.
+func yaml_parser_fetch_flow_collection_end(parser *yaml_parser_t, typ yaml_token_type_t) bool {
+ // Reset any potential simple key on the current flow level.
+ if !yaml_parser_remove_simple_key(parser) {
+ return false
+ }
+
+ // Decrease the flow level.
+ if !yaml_parser_decrease_flow_level(parser) {
+ return false
+ }
+
+ // No simple keys after the indicators ']' and '}'.
+ parser.simple_key_allowed = false
+
+ // Consume the token.
+
+ start_mark := parser.mark
+ skip(parser)
+ end_mark := parser.mark
+
+ // Create the FLOW-SEQUENCE-END of FLOW-MAPPING-END token.
+ token := yaml_token_t{
+ typ: typ,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ }
+ // Append the token to the queue.
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the FLOW-ENTRY token.
+func yaml_parser_fetch_flow_entry(parser *yaml_parser_t) bool {
+ // Reset any potential simple keys on the current flow level.
+ if !yaml_parser_remove_simple_key(parser) {
+ return false
+ }
+
+ // Simple keys are allowed after ','.
+ parser.simple_key_allowed = true
+
+ // Consume the token.
+ start_mark := parser.mark
+ skip(parser)
+ end_mark := parser.mark
+
+ // Create the FLOW-ENTRY token and append it to the queue.
+ token := yaml_token_t{
+ typ: yaml_FLOW_ENTRY_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the BLOCK-ENTRY token.
+func yaml_parser_fetch_block_entry(parser *yaml_parser_t) bool {
+ // Check if the scanner is in the block context.
+ if parser.flow_level == 0 {
+ // Check if we are allowed to start a new entry.
+ if !parser.simple_key_allowed {
+ return yaml_parser_set_scanner_error(parser, "", parser.mark,
+ "block sequence entries are not allowed in this context")
+ }
+ // Add the BLOCK-SEQUENCE-START token if needed.
+ if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_SEQUENCE_START_TOKEN, parser.mark) {
+ return false
+ }
+ } else {
+ // It is an error for the '-' indicator to occur in the flow context,
+ // but we let the Parser detect and report about it because the Parser
+ // is able to point to the context.
+ }
+
+ // Reset any potential simple keys on the current flow level.
+ if !yaml_parser_remove_simple_key(parser) {
+ return false
+ }
+
+ // Simple keys are allowed after '-'.
+ parser.simple_key_allowed = true
+
+ // Consume the token.
+ start_mark := parser.mark
+ skip(parser)
+ end_mark := parser.mark
+
+ // Create the BLOCK-ENTRY token and append it to the queue.
+ token := yaml_token_t{
+ typ: yaml_BLOCK_ENTRY_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the KEY token.
+func yaml_parser_fetch_key(parser *yaml_parser_t) bool {
+
+ // In the block context, additional checks are required.
+ if parser.flow_level == 0 {
+ // Check if we are allowed to start a new key (not nessesary simple).
+ if !parser.simple_key_allowed {
+ return yaml_parser_set_scanner_error(parser, "", parser.mark,
+ "mapping keys are not allowed in this context")
+ }
+ // Add the BLOCK-MAPPING-START token if needed.
+ if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_MAPPING_START_TOKEN, parser.mark) {
+ return false
+ }
+ }
+
+ // Reset any potential simple keys on the current flow level.
+ if !yaml_parser_remove_simple_key(parser) {
+ return false
+ }
+
+ // Simple keys are allowed after '?' in the block context.
+ parser.simple_key_allowed = parser.flow_level == 0
+
+ // Consume the token.
+ start_mark := parser.mark
+ skip(parser)
+ end_mark := parser.mark
+
+ // Create the KEY token and append it to the queue.
+ token := yaml_token_t{
+ typ: yaml_KEY_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the VALUE token.
+func yaml_parser_fetch_value(parser *yaml_parser_t) bool {
+
+ simple_key := &parser.simple_keys[len(parser.simple_keys)-1]
+
+ // Have we found a simple key?
+ if valid, ok := yaml_simple_key_is_valid(parser, simple_key); !ok {
+ return false
+
+ } else if valid {
+
+ // Create the KEY token and insert it into the queue.
+ token := yaml_token_t{
+ typ: yaml_KEY_TOKEN,
+ start_mark: simple_key.mark,
+ end_mark: simple_key.mark,
+ }
+ yaml_insert_token(parser, simple_key.token_number-parser.tokens_parsed, &token)
+
+ // In the block context, we may need to add the BLOCK-MAPPING-START token.
+ if !yaml_parser_roll_indent(parser, simple_key.mark.column,
+ simple_key.token_number,
+ yaml_BLOCK_MAPPING_START_TOKEN, simple_key.mark) {
+ return false
+ }
+
+ // Remove the simple key.
+ simple_key.possible = false
+ delete(parser.simple_keys_by_tok, simple_key.token_number)
+
+ // A simple key cannot follow another simple key.
+ parser.simple_key_allowed = false
+
+ } else {
+ // The ':' indicator follows a complex key.
+
+ // In the block context, extra checks are required.
+ if parser.flow_level == 0 {
+
+ // Check if we are allowed to start a complex value.
+ if !parser.simple_key_allowed {
+ return yaml_parser_set_scanner_error(parser, "", parser.mark,
+ "mapping values are not allowed in this context")
+ }
+
+ // Add the BLOCK-MAPPING-START token if needed.
+ if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_MAPPING_START_TOKEN, parser.mark) {
+ return false
+ }
+ }
+
+ // Simple keys after ':' are allowed in the block context.
+ parser.simple_key_allowed = parser.flow_level == 0
+ }
+
+ // Consume the token.
+ start_mark := parser.mark
+ skip(parser)
+ end_mark := parser.mark
+
+ // Create the VALUE token and append it to the queue.
+ token := yaml_token_t{
+ typ: yaml_VALUE_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the ALIAS or ANCHOR token.
+func yaml_parser_fetch_anchor(parser *yaml_parser_t, typ yaml_token_type_t) bool {
+ // An anchor or an alias could be a simple key.
+ if !yaml_parser_save_simple_key(parser) {
+ return false
+ }
+
+ // A simple key cannot follow an anchor or an alias.
+ parser.simple_key_allowed = false
+
+ // Create the ALIAS or ANCHOR token and append it to the queue.
+ var token yaml_token_t
+ if !yaml_parser_scan_anchor(parser, &token, typ) {
+ return false
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the TAG token.
+func yaml_parser_fetch_tag(parser *yaml_parser_t) bool {
+ // A tag could be a simple key.
+ if !yaml_parser_save_simple_key(parser) {
+ return false
+ }
+
+ // A simple key cannot follow a tag.
+ parser.simple_key_allowed = false
+
+ // Create the TAG token and append it to the queue.
+ var token yaml_token_t
+ if !yaml_parser_scan_tag(parser, &token) {
+ return false
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the SCALAR(...,literal) or SCALAR(...,folded) tokens.
+func yaml_parser_fetch_block_scalar(parser *yaml_parser_t, literal bool) bool {
+ // Remove any potential simple keys.
+ if !yaml_parser_remove_simple_key(parser) {
+ return false
+ }
+
+ // A simple key may follow a block scalar.
+ parser.simple_key_allowed = true
+
+ // Create the SCALAR token and append it to the queue.
+ var token yaml_token_t
+ if !yaml_parser_scan_block_scalar(parser, &token, literal) {
+ return false
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the SCALAR(...,single-quoted) or SCALAR(...,double-quoted) tokens.
+func yaml_parser_fetch_flow_scalar(parser *yaml_parser_t, single bool) bool {
+ // A plain scalar could be a simple key.
+ if !yaml_parser_save_simple_key(parser) {
+ return false
+ }
+
+ // A simple key cannot follow a flow scalar.
+ parser.simple_key_allowed = false
+
+ // Create the SCALAR token and append it to the queue.
+ var token yaml_token_t
+ if !yaml_parser_scan_flow_scalar(parser, &token, single) {
+ return false
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the SCALAR(...,plain) token.
+func yaml_parser_fetch_plain_scalar(parser *yaml_parser_t) bool {
+ // A plain scalar could be a simple key.
+ if !yaml_parser_save_simple_key(parser) {
+ return false
+ }
+
+ // A simple key cannot follow a flow scalar.
+ parser.simple_key_allowed = false
+
+ // Create the SCALAR token and append it to the queue.
+ var token yaml_token_t
+ if !yaml_parser_scan_plain_scalar(parser, &token) {
+ return false
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Eat whitespaces and comments until the next token is found.
+func yaml_parser_scan_to_next_token(parser *yaml_parser_t) bool {
+
+ // Until the next token is not found.
+ for {
+ // Allow the BOM mark to start a line.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ if parser.mark.column == 0 && is_bom(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ }
+
+ // Eat whitespaces.
+ // Tabs are allowed:
+ // - in the flow context
+ // - in the block context, but not at the beginning of the line or
+ // after '-', '?', or ':' (complex value).
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ for parser.buffer[parser.buffer_pos] == ' ' || ((parser.flow_level > 0 || !parser.simple_key_allowed) && parser.buffer[parser.buffer_pos] == '\t') {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Eat a comment until a line break.
+ if parser.buffer[parser.buffer_pos] == '#' {
+ for !is_breakz(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+ }
+
+ // If it is a line break, eat it.
+ if is_break(parser.buffer, parser.buffer_pos) {
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+ skip_line(parser)
+
+ // In the block context, a new line may start a simple key.
+ if parser.flow_level == 0 {
+ parser.simple_key_allowed = true
+ }
+ } else {
+ break // We have found a token.
+ }
+ }
+
+ return true
+}
+
+// Scan a YAML-DIRECTIVE or TAG-DIRECTIVE token.
+//
+// Scope:
+// %YAML 1.1 # a comment \n
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+// %TAG !yaml! tag:yaml.org,2002: \n
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//
+func yaml_parser_scan_directive(parser *yaml_parser_t, token *yaml_token_t) bool {
+ // Eat '%'.
+ start_mark := parser.mark
+ skip(parser)
+
+ // Scan the directive name.
+ var name []byte
+ if !yaml_parser_scan_directive_name(parser, start_mark, &name) {
+ return false
+ }
+
+ // Is it a YAML directive?
+ if bytes.Equal(name, []byte("YAML")) {
+ // Scan the VERSION directive value.
+ var major, minor int8
+ if !yaml_parser_scan_version_directive_value(parser, start_mark, &major, &minor) {
+ return false
+ }
+ end_mark := parser.mark
+
+ // Create a VERSION-DIRECTIVE token.
+ *token = yaml_token_t{
+ typ: yaml_VERSION_DIRECTIVE_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ major: major,
+ minor: minor,
+ }
+
+ // Is it a TAG directive?
+ } else if bytes.Equal(name, []byte("TAG")) {
+ // Scan the TAG directive value.
+ var handle, prefix []byte
+ if !yaml_parser_scan_tag_directive_value(parser, start_mark, &handle, &prefix) {
+ return false
+ }
+ end_mark := parser.mark
+
+ // Create a TAG-DIRECTIVE token.
+ *token = yaml_token_t{
+ typ: yaml_TAG_DIRECTIVE_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ value: handle,
+ prefix: prefix,
+ }
+
+ // Unknown directive.
+ } else {
+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
+ start_mark, "found unknown directive name")
+ return false
+ }
+
+ // Eat the rest of the line including any comments.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ for is_blank(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ if parser.buffer[parser.buffer_pos] == '#' {
+ for !is_breakz(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+ }
+
+ // Check if we are at the end of the line.
+ if !is_breakz(parser.buffer, parser.buffer_pos) {
+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
+ start_mark, "did not find expected comment or line break")
+ return false
+ }
+
+ // Eat a line break.
+ if is_break(parser.buffer, parser.buffer_pos) {
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+ skip_line(parser)
+ }
+
+ return true
+}
+
+// Scan the directive name.
+//
+// Scope:
+// %YAML 1.1 # a comment \n
+// ^^^^
+// %TAG !yaml! tag:yaml.org,2002: \n
+// ^^^
+//
+func yaml_parser_scan_directive_name(parser *yaml_parser_t, start_mark yaml_mark_t, name *[]byte) bool {
+ // Consume the directive name.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ var s []byte
+ for is_alpha(parser.buffer, parser.buffer_pos) {
+ s = read(parser, s)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Check if the name is empty.
+ if len(s) == 0 {
+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
+ start_mark, "could not find expected directive name")
+ return false
+ }
+
+ // Check for an blank character after the name.
+ if !is_blankz(parser.buffer, parser.buffer_pos) {
+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
+ start_mark, "found unexpected non-alphabetical character")
+ return false
+ }
+ *name = s
+ return true
+}
+
+// Scan the value of VERSION-DIRECTIVE.
+//
+// Scope:
+// %YAML 1.1 # a comment \n
+// ^^^^^^
+func yaml_parser_scan_version_directive_value(parser *yaml_parser_t, start_mark yaml_mark_t, major, minor *int8) bool {
+ // Eat whitespaces.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ for is_blank(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Consume the major version number.
+ if !yaml_parser_scan_version_directive_number(parser, start_mark, major) {
+ return false
+ }
+
+ // Eat '.'.
+ if parser.buffer[parser.buffer_pos] != '.' {
+ return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
+ start_mark, "did not find expected digit or '.' character")
+ }
+
+ skip(parser)
+
+ // Consume the minor version number.
+ if !yaml_parser_scan_version_directive_number(parser, start_mark, minor) {
+ return false
+ }
+ return true
+}
+
+const max_number_length = 2
+
+// Scan the version number of VERSION-DIRECTIVE.
+//
+// Scope:
+// %YAML 1.1 # a comment \n
+// ^
+// %YAML 1.1 # a comment \n
+// ^
+func yaml_parser_scan_version_directive_number(parser *yaml_parser_t, start_mark yaml_mark_t, number *int8) bool {
+
+ // Repeat while the next character is digit.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ var value, length int8
+ for is_digit(parser.buffer, parser.buffer_pos) {
+ // Check if the number is too long.
+ length++
+ if length > max_number_length {
+ return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
+ start_mark, "found extremely long version number")
+ }
+ value = value*10 + int8(as_digit(parser.buffer, parser.buffer_pos))
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Check if the number was present.
+ if length == 0 {
+ return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
+ start_mark, "did not find expected version number")
+ }
+ *number = value
+ return true
+}
+
+// Scan the value of a TAG-DIRECTIVE token.
+//
+// Scope:
+// %TAG !yaml! tag:yaml.org,2002: \n
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//
+func yaml_parser_scan_tag_directive_value(parser *yaml_parser_t, start_mark yaml_mark_t, handle, prefix *[]byte) bool {
+ var handle_value, prefix_value []byte
+
+ // Eat whitespaces.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ for is_blank(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Scan a handle.
+ if !yaml_parser_scan_tag_handle(parser, true, start_mark, &handle_value) {
+ return false
+ }
+
+ // Expect a whitespace.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ if !is_blank(parser.buffer, parser.buffer_pos) {
+ yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive",
+ start_mark, "did not find expected whitespace")
+ return false
+ }
+
+ // Eat whitespaces.
+ for is_blank(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Scan a prefix.
+ if !yaml_parser_scan_tag_uri(parser, true, nil, start_mark, &prefix_value) {
+ return false
+ }
+
+ // Expect a whitespace or line break.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ if !is_blankz(parser.buffer, parser.buffer_pos) {
+ yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive",
+ start_mark, "did not find expected whitespace or line break")
+ return false
+ }
+
+ *handle = handle_value
+ *prefix = prefix_value
+ return true
+}
+
+func yaml_parser_scan_anchor(parser *yaml_parser_t, token *yaml_token_t, typ yaml_token_type_t) bool {
+ var s []byte
+
+ // Eat the indicator character.
+ start_mark := parser.mark
+ skip(parser)
+
+ // Consume the value.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ for is_alpha(parser.buffer, parser.buffer_pos) {
+ s = read(parser, s)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ end_mark := parser.mark
+
+ /*
+ * Check if length of the anchor is greater than 0 and it is followed by
+ * a whitespace character or one of the indicators:
+ *
+ * '?', ':', ',', ']', '}', '%', '@', '`'.
+ */
+
+ if len(s) == 0 ||
+ !(is_blankz(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == '?' ||
+ parser.buffer[parser.buffer_pos] == ':' || parser.buffer[parser.buffer_pos] == ',' ||
+ parser.buffer[parser.buffer_pos] == ']' || parser.buffer[parser.buffer_pos] == '}' ||
+ parser.buffer[parser.buffer_pos] == '%' || parser.buffer[parser.buffer_pos] == '@' ||
+ parser.buffer[parser.buffer_pos] == '`') {
+ context := "while scanning an alias"
+ if typ == yaml_ANCHOR_TOKEN {
+ context = "while scanning an anchor"
+ }
+ yaml_parser_set_scanner_error(parser, context, start_mark,
+ "did not find expected alphabetic or numeric character")
+ return false
+ }
+
+ // Create a token.
+ *token = yaml_token_t{
+ typ: typ,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ value: s,
+ }
+
+ return true
+}
+
+/*
+ * Scan a TAG token.
+ */
+
+func yaml_parser_scan_tag(parser *yaml_parser_t, token *yaml_token_t) bool {
+ var handle, suffix []byte
+
+ start_mark := parser.mark
+
+ // Check if the tag is in the canonical form.
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+
+ if parser.buffer[parser.buffer_pos+1] == '<' {
+ // Keep the handle as ''
+
+ // Eat '!<'
+ skip(parser)
+ skip(parser)
+
+ // Consume the tag value.
+ if !yaml_parser_scan_tag_uri(parser, false, nil, start_mark, &suffix) {
+ return false
+ }
+
+ // Check for '>' and eat it.
+ if parser.buffer[parser.buffer_pos] != '>' {
+ yaml_parser_set_scanner_error(parser, "while scanning a tag",
+ start_mark, "did not find the expected '>'")
+ return false
+ }
+
+ skip(parser)
+ } else {
+ // The tag has either the '!suffix' or the '!handle!suffix' form.
+
+ // First, try to scan a handle.
+ if !yaml_parser_scan_tag_handle(parser, false, start_mark, &handle) {
+ return false
+ }
+
+ // Check if it is, indeed, handle.
+ if handle[0] == '!' && len(handle) > 1 && handle[len(handle)-1] == '!' {
+ // Scan the suffix now.
+ if !yaml_parser_scan_tag_uri(parser, false, nil, start_mark, &suffix) {
+ return false
+ }
+ } else {
+ // It wasn't a handle after all. Scan the rest of the tag.
+ if !yaml_parser_scan_tag_uri(parser, false, handle, start_mark, &suffix) {
+ return false
+ }
+
+ // Set the handle to '!'.
+ handle = []byte{'!'}
+
+ // A special case: the '!' tag. Set the handle to '' and the
+ // suffix to '!'.
+ if len(suffix) == 0 {
+ handle, suffix = suffix, handle
+ }
+ }
+ }
+
+ // Check the character which ends the tag.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ if !is_blankz(parser.buffer, parser.buffer_pos) {
+ yaml_parser_set_scanner_error(parser, "while scanning a tag",
+ start_mark, "did not find expected whitespace or line break")
+ return false
+ }
+
+ end_mark := parser.mark
+
+ // Create a token.
+ *token = yaml_token_t{
+ typ: yaml_TAG_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ value: handle,
+ suffix: suffix,
+ }
+ return true
+}
+
+// Scan a tag handle.
+func yaml_parser_scan_tag_handle(parser *yaml_parser_t, directive bool, start_mark yaml_mark_t, handle *[]byte) bool {
+ // Check the initial '!' character.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ if parser.buffer[parser.buffer_pos] != '!' {
+ yaml_parser_set_scanner_tag_error(parser, directive,
+ start_mark, "did not find expected '!'")
+ return false
+ }
+
+ var s []byte
+
+ // Copy the '!' character.
+ s = read(parser, s)
+
+ // Copy all subsequent alphabetical and numerical characters.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ for is_alpha(parser.buffer, parser.buffer_pos) {
+ s = read(parser, s)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Check if the trailing character is '!' and copy it.
+ if parser.buffer[parser.buffer_pos] == '!' {
+ s = read(parser, s)
+ } else {
+ // It's either the '!' tag or not really a tag handle. If it's a %TAG
+ // directive, it's an error. If it's a tag token, it must be a part of URI.
+ if directive && string(s) != "!" {
+ yaml_parser_set_scanner_tag_error(parser, directive,
+ start_mark, "did not find expected '!'")
+ return false
+ }
+ }
+
+ *handle = s
+ return true
+}
+
+// Scan a tag.
+func yaml_parser_scan_tag_uri(parser *yaml_parser_t, directive bool, head []byte, start_mark yaml_mark_t, uri *[]byte) bool {
+ //size_t length = head ? strlen((char *)head) : 0
+ var s []byte
+ hasTag := len(head) > 0
+
+ // Copy the head if needed.
+ //
+ // Note that we don't copy the leading '!' character.
+ if len(head) > 1 {
+ s = append(s, head[1:]...)
+ }
+
+ // Scan the tag.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ // The set of characters that may appear in URI is as follows:
+ //
+ // '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&',
+ // '=', '+', '$', ',', '.', '!', '~', '*', '\'', '(', ')', '[', ']',
+ // '%'.
+ // [Go] Convert this into more reasonable logic.
+ for is_alpha(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == ';' ||
+ parser.buffer[parser.buffer_pos] == '/' || parser.buffer[parser.buffer_pos] == '?' ||
+ parser.buffer[parser.buffer_pos] == ':' || parser.buffer[parser.buffer_pos] == '@' ||
+ parser.buffer[parser.buffer_pos] == '&' || parser.buffer[parser.buffer_pos] == '=' ||
+ parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '$' ||
+ parser.buffer[parser.buffer_pos] == ',' || parser.buffer[parser.buffer_pos] == '.' ||
+ parser.buffer[parser.buffer_pos] == '!' || parser.buffer[parser.buffer_pos] == '~' ||
+ parser.buffer[parser.buffer_pos] == '*' || parser.buffer[parser.buffer_pos] == '\'' ||
+ parser.buffer[parser.buffer_pos] == '(' || parser.buffer[parser.buffer_pos] == ')' ||
+ parser.buffer[parser.buffer_pos] == '[' || parser.buffer[parser.buffer_pos] == ']' ||
+ parser.buffer[parser.buffer_pos] == '%' {
+ // Check if it is a URI-escape sequence.
+ if parser.buffer[parser.buffer_pos] == '%' {
+ if !yaml_parser_scan_uri_escapes(parser, directive, start_mark, &s) {
+ return false
+ }
+ } else {
+ s = read(parser, s)
+ }
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ hasTag = true
+ }
+
+ if !hasTag {
+ yaml_parser_set_scanner_tag_error(parser, directive,
+ start_mark, "did not find expected tag URI")
+ return false
+ }
+ *uri = s
+ return true
+}
+
+// Decode an URI-escape sequence corresponding to a single UTF-8 character.
+func yaml_parser_scan_uri_escapes(parser *yaml_parser_t, directive bool, start_mark yaml_mark_t, s *[]byte) bool {
+
+ // Decode the required number of characters.
+ w := 1024
+ for w > 0 {
+ // Check for a URI-escaped octet.
+ if parser.unread < 3 && !yaml_parser_update_buffer(parser, 3) {
+ return false
+ }
+
+ if !(parser.buffer[parser.buffer_pos] == '%' &&
+ is_hex(parser.buffer, parser.buffer_pos+1) &&
+ is_hex(parser.buffer, parser.buffer_pos+2)) {
+ return yaml_parser_set_scanner_tag_error(parser, directive,
+ start_mark, "did not find URI escaped octet")
+ }
+
+ // Get the octet.
+ octet := byte((as_hex(parser.buffer, parser.buffer_pos+1) << 4) + as_hex(parser.buffer, parser.buffer_pos+2))
+
+ // If it is the leading octet, determine the length of the UTF-8 sequence.
+ if w == 1024 {
+ w = width(octet)
+ if w == 0 {
+ return yaml_parser_set_scanner_tag_error(parser, directive,
+ start_mark, "found an incorrect leading UTF-8 octet")
+ }
+ } else {
+ // Check if the trailing octet is correct.
+ if octet&0xC0 != 0x80 {
+ return yaml_parser_set_scanner_tag_error(parser, directive,
+ start_mark, "found an incorrect trailing UTF-8 octet")
+ }
+ }
+
+ // Copy the octet and move the pointers.
+ *s = append(*s, octet)
+ skip(parser)
+ skip(parser)
+ skip(parser)
+ w--
+ }
+ return true
+}
+
+// Scan a block scalar.
+func yaml_parser_scan_block_scalar(parser *yaml_parser_t, token *yaml_token_t, literal bool) bool {
+ // Eat the indicator '|' or '>'.
+ start_mark := parser.mark
+ skip(parser)
+
+ // Scan the additional block scalar indicators.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ // Check for a chomping indicator.
+ var chomping, increment int
+ if parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '-' {
+ // Set the chomping method and eat the indicator.
+ if parser.buffer[parser.buffer_pos] == '+' {
+ chomping = +1
+ } else {
+ chomping = -1
+ }
+ skip(parser)
+
+ // Check for an indentation indicator.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ if is_digit(parser.buffer, parser.buffer_pos) {
+ // Check that the indentation is greater than 0.
+ if parser.buffer[parser.buffer_pos] == '0' {
+ yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
+ start_mark, "found an indentation indicator equal to 0")
+ return false
+ }
+
+ // Get the indentation level and eat the indicator.
+ increment = as_digit(parser.buffer, parser.buffer_pos)
+ skip(parser)
+ }
+
+ } else if is_digit(parser.buffer, parser.buffer_pos) {
+ // Do the same as above, but in the opposite order.
+
+ if parser.buffer[parser.buffer_pos] == '0' {
+ yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
+ start_mark, "found an indentation indicator equal to 0")
+ return false
+ }
+ increment = as_digit(parser.buffer, parser.buffer_pos)
+ skip(parser)
+
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ if parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '-' {
+ if parser.buffer[parser.buffer_pos] == '+' {
+ chomping = +1
+ } else {
+ chomping = -1
+ }
+ skip(parser)
+ }
+ }
+
+ // Eat whitespaces and comments to the end of the line.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ for is_blank(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+ if parser.buffer[parser.buffer_pos] == '#' {
+ for !is_breakz(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+ }
+
+ // Check if we are at the end of the line.
+ if !is_breakz(parser.buffer, parser.buffer_pos) {
+ yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
+ start_mark, "did not find expected comment or line break")
+ return false
+ }
+
+ // Eat a line break.
+ if is_break(parser.buffer, parser.buffer_pos) {
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+ skip_line(parser)
+ }
+
+ end_mark := parser.mark
+
+ // Set the indentation level if it was specified.
+ var indent int
+ if increment > 0 {
+ if parser.indent >= 0 {
+ indent = parser.indent + increment
+ } else {
+ indent = increment
+ }
+ }
+
+ // Scan the leading line breaks and determine the indentation level if needed.
+ var s, leading_break, trailing_breaks []byte
+ if !yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, start_mark, &end_mark) {
+ return false
+ }
+
+ // Scan the block scalar content.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ var leading_blank, trailing_blank bool
+ for parser.mark.column == indent && !is_z(parser.buffer, parser.buffer_pos) {
+ // We are at the beginning of a non-empty line.
+
+ // Is it a trailing whitespace?
+ trailing_blank = is_blank(parser.buffer, parser.buffer_pos)
+
+ // Check if we need to fold the leading line break.
+ if !literal && !leading_blank && !trailing_blank && len(leading_break) > 0 && leading_break[0] == '\n' {
+ // Do we need to join the lines by space?
+ if len(trailing_breaks) == 0 {
+ s = append(s, ' ')
+ }
+ } else {
+ s = append(s, leading_break...)
+ }
+ leading_break = leading_break[:0]
+
+ // Append the remaining line breaks.
+ s = append(s, trailing_breaks...)
+ trailing_breaks = trailing_breaks[:0]
+
+ // Is it a leading whitespace?
+ leading_blank = is_blank(parser.buffer, parser.buffer_pos)
+
+ // Consume the current line.
+ for !is_breakz(parser.buffer, parser.buffer_pos) {
+ s = read(parser, s)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Consume the line break.
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+
+ leading_break = read_line(parser, leading_break)
+
+ // Eat the following indentation spaces and line breaks.
+ if !yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, start_mark, &end_mark) {
+ return false
+ }
+ }
+
+ // Chomp the tail.
+ if chomping != -1 {
+ s = append(s, leading_break...)
+ }
+ if chomping == 1 {
+ s = append(s, trailing_breaks...)
+ }
+
+ // Create a token.
+ *token = yaml_token_t{
+ typ: yaml_SCALAR_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ value: s,
+ style: yaml_LITERAL_SCALAR_STYLE,
+ }
+ if !literal {
+ token.style = yaml_FOLDED_SCALAR_STYLE
+ }
+ return true
+}
+
+// Scan indentation spaces and line breaks for a block scalar. Determine the
+// indentation level if needed.
+func yaml_parser_scan_block_scalar_breaks(parser *yaml_parser_t, indent *int, breaks *[]byte, start_mark yaml_mark_t, end_mark *yaml_mark_t) bool {
+ *end_mark = parser.mark
+
+ // Eat the indentation spaces and line breaks.
+ max_indent := 0
+ for {
+ // Eat the indentation spaces.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ for (*indent == 0 || parser.mark.column < *indent) && is_space(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+ if parser.mark.column > max_indent {
+ max_indent = parser.mark.column
+ }
+
+ // Check for a tab character messing the indentation.
+ if (*indent == 0 || parser.mark.column < *indent) && is_tab(parser.buffer, parser.buffer_pos) {
+ return yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
+ start_mark, "found a tab character where an indentation space is expected")
+ }
+
+ // Have we found a non-empty line?
+ if !is_break(parser.buffer, parser.buffer_pos) {
+ break
+ }
+
+ // Consume the line break.
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+ // [Go] Should really be returning breaks instead.
+ *breaks = read_line(parser, *breaks)
+ *end_mark = parser.mark
+ }
+
+ // Determine the indentation level if needed.
+ if *indent == 0 {
+ *indent = max_indent
+ if *indent < parser.indent+1 {
+ *indent = parser.indent + 1
+ }
+ if *indent < 1 {
+ *indent = 1
+ }
+ }
+ return true
+}
+
+// Scan a quoted scalar.
+func yaml_parser_scan_flow_scalar(parser *yaml_parser_t, token *yaml_token_t, single bool) bool {
+ // Eat the left quote.
+ start_mark := parser.mark
+ skip(parser)
+
+ // Consume the content of the quoted scalar.
+ var s, leading_break, trailing_breaks, whitespaces []byte
+ for {
+ // Check that there are no document indicators at the beginning of the line.
+ if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) {
+ return false
+ }
+
+ if parser.mark.column == 0 &&
+ ((parser.buffer[parser.buffer_pos+0] == '-' &&
+ parser.buffer[parser.buffer_pos+1] == '-' &&
+ parser.buffer[parser.buffer_pos+2] == '-') ||
+ (parser.buffer[parser.buffer_pos+0] == '.' &&
+ parser.buffer[parser.buffer_pos+1] == '.' &&
+ parser.buffer[parser.buffer_pos+2] == '.')) &&
+ is_blankz(parser.buffer, parser.buffer_pos+3) {
+ yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar",
+ start_mark, "found unexpected document indicator")
+ return false
+ }
+
+ // Check for EOF.
+ if is_z(parser.buffer, parser.buffer_pos) {
+ yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar",
+ start_mark, "found unexpected end of stream")
+ return false
+ }
+
+ // Consume non-blank characters.
+ leading_blanks := false
+ for !is_blankz(parser.buffer, parser.buffer_pos) {
+ if single && parser.buffer[parser.buffer_pos] == '\'' && parser.buffer[parser.buffer_pos+1] == '\'' {
+ // Is is an escaped single quote.
+ s = append(s, '\'')
+ skip(parser)
+ skip(parser)
+
+ } else if single && parser.buffer[parser.buffer_pos] == '\'' {
+ // It is a right single quote.
+ break
+ } else if !single && parser.buffer[parser.buffer_pos] == '"' {
+ // It is a right double quote.
+ break
+
+ } else if !single && parser.buffer[parser.buffer_pos] == '\\' && is_break(parser.buffer, parser.buffer_pos+1) {
+ // It is an escaped line break.
+ if parser.unread < 3 && !yaml_parser_update_buffer(parser, 3) {
+ return false
+ }
+ skip(parser)
+ skip_line(parser)
+ leading_blanks = true
+ break
+
+ } else if !single && parser.buffer[parser.buffer_pos] == '\\' {
+ // It is an escape sequence.
+ code_length := 0
+
+ // Check the escape character.
+ switch parser.buffer[parser.buffer_pos+1] {
+ case '0':
+ s = append(s, 0)
+ case 'a':
+ s = append(s, '\x07')
+ case 'b':
+ s = append(s, '\x08')
+ case 't', '\t':
+ s = append(s, '\x09')
+ case 'n':
+ s = append(s, '\x0A')
+ case 'v':
+ s = append(s, '\x0B')
+ case 'f':
+ s = append(s, '\x0C')
+ case 'r':
+ s = append(s, '\x0D')
+ case 'e':
+ s = append(s, '\x1B')
+ case ' ':
+ s = append(s, '\x20')
+ case '"':
+ s = append(s, '"')
+ case '\'':
+ s = append(s, '\'')
+ case '\\':
+ s = append(s, '\\')
+ case 'N': // NEL (#x85)
+ s = append(s, '\xC2')
+ s = append(s, '\x85')
+ case '_': // #xA0
+ s = append(s, '\xC2')
+ s = append(s, '\xA0')
+ case 'L': // LS (#x2028)
+ s = append(s, '\xE2')
+ s = append(s, '\x80')
+ s = append(s, '\xA8')
+ case 'P': // PS (#x2029)
+ s = append(s, '\xE2')
+ s = append(s, '\x80')
+ s = append(s, '\xA9')
+ case 'x':
+ code_length = 2
+ case 'u':
+ code_length = 4
+ case 'U':
+ code_length = 8
+ default:
+ yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
+ start_mark, "found unknown escape character")
+ return false
+ }
+
+ skip(parser)
+ skip(parser)
+
+ // Consume an arbitrary escape code.
+ if code_length > 0 {
+ var value int
+
+ // Scan the character value.
+ if parser.unread < code_length && !yaml_parser_update_buffer(parser, code_length) {
+ return false
+ }
+ for k := 0; k < code_length; k++ {
+ if !is_hex(parser.buffer, parser.buffer_pos+k) {
+ yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
+ start_mark, "did not find expected hexdecimal number")
+ return false
+ }
+ value = (value << 4) + as_hex(parser.buffer, parser.buffer_pos+k)
+ }
+
+ // Check the value and write the character.
+ if (value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF {
+ yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
+ start_mark, "found invalid Unicode character escape code")
+ return false
+ }
+ if value <= 0x7F {
+ s = append(s, byte(value))
+ } else if value <= 0x7FF {
+ s = append(s, byte(0xC0+(value>>6)))
+ s = append(s, byte(0x80+(value&0x3F)))
+ } else if value <= 0xFFFF {
+ s = append(s, byte(0xE0+(value>>12)))
+ s = append(s, byte(0x80+((value>>6)&0x3F)))
+ s = append(s, byte(0x80+(value&0x3F)))
+ } else {
+ s = append(s, byte(0xF0+(value>>18)))
+ s = append(s, byte(0x80+((value>>12)&0x3F)))
+ s = append(s, byte(0x80+((value>>6)&0x3F)))
+ s = append(s, byte(0x80+(value&0x3F)))
+ }
+
+ // Advance the pointer.
+ for k := 0; k < code_length; k++ {
+ skip(parser)
+ }
+ }
+ } else {
+ // It is a non-escaped non-blank character.
+ s = read(parser, s)
+ }
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+ }
+
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ // Check if we are at the end of the scalar.
+ if single {
+ if parser.buffer[parser.buffer_pos] == '\'' {
+ break
+ }
+ } else {
+ if parser.buffer[parser.buffer_pos] == '"' {
+ break
+ }
+ }
+
+ // Consume blank characters.
+ for is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos) {
+ if is_blank(parser.buffer, parser.buffer_pos) {
+ // Consume a space or a tab character.
+ if !leading_blanks {
+ whitespaces = read(parser, whitespaces)
+ } else {
+ skip(parser)
+ }
+ } else {
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+
+ // Check if it is a first line break.
+ if !leading_blanks {
+ whitespaces = whitespaces[:0]
+ leading_break = read_line(parser, leading_break)
+ leading_blanks = true
+ } else {
+ trailing_breaks = read_line(parser, trailing_breaks)
+ }
+ }
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Join the whitespaces or fold line breaks.
+ if leading_blanks {
+ // Do we need to fold line breaks?
+ if len(leading_break) > 0 && leading_break[0] == '\n' {
+ if len(trailing_breaks) == 0 {
+ s = append(s, ' ')
+ } else {
+ s = append(s, trailing_breaks...)
+ }
+ } else {
+ s = append(s, leading_break...)
+ s = append(s, trailing_breaks...)
+ }
+ trailing_breaks = trailing_breaks[:0]
+ leading_break = leading_break[:0]
+ } else {
+ s = append(s, whitespaces...)
+ whitespaces = whitespaces[:0]
+ }
+ }
+
+ // Eat the right quote.
+ skip(parser)
+ end_mark := parser.mark
+
+ // Create a token.
+ *token = yaml_token_t{
+ typ: yaml_SCALAR_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ value: s,
+ style: yaml_SINGLE_QUOTED_SCALAR_STYLE,
+ }
+ if !single {
+ token.style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
+ }
+ return true
+}
+
+// Scan a plain scalar.
+func yaml_parser_scan_plain_scalar(parser *yaml_parser_t, token *yaml_token_t) bool {
+
+ var s, leading_break, trailing_breaks, whitespaces []byte
+ var leading_blanks bool
+ var indent = parser.indent + 1
+
+ start_mark := parser.mark
+ end_mark := parser.mark
+
+ // Consume the content of the plain scalar.
+ for {
+ // Check for a document indicator.
+ if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) {
+ return false
+ }
+ if parser.mark.column == 0 &&
+ ((parser.buffer[parser.buffer_pos+0] == '-' &&
+ parser.buffer[parser.buffer_pos+1] == '-' &&
+ parser.buffer[parser.buffer_pos+2] == '-') ||
+ (parser.buffer[parser.buffer_pos+0] == '.' &&
+ parser.buffer[parser.buffer_pos+1] == '.' &&
+ parser.buffer[parser.buffer_pos+2] == '.')) &&
+ is_blankz(parser.buffer, parser.buffer_pos+3) {
+ break
+ }
+
+ // Check for a comment.
+ if parser.buffer[parser.buffer_pos] == '#' {
+ break
+ }
+
+ // Consume non-blank characters.
+ for !is_blankz(parser.buffer, parser.buffer_pos) {
+
+ // Check for indicators that may end a plain scalar.
+ if (parser.buffer[parser.buffer_pos] == ':' && is_blankz(parser.buffer, parser.buffer_pos+1)) ||
+ (parser.flow_level > 0 &&
+ (parser.buffer[parser.buffer_pos] == ',' ||
+ parser.buffer[parser.buffer_pos] == '?' || parser.buffer[parser.buffer_pos] == '[' ||
+ parser.buffer[parser.buffer_pos] == ']' || parser.buffer[parser.buffer_pos] == '{' ||
+ parser.buffer[parser.buffer_pos] == '}')) {
+ break
+ }
+
+ // Check if we need to join whitespaces and breaks.
+ if leading_blanks || len(whitespaces) > 0 {
+ if leading_blanks {
+ // Do we need to fold line breaks?
+ if leading_break[0] == '\n' {
+ if len(trailing_breaks) == 0 {
+ s = append(s, ' ')
+ } else {
+ s = append(s, trailing_breaks...)
+ }
+ } else {
+ s = append(s, leading_break...)
+ s = append(s, trailing_breaks...)
+ }
+ trailing_breaks = trailing_breaks[:0]
+ leading_break = leading_break[:0]
+ leading_blanks = false
+ } else {
+ s = append(s, whitespaces...)
+ whitespaces = whitespaces[:0]
+ }
+ }
+
+ // Copy the character.
+ s = read(parser, s)
+
+ end_mark = parser.mark
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+ }
+
+ // Is it the end?
+ if !(is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos)) {
+ break
+ }
+
+ // Consume blank characters.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ for is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos) {
+ if is_blank(parser.buffer, parser.buffer_pos) {
+
+ // Check for tab characters that abuse indentation.
+ if leading_blanks && parser.mark.column < indent && is_tab(parser.buffer, parser.buffer_pos) {
+ yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",
+ start_mark, "found a tab character that violates indentation")
+ return false
+ }
+
+ // Consume a space or a tab character.
+ if !leading_blanks {
+ whitespaces = read(parser, whitespaces)
+ } else {
+ skip(parser)
+ }
+ } else {
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+
+ // Check if it is a first line break.
+ if !leading_blanks {
+ whitespaces = whitespaces[:0]
+ leading_break = read_line(parser, leading_break)
+ leading_blanks = true
+ } else {
+ trailing_breaks = read_line(parser, trailing_breaks)
+ }
+ }
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Check indentation level.
+ if parser.flow_level == 0 && parser.mark.column < indent {
+ break
+ }
+ }
+
+ // Create a token.
+ *token = yaml_token_t{
+ typ: yaml_SCALAR_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ value: s,
+ style: yaml_PLAIN_SCALAR_STYLE,
+ }
+
+ // Note that we change the 'simple_key_allowed' flag.
+ if leading_blanks {
+ parser.simple_key_allowed = true
+ }
+ return true
+}
diff --git a/vendor/sigs.k8s.io/yaml/goyaml.v2/sorter.go b/vendor/sigs.k8s.io/yaml/goyaml.v2/sorter.go
new file mode 100644
index 0000000000..4c45e660a8
--- /dev/null
+++ b/vendor/sigs.k8s.io/yaml/goyaml.v2/sorter.go
@@ -0,0 +1,113 @@
+package yaml
+
+import (
+ "reflect"
+ "unicode"
+)
+
+type keyList []reflect.Value
+
+func (l keyList) Len() int { return len(l) }
+func (l keyList) Swap(i, j int) { l[i], l[j] = l[j], l[i] }
+func (l keyList) Less(i, j int) bool {
+ a := l[i]
+ b := l[j]
+ ak := a.Kind()
+ bk := b.Kind()
+ for (ak == reflect.Interface || ak == reflect.Ptr) && !a.IsNil() {
+ a = a.Elem()
+ ak = a.Kind()
+ }
+ for (bk == reflect.Interface || bk == reflect.Ptr) && !b.IsNil() {
+ b = b.Elem()
+ bk = b.Kind()
+ }
+ af, aok := keyFloat(a)
+ bf, bok := keyFloat(b)
+ if aok && bok {
+ if af != bf {
+ return af < bf
+ }
+ if ak != bk {
+ return ak < bk
+ }
+ return numLess(a, b)
+ }
+ if ak != reflect.String || bk != reflect.String {
+ return ak < bk
+ }
+ ar, br := []rune(a.String()), []rune(b.String())
+ for i := 0; i < len(ar) && i < len(br); i++ {
+ if ar[i] == br[i] {
+ continue
+ }
+ al := unicode.IsLetter(ar[i])
+ bl := unicode.IsLetter(br[i])
+ if al && bl {
+ return ar[i] < br[i]
+ }
+ if al || bl {
+ return bl
+ }
+ var ai, bi int
+ var an, bn int64
+ if ar[i] == '0' || br[i] == '0' {
+ for j := i-1; j >= 0 && unicode.IsDigit(ar[j]); j-- {
+ if ar[j] != '0' {
+ an = 1
+ bn = 1
+ break
+ }
+ }
+ }
+ for ai = i; ai < len(ar) && unicode.IsDigit(ar[ai]); ai++ {
+ an = an*10 + int64(ar[ai]-'0')
+ }
+ for bi = i; bi < len(br) && unicode.IsDigit(br[bi]); bi++ {
+ bn = bn*10 + int64(br[bi]-'0')
+ }
+ if an != bn {
+ return an < bn
+ }
+ if ai != bi {
+ return ai < bi
+ }
+ return ar[i] < br[i]
+ }
+ return len(ar) < len(br)
+}
+
+// keyFloat returns a float value for v if it is a number/bool
+// and whether it is a number/bool or not.
+func keyFloat(v reflect.Value) (f float64, ok bool) {
+ switch v.Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return float64(v.Int()), true
+ case reflect.Float32, reflect.Float64:
+ return v.Float(), true
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return float64(v.Uint()), true
+ case reflect.Bool:
+ if v.Bool() {
+ return 1, true
+ }
+ return 0, true
+ }
+ return 0, false
+}
+
+// numLess returns whether a < b.
+// a and b must necessarily have the same kind.
+func numLess(a, b reflect.Value) bool {
+ switch a.Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return a.Int() < b.Int()
+ case reflect.Float32, reflect.Float64:
+ return a.Float() < b.Float()
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return a.Uint() < b.Uint()
+ case reflect.Bool:
+ return !a.Bool() && b.Bool()
+ }
+ panic("not a number")
+}
diff --git a/vendor/sigs.k8s.io/yaml/goyaml.v2/writerc.go b/vendor/sigs.k8s.io/yaml/goyaml.v2/writerc.go
new file mode 100644
index 0000000000..a2dde608cb
--- /dev/null
+++ b/vendor/sigs.k8s.io/yaml/goyaml.v2/writerc.go
@@ -0,0 +1,26 @@
+package yaml
+
+// Set the writer error and return false.
+func yaml_emitter_set_writer_error(emitter *yaml_emitter_t, problem string) bool {
+ emitter.error = yaml_WRITER_ERROR
+ emitter.problem = problem
+ return false
+}
+
+// Flush the output buffer.
+func yaml_emitter_flush(emitter *yaml_emitter_t) bool {
+ if emitter.write_handler == nil {
+ panic("write handler not set")
+ }
+
+ // Check if the buffer is empty.
+ if emitter.buffer_pos == 0 {
+ return true
+ }
+
+ if err := emitter.write_handler(emitter, emitter.buffer[:emitter.buffer_pos]); err != nil {
+ return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error())
+ }
+ emitter.buffer_pos = 0
+ return true
+}
diff --git a/vendor/sigs.k8s.io/yaml/goyaml.v2/yaml.go b/vendor/sigs.k8s.io/yaml/goyaml.v2/yaml.go
new file mode 100644
index 0000000000..30813884c0
--- /dev/null
+++ b/vendor/sigs.k8s.io/yaml/goyaml.v2/yaml.go
@@ -0,0 +1,478 @@
+// Package yaml implements YAML support for the Go language.
+//
+// Source code and other details for the project are available at GitHub:
+//
+// https://github.com/go-yaml/yaml
+//
+package yaml
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "reflect"
+ "strings"
+ "sync"
+)
+
+// MapSlice encodes and decodes as a YAML map.
+// The order of keys is preserved when encoding and decoding.
+type MapSlice []MapItem
+
+// MapItem is an item in a MapSlice.
+type MapItem struct {
+ Key, Value interface{}
+}
+
+// The Unmarshaler interface may be implemented by types to customize their
+// behavior when being unmarshaled from a YAML document. The UnmarshalYAML
+// method receives a function that may be called to unmarshal the original
+// YAML value into a field or variable. It is safe to call the unmarshal
+// function parameter more than once if necessary.
+type Unmarshaler interface {
+ UnmarshalYAML(unmarshal func(interface{}) error) error
+}
+
+// The Marshaler interface may be implemented by types to customize their
+// behavior when being marshaled into a YAML document. The returned value
+// is marshaled in place of the original value implementing Marshaler.
+//
+// If an error is returned by MarshalYAML, the marshaling procedure stops
+// and returns with the provided error.
+type Marshaler interface {
+ MarshalYAML() (interface{}, error)
+}
+
+// Unmarshal decodes the first document found within the in byte slice
+// and assigns decoded values into the out value.
+//
+// Maps and pointers (to a struct, string, int, etc) are accepted as out
+// values. If an internal pointer within a struct is not initialized,
+// the yaml package will initialize it if necessary for unmarshalling
+// the provided data. The out parameter must not be nil.
+//
+// The type of the decoded values should be compatible with the respective
+// values in out. If one or more values cannot be decoded due to a type
+// mismatches, decoding continues partially until the end of the YAML
+// content, and a *yaml.TypeError is returned with details for all
+// missed values.
+//
+// Struct fields are only unmarshalled if they are exported (have an
+// upper case first letter), and are unmarshalled using the field name
+// lowercased as the default key. Custom keys may be defined via the
+// "yaml" name in the field tag: the content preceding the first comma
+// is used as the key, and the following comma-separated options are
+// used to tweak the marshalling process (see Marshal).
+// Conflicting names result in a runtime error.
+//
+// For example:
+//
+// type T struct {
+// F int `yaml:"a,omitempty"`
+// B int
+// }
+// var t T
+// yaml.Unmarshal([]byte("a: 1\nb: 2"), &t)
+//
+// See the documentation of Marshal for the format of tags and a list of
+// supported tag options.
+//
+func Unmarshal(in []byte, out interface{}) (err error) {
+ return unmarshal(in, out, false)
+}
+
+// UnmarshalStrict is like Unmarshal except that any fields that are found
+// in the data that do not have corresponding struct members, or mapping
+// keys that are duplicates, will result in
+// an error.
+func UnmarshalStrict(in []byte, out interface{}) (err error) {
+ return unmarshal(in, out, true)
+}
+
+// A Decoder reads and decodes YAML values from an input stream.
+type Decoder struct {
+ strict bool
+ parser *parser
+}
+
+// NewDecoder returns a new decoder that reads from r.
+//
+// The decoder introduces its own buffering and may read
+// data from r beyond the YAML values requested.
+func NewDecoder(r io.Reader) *Decoder {
+ return &Decoder{
+ parser: newParserFromReader(r),
+ }
+}
+
+// SetStrict sets whether strict decoding behaviour is enabled when
+// decoding items in the data (see UnmarshalStrict). By default, decoding is not strict.
+func (dec *Decoder) SetStrict(strict bool) {
+ dec.strict = strict
+}
+
+// Decode reads the next YAML-encoded value from its input
+// and stores it in the value pointed to by v.
+//
+// See the documentation for Unmarshal for details about the
+// conversion of YAML into a Go value.
+func (dec *Decoder) Decode(v interface{}) (err error) {
+ d := newDecoder(dec.strict)
+ defer handleErr(&err)
+ node := dec.parser.parse()
+ if node == nil {
+ return io.EOF
+ }
+ out := reflect.ValueOf(v)
+ if out.Kind() == reflect.Ptr && !out.IsNil() {
+ out = out.Elem()
+ }
+ d.unmarshal(node, out)
+ if len(d.terrors) > 0 {
+ return &TypeError{d.terrors}
+ }
+ return nil
+}
+
+func unmarshal(in []byte, out interface{}, strict bool) (err error) {
+ defer handleErr(&err)
+ d := newDecoder(strict)
+ p := newParser(in)
+ defer p.destroy()
+ node := p.parse()
+ if node != nil {
+ v := reflect.ValueOf(out)
+ if v.Kind() == reflect.Ptr && !v.IsNil() {
+ v = v.Elem()
+ }
+ d.unmarshal(node, v)
+ }
+ if len(d.terrors) > 0 {
+ return &TypeError{d.terrors}
+ }
+ return nil
+}
+
+// Marshal serializes the value provided into a YAML document. The structure
+// of the generated document will reflect the structure of the value itself.
+// Maps and pointers (to struct, string, int, etc) are accepted as the in value.
+//
+// Struct fields are only marshalled if they are exported (have an upper case
+// first letter), and are marshalled using the field name lowercased as the
+// default key. Custom keys may be defined via the "yaml" name in the field
+// tag: the content preceding the first comma is used as the key, and the
+// following comma-separated options are used to tweak the marshalling process.
+// Conflicting names result in a runtime error.
+//
+// The field tag format accepted is:
+//
+// `(...) yaml:"[][,[,]]" (...)`
+//
+// The following flags are currently supported:
+//
+// omitempty Only include the field if it's not set to the zero
+// value for the type or to empty slices or maps.
+// Zero valued structs will be omitted if all their public
+// fields are zero, unless they implement an IsZero
+// method (see the IsZeroer interface type), in which
+// case the field will be excluded if IsZero returns true.
+//
+// flow Marshal using a flow style (useful for structs,
+// sequences and maps).
+//
+// inline Inline the field, which must be a struct or a map,
+// causing all of its fields or keys to be processed as if
+// they were part of the outer struct. For maps, keys must
+// not conflict with the yaml keys of other struct fields.
+//
+// In addition, if the key is "-", the field is ignored.
+//
+// For example:
+//
+// type T struct {
+// F int `yaml:"a,omitempty"`
+// B int
+// }
+// yaml.Marshal(&T{B: 2}) // Returns "b: 2\n"
+// yaml.Marshal(&T{F: 1}} // Returns "a: 1\nb: 0\n"
+//
+func Marshal(in interface{}) (out []byte, err error) {
+ defer handleErr(&err)
+ e := newEncoder()
+ defer e.destroy()
+ e.marshalDoc("", reflect.ValueOf(in))
+ e.finish()
+ out = e.out
+ return
+}
+
+// An Encoder writes YAML values to an output stream.
+type Encoder struct {
+ encoder *encoder
+}
+
+// NewEncoder returns a new encoder that writes to w.
+// The Encoder should be closed after use to flush all data
+// to w.
+func NewEncoder(w io.Writer) *Encoder {
+ return &Encoder{
+ encoder: newEncoderWithWriter(w),
+ }
+}
+
+// Encode writes the YAML encoding of v to the stream.
+// If multiple items are encoded to the stream, the
+// second and subsequent document will be preceded
+// with a "---" document separator, but the first will not.
+//
+// See the documentation for Marshal for details about the conversion of Go
+// values to YAML.
+func (e *Encoder) Encode(v interface{}) (err error) {
+ defer handleErr(&err)
+ e.encoder.marshalDoc("", reflect.ValueOf(v))
+ return nil
+}
+
+// Close closes the encoder by writing any remaining data.
+// It does not write a stream terminating string "...".
+func (e *Encoder) Close() (err error) {
+ defer handleErr(&err)
+ e.encoder.finish()
+ return nil
+}
+
+func handleErr(err *error) {
+ if v := recover(); v != nil {
+ if e, ok := v.(yamlError); ok {
+ *err = e.err
+ } else {
+ panic(v)
+ }
+ }
+}
+
+type yamlError struct {
+ err error
+}
+
+func fail(err error) {
+ panic(yamlError{err})
+}
+
+func failf(format string, args ...interface{}) {
+ panic(yamlError{fmt.Errorf("yaml: "+format, args...)})
+}
+
+// A TypeError is returned by Unmarshal when one or more fields in
+// the YAML document cannot be properly decoded into the requested
+// types. When this error is returned, the value is still
+// unmarshaled partially.
+type TypeError struct {
+ Errors []string
+}
+
+func (e *TypeError) Error() string {
+ return fmt.Sprintf("yaml: unmarshal errors:\n %s", strings.Join(e.Errors, "\n "))
+}
+
+// --------------------------------------------------------------------------
+// Maintain a mapping of keys to structure field indexes
+
+// The code in this section was copied from mgo/bson.
+
+// structInfo holds details for the serialization of fields of
+// a given struct.
+type structInfo struct {
+ FieldsMap map[string]fieldInfo
+ FieldsList []fieldInfo
+
+ // InlineMap is the number of the field in the struct that
+ // contains an ,inline map, or -1 if there's none.
+ InlineMap int
+}
+
+type fieldInfo struct {
+ Key string
+ Num int
+ OmitEmpty bool
+ Flow bool
+ // Id holds the unique field identifier, so we can cheaply
+ // check for field duplicates without maintaining an extra map.
+ Id int
+
+ // Inline holds the field index if the field is part of an inlined struct.
+ Inline []int
+}
+
+var structMap = make(map[reflect.Type]*structInfo)
+var fieldMapMutex sync.RWMutex
+
+func getStructInfo(st reflect.Type) (*structInfo, error) {
+ fieldMapMutex.RLock()
+ sinfo, found := structMap[st]
+ fieldMapMutex.RUnlock()
+ if found {
+ return sinfo, nil
+ }
+
+ n := st.NumField()
+ fieldsMap := make(map[string]fieldInfo)
+ fieldsList := make([]fieldInfo, 0, n)
+ inlineMap := -1
+ for i := 0; i != n; i++ {
+ field := st.Field(i)
+ if field.PkgPath != "" && !field.Anonymous {
+ continue // Private field
+ }
+
+ info := fieldInfo{Num: i}
+
+ tag := field.Tag.Get("yaml")
+ if tag == "" && strings.Index(string(field.Tag), ":") < 0 {
+ tag = string(field.Tag)
+ }
+ if tag == "-" {
+ continue
+ }
+
+ inline := false
+ fields := strings.Split(tag, ",")
+ if len(fields) > 1 {
+ for _, flag := range fields[1:] {
+ switch flag {
+ case "omitempty":
+ info.OmitEmpty = true
+ case "flow":
+ info.Flow = true
+ case "inline":
+ inline = true
+ default:
+ return nil, errors.New(fmt.Sprintf("Unsupported flag %q in tag %q of type %s", flag, tag, st))
+ }
+ }
+ tag = fields[0]
+ }
+
+ if inline {
+ switch field.Type.Kind() {
+ case reflect.Map:
+ if inlineMap >= 0 {
+ return nil, errors.New("Multiple ,inline maps in struct " + st.String())
+ }
+ if field.Type.Key() != reflect.TypeOf("") {
+ return nil, errors.New("Option ,inline needs a map with string keys in struct " + st.String())
+ }
+ inlineMap = info.Num
+ case reflect.Struct:
+ sinfo, err := getStructInfo(field.Type)
+ if err != nil {
+ return nil, err
+ }
+ for _, finfo := range sinfo.FieldsList {
+ if _, found := fieldsMap[finfo.Key]; found {
+ msg := "Duplicated key '" + finfo.Key + "' in struct " + st.String()
+ return nil, errors.New(msg)
+ }
+ if finfo.Inline == nil {
+ finfo.Inline = []int{i, finfo.Num}
+ } else {
+ finfo.Inline = append([]int{i}, finfo.Inline...)
+ }
+ finfo.Id = len(fieldsList)
+ fieldsMap[finfo.Key] = finfo
+ fieldsList = append(fieldsList, finfo)
+ }
+ default:
+ //return nil, errors.New("Option ,inline needs a struct value or map field")
+ return nil, errors.New("Option ,inline needs a struct value field")
+ }
+ continue
+ }
+
+ if tag != "" {
+ info.Key = tag
+ } else {
+ info.Key = strings.ToLower(field.Name)
+ }
+
+ if _, found = fieldsMap[info.Key]; found {
+ msg := "Duplicated key '" + info.Key + "' in struct " + st.String()
+ return nil, errors.New(msg)
+ }
+
+ info.Id = len(fieldsList)
+ fieldsList = append(fieldsList, info)
+ fieldsMap[info.Key] = info
+ }
+
+ sinfo = &structInfo{
+ FieldsMap: fieldsMap,
+ FieldsList: fieldsList,
+ InlineMap: inlineMap,
+ }
+
+ fieldMapMutex.Lock()
+ structMap[st] = sinfo
+ fieldMapMutex.Unlock()
+ return sinfo, nil
+}
+
+// IsZeroer is used to check whether an object is zero to
+// determine whether it should be omitted when marshaling
+// with the omitempty flag. One notable implementation
+// is time.Time.
+type IsZeroer interface {
+ IsZero() bool
+}
+
+func isZero(v reflect.Value) bool {
+ kind := v.Kind()
+ if z, ok := v.Interface().(IsZeroer); ok {
+ if (kind == reflect.Ptr || kind == reflect.Interface) && v.IsNil() {
+ return true
+ }
+ return z.IsZero()
+ }
+ switch kind {
+ case reflect.String:
+ return len(v.String()) == 0
+ case reflect.Interface, reflect.Ptr:
+ return v.IsNil()
+ case reflect.Slice:
+ return v.Len() == 0
+ case reflect.Map:
+ return v.Len() == 0
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return v.Int() == 0
+ case reflect.Float32, reflect.Float64:
+ return v.Float() == 0
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return v.Uint() == 0
+ case reflect.Bool:
+ return !v.Bool()
+ case reflect.Struct:
+ vt := v.Type()
+ for i := v.NumField() - 1; i >= 0; i-- {
+ if vt.Field(i).PkgPath != "" {
+ continue // Private field
+ }
+ if !isZero(v.Field(i)) {
+ return false
+ }
+ }
+ return true
+ }
+ return false
+}
+
+// FutureLineWrap globally disables line wrapping when encoding long strings.
+// This is a temporary and thus deprecated method introduced to faciliate
+// migration towards v3, which offers more control of line lengths on
+// individual encodings, and has a default matching the behavior introduced
+// by this function.
+//
+// The default formatting of v2 was erroneously changed in v2.3.0 and reverted
+// in v2.4.0, at which point this function was introduced to help migration.
+func FutureLineWrap() {
+ disableLineWrapping = true
+}
diff --git a/vendor/sigs.k8s.io/yaml/goyaml.v2/yamlh.go b/vendor/sigs.k8s.io/yaml/goyaml.v2/yamlh.go
new file mode 100644
index 0000000000..f6a9c8e34b
--- /dev/null
+++ b/vendor/sigs.k8s.io/yaml/goyaml.v2/yamlh.go
@@ -0,0 +1,739 @@
+package yaml
+
+import (
+ "fmt"
+ "io"
+)
+
+// The version directive data.
+type yaml_version_directive_t struct {
+ major int8 // The major version number.
+ minor int8 // The minor version number.
+}
+
+// The tag directive data.
+type yaml_tag_directive_t struct {
+ handle []byte // The tag handle.
+ prefix []byte // The tag prefix.
+}
+
+type yaml_encoding_t int
+
+// The stream encoding.
+const (
+ // Let the parser choose the encoding.
+ yaml_ANY_ENCODING yaml_encoding_t = iota
+
+ yaml_UTF8_ENCODING // The default UTF-8 encoding.
+ yaml_UTF16LE_ENCODING // The UTF-16-LE encoding with BOM.
+ yaml_UTF16BE_ENCODING // The UTF-16-BE encoding with BOM.
+)
+
+type yaml_break_t int
+
+// Line break types.
+const (
+ // Let the parser choose the break type.
+ yaml_ANY_BREAK yaml_break_t = iota
+
+ yaml_CR_BREAK // Use CR for line breaks (Mac style).
+ yaml_LN_BREAK // Use LN for line breaks (Unix style).
+ yaml_CRLN_BREAK // Use CR LN for line breaks (DOS style).
+)
+
+type yaml_error_type_t int
+
+// Many bad things could happen with the parser and emitter.
+const (
+ // No error is produced.
+ yaml_NO_ERROR yaml_error_type_t = iota
+
+ yaml_MEMORY_ERROR // Cannot allocate or reallocate a block of memory.
+ yaml_READER_ERROR // Cannot read or decode the input stream.
+ yaml_SCANNER_ERROR // Cannot scan the input stream.
+ yaml_PARSER_ERROR // Cannot parse the input stream.
+ yaml_COMPOSER_ERROR // Cannot compose a YAML document.
+ yaml_WRITER_ERROR // Cannot write to the output stream.
+ yaml_EMITTER_ERROR // Cannot emit a YAML stream.
+)
+
+// The pointer position.
+type yaml_mark_t struct {
+ index int // The position index.
+ line int // The position line.
+ column int // The position column.
+}
+
+// Node Styles
+
+type yaml_style_t int8
+
+type yaml_scalar_style_t yaml_style_t
+
+// Scalar styles.
+const (
+ // Let the emitter choose the style.
+ yaml_ANY_SCALAR_STYLE yaml_scalar_style_t = iota
+
+ yaml_PLAIN_SCALAR_STYLE // The plain scalar style.
+ yaml_SINGLE_QUOTED_SCALAR_STYLE // The single-quoted scalar style.
+ yaml_DOUBLE_QUOTED_SCALAR_STYLE // The double-quoted scalar style.
+ yaml_LITERAL_SCALAR_STYLE // The literal scalar style.
+ yaml_FOLDED_SCALAR_STYLE // The folded scalar style.
+)
+
+type yaml_sequence_style_t yaml_style_t
+
+// Sequence styles.
+const (
+ // Let the emitter choose the style.
+ yaml_ANY_SEQUENCE_STYLE yaml_sequence_style_t = iota
+
+ yaml_BLOCK_SEQUENCE_STYLE // The block sequence style.
+ yaml_FLOW_SEQUENCE_STYLE // The flow sequence style.
+)
+
+type yaml_mapping_style_t yaml_style_t
+
+// Mapping styles.
+const (
+ // Let the emitter choose the style.
+ yaml_ANY_MAPPING_STYLE yaml_mapping_style_t = iota
+
+ yaml_BLOCK_MAPPING_STYLE // The block mapping style.
+ yaml_FLOW_MAPPING_STYLE // The flow mapping style.
+)
+
+// Tokens
+
+type yaml_token_type_t int
+
+// Token types.
+const (
+ // An empty token.
+ yaml_NO_TOKEN yaml_token_type_t = iota
+
+ yaml_STREAM_START_TOKEN // A STREAM-START token.
+ yaml_STREAM_END_TOKEN // A STREAM-END token.
+
+ yaml_VERSION_DIRECTIVE_TOKEN // A VERSION-DIRECTIVE token.
+ yaml_TAG_DIRECTIVE_TOKEN // A TAG-DIRECTIVE token.
+ yaml_DOCUMENT_START_TOKEN // A DOCUMENT-START token.
+ yaml_DOCUMENT_END_TOKEN // A DOCUMENT-END token.
+
+ yaml_BLOCK_SEQUENCE_START_TOKEN // A BLOCK-SEQUENCE-START token.
+ yaml_BLOCK_MAPPING_START_TOKEN // A BLOCK-SEQUENCE-END token.
+ yaml_BLOCK_END_TOKEN // A BLOCK-END token.
+
+ yaml_FLOW_SEQUENCE_START_TOKEN // A FLOW-SEQUENCE-START token.
+ yaml_FLOW_SEQUENCE_END_TOKEN // A FLOW-SEQUENCE-END token.
+ yaml_FLOW_MAPPING_START_TOKEN // A FLOW-MAPPING-START token.
+ yaml_FLOW_MAPPING_END_TOKEN // A FLOW-MAPPING-END token.
+
+ yaml_BLOCK_ENTRY_TOKEN // A BLOCK-ENTRY token.
+ yaml_FLOW_ENTRY_TOKEN // A FLOW-ENTRY token.
+ yaml_KEY_TOKEN // A KEY token.
+ yaml_VALUE_TOKEN // A VALUE token.
+
+ yaml_ALIAS_TOKEN // An ALIAS token.
+ yaml_ANCHOR_TOKEN // An ANCHOR token.
+ yaml_TAG_TOKEN // A TAG token.
+ yaml_SCALAR_TOKEN // A SCALAR token.
+)
+
+func (tt yaml_token_type_t) String() string {
+ switch tt {
+ case yaml_NO_TOKEN:
+ return "yaml_NO_TOKEN"
+ case yaml_STREAM_START_TOKEN:
+ return "yaml_STREAM_START_TOKEN"
+ case yaml_STREAM_END_TOKEN:
+ return "yaml_STREAM_END_TOKEN"
+ case yaml_VERSION_DIRECTIVE_TOKEN:
+ return "yaml_VERSION_DIRECTIVE_TOKEN"
+ case yaml_TAG_DIRECTIVE_TOKEN:
+ return "yaml_TAG_DIRECTIVE_TOKEN"
+ case yaml_DOCUMENT_START_TOKEN:
+ return "yaml_DOCUMENT_START_TOKEN"
+ case yaml_DOCUMENT_END_TOKEN:
+ return "yaml_DOCUMENT_END_TOKEN"
+ case yaml_BLOCK_SEQUENCE_START_TOKEN:
+ return "yaml_BLOCK_SEQUENCE_START_TOKEN"
+ case yaml_BLOCK_MAPPING_START_TOKEN:
+ return "yaml_BLOCK_MAPPING_START_TOKEN"
+ case yaml_BLOCK_END_TOKEN:
+ return "yaml_BLOCK_END_TOKEN"
+ case yaml_FLOW_SEQUENCE_START_TOKEN:
+ return "yaml_FLOW_SEQUENCE_START_TOKEN"
+ case yaml_FLOW_SEQUENCE_END_TOKEN:
+ return "yaml_FLOW_SEQUENCE_END_TOKEN"
+ case yaml_FLOW_MAPPING_START_TOKEN:
+ return "yaml_FLOW_MAPPING_START_TOKEN"
+ case yaml_FLOW_MAPPING_END_TOKEN:
+ return "yaml_FLOW_MAPPING_END_TOKEN"
+ case yaml_BLOCK_ENTRY_TOKEN:
+ return "yaml_BLOCK_ENTRY_TOKEN"
+ case yaml_FLOW_ENTRY_TOKEN:
+ return "yaml_FLOW_ENTRY_TOKEN"
+ case yaml_KEY_TOKEN:
+ return "yaml_KEY_TOKEN"
+ case yaml_VALUE_TOKEN:
+ return "yaml_VALUE_TOKEN"
+ case yaml_ALIAS_TOKEN:
+ return "yaml_ALIAS_TOKEN"
+ case yaml_ANCHOR_TOKEN:
+ return "yaml_ANCHOR_TOKEN"
+ case yaml_TAG_TOKEN:
+ return "yaml_TAG_TOKEN"
+ case yaml_SCALAR_TOKEN:
+ return "yaml_SCALAR_TOKEN"
+ }
+ return ""
+}
+
+// The token structure.
+type yaml_token_t struct {
+ // The token type.
+ typ yaml_token_type_t
+
+ // The start/end of the token.
+ start_mark, end_mark yaml_mark_t
+
+ // The stream encoding (for yaml_STREAM_START_TOKEN).
+ encoding yaml_encoding_t
+
+ // The alias/anchor/scalar value or tag/tag directive handle
+ // (for yaml_ALIAS_TOKEN, yaml_ANCHOR_TOKEN, yaml_SCALAR_TOKEN, yaml_TAG_TOKEN, yaml_TAG_DIRECTIVE_TOKEN).
+ value []byte
+
+ // The tag suffix (for yaml_TAG_TOKEN).
+ suffix []byte
+
+ // The tag directive prefix (for yaml_TAG_DIRECTIVE_TOKEN).
+ prefix []byte
+
+ // The scalar style (for yaml_SCALAR_TOKEN).
+ style yaml_scalar_style_t
+
+ // The version directive major/minor (for yaml_VERSION_DIRECTIVE_TOKEN).
+ major, minor int8
+}
+
+// Events
+
+type yaml_event_type_t int8
+
+// Event types.
+const (
+ // An empty event.
+ yaml_NO_EVENT yaml_event_type_t = iota
+
+ yaml_STREAM_START_EVENT // A STREAM-START event.
+ yaml_STREAM_END_EVENT // A STREAM-END event.
+ yaml_DOCUMENT_START_EVENT // A DOCUMENT-START event.
+ yaml_DOCUMENT_END_EVENT // A DOCUMENT-END event.
+ yaml_ALIAS_EVENT // An ALIAS event.
+ yaml_SCALAR_EVENT // A SCALAR event.
+ yaml_SEQUENCE_START_EVENT // A SEQUENCE-START event.
+ yaml_SEQUENCE_END_EVENT // A SEQUENCE-END event.
+ yaml_MAPPING_START_EVENT // A MAPPING-START event.
+ yaml_MAPPING_END_EVENT // A MAPPING-END event.
+)
+
+var eventStrings = []string{
+ yaml_NO_EVENT: "none",
+ yaml_STREAM_START_EVENT: "stream start",
+ yaml_STREAM_END_EVENT: "stream end",
+ yaml_DOCUMENT_START_EVENT: "document start",
+ yaml_DOCUMENT_END_EVENT: "document end",
+ yaml_ALIAS_EVENT: "alias",
+ yaml_SCALAR_EVENT: "scalar",
+ yaml_SEQUENCE_START_EVENT: "sequence start",
+ yaml_SEQUENCE_END_EVENT: "sequence end",
+ yaml_MAPPING_START_EVENT: "mapping start",
+ yaml_MAPPING_END_EVENT: "mapping end",
+}
+
+func (e yaml_event_type_t) String() string {
+ if e < 0 || int(e) >= len(eventStrings) {
+ return fmt.Sprintf("unknown event %d", e)
+ }
+ return eventStrings[e]
+}
+
+// The event structure.
+type yaml_event_t struct {
+
+ // The event type.
+ typ yaml_event_type_t
+
+ // The start and end of the event.
+ start_mark, end_mark yaml_mark_t
+
+ // The document encoding (for yaml_STREAM_START_EVENT).
+ encoding yaml_encoding_t
+
+ // The version directive (for yaml_DOCUMENT_START_EVENT).
+ version_directive *yaml_version_directive_t
+
+ // The list of tag directives (for yaml_DOCUMENT_START_EVENT).
+ tag_directives []yaml_tag_directive_t
+
+ // The anchor (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT, yaml_ALIAS_EVENT).
+ anchor []byte
+
+ // The tag (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT).
+ tag []byte
+
+ // The scalar value (for yaml_SCALAR_EVENT).
+ value []byte
+
+ // Is the document start/end indicator implicit, or the tag optional?
+ // (for yaml_DOCUMENT_START_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT, yaml_SCALAR_EVENT).
+ implicit bool
+
+ // Is the tag optional for any non-plain style? (for yaml_SCALAR_EVENT).
+ quoted_implicit bool
+
+ // The style (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT).
+ style yaml_style_t
+}
+
+func (e *yaml_event_t) scalar_style() yaml_scalar_style_t { return yaml_scalar_style_t(e.style) }
+func (e *yaml_event_t) sequence_style() yaml_sequence_style_t { return yaml_sequence_style_t(e.style) }
+func (e *yaml_event_t) mapping_style() yaml_mapping_style_t { return yaml_mapping_style_t(e.style) }
+
+// Nodes
+
+const (
+ yaml_NULL_TAG = "tag:yaml.org,2002:null" // The tag !!null with the only possible value: null.
+ yaml_BOOL_TAG = "tag:yaml.org,2002:bool" // The tag !!bool with the values: true and false.
+ yaml_STR_TAG = "tag:yaml.org,2002:str" // The tag !!str for string values.
+ yaml_INT_TAG = "tag:yaml.org,2002:int" // The tag !!int for integer values.
+ yaml_FLOAT_TAG = "tag:yaml.org,2002:float" // The tag !!float for float values.
+ yaml_TIMESTAMP_TAG = "tag:yaml.org,2002:timestamp" // The tag !!timestamp for date and time values.
+
+ yaml_SEQ_TAG = "tag:yaml.org,2002:seq" // The tag !!seq is used to denote sequences.
+ yaml_MAP_TAG = "tag:yaml.org,2002:map" // The tag !!map is used to denote mapping.
+
+ // Not in original libyaml.
+ yaml_BINARY_TAG = "tag:yaml.org,2002:binary"
+ yaml_MERGE_TAG = "tag:yaml.org,2002:merge"
+
+ yaml_DEFAULT_SCALAR_TAG = yaml_STR_TAG // The default scalar tag is !!str.
+ yaml_DEFAULT_SEQUENCE_TAG = yaml_SEQ_TAG // The default sequence tag is !!seq.
+ yaml_DEFAULT_MAPPING_TAG = yaml_MAP_TAG // The default mapping tag is !!map.
+)
+
+type yaml_node_type_t int
+
+// Node types.
+const (
+ // An empty node.
+ yaml_NO_NODE yaml_node_type_t = iota
+
+ yaml_SCALAR_NODE // A scalar node.
+ yaml_SEQUENCE_NODE // A sequence node.
+ yaml_MAPPING_NODE // A mapping node.
+)
+
+// An element of a sequence node.
+type yaml_node_item_t int
+
+// An element of a mapping node.
+type yaml_node_pair_t struct {
+ key int // The key of the element.
+ value int // The value of the element.
+}
+
+// The node structure.
+type yaml_node_t struct {
+ typ yaml_node_type_t // The node type.
+ tag []byte // The node tag.
+
+ // The node data.
+
+ // The scalar parameters (for yaml_SCALAR_NODE).
+ scalar struct {
+ value []byte // The scalar value.
+ length int // The length of the scalar value.
+ style yaml_scalar_style_t // The scalar style.
+ }
+
+ // The sequence parameters (for YAML_SEQUENCE_NODE).
+ sequence struct {
+ items_data []yaml_node_item_t // The stack of sequence items.
+ style yaml_sequence_style_t // The sequence style.
+ }
+
+ // The mapping parameters (for yaml_MAPPING_NODE).
+ mapping struct {
+ pairs_data []yaml_node_pair_t // The stack of mapping pairs (key, value).
+ pairs_start *yaml_node_pair_t // The beginning of the stack.
+ pairs_end *yaml_node_pair_t // The end of the stack.
+ pairs_top *yaml_node_pair_t // The top of the stack.
+ style yaml_mapping_style_t // The mapping style.
+ }
+
+ start_mark yaml_mark_t // The beginning of the node.
+ end_mark yaml_mark_t // The end of the node.
+
+}
+
+// The document structure.
+type yaml_document_t struct {
+
+ // The document nodes.
+ nodes []yaml_node_t
+
+ // The version directive.
+ version_directive *yaml_version_directive_t
+
+ // The list of tag directives.
+ tag_directives_data []yaml_tag_directive_t
+ tag_directives_start int // The beginning of the tag directives list.
+ tag_directives_end int // The end of the tag directives list.
+
+ start_implicit int // Is the document start indicator implicit?
+ end_implicit int // Is the document end indicator implicit?
+
+ // The start/end of the document.
+ start_mark, end_mark yaml_mark_t
+}
+
+// The prototype of a read handler.
+//
+// The read handler is called when the parser needs to read more bytes from the
+// source. The handler should write not more than size bytes to the buffer.
+// The number of written bytes should be set to the size_read variable.
+//
+// [in,out] data A pointer to an application data specified by
+// yaml_parser_set_input().
+// [out] buffer The buffer to write the data from the source.
+// [in] size The size of the buffer.
+// [out] size_read The actual number of bytes read from the source.
+//
+// On success, the handler should return 1. If the handler failed,
+// the returned value should be 0. On EOF, the handler should set the
+// size_read to 0 and return 1.
+type yaml_read_handler_t func(parser *yaml_parser_t, buffer []byte) (n int, err error)
+
+// This structure holds information about a potential simple key.
+type yaml_simple_key_t struct {
+ possible bool // Is a simple key possible?
+ required bool // Is a simple key required?
+ token_number int // The number of the token.
+ mark yaml_mark_t // The position mark.
+}
+
+// The states of the parser.
+type yaml_parser_state_t int
+
+const (
+ yaml_PARSE_STREAM_START_STATE yaml_parser_state_t = iota
+
+ yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE // Expect the beginning of an implicit document.
+ yaml_PARSE_DOCUMENT_START_STATE // Expect DOCUMENT-START.
+ yaml_PARSE_DOCUMENT_CONTENT_STATE // Expect the content of a document.
+ yaml_PARSE_DOCUMENT_END_STATE // Expect DOCUMENT-END.
+ yaml_PARSE_BLOCK_NODE_STATE // Expect a block node.
+ yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE // Expect a block node or indentless sequence.
+ yaml_PARSE_FLOW_NODE_STATE // Expect a flow node.
+ yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE // Expect the first entry of a block sequence.
+ yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE // Expect an entry of a block sequence.
+ yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE // Expect an entry of an indentless sequence.
+ yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE // Expect the first key of a block mapping.
+ yaml_PARSE_BLOCK_MAPPING_KEY_STATE // Expect a block mapping key.
+ yaml_PARSE_BLOCK_MAPPING_VALUE_STATE // Expect a block mapping value.
+ yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE // Expect the first entry of a flow sequence.
+ yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE // Expect an entry of a flow sequence.
+ yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE // Expect a key of an ordered mapping.
+ yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE // Expect a value of an ordered mapping.
+ yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE // Expect the and of an ordered mapping entry.
+ yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE // Expect the first key of a flow mapping.
+ yaml_PARSE_FLOW_MAPPING_KEY_STATE // Expect a key of a flow mapping.
+ yaml_PARSE_FLOW_MAPPING_VALUE_STATE // Expect a value of a flow mapping.
+ yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE // Expect an empty value of a flow mapping.
+ yaml_PARSE_END_STATE // Expect nothing.
+)
+
+func (ps yaml_parser_state_t) String() string {
+ switch ps {
+ case yaml_PARSE_STREAM_START_STATE:
+ return "yaml_PARSE_STREAM_START_STATE"
+ case yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE:
+ return "yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE"
+ case yaml_PARSE_DOCUMENT_START_STATE:
+ return "yaml_PARSE_DOCUMENT_START_STATE"
+ case yaml_PARSE_DOCUMENT_CONTENT_STATE:
+ return "yaml_PARSE_DOCUMENT_CONTENT_STATE"
+ case yaml_PARSE_DOCUMENT_END_STATE:
+ return "yaml_PARSE_DOCUMENT_END_STATE"
+ case yaml_PARSE_BLOCK_NODE_STATE:
+ return "yaml_PARSE_BLOCK_NODE_STATE"
+ case yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE:
+ return "yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE"
+ case yaml_PARSE_FLOW_NODE_STATE:
+ return "yaml_PARSE_FLOW_NODE_STATE"
+ case yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE:
+ return "yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE"
+ case yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE:
+ return "yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE"
+ case yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE:
+ return "yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE"
+ case yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE:
+ return "yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE"
+ case yaml_PARSE_BLOCK_MAPPING_KEY_STATE:
+ return "yaml_PARSE_BLOCK_MAPPING_KEY_STATE"
+ case yaml_PARSE_BLOCK_MAPPING_VALUE_STATE:
+ return "yaml_PARSE_BLOCK_MAPPING_VALUE_STATE"
+ case yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE:
+ return "yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE"
+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE:
+ return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE"
+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE:
+ return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE"
+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE:
+ return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE"
+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE:
+ return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE"
+ case yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE:
+ return "yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE"
+ case yaml_PARSE_FLOW_MAPPING_KEY_STATE:
+ return "yaml_PARSE_FLOW_MAPPING_KEY_STATE"
+ case yaml_PARSE_FLOW_MAPPING_VALUE_STATE:
+ return "yaml_PARSE_FLOW_MAPPING_VALUE_STATE"
+ case yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE:
+ return "yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE"
+ case yaml_PARSE_END_STATE:
+ return "yaml_PARSE_END_STATE"
+ }
+ return ""
+}
+
+// This structure holds aliases data.
+type yaml_alias_data_t struct {
+ anchor []byte // The anchor.
+ index int // The node id.
+ mark yaml_mark_t // The anchor mark.
+}
+
+// The parser structure.
+//
+// All members are internal. Manage the structure using the
+// yaml_parser_ family of functions.
+type yaml_parser_t struct {
+
+ // Error handling
+
+ error yaml_error_type_t // Error type.
+
+ problem string // Error description.
+
+ // The byte about which the problem occurred.
+ problem_offset int
+ problem_value int
+ problem_mark yaml_mark_t
+
+ // The error context.
+ context string
+ context_mark yaml_mark_t
+
+ // Reader stuff
+
+ read_handler yaml_read_handler_t // Read handler.
+
+ input_reader io.Reader // File input data.
+ input []byte // String input data.
+ input_pos int
+
+ eof bool // EOF flag
+
+ buffer []byte // The working buffer.
+ buffer_pos int // The current position of the buffer.
+
+ unread int // The number of unread characters in the buffer.
+
+ raw_buffer []byte // The raw buffer.
+ raw_buffer_pos int // The current position of the buffer.
+
+ encoding yaml_encoding_t // The input encoding.
+
+ offset int // The offset of the current position (in bytes).
+ mark yaml_mark_t // The mark of the current position.
+
+ // Scanner stuff
+
+ stream_start_produced bool // Have we started to scan the input stream?
+ stream_end_produced bool // Have we reached the end of the input stream?
+
+ flow_level int // The number of unclosed '[' and '{' indicators.
+
+ tokens []yaml_token_t // The tokens queue.
+ tokens_head int // The head of the tokens queue.
+ tokens_parsed int // The number of tokens fetched from the queue.
+ token_available bool // Does the tokens queue contain a token ready for dequeueing.
+
+ indent int // The current indentation level.
+ indents []int // The indentation levels stack.
+
+ simple_key_allowed bool // May a simple key occur at the current position?
+ simple_keys []yaml_simple_key_t // The stack of simple keys.
+ simple_keys_by_tok map[int]int // possible simple_key indexes indexed by token_number
+
+ // Parser stuff
+
+ state yaml_parser_state_t // The current parser state.
+ states []yaml_parser_state_t // The parser states stack.
+ marks []yaml_mark_t // The stack of marks.
+ tag_directives []yaml_tag_directive_t // The list of TAG directives.
+
+ // Dumper stuff
+
+ aliases []yaml_alias_data_t // The alias data.
+
+ document *yaml_document_t // The currently parsed document.
+}
+
+// Emitter Definitions
+
+// The prototype of a write handler.
+//
+// The write handler is called when the emitter needs to flush the accumulated
+// characters to the output. The handler should write @a size bytes of the
+// @a buffer to the output.
+//
+// @param[in,out] data A pointer to an application data specified by
+// yaml_emitter_set_output().
+// @param[in] buffer The buffer with bytes to be written.
+// @param[in] size The size of the buffer.
+//
+// @returns On success, the handler should return @c 1. If the handler failed,
+// the returned value should be @c 0.
+//
+type yaml_write_handler_t func(emitter *yaml_emitter_t, buffer []byte) error
+
+type yaml_emitter_state_t int
+
+// The emitter states.
+const (
+ // Expect STREAM-START.
+ yaml_EMIT_STREAM_START_STATE yaml_emitter_state_t = iota
+
+ yaml_EMIT_FIRST_DOCUMENT_START_STATE // Expect the first DOCUMENT-START or STREAM-END.
+ yaml_EMIT_DOCUMENT_START_STATE // Expect DOCUMENT-START or STREAM-END.
+ yaml_EMIT_DOCUMENT_CONTENT_STATE // Expect the content of a document.
+ yaml_EMIT_DOCUMENT_END_STATE // Expect DOCUMENT-END.
+ yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE // Expect the first item of a flow sequence.
+ yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE // Expect an item of a flow sequence.
+ yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE // Expect the first key of a flow mapping.
+ yaml_EMIT_FLOW_MAPPING_KEY_STATE // Expect a key of a flow mapping.
+ yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE // Expect a value for a simple key of a flow mapping.
+ yaml_EMIT_FLOW_MAPPING_VALUE_STATE // Expect a value of a flow mapping.
+ yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE // Expect the first item of a block sequence.
+ yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE // Expect an item of a block sequence.
+ yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE // Expect the first key of a block mapping.
+ yaml_EMIT_BLOCK_MAPPING_KEY_STATE // Expect the key of a block mapping.
+ yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE // Expect a value for a simple key of a block mapping.
+ yaml_EMIT_BLOCK_MAPPING_VALUE_STATE // Expect a value of a block mapping.
+ yaml_EMIT_END_STATE // Expect nothing.
+)
+
+// The emitter structure.
+//
+// All members are internal. Manage the structure using the @c yaml_emitter_
+// family of functions.
+type yaml_emitter_t struct {
+
+ // Error handling
+
+ error yaml_error_type_t // Error type.
+ problem string // Error description.
+
+ // Writer stuff
+
+ write_handler yaml_write_handler_t // Write handler.
+
+ output_buffer *[]byte // String output data.
+ output_writer io.Writer // File output data.
+
+ buffer []byte // The working buffer.
+ buffer_pos int // The current position of the buffer.
+
+ raw_buffer []byte // The raw buffer.
+ raw_buffer_pos int // The current position of the buffer.
+
+ encoding yaml_encoding_t // The stream encoding.
+
+ // Emitter stuff
+
+ canonical bool // If the output is in the canonical style?
+ best_indent int // The number of indentation spaces.
+ best_width int // The preferred width of the output lines.
+ unicode bool // Allow unescaped non-ASCII characters?
+ line_break yaml_break_t // The preferred line break.
+
+ state yaml_emitter_state_t // The current emitter state.
+ states []yaml_emitter_state_t // The stack of states.
+
+ events []yaml_event_t // The event queue.
+ events_head int // The head of the event queue.
+
+ indents []int // The stack of indentation levels.
+
+ tag_directives []yaml_tag_directive_t // The list of tag directives.
+
+ indent int // The current indentation level.
+
+ flow_level int // The current flow level.
+
+ root_context bool // Is it the document root context?
+ sequence_context bool // Is it a sequence context?
+ mapping_context bool // Is it a mapping context?
+ simple_key_context bool // Is it a simple mapping key context?
+
+ line int // The current line.
+ column int // The current column.
+ whitespace bool // If the last character was a whitespace?
+ indention bool // If the last character was an indentation character (' ', '-', '?', ':')?
+ open_ended bool // If an explicit document end is required?
+
+ // Anchor analysis.
+ anchor_data struct {
+ anchor []byte // The anchor value.
+ alias bool // Is it an alias?
+ }
+
+ // Tag analysis.
+ tag_data struct {
+ handle []byte // The tag handle.
+ suffix []byte // The tag suffix.
+ }
+
+ // Scalar analysis.
+ scalar_data struct {
+ value []byte // The scalar value.
+ multiline bool // Does the scalar contain line breaks?
+ flow_plain_allowed bool // Can the scalar be expessed in the flow plain style?
+ block_plain_allowed bool // Can the scalar be expressed in the block plain style?
+ single_quoted_allowed bool // Can the scalar be expressed in the single quoted style?
+ block_allowed bool // Can the scalar be expressed in the literal or folded styles?
+ style yaml_scalar_style_t // The output style.
+ }
+
+ // Dumper stuff
+
+ opened bool // If the stream was already opened?
+ closed bool // If the stream was already closed?
+
+ // The information associated with the document nodes.
+ anchors *struct {
+ references int // The number of references.
+ anchor int // The anchor id.
+ serialized bool // If the node has been emitted?
+ }
+
+ last_anchor_id int // The last assigned anchor id.
+
+ document *yaml_document_t // The currently emitted document.
+}
diff --git a/vendor/sigs.k8s.io/yaml/goyaml.v2/yamlprivateh.go b/vendor/sigs.k8s.io/yaml/goyaml.v2/yamlprivateh.go
new file mode 100644
index 0000000000..8110ce3c37
--- /dev/null
+++ b/vendor/sigs.k8s.io/yaml/goyaml.v2/yamlprivateh.go
@@ -0,0 +1,173 @@
+package yaml
+
+const (
+ // The size of the input raw buffer.
+ input_raw_buffer_size = 512
+
+ // The size of the input buffer.
+ // It should be possible to decode the whole raw buffer.
+ input_buffer_size = input_raw_buffer_size * 3
+
+ // The size of the output buffer.
+ output_buffer_size = 128
+
+ // The size of the output raw buffer.
+ // It should be possible to encode the whole output buffer.
+ output_raw_buffer_size = (output_buffer_size*2 + 2)
+
+ // The size of other stacks and queues.
+ initial_stack_size = 16
+ initial_queue_size = 16
+ initial_string_size = 16
+)
+
+// Check if the character at the specified position is an alphabetical
+// character, a digit, '_', or '-'.
+func is_alpha(b []byte, i int) bool {
+ return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'Z' || b[i] >= 'a' && b[i] <= 'z' || b[i] == '_' || b[i] == '-'
+}
+
+// Check if the character at the specified position is a digit.
+func is_digit(b []byte, i int) bool {
+ return b[i] >= '0' && b[i] <= '9'
+}
+
+// Get the value of a digit.
+func as_digit(b []byte, i int) int {
+ return int(b[i]) - '0'
+}
+
+// Check if the character at the specified position is a hex-digit.
+func is_hex(b []byte, i int) bool {
+ return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'F' || b[i] >= 'a' && b[i] <= 'f'
+}
+
+// Get the value of a hex-digit.
+func as_hex(b []byte, i int) int {
+ bi := b[i]
+ if bi >= 'A' && bi <= 'F' {
+ return int(bi) - 'A' + 10
+ }
+ if bi >= 'a' && bi <= 'f' {
+ return int(bi) - 'a' + 10
+ }
+ return int(bi) - '0'
+}
+
+// Check if the character is ASCII.
+func is_ascii(b []byte, i int) bool {
+ return b[i] <= 0x7F
+}
+
+// Check if the character at the start of the buffer can be printed unescaped.
+func is_printable(b []byte, i int) bool {
+ return ((b[i] == 0x0A) || // . == #x0A
+ (b[i] >= 0x20 && b[i] <= 0x7E) || // #x20 <= . <= #x7E
+ (b[i] == 0xC2 && b[i+1] >= 0xA0) || // #0xA0 <= . <= #xD7FF
+ (b[i] > 0xC2 && b[i] < 0xED) ||
+ (b[i] == 0xED && b[i+1] < 0xA0) ||
+ (b[i] == 0xEE) ||
+ (b[i] == 0xEF && // #xE000 <= . <= #xFFFD
+ !(b[i+1] == 0xBB && b[i+2] == 0xBF) && // && . != #xFEFF
+ !(b[i+1] == 0xBF && (b[i+2] == 0xBE || b[i+2] == 0xBF))))
+}
+
+// Check if the character at the specified position is NUL.
+func is_z(b []byte, i int) bool {
+ return b[i] == 0x00
+}
+
+// Check if the beginning of the buffer is a BOM.
+func is_bom(b []byte, i int) bool {
+ return b[0] == 0xEF && b[1] == 0xBB && b[2] == 0xBF
+}
+
+// Check if the character at the specified position is space.
+func is_space(b []byte, i int) bool {
+ return b[i] == ' '
+}
+
+// Check if the character at the specified position is tab.
+func is_tab(b []byte, i int) bool {
+ return b[i] == '\t'
+}
+
+// Check if the character at the specified position is blank (space or tab).
+func is_blank(b []byte, i int) bool {
+ //return is_space(b, i) || is_tab(b, i)
+ return b[i] == ' ' || b[i] == '\t'
+}
+
+// Check if the character at the specified position is a line break.
+func is_break(b []byte, i int) bool {
+ return (b[i] == '\r' || // CR (#xD)
+ b[i] == '\n' || // LF (#xA)
+ b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
+ b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
+ b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9) // PS (#x2029)
+}
+
+func is_crlf(b []byte, i int) bool {
+ return b[i] == '\r' && b[i+1] == '\n'
+}
+
+// Check if the character is a line break or NUL.
+func is_breakz(b []byte, i int) bool {
+ //return is_break(b, i) || is_z(b, i)
+ return ( // is_break:
+ b[i] == '\r' || // CR (#xD)
+ b[i] == '\n' || // LF (#xA)
+ b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
+ b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
+ b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
+ // is_z:
+ b[i] == 0)
+}
+
+// Check if the character is a line break, space, or NUL.
+func is_spacez(b []byte, i int) bool {
+ //return is_space(b, i) || is_breakz(b, i)
+ return ( // is_space:
+ b[i] == ' ' ||
+ // is_breakz:
+ b[i] == '\r' || // CR (#xD)
+ b[i] == '\n' || // LF (#xA)
+ b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
+ b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
+ b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
+ b[i] == 0)
+}
+
+// Check if the character is a line break, space, tab, or NUL.
+func is_blankz(b []byte, i int) bool {
+ //return is_blank(b, i) || is_breakz(b, i)
+ return ( // is_blank:
+ b[i] == ' ' || b[i] == '\t' ||
+ // is_breakz:
+ b[i] == '\r' || // CR (#xD)
+ b[i] == '\n' || // LF (#xA)
+ b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
+ b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
+ b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
+ b[i] == 0)
+}
+
+// Determine the width of the character.
+func width(b byte) int {
+ // Don't replace these by a switch without first
+ // confirming that it is being inlined.
+ if b&0x80 == 0x00 {
+ return 1
+ }
+ if b&0xE0 == 0xC0 {
+ return 2
+ }
+ if b&0xF0 == 0xE0 {
+ return 3
+ }
+ if b&0xF8 == 0xF0 {
+ return 4
+ }
+ return 0
+
+}
diff --git a/vendor/sigs.k8s.io/yaml/yaml.go b/vendor/sigs.k8s.io/yaml/yaml.go
index efbc535d41..fc10246bdb 100644
--- a/vendor/sigs.k8s.io/yaml/yaml.go
+++ b/vendor/sigs.k8s.io/yaml/yaml.go
@@ -1,3 +1,19 @@
+/*
+Copyright 2021 The Kubernetes 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 yaml
import (
@@ -8,56 +24,59 @@ import (
"reflect"
"strconv"
- "gopkg.in/yaml.v2"
+ "sigs.k8s.io/yaml/goyaml.v2"
)
-// Marshal marshals the object into JSON then converts JSON to YAML and returns the
-// YAML.
-func Marshal(o interface{}) ([]byte, error) {
- j, err := json.Marshal(o)
+// Marshal marshals obj into JSON using stdlib json.Marshal, and then converts JSON to YAML using JSONToYAML (see that method for more reference)
+func Marshal(obj interface{}) ([]byte, error) {
+ jsonBytes, err := json.Marshal(obj)
if err != nil {
- return nil, fmt.Errorf("error marshaling into JSON: %v", err)
+ return nil, fmt.Errorf("error marshaling into JSON: %w", err)
}
- y, err := JSONToYAML(j)
- if err != nil {
- return nil, fmt.Errorf("error converting JSON to YAML: %v", err)
- }
-
- return y, nil
+ return JSONToYAML(jsonBytes)
}
// JSONOpt is a decoding option for decoding from JSON format.
type JSONOpt func(*json.Decoder) *json.Decoder
-// Unmarshal converts YAML to JSON then uses JSON to unmarshal into an object,
-// optionally configuring the behavior of the JSON unmarshal.
-func Unmarshal(y []byte, o interface{}, opts ...JSONOpt) error {
- return yamlUnmarshal(y, o, false, opts...)
+// Unmarshal first converts the given YAML to JSON, and then unmarshals the JSON into obj. Options for the
+// standard library json.Decoder can be optionally specified, e.g. to decode untyped numbers into json.Number instead of float64, or to disallow unknown fields (but for that purpose, see also UnmarshalStrict). obj must be a non-nil pointer.
+//
+// Important notes about the Unmarshal logic:
+//
+// - Decoding is case-insensitive, unlike the rest of Kubernetes API machinery, as this is using the stdlib json library. This might be confusing to users.
+// - This decodes any number (although it is an integer) into a float64 if the type of obj is unknown, e.g. *map[string]interface{}, *interface{}, or *[]interface{}. This means integers above +/- 2^53 will lose precision when round-tripping. Make a JSONOpt that calls d.UseNumber() to avoid this.
+// - Duplicate fields, including in-case-sensitive matches, are ignored in an undefined order. Note that the YAML specification forbids duplicate fields, so this logic is more permissive than it needs to. See UnmarshalStrict for an alternative.
+// - Unknown fields, i.e. serialized data that do not map to a field in obj, are ignored. Use d.DisallowUnknownFields() or UnmarshalStrict to override.
+// - As per the YAML 1.1 specification, which yaml.v2 used underneath implements, literal 'yes' and 'no' strings without quotation marks will be converted to true/false implicitly.
+// - YAML non-string keys, e.g. ints, bools and floats, are converted to strings implicitly during the YAML to JSON conversion process.
+// - There are no compatibility guarantees for returned error values.
+func Unmarshal(yamlBytes []byte, obj interface{}, opts ...JSONOpt) error {
+ return unmarshal(yamlBytes, obj, yaml.Unmarshal, opts...)
}
-// UnmarshalStrict strictly converts YAML to JSON then uses JSON to unmarshal
-// into an object, optionally configuring the behavior of the JSON unmarshal.
-func UnmarshalStrict(y []byte, o interface{}, opts ...JSONOpt) error {
- return yamlUnmarshal(y, o, true, append(opts, DisallowUnknownFields)...)
+// UnmarshalStrict is similar to Unmarshal (please read its documentation for reference), with the following exceptions:
+//
+// - Duplicate fields in an object yield an error. This is according to the YAML specification.
+// - If obj, or any of its recursive children, is a struct, presence of fields in the serialized data unknown to the struct will yield an error.
+func UnmarshalStrict(yamlBytes []byte, obj interface{}, opts ...JSONOpt) error {
+ return unmarshal(yamlBytes, obj, yaml.UnmarshalStrict, append(opts, DisallowUnknownFields)...)
}
-// yamlUnmarshal unmarshals the given YAML byte stream into the given interface,
+// unmarshal unmarshals the given YAML byte stream into the given interface,
// optionally performing the unmarshalling strictly
-func yamlUnmarshal(y []byte, o interface{}, strict bool, opts ...JSONOpt) error {
- vo := reflect.ValueOf(o)
- unmarshalFn := yaml.Unmarshal
- if strict {
- unmarshalFn = yaml.UnmarshalStrict
- }
- j, err := yamlToJSON(y, &vo, unmarshalFn)
+func unmarshal(yamlBytes []byte, obj interface{}, unmarshalFn func([]byte, interface{}) error, opts ...JSONOpt) error {
+ jsonTarget := reflect.ValueOf(obj)
+
+ jsonBytes, err := yamlToJSONTarget(yamlBytes, &jsonTarget, unmarshalFn)
if err != nil {
- return fmt.Errorf("error converting YAML to JSON: %v", err)
+ return fmt.Errorf("error converting YAML to JSON: %w", err)
}
- err = jsonUnmarshal(bytes.NewReader(j), o, opts...)
+ err = jsonUnmarshal(bytes.NewReader(jsonBytes), obj, opts...)
if err != nil {
- return fmt.Errorf("error unmarshaling JSON: %v", err)
+ return fmt.Errorf("error unmarshaling JSON: %w", err)
}
return nil
@@ -67,21 +86,26 @@ func yamlUnmarshal(y []byte, o interface{}, strict bool, opts ...JSONOpt) error
// object, optionally applying decoder options prior to decoding. We are not
// using json.Unmarshal directly as we want the chance to pass in non-default
// options.
-func jsonUnmarshal(r io.Reader, o interface{}, opts ...JSONOpt) error {
- d := json.NewDecoder(r)
+func jsonUnmarshal(reader io.Reader, obj interface{}, opts ...JSONOpt) error {
+ d := json.NewDecoder(reader)
for _, opt := range opts {
d = opt(d)
}
- if err := d.Decode(&o); err != nil {
+ if err := d.Decode(&obj); err != nil {
return fmt.Errorf("while decoding JSON: %v", err)
}
return nil
}
-// JSONToYAML Converts JSON to YAML.
+// JSONToYAML converts JSON to YAML. Notable implementation details:
+//
+// - Duplicate fields, are case-sensitively ignored in an undefined order.
+// - The sequence indentation style is compact, which means that the "- " marker for a YAML sequence will be on the same indentation level as the sequence field name.
+// - Unlike Unmarshal, all integers, up to 64 bits, are preserved during this round-trip.
func JSONToYAML(j []byte) ([]byte, error) {
// Convert the JSON to an object.
var jsonObj interface{}
+
// We are using yaml.Unmarshal here (instead of json.Unmarshal) because the
// Go JSON library doesn't try to pick the right number type (int, float,
// etc.) when unmarshalling to interface{}, it just picks float64
@@ -93,35 +117,46 @@ func JSONToYAML(j []byte) ([]byte, error) {
}
// Marshal this object into YAML.
- return yaml.Marshal(jsonObj)
+ yamlBytes, err := yaml.Marshal(jsonObj)
+ if err != nil {
+ return nil, err
+ }
+
+ return yamlBytes, nil
}
// YAMLToJSON converts YAML to JSON. Since JSON is a subset of YAML,
// passing JSON through this method should be a no-op.
//
-// Things YAML can do that are not supported by JSON:
-// * In YAML you can have binary and null keys in your maps. These are invalid
-// in JSON. (int and float keys are converted to strings.)
-// * Binary data in YAML with the !!binary tag is not supported. If you want to
-// use binary data with this library, encode the data as base64 as usual but do
-// not use the !!binary tag in your YAML. This will ensure the original base64
-// encoded data makes it all the way through to the JSON.
+// Some things YAML can do that are not supported by JSON:
+// - In YAML you can have binary and null keys in your maps. These are invalid
+// in JSON, and therefore int, bool and float keys are converted to strings implicitly.
+// - Binary data in YAML with the !!binary tag is not supported. If you want to
+// use binary data with this library, encode the data as base64 as usual but do
+// not use the !!binary tag in your YAML. This will ensure the original base64
+// encoded data makes it all the way through to the JSON.
+// - And more... read the YAML specification for more details.
+//
+// Notable about the implementation:
//
-// For strict decoding of YAML, use YAMLToJSONStrict.
+// - Duplicate fields are case-sensitively ignored in an undefined order. Note that the YAML specification forbids duplicate fields, so this logic is more permissive than it needs to. See YAMLToJSONStrict for an alternative.
+// - As per the YAML 1.1 specification, which yaml.v2 used underneath implements, literal 'yes' and 'no' strings without quotation marks will be converted to true/false implicitly.
+// - Unlike Unmarshal, all integers, up to 64 bits, are preserved during this round-trip.
+// - There are no compatibility guarantees for returned error values.
func YAMLToJSON(y []byte) ([]byte, error) {
- return yamlToJSON(y, nil, yaml.Unmarshal)
+ return yamlToJSONTarget(y, nil, yaml.Unmarshal)
}
// YAMLToJSONStrict is like YAMLToJSON but enables strict YAML decoding,
// returning an error on any duplicate field names.
func YAMLToJSONStrict(y []byte) ([]byte, error) {
- return yamlToJSON(y, nil, yaml.UnmarshalStrict)
+ return yamlToJSONTarget(y, nil, yaml.UnmarshalStrict)
}
-func yamlToJSON(y []byte, jsonTarget *reflect.Value, yamlUnmarshal func([]byte, interface{}) error) ([]byte, error) {
+func yamlToJSONTarget(yamlBytes []byte, jsonTarget *reflect.Value, unmarshalFn func([]byte, interface{}) error) ([]byte, error) {
// Convert the YAML to an object.
var yamlObj interface{}
- err := yamlUnmarshal(y, &yamlObj)
+ err := unmarshalFn(yamlBytes, &yamlObj)
if err != nil {
return nil, err
}
@@ -136,7 +171,11 @@ func yamlToJSON(y []byte, jsonTarget *reflect.Value, yamlUnmarshal func([]byte,
}
// Convert this object to JSON and return the data.
- return json.Marshal(jsonObj)
+ jsonBytes, err := json.Marshal(jsonObj)
+ if err != nil {
+ return nil, err
+ }
+ return jsonBytes, nil
}
func convertToJSONableObject(yamlObj interface{}, jsonTarget *reflect.Value) (interface{}, error) {
@@ -147,13 +186,13 @@ func convertToJSONableObject(yamlObj interface{}, jsonTarget *reflect.Value) (in
// decoding into the value, we're just checking if the ultimate target is a
// string.
if jsonTarget != nil {
- ju, tu, pv := indirect(*jsonTarget, false)
+ jsonUnmarshaler, textUnmarshaler, pointerValue := indirect(*jsonTarget, false)
// We have a JSON or Text Umarshaler at this level, so we can't be trying
// to decode into a string.
- if ju != nil || tu != nil {
+ if jsonUnmarshaler != nil || textUnmarshaler != nil {
jsonTarget = nil
} else {
- jsonTarget = &pv
+ jsonTarget = &pointerValue
}
}
@@ -205,7 +244,7 @@ func convertToJSONableObject(yamlObj interface{}, jsonTarget *reflect.Value) (in
keyString = "false"
}
default:
- return nil, fmt.Errorf("Unsupported map key of type: %s, key: %+#v, value: %+#v",
+ return nil, fmt.Errorf("unsupported map key of type: %s, key: %+#v, value: %+#v",
reflect.TypeOf(k), k, v)
}
diff --git a/vendor/sigs.k8s.io/yaml/yaml_go110.go b/vendor/sigs.k8s.io/yaml/yaml_go110.go
index ab3e06a222..94abc1719d 100644
--- a/vendor/sigs.k8s.io/yaml/yaml_go110.go
+++ b/vendor/sigs.k8s.io/yaml/yaml_go110.go
@@ -1,7 +1,24 @@
// This file contains changes that are only compatible with go 1.10 and onwards.
+//go:build go1.10
// +build go1.10
+/*
+Copyright 2021 The Kubernetes 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 yaml
import "encoding/json"