You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficcontrol.apache.org by zr...@apache.org on 2023/06/14 18:25:31 UTC
[trafficcontrol] branch master updated: Bump github.com/lestrrat-go/jwx from 1.2.14 to 1.2.26 (#7577)
This is an automated email from the ASF dual-hosted git repository.
zrhoffman pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/trafficcontrol.git
The following commit(s) were added to refs/heads/master by this push:
new 927fe2878b Bump github.com/lestrrat-go/jwx from 1.2.14 to 1.2.26 (#7577)
927fe2878b is described below
commit 927fe2878b5188222b5a14f99017a162ea2e1358
Author: dependabot[bot] <49...@users.noreply.github.com>
AuthorDate: Wed Jun 14 12:25:21 2023 -0600
Bump github.com/lestrrat-go/jwx from 1.2.14 to 1.2.26 (#7577)
Bumps [github.com/lestrrat-go/jwx](https://github.com/lestrrat-go/jwx) from 1.2.14 to 1.2.26.
- [Release notes](https://github.com/lestrrat-go/jwx/releases)
- [Changelog](https://github.com/lestrrat-go/jwx/blob/v1.2.26/Changes)
- [Commits](https://github.com/lestrrat-go/jwx/compare/v1.2.14...v1.2.26)
---
updated-dependencies:
- dependency-name: github.com/lestrrat-go/jwx
dependency-type: direct:production
...
Signed-off-by: dependabot[bot] <su...@github.com>
Co-authored-by: dependabot[bot] <49...@users.noreply.github.com>
---
go.mod | 22 +-
go.sum | 72 ++-
.../decred/dcrd/dcrec/secp256k1/v4/README.md | 2 +-
.../dcrec/secp256k1/v4/compressedbytepoints.go | 11 +-
.../decred/dcrd/dcrec/secp256k1/v4/curve.go | 595 ++++++++++++++----
.../decred/dcrd/dcrec/secp256k1/v4/doc.go | 39 +-
.../decred/dcrd/dcrec/secp256k1/v4/ecdh.go | 4 +-
.../dcrd/dcrec/secp256k1/v4/ellipticadaptor.go | 6 +-
.../decred/dcrd/dcrec/secp256k1/v4/field.go | 193 +++---
.../decred/dcrd/dcrec/secp256k1/v4/genstatics.go | 195 ------
.../dcrd/dcrec/secp256k1/v4/loadprecomputed.go | 36 +-
.../decred/dcrd/dcrec/secp256k1/v4/modnscalar.go | 19 +-
.../decred/dcrd/dcrec/secp256k1/v4/privkey.go | 66 +-
.../decred/dcrd/dcrec/secp256k1/v4/pubkey.go | 19 +-
vendor/github.com/goccy/go-json/.golangci.yml | 8 +
vendor/github.com/goccy/go-json/CHANGELOG.md | 148 +++++
vendor/github.com/goccy/go-json/Makefile | 4 +-
vendor/github.com/goccy/go-json/README.md | 8 +-
vendor/github.com/goccy/go-json/decode.go | 31 +
vendor/github.com/goccy/go-json/docker-compose.yml | 2 +-
vendor/github.com/goccy/go-json/encode.go | 17 +-
vendor/github.com/goccy/go-json/error.go | 2 +
.../go-json/internal/decoder/anonymous_field.go | 4 +
.../goccy/go-json/internal/decoder/array.go | 9 +-
.../goccy/go-json/internal/decoder/assign.go | 438 +++++++++++++
.../goccy/go-json/internal/decoder/bool.go | 5 +
.../goccy/go-json/internal/decoder/bytes.go | 10 +-
.../goccy/go-json/internal/decoder/compile.go | 225 +++----
.../go-json/internal/decoder/compile_norace.go | 1 +
.../goccy/go-json/internal/decoder/compile_race.go | 1 +
.../goccy/go-json/internal/decoder/float.go | 12 +
.../goccy/go-json/internal/decoder/func.go | 5 +
.../goccy/go-json/internal/decoder/int.go | 16 +-
.../goccy/go-json/internal/decoder/interface.go | 70 +++
.../goccy/go-json/internal/decoder/invalid.go | 55 ++
.../goccy/go-json/internal/decoder/map.go | 100 ++-
.../goccy/go-json/internal/decoder/number.go | 11 +
.../goccy/go-json/internal/decoder/option.go | 2 +
.../goccy/go-json/internal/decoder/path.go | 670 ++++++++++++++++++++
.../goccy/go-json/internal/decoder/ptr.go | 9 +
.../goccy/go-json/internal/decoder/slice.go | 79 +++
.../goccy/go-json/internal/decoder/stream.go | 16 +-
.../goccy/go-json/internal/decoder/string.go | 153 +++--
.../goccy/go-json/internal/decoder/struct.go | 58 +-
.../goccy/go-json/internal/decoder/type.go | 1 +
.../goccy/go-json/internal/decoder/uint.go | 4 +
.../go-json/internal/decoder/unmarshal_json.go | 21 +-
.../go-json/internal/decoder/unmarshal_text.go | 5 +
.../go-json/internal/decoder/wrapped_string.go | 5 +
.../goccy/go-json/internal/encoder/code.go | 166 ++++-
.../goccy/go-json/internal/encoder/compiler.go | 73 ++-
.../go-json/internal/encoder/compiler_norace.go | 22 +-
.../go-json/internal/encoder/compiler_race.go | 23 +-
.../goccy/go-json/internal/encoder/decode_rune.go | 126 ++++
.../goccy/go-json/internal/encoder/encoder.go | 81 ++-
.../goccy/go-json/internal/encoder/map112.go | 3 +-
.../goccy/go-json/internal/encoder/map113.go | 3 +-
.../goccy/go-json/internal/encoder/opcode.go | 141 +++--
.../goccy/go-json/internal/encoder/option.go | 9 +-
.../goccy/go-json/internal/encoder/query.go | 135 +++++
.../goccy/go-json/internal/encoder/string.go | 675 ++++++++-------------
.../goccy/go-json/internal/encoder/string_table.go | 415 +++++++++++++
.../goccy/go-json/internal/encoder/vm/debug_vm.go | 27 +-
.../goccy/go-json/internal/encoder/vm/vm.go | 111 ++--
.../go-json/internal/encoder/vm_color/debug_vm.go | 21 +-
.../goccy/go-json/internal/encoder/vm_color/vm.go | 111 ++--
.../internal/encoder/vm_color_indent/debug_vm.go | 21 +-
.../internal/encoder/vm_color_indent/util.go | 7 +-
.../go-json/internal/encoder/vm_color_indent/vm.go | 111 ++--
.../go-json/internal/encoder/vm_indent/debug_vm.go | 21 +-
.../go-json/internal/encoder/vm_indent/util.go | 7 +-
.../goccy/go-json/internal/encoder/vm_indent/vm.go | 111 ++--
.../goccy/go-json/internal/errors/error.go | 19 +
.../goccy/go-json/internal/runtime/struct_field.go | 6 +-
vendor/github.com/goccy/go-json/json.go | 5 +
vendor/github.com/goccy/go-json/option.go | 33 +
vendor/github.com/goccy/go-json/path.go | 84 +++
vendor/github.com/goccy/go-json/query.go | 47 ++
.../lestrrat-go/blackmagic/blackmagic.go | 11 +-
vendor/github.com/lestrrat-go/httpcc/httpcc.go | 29 +-
.../lestrrat-go/iter/arrayiter/arrayiter.go | 21 +-
.../github.com/lestrrat-go/iter/mapiter/mapiter.go | 21 +-
vendor/github.com/lestrrat-go/jwx/.golangci.yml | 12 +-
vendor/github.com/lestrrat-go/jwx/Changes | 124 ++++
vendor/github.com/lestrrat-go/jwx/Makefile | 7 +-
vendor/github.com/lestrrat-go/jwx/README.md | 17 +-
.../lestrrat-go/jwx/internal/ecutil/ecutil.go | 1 +
.../lestrrat-go/jwx/internal/iter/mapiter.go | 1 +
.../lestrrat-go/jwx/internal/json/stdlib.go | 1 +
.../lestrrat-go/jwx/internal/keyconv/keyconv.go | 4 +-
.../lestrrat-go/jwx/internal/pool/pool.go | 3 +
.../github.com/lestrrat-go/jwx/jwa/elliptic_gen.go | 2 +-
vendor/github.com/lestrrat-go/jwx/jwe/encrypt.go | 1 +
vendor/github.com/lestrrat-go/jwx/jwe/headers.go | 6 +-
.../lestrrat-go/jwx/jwe/internal/aescbc/aescbc.go | 69 ++-
.../lestrrat-go/jwx/jwe/internal/cipher/cipher.go | 8 +-
.../jwx/jwe/internal/keyenc/interface.go | 2 +
.../lestrrat-go/jwx/jwe/internal/keyenc/keyenc.go | 28 +
vendor/github.com/lestrrat-go/jwx/jwe/jwe.go | 7 +
vendor/github.com/lestrrat-go/jwx/jwe/message.go | 6 +-
vendor/github.com/lestrrat-go/jwx/jwk/ecdsa.go | 6 +-
vendor/github.com/lestrrat-go/jwx/jwk/ecdsa_gen.go | 12 +-
vendor/github.com/lestrrat-go/jwx/jwk/interface.go | 10 +-
.../lestrrat-go/jwx/jwk/interface_gen.go | 13 +-
vendor/github.com/lestrrat-go/jwx/jwk/jwk.go | 29 +-
vendor/github.com/lestrrat-go/jwx/jwk/okp.go | 8 +-
vendor/github.com/lestrrat-go/jwx/jwk/okp_gen.go | 12 +-
vendor/github.com/lestrrat-go/jwx/jwk/option.go | 36 +-
vendor/github.com/lestrrat-go/jwx/jwk/refresh.go | 127 ++--
vendor/github.com/lestrrat-go/jwx/jwk/rsa.go | 33 +-
vendor/github.com/lestrrat-go/jwx/jwk/rsa_gen.go | 18 +-
vendor/github.com/lestrrat-go/jwx/jwk/set.go | 7 +-
vendor/github.com/lestrrat-go/jwx/jwk/symmetric.go | 6 +-
.../lestrrat-go/jwx/jwk/symmetric_gen.go | 6 +-
vendor/github.com/lestrrat-go/jwx/jws/ecdsa.go | 113 ++--
vendor/github.com/lestrrat-go/jwx/jws/eddsa.go | 15 +-
vendor/github.com/lestrrat-go/jwx/jws/es256k.go | 11 +
vendor/github.com/lestrrat-go/jwx/jws/headers.go | 6 +-
vendor/github.com/lestrrat-go/jwx/jws/interface.go | 1 +
vendor/github.com/lestrrat-go/jwx/jws/jws.go | 45 +-
vendor/github.com/lestrrat-go/jwx/jws/message.go | 25 +-
vendor/github.com/lestrrat-go/jwx/jws/option.go | 26 +-
vendor/github.com/lestrrat-go/jwx/jws/rsa.go | 16 +-
vendor/github.com/lestrrat-go/jwx/jwt/http.go | 5 +-
vendor/github.com/lestrrat-go/jwx/jwt/jwt.go | 45 +-
vendor/github.com/lestrrat-go/jwx/jwt/token_gen.go | 31 +
vendor/github.com/lestrrat-go/jwx/jwt/validate.go | 2 +
vendor/github.com/lestrrat-go/jwx/jwx.go | 5 +-
vendor/github.com/lestrrat-go/option/README.md | 157 ++++-
vendor/github.com/lestrrat-go/option/option.go | 8 +-
vendor/modules.txt | 25 +-
131 files changed, 5449 insertions(+), 1889 deletions(-)
diff --git a/go.mod b/go.mod
index 635d4b7aca..16e82a8876 100644
--- a/go.mod
+++ b/go.mod
@@ -40,7 +40,7 @@ require (
github.com/json-iterator/go v1.1.12
github.com/kelseyhightower/envconfig v1.4.0
github.com/kylelemons/godebug v1.1.1-0.20201107061927-e693023230a4
- github.com/lestrrat-go/jwx v1.2.14
+ github.com/lestrrat-go/jwx v1.2.26
github.com/lib/pq v1.10.4
github.com/miekg/dns v1.1.43
github.com/onsi/ginkgo v1.16.5
@@ -48,9 +48,9 @@ require (
github.com/pborman/getopt/v2 v2.1.0
github.com/pkg/errors v0.9.1
go.etcd.io/bbolt v1.3.6
- golang.org/x/crypto v0.0.0-20210921155107-089bfa567519
- golang.org/x/net v0.0.0-20211013171255-e13a2654a71e
- golang.org/x/sys v0.0.0-20211013075003-97ac67df715c
+ golang.org/x/crypto v0.9.0
+ golang.org/x/net v0.10.0
+ golang.org/x/sys v0.8.0
gopkg.in/DATA-DOG/go-sqlmock.v1 v1.3.0
gopkg.in/yaml.v2 v2.4.0
)
@@ -59,17 +59,17 @@ require (
github.com/Azure/go-ntlmssp v0.0.0-20200615164410-66371956d46c // indirect
github.com/basho/backoff v0.0.0-20150307023525-2ff7c4694083 // indirect
github.com/cenkalti/backoff v2.2.1+incompatible // indirect
- github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.0-20210816181553-5444fa50b93d // indirect
+ github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect
github.com/go-asn1-ber/asn1-ber v1.5.1 // indirect
- github.com/goccy/go-json v0.8.1 // indirect
+ github.com/goccy/go-json v0.10.2 // indirect
github.com/golang/protobuf v1.5.2 // indirect
github.com/hashicorp/errwrap v1.0.0 // indirect
github.com/hashicorp/go-multierror v1.1.0 // indirect
github.com/lestrrat-go/backoff/v2 v2.0.8 // indirect
- github.com/lestrrat-go/blackmagic v1.0.0 // indirect
- github.com/lestrrat-go/httpcc v1.0.0 // indirect
- github.com/lestrrat-go/iter v1.0.1 // indirect
- github.com/lestrrat-go/option v1.0.0 // indirect
+ github.com/lestrrat-go/blackmagic v1.0.1 // indirect
+ github.com/lestrrat-go/httpcc v1.0.1 // indirect
+ github.com/lestrrat-go/iter v1.0.2 // indirect
+ github.com/lestrrat-go/option v1.0.1 // indirect
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/nxadm/tail v1.4.8
@@ -94,7 +94,7 @@ require (
github.com/jcmturner/gofork v1.0.0 // indirect
github.com/pierrec/lz4 v2.5.2+incompatible // indirect
github.com/rcrowley/go-metrics v0.0.0-20200313005456-10cdbea86bc0 // indirect
- golang.org/x/text v0.3.7 // indirect
+ golang.org/x/text v0.9.0 // indirect
gopkg.in/jcmturner/aescts.v1 v1.0.1 // indirect
gopkg.in/jcmturner/dnsutils.v1 v1.0.1 // indirect
gopkg.in/jcmturner/gokrb5.v7 v7.5.0 // indirect
diff --git a/go.sum b/go.sum
index a0fbfa4ef2..1b5971b37e 100644
--- a/go.sum
+++ b/go.sum
@@ -383,9 +383,9 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dchest/siphash v1.2.2 h1:9DFz8tQwl9pTVt5iok/9zKyzA1Q6bRGiF3HPiEEVr9I=
github.com/dchest/siphash v1.2.2/go.mod h1:q+IRvb2gOSrUnYoPqHiyHXS0FOBBOdl6tONBlVnOnt4=
-github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc=
-github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.0-20210816181553-5444fa50b93d h1:1iy2qD6JEhHKKhUOA9IWs7mjco7lnw2qx8FsRI2wirE=
-github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.0-20210816181553-5444fa50b93d/go.mod h1:tmAIfUFEirG/Y8jhZ9M+h36obRZAk/1fcSpXwAVlfqE=
+github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 h1:8UrgZ3GkP4i/CLijOJx79Yu+etlyjdBU4sfcs2WYQMs=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0=
github.com/deepmap/oapi-codegen v1.6.0/go.mod h1:ryDa9AgbELGeB+YEXE1dR53yAjHwFvE9iAUlWl9Al3M=
github.com/denisenkom/go-mssqldb v0.10.0/go.mod h1:xbL0rPBG9cCiLr28tMa8zpbdarY27NDyej4t/EjAShU=
github.com/denverdino/aliyungo v0.0.0-20190125010748-a747050bb1ba/go.mod h1:dV8lFg6daOBZbT6/BDGIz6Y3WFGn8juu6G+CQ6LHtl0=
@@ -591,8 +591,8 @@ github.com/gobuffalo/packd v0.1.0/go.mod h1:M2Juc+hhDXf/PnmBANFCqx4DM3wRbgDvnVWe
github.com/gobuffalo/packr/v2 v2.0.9/go.mod h1:emmyGweYTm6Kdper+iywB6YK5YzuKchGtJQZ0Odn4pQ=
github.com/gobuffalo/packr/v2 v2.2.0/go.mod h1:CaAwI0GPIAv+5wKLtv8Afwl+Cm78K/I/VCm/3ptBN+0=
github.com/gobuffalo/syncx v0.0.0-20190224160051-33c29581e754/go.mod h1:HhnNqWY95UYwwW3uSASeV7vtgYkT2t16hJgV3AEPUpw=
-github.com/goccy/go-json v0.8.1 h1:4/Wjm0JIJaTDm8K1KcGrLHJoa8EsJ13YWeX+6Kfq6uI=
-github.com/goccy/go-json v0.8.1/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
github.com/gocql/gocql v0.0.0-20210515062232-b7ef815b4556/go.mod h1:DL0ekTmBSTdlNF25Orwt/JMzqIq3EJ4MVa/J/uK64OY=
github.com/godbus/dbus v0.0.0-20151105175453-c7fdd8b5cd55/go.mod h1:/YcGZj5zSblfDWMMoOzV4fas9FZnQYTkDnsGvmh2Grw=
github.com/godbus/dbus v0.0.0-20180201030542-885f9cc04c9c/go.mod h1:/YcGZj5zSblfDWMMoOzV4fas9FZnQYTkDnsGvmh2Grw=
@@ -938,16 +938,17 @@ github.com/labstack/echo/v4 v4.2.1/go.mod h1:AA49e0DZ8kk5jTOOCKNuPR6oTnBS0dYiM4F
github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
github.com/lestrrat-go/backoff/v2 v2.0.8 h1:oNb5E5isby2kiro9AgdHLv5N5tint1AnDVVf2E2un5A=
github.com/lestrrat-go/backoff/v2 v2.0.8/go.mod h1:rHP/q/r9aT27n24JQLa7JhSQZCKBBOiM/uP402WwN8Y=
-github.com/lestrrat-go/blackmagic v1.0.0 h1:XzdxDbuQTz0RZZEmdU7cnQxUtFUzgCSPq8RCz4BxIi4=
-github.com/lestrrat-go/blackmagic v1.0.0/go.mod h1:TNgH//0vYSs8VXDCfkZLgIrVTTXQELZffUV0tz3MtdQ=
-github.com/lestrrat-go/httpcc v1.0.0 h1:FszVC6cKfDvBKcJv646+lkh4GydQg2Z29scgUfkOpYc=
-github.com/lestrrat-go/httpcc v1.0.0/go.mod h1:tGS/u00Vh5N6FHNkExqGGNId8e0Big+++0Gf8MBnAvE=
-github.com/lestrrat-go/iter v1.0.1 h1:q8faalr2dY6o8bV45uwrxq12bRa1ezKrB6oM9FUgN4A=
-github.com/lestrrat-go/iter v1.0.1/go.mod h1:zIdgO1mRKhn8l9vrZJZz9TUMMFbQbLeTsbqPDrJ/OJc=
-github.com/lestrrat-go/jwx v1.2.14 h1:69OeaiFKCTn8xDmBGzHTgv/GBoO1LJcXw99GfYCDKzg=
-github.com/lestrrat-go/jwx v1.2.14/go.mod h1:3Q3Re8TaOcVTdpx4Tvz++OWmryDklihTDqrrwQiyS2A=
-github.com/lestrrat-go/option v1.0.0 h1:WqAWL8kh8VcSoD6xjSH34/1m8yxluXQbDeKNfvFeEO4=
+github.com/lestrrat-go/blackmagic v1.0.1 h1:lS5Zts+5HIC/8og6cGHb0uCcNCa3OUt1ygh3Qz2Fe80=
+github.com/lestrrat-go/blackmagic v1.0.1/go.mod h1:UrEqBzIR2U6CnzVyUtfM6oZNMt/7O7Vohk2J0OGSAtU=
+github.com/lestrrat-go/httpcc v1.0.1 h1:ydWCStUeJLkpYyjLDHihupbn2tYmZ7m22BGkcvZZrIE=
+github.com/lestrrat-go/httpcc v1.0.1/go.mod h1:qiltp3Mt56+55GPVCbTdM9MlqhvzyuL6W/NMDA8vA5E=
+github.com/lestrrat-go/iter v1.0.2 h1:gMXo1q4c2pHmC3dn8LzRhJfP1ceCbgSiT9lUydIzltI=
+github.com/lestrrat-go/iter v1.0.2/go.mod h1:Momfcq3AnRlRjI5b5O8/G5/BvpzrhoFTZcn06fEOPt4=
+github.com/lestrrat-go/jwx v1.2.26 h1:4iFo8FPRZGDYe1t19mQP0zTRqA7n8HnJ5lkIiDvJcB0=
+github.com/lestrrat-go/jwx v1.2.26/go.mod h1:MaiCdGbn3/cckbOFSCluJlJMmp9dmZm5hDuIkx8ftpQ=
github.com/lestrrat-go/option v1.0.0/go.mod h1:5ZHFbivi4xwXxhxY9XHDe2FHo6/Z7WWmtT7T5nBBp3I=
+github.com/lestrrat-go/option v1.0.1 h1:oAzP2fvZGQKWkvHa1/SAcFolBEca1oN+mQ7eooNBEYU=
+github.com/lestrrat-go/option v1.0.1/go.mod h1:5ZHFbivi4xwXxhxY9XHDe2FHo6/Z7WWmtT7T5nBBp3I=
github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
github.com/lib/pq v1.1.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
@@ -1277,6 +1278,8 @@ github.com/stretchr/objx v0.0.0-20180129172003-8a3f7159479f/go.mod h1:HFkY916IF+
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/testify v0.0.0-20180303142811-b89eecf5ca5d/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.2.0/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
@@ -1284,8 +1287,11 @@ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UV
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
github.com/syndtr/gocapability v0.0.0-20170704070218-db04d3cc01c8/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww=
github.com/syndtr/gocapability v0.0.0-20180916011248-d98352740cb2/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww=
github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww=
@@ -1340,6 +1346,7 @@ github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de
github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
github.com/yvasiyarov/go-metrics v0.0.0-20140926110328-57bccd1ccd43/go.mod h1:aX5oPXxHm3bOH+xeAttToC8pqch2ScQN/JoXYupl6xs=
github.com/yvasiyarov/gorelic v0.0.0-20141212073537-a9bba5b9ab50/go.mod h1:NUSPSUX/bi6SeDMUh6brw0nXpxHnc96TguQh0+r/ssA=
github.com/yvasiyarov/newrelic_platform_go v0.0.0-20140908184405-b21fdbd4370f/go.mod h1:GlGEuHIJweS1mbCqG+7vt2nvWLzLLnRHbXz5JKd/Qbg=
@@ -1418,12 +1425,12 @@ golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPh
golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20201217014255-9d1352758620/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.0.0-20210921155107-089bfa567519 h1:7I4JAnoQBe7ZtJcBaYHi5UtiO8tQHbUSXxL+pnGRANg=
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.9.0 h1:LF6fAI+IutBocDJ2OT0Q1g8plpYljMZ4+lty+dsqw3g=
+golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0=
golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
@@ -1471,6 +1478,8 @@ golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
golang.org/x/net v0.0.0-20170114055629-f2499483f923/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20180218175443-cbe0f9307d01/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -1538,8 +1547,11 @@ golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qx
golang.org/x/net v0.0.0-20210505024714-0287a6fb4125/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20210614182718-04defd469f4e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20211013171255-e13a2654a71e h1:Xj+JO91noE97IN6F/7WZxzC5QE6yENAQPrwIYhW3bsA=
golang.org/x/net v0.0.0-20211013171255-e13a2654a71e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
golang.org/x/oauth2 v0.0.0-20180227000427-d7d64896b5ff/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
golang.org/x/oauth2 v0.0.0-20181106182150-f42d05182288/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
@@ -1566,8 +1578,10 @@ golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJ
golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sys v0.0.0-20170830134202-bb24a47a89ea/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20180224232135-f6cff0780e54/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -1681,10 +1695,17 @@ golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBc
golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210818153620-00dd8d7831e7/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20211013075003-97ac67df715c h1:taxlMj0D/1sOAuv/CbSD+MMDof2vbyPTqz5FNYKpXt8=
golang.org/x/sys v0.0.0-20211013075003-97ac67df715c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
golang.org/x/text v0.0.0-20160726164857-2910a502d2bf/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -1694,8 +1715,10 @@ golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
@@ -1787,8 +1810,10 @@ golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.1.5 h1:ouewzE6p+/VEB31YYnTbEJdi8pFqKp4P4n85vwo3DHA=
golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0 h1:BOw41kyTf3PuCW1pVQf8+Cyg8pMlkYB1oo9iJ6D/lKM=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
golang.org/x/xerrors v0.0.0-20190410155217-1f06c39b4373/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -2004,8 +2029,9 @@ gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776 h1:tQIYjPdBoyREyB9XMu+nnTclpTYkz2zFM+lzLJFO4gQ=
gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gorm.io/driver/postgres v1.0.8/go.mod h1:4eOzrI1MUfm6ObJU/UcmbXyiHSs8jSwH95G5P5dxcAg=
gorm.io/gorm v1.20.12/go.mod h1:0HFTzE/SqkGTzK6TlDPPQbAYCluiVvhzoA1+aVyzenw=
gorm.io/gorm v1.21.4/go.mod h1:0HFTzE/SqkGTzK6TlDPPQbAYCluiVvhzoA1+aVyzenw=
diff --git a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/README.md b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/README.md
index 4ae25dba0c..b84bcdb77d 100644
--- a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/README.md
+++ b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/README.md
@@ -57,7 +57,7 @@ defined by the secp256k1 domain parameters.
## Installation and Updating
-This package is part of the `github.com/decred/dcrd/dcrec/secp256k1/v3` module.
+This package is part of the `github.com/decred/dcrd/dcrec/secp256k1/v4` module.
Use the standard go tooling for working with modules to incorporate it.
## Examples
diff --git a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/compressedbytepoints.go b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/compressedbytepoints.go
index ca4be1218b..bb0b41fda1 100644
--- a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/compressedbytepoints.go
+++ b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/compressedbytepoints.go
@@ -1,5 +1,5 @@
// Copyright (c) 2015 The btcsuite developers
-// Copyright (c) 2015-2021 The Decred developers
+// Copyright (c) 2015-2022 The Decred developers
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
@@ -8,4 +8,11 @@ package secp256k1
// Auto-generated file (see genprecomps.go)
// DO NOT EDIT
-var compressedBytePoints = "eJys14c+EI6/ANDvMDLLyA5ZhWSVRKgQQlRGRQNpyohSlJA0SCqKhobyq4ykJQ2JUkqikkgLJZJCQqX7ue/wP29x4H/sgosJDpbnkcdUPZ6rl8yBzqvp8TlZdKpsYEc2JN2BaNQT1YT4tG7uUYmEzwvTeL1sGSd8jmILo3ds/G4Y3rrMQqPsACgbPwo+NkhRs/BDeveygsdtzuaRMg9pVbkaLlvUxYseJJG53k4sfKAHPrW68GPLMlT6bo+bB1z4YPcvyk9tpOO9Zyln5xJwNYni8X8FYHqzB8+9f4oDBoKo9nsl6Mw8jSW3ffnPDEeWs9rGd01CwalKG2z9sqnKuY4SDvZRkZcTtjemUvWUn/Rmgy9OijzHS3XsaFWEFgxdnksimTdJZ6YtX3+TjpdPpXD0Ezdcv8wC3lx5z998jpLNQhEwkG7Du+duQHGXHHzKz6etvbJ8uDUWPsw+ [...]
+var compressedBytePoints = "eJyk2wNCIAgAAMBs27Zt27a52bZt27Zt27Ztu+4RN/8YgP8pmqLC650yqn+RN9o5WamIzkLa9Agq2bEoRaoJ/oRJplKgCMS4iEExiT3u5gnfu//K8yz4XhSnQzTXYdtp6i45sAprIIyKo/AhtXelFMQPtnAcGf58V/JbVveLAN8Vcf0Q+bnIk0kWveCiUp9zy1Ko9e0uaYkPT0UfsCTgaZhyQTuNksSeqX9vTrQ5GH/G8fWiUIiM8Zvl31woXxiquMqOQMJCoQiZ/iXuDOqY7tTyHlv85rmSanWdJIe0JD1VkaEwqclvlvbtOy07cCk4KT/jXWxBk6kb7TMLkeWtCZli02fkxlspmDtHfMonSi0ScKI+ypNPlZVHgO1W4GkR4AkSbYSxX5oGlIctKHhCjRY9eR0GsIluyh4QFg9t4FU0TdkfLf4BSXR4MMmKV/aDCqtzxLvXaFGs0GVb [...]
+
+// Set accessor to a real function.
+func init() {
+ compressedBytePointsFn = func() string {
+ return compressedBytePoints
+ }
+}
diff --git a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/curve.go b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/curve.go
index e8620608fb..c9d47f3078 100644
--- a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/curve.go
+++ b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/curve.go
@@ -1,4 +1,4 @@
-// Copyright (c) 2015-2021 The Decred developers
+// Copyright (c) 2015-2022 The Decred developers
// Copyright 2013-2014 The btcsuite developers
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
@@ -7,7 +7,7 @@ package secp256k1
import (
"encoding/hex"
- "math/big"
+ "math/bits"
)
// References:
@@ -18,6 +18,9 @@ import (
//
// [BRID]: On Binary Representations of Integers with Digits -1, 0, 1
// (Prodinger, Helmut)
+//
+// [STWS]: Secure-TWS: Authenticating Node to Multi-user Communication in
+// Shared Sensor Networks (Oliveira, Leonardo B. et al)
// All group operations are performed using Jacobian coordinates. For a given
// (x, y) position on the curve, the Jacobian coordinates are (x1, y1, z1)
@@ -39,29 +42,59 @@ func hexToFieldVal(s string) *FieldVal {
return &f
}
+// hexToModNScalar converts the passed hex string into a ModNScalar and will
+// panic if there is an error. This is only provided for the hard-coded
+// constants so errors in the source code can be detected. It will only (and
+// must only) be called with hard-coded values.
+func hexToModNScalar(s string) *ModNScalar {
+ var isNegative bool
+ if len(s) > 0 && s[0] == '-' {
+ isNegative = true
+ s = s[1:]
+ }
+ if len(s)%2 != 0 {
+ s = "0" + s
+ }
+ b, err := hex.DecodeString(s)
+ if err != nil {
+ panic("invalid hex in source file: " + s)
+ }
+ var scalar ModNScalar
+ if overflow := scalar.SetByteSlice(b); overflow {
+ panic("hex in source file overflows mod N scalar: " + s)
+ }
+ if isNegative {
+ scalar.Negate()
+ }
+ return &scalar
+}
+
var (
- // Next 6 constants are from Hal Finney's bitcointalk.org post:
- // https://bitcointalk.org/index.php?topic=3238.msg45565#msg45565
- // May he rest in peace.
- //
- // They have also been independently derived from the code in the
- // EndomorphismVectors function in genstatics.go.
- endomorphismLambda = fromHex("5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72")
- endomorphismBeta = hexToFieldVal("7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee")
- endomorphismA1 = fromHex("3086d221a7d46bcde86c90e49284eb15")
- endomorphismB1 = fromHex("-e4437ed6010e88286f547fa90abfe4c3")
- endomorphismA2 = fromHex("114ca50f7a8e2f3f657c1108d9d44cfd8")
- endomorphismB2 = fromHex("3086d221a7d46bcde86c90e49284eb15")
-
- // Alternatively, the following parameters are valid as well, however, they
- // seem to be about 8% slower in practice.
- //
- // endomorphismLambda = fromHex("AC9C52B33FA3CF1F5AD9E3FD77ED9BA4A880B9FC8EC739C2E0CFC810B51283CE")
- // endomorphismBeta = hexToFieldVal("851695D49A83F8EF919BB86153CBCB16630FB68AED0A766A3EC693D68E6AFA40")
- // endomorphismA1 = fromHex("E4437ED6010E88286F547FA90ABFE4C3")
- // endomorphismB1 = fromHex("-3086D221A7D46BCDE86C90E49284EB15")
- // endomorphismA2 = fromHex("3086D221A7D46BCDE86C90E49284EB15")
- // endomorphismB2 = fromHex("114CA50F7A8E2F3F657C1108D9D44CFD8")
+ // The following constants are used to accelerate scalar point
+ // multiplication through the use of the endomorphism:
+ //
+ // φ(Q) ⟼ λ*Q = (β*Q.x mod p, Q.y)
+ //
+ // See the code in the deriveEndomorphismParams function in genprecomps.go
+ // for details on their derivation.
+ //
+ // Additionally, see the scalar multiplication function in this file for
+ // details on how they are used.
+ endoNegLambda = hexToModNScalar("-5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72")
+ endoBeta = hexToFieldVal("7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee")
+ endoNegB1 = hexToModNScalar("e4437ed6010e88286f547fa90abfe4c3")
+ endoNegB2 = hexToModNScalar("-3086d221a7d46bcde86c90e49284eb15")
+ endoZ1 = hexToModNScalar("3086d221a7d46bcde86c90e49284eb153daa8a1471e8ca7f")
+ endoZ2 = hexToModNScalar("e4437ed6010e88286f547fa90abfe4c4221208ac9df506c6")
+
+ // Alternatively, the following parameters are valid as well, however,
+ // benchmarks show them to be about 2% slower in practice.
+ // endoNegLambda = hexToModNScalar("-ac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283ce")
+ // endoBeta = hexToFieldVal("851695d49a83f8ef919bb86153cbcb16630fb68aed0a766a3ec693d68e6afa40")
+ // endoNegB1 = hexToModNScalar("3086d221a7d46bcde86c90e49284eb15")
+ // endoNegB2 = hexToModNScalar("-114ca50f7a8e2f3f657c1108d9d44cfd8")
+ // endoZ1 = hexToModNScalar("114ca50f7a8e2f3f657c1108d9d44cfd95fbc92c10fddd145")
+ // endoZ2 = hexToModNScalar("3086d221a7d46bcde86c90e49284eb153daa8a1471e8ca7f")
)
// JacobianPoint is an element of the group formed by the secp256k1 curve in
@@ -178,7 +211,7 @@ func addZ1AndZ2EqualsOne(p1, p2, result *JacobianPoint) {
y3.Set(&v).Add(&negX3).Mul(&r).Add(&j) // Y3 = r*(V-X3)-2*Y1*J (mag: 4)
z3.Set(&h).MulInt(2) // Z3 = 2*H (mag: 6)
- // Normalize the resulting field values to a magnitude of 1 as needed.
+ // Normalize the resulting field values as needed.
x3.Normalize()
y3.Normalize()
z3.Normalize()
@@ -196,7 +229,7 @@ func addZ1EqualsZ2(p1, p2, result *JacobianPoint) {
// the equation into intermediate elements which are used to minimize
// the number of field multiplications using a slightly modified version
// of the method shown at:
- // https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#addition-mmadd-2007-bl
+ // https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#addition-zadd-2007-m
//
// In particular it performs the calculations using the following:
// A = X2-X1, B = A^2, C=Y2-Y1, D = C^2, E = X1*B, F = X2*B
@@ -242,13 +275,13 @@ func addZ1EqualsZ2(p1, p2, result *JacobianPoint) {
e.Mul2(x1, &b) // E = X1*B (mag: 1)
negE.Set(&e).Negate(1) // negE = -E (mag: 2)
f.Mul2(x2, &b) // F = X2*B (mag: 1)
- x3.Add2(&e, &f).Negate(3).Add(&d) // X3 = D-E-F (mag: 5)
- negX3.Set(x3).Negate(5).Normalize() // negX3 = -X3 (mag: 1)
- y3.Set(y1).Mul(f.Add(&negE)).Negate(3) // Y3 = -(Y1*(F-E)) (mag: 4)
- y3.Add(e.Add(&negX3).Mul(&c)) // Y3 = C*(E-X3)+Y3 (mag: 5)
+ x3.Add2(&e, &f).Negate(2).Add(&d) // X3 = D-E-F (mag: 4)
+ negX3.Set(x3).Negate(4) // negX3 = -X3 (mag: 5)
+ y3.Set(y1).Mul(f.Add(&negE)).Negate(1) // Y3 = -(Y1*(F-E)) (mag: 2)
+ y3.Add(e.Add(&negX3).Mul(&c)) // Y3 = C*(E-X3)+Y3 (mag: 3)
z3.Mul2(z1, &a) // Z3 = Z1*A (mag: 1)
- // Normalize the resulting field values to a magnitude of 1 as needed.
+ // Normalize the resulting field values as needed.
x3.Normalize()
y3.Normalize()
z3.Normalize()
@@ -330,7 +363,7 @@ func addZ2EqualsOne(p1, p2, result *JacobianPoint) {
z3.Add2(z1, &h).Square() // Z3 = (Z1+H)^2 (mag: 1)
z3.Add(z1z1.Add(&hh).Negate(2)) // Z3 = Z3-(Z1Z1+HH) (mag: 4)
- // Normalize the resulting field values to a magnitude of 1 as needed.
+ // Normalize the resulting field values as needed.
x3.Normalize()
y3.Normalize()
z3.Normalize()
@@ -397,7 +430,7 @@ func addGeneric(p1, p2, result *JacobianPoint) {
var negU1, negS1, negX3 FieldVal
negU1.Set(&u1).Negate(1) // negU1 = -U1 (mag: 2)
h.Add2(&u2, &negU1) // H = U2-U1 (mag: 3)
- i.Set(&h).MulInt(2).Square() // I = (2*H)^2 (mag: 2)
+ i.Set(&h).MulInt(2).Square() // I = (2*H)^2 (mag: 1)
j.Mul2(&h, &i) // J = H*I (mag: 1)
negS1.Set(&s1).Negate(1) // negS1 = -S1 (mag: 2)
r.Set(&s2).Add(&negS1).MulInt(2) // r = 2*(S2-S1) (mag: 6)
@@ -412,7 +445,7 @@ func addGeneric(p1, p2, result *JacobianPoint) {
z3.Add(z1z1.Add(&z2z2).Negate(2)) // Z3 = Z3-(Z1Z1+Z2Z2) (mag: 4)
z3.Mul(&h) // Z3 = Z3*H (mag: 1)
- // Normalize the resulting field values to a magnitude of 1 as needed.
+ // Normalize the resulting field values as needed.
x3.Normalize()
y3.Normalize()
z3.Normalize()
@@ -424,7 +457,7 @@ func addGeneric(p1, p2, result *JacobianPoint) {
// NOTE: The points must be normalized for this function to return the correct
// result. The resulting point will be normalized.
func AddNonConst(p1, p2, result *JacobianPoint) {
- // A point at infinity is the identity according to the group law for
+ // The point at infinity is the identity according to the group law for
// elliptic curve cryptography. Thus, ∞ + P = P and P + ∞ = P.
if (p1.X.IsZero() && p1.Y.IsZero()) || p1.Z.IsZero() {
result.Set(p2)
@@ -508,7 +541,7 @@ func doubleZ1EqualsOne(p, result *JacobianPoint) {
y3.Set(&c).MulInt(8).Negate(8) // Y3 = -(8*C) (mag: 9)
y3.Add(f.Mul(&e)) // Y3 = E*F+Y3 (mag: 10)
- // Normalize the field values back to a magnitude of 1.
+ // Normalize the resulting field values as needed.
x3.Normalize()
y3.Normalize()
z3.Normalize()
@@ -562,7 +595,7 @@ func doubleGeneric(p, result *JacobianPoint) {
y3.Set(&c).MulInt(8).Negate(8) // Y3 = -(8*C) (mag: 9)
y3.Add(f.Mul(&e)) // Y3 = E*F+Y3 (mag: 10)
- // Normalize the field values back to a magnitude of 1.
+ // Normalize the resulting field values as needed.
x3.Normalize()
y3.Normalize()
z3.Normalize()
@@ -574,7 +607,7 @@ func doubleGeneric(p, result *JacobianPoint) {
// NOTE: The point must be normalized for this function to return the correct
// result. The resulting point will be normalized.
func DoubleNonConst(p, result *JacobianPoint) {
- // Doubling a point at infinity is still infinity.
+ // Doubling the point at infinity is still infinity.
if p.Y.IsZero() || p.Z.IsZero() {
result.X.SetInt(0)
result.Y.SetInt(0)
@@ -596,47 +629,283 @@ func DoubleNonConst(p, result *JacobianPoint) {
doubleGeneric(p, result)
}
-// splitK returns a balanced length-two representation of k and their signs.
-// This is algorithm 3.74 from [GECC].
-//
-// One thing of note about this algorithm is that no matter what c1 and c2 are,
-// the final equation of k = k1 + k2 * lambda (mod n) will hold. This is
-// provable mathematically due to how a1/b1/a2/b2 are computed.
+// mulAdd64 multiplies the two passed base 2^64 digits together, adds the given
+// value to the result, and returns the 128-bit result via a (hi, lo) tuple
+// where the upper half of the bits are returned in hi and the lower half in lo.
+func mulAdd64(digit1, digit2, m uint64) (hi, lo uint64) {
+ // Note the carry on the final add is safe to discard because the maximum
+ // possible value is:
+ // (2^64 - 1)(2^64 - 1) + (2^64 - 1) = 2^128 - 2^64
+ // and:
+ // 2^128 - 2^64 < 2^128.
+ var c uint64
+ hi, lo = bits.Mul64(digit1, digit2)
+ lo, c = bits.Add64(lo, m, 0)
+ hi, _ = bits.Add64(hi, 0, c)
+ return hi, lo
+}
+
+// mulAdd64Carry multiplies the two passed base 2^64 digits together, adds both
+// the given value and carry to the result, and returns the 128-bit result via a
+// (hi, lo) tuple where the upper half of the bits are returned in hi and the
+// lower half in lo.
+func mulAdd64Carry(digit1, digit2, m, c uint64) (hi, lo uint64) {
+ // Note the carry on the high order add is safe to discard because the
+ // maximum possible value is:
+ // (2^64 - 1)(2^64 - 1) + 2*(2^64 - 1) = 2^128 - 1
+ // and:
+ // 2^128 - 1 < 2^128.
+ var c2 uint64
+ hi, lo = mulAdd64(digit1, digit2, m)
+ lo, c2 = bits.Add64(lo, c, 0)
+ hi, _ = bits.Add64(hi, 0, c2)
+ return hi, lo
+}
+
+// mul512Rsh320Round computes the full 512-bit product of the two given scalars,
+// right shifts the result by 320 bits, rounds to the nearest integer, and
+// returns the result in constant time.
//
-// c1 and c2 are chosen to minimize the max(k1,k2).
-func splitK(k []byte) ([]byte, []byte, int, int) {
- // All math here is done with big.Int, which is slow.
- // At some point, it might be useful to write something similar to
- // FieldVal but for N instead of P as the prime field if this ends up
- // being a bottleneck.
- bigIntK := new(big.Int)
- c1, c2 := new(big.Int), new(big.Int)
- tmp1, tmp2 := new(big.Int), new(big.Int)
- k1, k2 := new(big.Int), new(big.Int)
-
- bigIntK.SetBytes(k)
- // c1 = round(b2 * k / n) from step 4.
- // Rounding isn't really necessary and costs too much, hence skipped
- c1.Mul(endomorphismB2, bigIntK)
- c1.Div(c1, curveParams.N)
- // c2 = round(b1 * k / n) from step 4 (sign reversed to optimize one step)
- // Rounding isn't really necessary and costs too much, hence skipped
- c2.Mul(endomorphismB1, bigIntK)
- c2.Div(c2, curveParams.N)
- // k1 = k - c1 * a1 - c2 * a2 from step 5 (note c2's sign is reversed)
- tmp1.Mul(c1, endomorphismA1)
- tmp2.Mul(c2, endomorphismA2)
- k1.Sub(bigIntK, tmp1)
- k1.Add(k1, tmp2)
- // k2 = - c1 * b1 - c2 * b2 from step 5 (note c2's sign is reversed)
- tmp1.Mul(c1, endomorphismB1)
- tmp2.Mul(c2, endomorphismB2)
- k2.Sub(tmp2, tmp1)
-
- // Note Bytes() throws out the sign of k1 and k2. This matters
- // since k1 and/or k2 can be negative. Hence, we pass that
- // back separately.
- return k1.Bytes(), k2.Bytes(), k1.Sign(), k2.Sign()
+// Note that despite the inputs and output being mod n scalars, the 512-bit
+// product is NOT reduced mod N prior to the right shift. This is intentional
+// because it is used for replacing division with multiplication and thus the
+// intermediate results must be done via a field extension to a larger field.
+func mul512Rsh320Round(n1, n2 *ModNScalar) ModNScalar {
+ // Convert n1 and n2 to base 2^64 digits.
+ n1Digit0 := uint64(n1.n[0]) | uint64(n1.n[1])<<32
+ n1Digit1 := uint64(n1.n[2]) | uint64(n1.n[3])<<32
+ n1Digit2 := uint64(n1.n[4]) | uint64(n1.n[5])<<32
+ n1Digit3 := uint64(n1.n[6]) | uint64(n1.n[7])<<32
+ n2Digit0 := uint64(n2.n[0]) | uint64(n2.n[1])<<32
+ n2Digit1 := uint64(n2.n[2]) | uint64(n2.n[3])<<32
+ n2Digit2 := uint64(n2.n[4]) | uint64(n2.n[5])<<32
+ n2Digit3 := uint64(n2.n[6]) | uint64(n2.n[7])<<32
+
+ // Compute the full 512-bit product n1*n2.
+ var r0, r1, r2, r3, r4, r5, r6, r7, c uint64
+
+ // Terms resulting from the product of the first digit of the second number
+ // by all digits of the first number.
+ //
+ // Note that r0 is ignored because it is not needed to compute the higher
+ // terms and it is shifted out below anyway.
+ c, _ = bits.Mul64(n2Digit0, n1Digit0)
+ c, r1 = mulAdd64(n2Digit0, n1Digit1, c)
+ c, r2 = mulAdd64(n2Digit0, n1Digit2, c)
+ r4, r3 = mulAdd64(n2Digit0, n1Digit3, c)
+
+ // Terms resulting from the product of the second digit of the second number
+ // by all digits of the first number.
+ //
+ // Note that r1 is ignored because it is no longer needed to compute the
+ // higher terms and it is shifted out below anyway.
+ c, _ = mulAdd64(n2Digit1, n1Digit0, r1)
+ c, r2 = mulAdd64Carry(n2Digit1, n1Digit1, r2, c)
+ c, r3 = mulAdd64Carry(n2Digit1, n1Digit2, r3, c)
+ r5, r4 = mulAdd64Carry(n2Digit1, n1Digit3, r4, c)
+
+ // Terms resulting from the product of the third digit of the second number
+ // by all digits of the first number.
+ //
+ // Note that r2 is ignored because it is no longer needed to compute the
+ // higher terms and it is shifted out below anyway.
+ c, _ = mulAdd64(n2Digit2, n1Digit0, r2)
+ c, r3 = mulAdd64Carry(n2Digit2, n1Digit1, r3, c)
+ c, r4 = mulAdd64Carry(n2Digit2, n1Digit2, r4, c)
+ r6, r5 = mulAdd64Carry(n2Digit2, n1Digit3, r5, c)
+
+ // Terms resulting from the product of the fourth digit of the second number
+ // by all digits of the first number.
+ //
+ // Note that r3 is ignored because it is no longer needed to compute the
+ // higher terms and it is shifted out below anyway.
+ c, _ = mulAdd64(n2Digit3, n1Digit0, r3)
+ c, r4 = mulAdd64Carry(n2Digit3, n1Digit1, r4, c)
+ c, r5 = mulAdd64Carry(n2Digit3, n1Digit2, r5, c)
+ r7, r6 = mulAdd64Carry(n2Digit3, n1Digit3, r6, c)
+
+ // At this point the upper 256 bits of the full 512-bit product n1*n2 are in
+ // r4..r7 (recall the low order results were discarded as noted above).
+ //
+ // Right shift the result 320 bits. Note that the MSB of r4 determines
+ // whether or not to round because it is the final bit that is shifted out.
+ //
+ // Also, notice that r3..r7 would also ordinarily be set to 0 as well for
+ // the full shift, but that is skipped since they are no longer used as
+ // their values are known to be zero.
+ roundBit := r4 >> 63
+ r2, r1, r0 = r7, r6, r5
+
+ // Conditionally add 1 depending on the round bit in constant time.
+ r0, c = bits.Add64(r0, roundBit, 0)
+ r1, c = bits.Add64(r1, 0, c)
+ r2, r3 = bits.Add64(r2, 0, c)
+
+ // Finally, convert the result to a mod n scalar.
+ //
+ // No modular reduction is needed because the result is guaranteed to be
+ // less than the group order given the group order is > 2^255 and the
+ // maximum possible value of the result is 2^192.
+ var result ModNScalar
+ result.n[0] = uint32(r0)
+ result.n[1] = uint32(r0 >> 32)
+ result.n[2] = uint32(r1)
+ result.n[3] = uint32(r1 >> 32)
+ result.n[4] = uint32(r2)
+ result.n[5] = uint32(r2 >> 32)
+ result.n[6] = uint32(r3)
+ result.n[7] = uint32(r3 >> 32)
+ return result
+}
+
+// splitK returns two scalars (k1 and k2) that are a balanced length-two
+// representation of the provided scalar such that k ≡ k1 + k2*λ (mod N), where
+// N is the secp256k1 group order.
+func splitK(k *ModNScalar) (ModNScalar, ModNScalar) {
+ // The ultimate goal is to decompose k into two scalars that are around
+ // half the bit length of k such that the following equation is satisfied:
+ //
+ // k1 + k2*λ ≡ k (mod n)
+ //
+ // The strategy used here is based on algorithm 3.74 from [GECC] with a few
+ // modifications to make use of the more efficient mod n scalar type, avoid
+ // some costly long divisions, and minimize the number of calculations.
+ //
+ // Start by defining a function that takes a vector v = <a,b> ∈ ℤ⨯ℤ:
+ //
+ // f(v) = a + bλ (mod n)
+ //
+ // Then, find two vectors, v1 = <a1,b1>, and v2 = <a2,b2> in ℤ⨯ℤ such that:
+ // 1) v1 and v2 are linearly independent
+ // 2) f(v1) = f(v2) = 0
+ // 3) v1 and v2 have small Euclidean norm
+ //
+ // The vectors that satisfy these properties are found via the Euclidean
+ // algorithm and are precomputed since both n and λ are fixed values for the
+ // secp256k1 curve. See genprecomps.go for derivation details.
+ //
+ // Next, consider k as a vector <k, 0> in ℚ⨯ℚ and by linear algebra write:
+ //
+ // <k, 0> = g1*v1 + g2*v2, where g1, g2 ∈ ℚ
+ //
+ // Note that, per above, the components of vector v1 are a1 and b1 while the
+ // components of vector v2 are a2 and b2. Given the vectors v1 and v2 were
+ // generated such that a1*b2 - a2*b1 = n, solving the equation for g1 and g2
+ // yields:
+ //
+ // g1 = b2*k / n
+ // g2 = -b1*k / n
+ //
+ // Observe:
+ // <k, 0> = g1*v1 + g2*v2
+ // = (b2*k/n)*<a1,b1> + (-b1*k/n)*<a2,b2> | substitute
+ // = <a1*b2*k/n, b1*b2*k/n> + <-a2*b1*k/n, -b2*b1*k/n> | scalar mul
+ // = <a1*b2*k/n - a2*b1*k/n, b1*b2*k/n - b2*b1*k/n> | vector add
+ // = <[a1*b2*k - a2*b1*k]/n, 0> | simplify
+ // = <k*[a1*b2 - a2*b1]/n, 0> | factor out k
+ // = <k*n/n, 0> | substitute
+ // = <k, 0> | simplify
+ //
+ // Now, consider an integer-valued vector v:
+ //
+ // v = c1*v1 + c2*v2, where c1, c2 ∈ ℤ (mod n)
+ //
+ // Since vectors v1 and v2 are linearly independent and were generated such
+ // that f(v1) = f(v2) = 0, all possible scalars c1 and c2 also produce a
+ // vector v such that f(v) = 0.
+ //
+ // In other words, c1 and c2 can be any integers and the resulting
+ // decomposition will still satisfy the required equation. However, since
+ // the goal is to produce a balanced decomposition that provides a
+ // performance advantage by minimizing max(k1, k2), c1 and c2 need to be
+ // integers close to g1 and g2, respectively, so the resulting vector v is
+ // an integer-valued vector that is close to <k, 0>.
+ //
+ // Finally, consider the vector u:
+ //
+ // u = <k, 0> - v
+ //
+ // It follows that f(u) = k and thus the two components of vector u satisfy
+ // the required equation:
+ //
+ // k1 + k2*λ ≡ k (mod n)
+ //
+ // Choosing c1 and c2:
+ // -------------------
+ //
+ // As mentioned above, c1 and c2 need to be integers close to g1 and g2,
+ // respectively. The algorithm in [GECC] chooses the following values:
+ //
+ // c1 = round(g1) = round(b2*k / n)
+ // c2 = round(g2) = round(-b1*k / n)
+ //
+ // However, as section 3.4.2 of [STWS] notes, the aforementioned approach
+ // requires costly long divisions that can be avoided by precomputing
+ // rounded estimates as follows:
+ //
+ // t = bitlen(n) + 1
+ // z1 = round(2^t * b2 / n)
+ // z2 = round(2^t * -b1 / n)
+ //
+ // Then, use those precomputed estimates to perform a multiplication by k
+ // along with a floored division by 2^t, which is a simple right shift by t:
+ //
+ // c1 = floor(k * z1 / 2^t) = (k * z1) >> t
+ // c2 = floor(k * z2 / 2^t) = (k * z2) >> t
+ //
+ // Finally, round up if last bit discarded in the right shift by t is set by
+ // adding 1.
+ //
+ // As a further optimization, rather than setting t = bitlen(n) + 1 = 257 as
+ // stated by [STWS], this implementation uses a higher precision estimate of
+ // t = bitlen(n) + 64 = 320 because it allows simplification of the shifts
+ // in the internal calculations that are done via uint64s and also allows
+ // the use of floor in the precomputations.
+ //
+ // Thus, the calculations this implementation uses are:
+ //
+ // z1 = floor(b2<<320 / n) | precomputed
+ // z2 = floor((-b1)<<320) / n) | precomputed
+ // c1 = ((k * z1) >> 320) + (((k * z1) >> 319) & 1)
+ // c2 = ((k * z2) >> 320) + (((k * z2) >> 319) & 1)
+ //
+ // Putting it all together:
+ // ------------------------
+ //
+ // Calculate the following vectors using the values discussed above:
+ //
+ // v = c1*v1 + c2*v2
+ // u = <k, 0> - v
+ //
+ // The two components of the resulting vector v are:
+ // va = c1*a1 + c2*a2
+ // vb = c1*b1 + c2*b2
+ //
+ // Thus, the two components of the resulting vector u are:
+ // k1 = k - va
+ // k2 = 0 - vb = -vb
+ //
+ // As some final optimizations:
+ //
+ // 1) Note that k1 + k2*λ ≡ k (mod n) means that k1 ≡ k - k2*λ (mod n).
+ // Therefore, the computation of va can be avoided to save two
+ // field multiplications and a field addition.
+ //
+ // 2) Since k1 = k - k2*λ = k + k2*(-λ), an additional field negation is
+ // saved by storing and using the negative version of λ.
+ //
+ // 3) Since k2 = -vb = -(c1*b1 + c2*b2) = c1*(-b1) + c2*(-b2), one more
+ // field negation is saved by storing and using the negative versions of
+ // b1 and b2.
+ //
+ // k2 = c1*(-b1) + c2*(-b2)
+ // k1 = k + k2*(-λ)
+ var k1, k2 ModNScalar
+ c1 := mul512Rsh320Round(k, endoZ1)
+ c2 := mul512Rsh320Round(k, endoZ2)
+ k2.Add2(c1.Mul(endoNegB1), c2.Mul(endoNegB2))
+ k1.Mul2(&k2, endoNegLambda).Add(k)
+ return k1, k2
}
// nafScalar represents a positive integer up to a maximum value of 2^256 - 1
@@ -775,70 +1044,132 @@ func naf(k []byte) nafScalar {
return result
}
-// ScalarMultNonConst multiplies k*P where k is a big endian integer modulo the
-// curve order and P is a point in Jacobian projective coordinates and stores
-// the result in the provided Jacobian point.
+// ScalarMultNonConst multiplies k*P where k is a scalar modulo the curve order
+// and P is a point in Jacobian projective coordinates and stores the result in
+// the provided Jacobian point.
//
// NOTE: The point must be normalized for this function to return the correct
// result. The resulting point will be normalized.
func ScalarMultNonConst(k *ModNScalar, point, result *JacobianPoint) {
- // Decompose K into k1 and k2 in order to halve the number of EC ops.
- // See Algorithm 3.74 in [GECC].
- kBytes := k.Bytes()
- k1, k2, signK1, signK2 := splitK(kBytes[:])
- zeroArray32(&kBytes)
+ // -------------------------------------------------------------------------
+ // This makes use of the following efficiently-computable endomorphism to
+ // accelerate the computation:
+ //
+ // φ(P) ⟼ λ*P = (β*P.x mod p, P.y)
+ //
+ // In other words, there is a special scalar λ that every point on the
+ // elliptic curve can be multiplied by that will result in the same point as
+ // performing a single field multiplication of the point's X coordinate by
+ // the special value β.
+ //
+ // This is useful because scalar point multiplication is significantly more
+ // expensive than a single field multiplication given the former involves a
+ // series of point doublings and additions which themselves consist of a
+ // combination of several field multiplications, squarings, and additions.
+ //
+ // So, the idea behind making use of the endomorphism is thus to decompose
+ // the scalar into two scalars that are each about half the bit length of
+ // the original scalar such that:
+ //
+ // k ≡ k1 + k2*λ (mod n)
+ //
+ // This in turn allows the scalar point multiplication to be performed as a
+ // sum of two smaller half-length multiplications as follows:
+ //
+ // k*P = (k1 + k2*λ)*P
+ // = k1*P + k2*λ*P
+ // = k1*P + k2*φ(P)
+ //
+ // Thus, a speedup is achieved so long as it's faster to decompose the
+ // scalar, compute φ(P), and perform a simultaneous multiply of the
+ // half-length point multiplications than it is to compute a full width
+ // point multiplication.
+ //
+ // In practice, benchmarks show the current implementation provides a
+ // speedup of around 30-35% versus not using the endomorphism.
+ //
+ // See section 3.5 in [GECC] for a more rigorous treatment.
+ // -------------------------------------------------------------------------
- // The main equation here to remember is:
- // k * P = k1 * P + k2 * ϕ(P)
+ // Per above, the main equation here to remember is:
+ // k*P = k1*P + k2*φ(P)
//
- // P1 below is P in the equation, P2 below is ϕ(P) in the equation
+ // p1 below is P in the equation while p2 is φ(P) in the equation.
+ //
+ // NOTE: φ(x,y) = (β*x,y). The Jacobian z coordinates are the same, so this
+ // math goes through.
+ //
+ // Also, calculate -p1 and -p2 for use in the NAF optimization.
p1, p1Neg := new(JacobianPoint), new(JacobianPoint)
p1.Set(point)
p1Neg.Set(p1)
p1Neg.Y.Negate(1).Normalize()
-
- // NOTE: ϕ(x,y) = (βx,y). The Jacobian z coordinates are the same, so this
- // math goes through.
p2, p2Neg := new(JacobianPoint), new(JacobianPoint)
p2.Set(p1)
- p2.X.Mul(endomorphismBeta).Normalize()
+ p2.X.Mul(endoBeta).Normalize()
p2Neg.Set(p2)
p2Neg.Y.Negate(1).Normalize()
- // Flip the positive and negative values of the points as needed
- // depending on the signs of k1 and k2. As mentioned in the equation
- // above, each of k1 and k2 are multiplied by the respective point.
- // Since -k * P is the same thing as k * -P, and the group law for
- // elliptic curves states that P(x, y) = -P(x, -y), it's faster and
- // simplifies the code to just make the point negative.
- if signK1 == -1 {
+ // Decompose k into k1 and k2 such that k = k1 + k2*λ (mod n) where k1 and
+ // k2 are around half the bit length of k in order to halve the number of EC
+ // operations.
+ //
+ // Notice that this also flips the sign of the scalars and points as needed
+ // to minimize the bit lengths of the scalars k1 and k2.
+ //
+ // This is done because the scalars are operating modulo the group order
+ // which means that when they would otherwise be a small negative magnitude
+ // they will instead be a large positive magnitude. Since the goal is for
+ // the scalars to have a small magnitude to achieve a performance boost, use
+ // their negation when they are greater than the half order of the group and
+ // flip the positive and negative values of the corresponding point that
+ // will be multiplied by to compensate.
+ //
+ // In other words, transform the calc when k1 is over the half order to:
+ // k1*P = -k1*-P
+ //
+ // Similarly, transform the calc when k2 is over the half order to:
+ // k2*φ(P) = -k2*-φ(P)
+ k1, k2 := splitK(k)
+ if k1.IsOverHalfOrder() {
+ k1.Negate()
p1, p1Neg = p1Neg, p1
}
- if signK2 == -1 {
+ if k2.IsOverHalfOrder() {
+ k2.Negate()
p2, p2Neg = p2Neg, p2
}
- // NAF versions of k1 and k2 should have a lot more zeros.
+ // Convert k1 and k2 into their NAF representations since NAF has a lot more
+ // zeros overall on average which minimizes the number of required point
+ // additions in exchange for a mix of fewer point additions and subtractions
+ // at the cost of one additional point doubling.
+ //
+ // This is an excellent tradeoff because subtraction of points has the same
+ // computational complexity as addition of points and point doubling is
+ // faster than both.
+ //
+ // Concretely, on average, 1/2 of all bits will be non-zero with the normal
+ // binary representation whereas only 1/3rd of the bits will be non-zero
+ // with NAF.
//
- // The Pos version of the bytes contain the +1s and the Neg versions
- // contain the -1s.
- k1NAF, k2NAF := naf(k1), naf(k2)
+ // The Pos version of the bytes contain the +1s and the Neg versions contain
+ // the -1s.
+ k1Bytes, k2Bytes := k1.Bytes(), k2.Bytes()
+ k1NAF, k2NAF := naf(k1Bytes[:]), naf(k2Bytes[:])
k1PosNAF, k1NegNAF := k1NAF.Pos(), k1NAF.Neg()
k2PosNAF, k2NegNAF := k2NAF.Pos(), k2NAF.Neg()
k1Len, k2Len := len(k1PosNAF), len(k2PosNAF)
+ // Add left-to-right using the NAF optimization. See algorithm 3.77 from
+ // [GECC].
+ //
+ // Point Q = ∞ (point at infinity).
+ var q JacobianPoint
m := k1Len
if m < k2Len {
m = k2Len
}
-
- // Point Q = ∞ (point at infinity).
- var q JacobianPoint
-
- // Add left-to-right using the NAF optimization. See algorithm 3.77
- // from [GECC]. This should be faster overall since there will be a lot
- // more instances of 0, hence reducing the number of Jacobian additions
- // at the cost of 1 possible extra doubling.
for i := 0; i < m; i++ {
// Since k1 and k2 are potentially different lengths and the calculation
// is being done left to right, pad the front of the shorter one with
@@ -850,7 +1181,8 @@ func ScalarMultNonConst(k *ModNScalar, point, result *JacobianPoint) {
if i >= m-k2Len {
k2BytePos, k2ByteNeg = k2PosNAF[i-(m-k2Len)], k2NegNAF[i-(m-k2Len)]
}
- for bit, mask := 7, uint8(1<<7); bit >= 0; bit, mask = bit-1, mask>>1 {
+
+ for mask := uint8(1 << 7); mask > 0; mask >>= 1 {
// Q = 2 * Q
DoubleNonConst(&q, &q)
@@ -883,31 +1215,28 @@ func ScalarMultNonConst(k *ModNScalar, point, result *JacobianPoint) {
result.Set(&q)
}
-// ScalarBaseMultNonConst multiplies k*G where G is the base point of the group
-// and k is a big endian integer. The result is stored in Jacobian coordinates
-// (x1, y1, z1).
+// ScalarBaseMultNonConst multiplies k*G where k is a scalar modulo the curve
+// order and G is the base point of the group and stores the result in the
+// provided Jacobian point.
//
// NOTE: The resulting point will be normalized.
func ScalarBaseMultNonConst(k *ModNScalar, result *JacobianPoint) {
bytePoints := s256BytePoints()
- // Point Q = ∞ (point at infinity).
- var q JacobianPoint
-
- // curve.bytePoints has all 256 byte points for each 8-bit window. The
- // strategy is to add up the byte points. This is best understood by
- // expressing k in base-256 which it already sort of is. Each "digit" in
- // the 8-bit window can be looked up using bytePoints and added together.
- var pt JacobianPoint
- for i, byteVal := range k.Bytes() {
- p := bytePoints[i][byteVal]
- pt.X.Set(&p[0])
- pt.Y.Set(&p[1])
- pt.Z.SetInt(1)
- AddNonConst(&q, &pt, &q)
+ // Start with the point at infinity.
+ result.X.Zero()
+ result.Y.Zero()
+ result.Z.Zero()
+
+ // bytePoints has all 256 byte points for each 8-bit window. The strategy
+ // is to add up the byte points. This is best understood by expressing k in
+ // base-256 which it already sort of is. Each "digit" in the 8-bit window
+ // can be looked up using bytePoints and added together.
+ kb := k.Bytes()
+ for i := 0; i < len(kb); i++ {
+ pt := &bytePoints[i][kb[i]]
+ AddNonConst(result, pt, result)
}
-
- result.Set(&q)
}
// isOnCurve returns whether or not the affine point (x,y) is on the curve.
diff --git a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/doc.go b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/doc.go
index 91a670e51b..ac01e2343c 100644
--- a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/doc.go
+++ b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/doc.go
@@ -1,10 +1,11 @@
// Copyright (c) 2013-2014 The btcsuite developers
-// Copyright (c) 2015-2019 The Decred developers
+// Copyright (c) 2015-2022 The Decred developers
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
/*
-Package secp256k1 implements optimized secp256k1 elliptic curve operations.
+Package secp256k1 implements optimized secp256k1 elliptic curve operations in
+pure Go.
This package provides an optimized pure Go implementation of elliptic curve
cryptography operations over the secp256k1 curve as well as data structures and
@@ -18,22 +19,22 @@ packages for more details about those aspects.
An overview of the features provided by this package are as follows:
- - Private key generation, serialization, and parsing
- - Public key generation, serialization and parsing per ANSI X9.62-1998
- - Parses uncompressed, compressed, and hybrid public keys
- - Serializes uncompressed and compressed public keys
- - Specialized types for performing optimized and constant time field operations
- - FieldVal type for working modulo the secp256k1 field prime
- - ModNScalar type for working modulo the secp256k1 group order
- - Elliptic curve operations in Jacobian projective coordinates
- - Point addition
- - Point doubling
- - Scalar multiplication with an arbitrary point
- - Scalar multiplication with the base point (group generator)
- - Point decompression from a given x coordinate
- - Nonce generation via RFC6979 with support for extra data and version
- information that can be used to prevent nonce reuse between signing
- algorithms
+ - Private key generation, serialization, and parsing
+ - Public key generation, serialization and parsing per ANSI X9.62-1998
+ - Parses uncompressed, compressed, and hybrid public keys
+ - Serializes uncompressed and compressed public keys
+ - Specialized types for performing optimized and constant time field operations
+ - FieldVal type for working modulo the secp256k1 field prime
+ - ModNScalar type for working modulo the secp256k1 group order
+ - Elliptic curve operations in Jacobian projective coordinates
+ - Point addition
+ - Point doubling
+ - Scalar multiplication with an arbitrary point
+ - Scalar multiplication with the base point (group generator)
+ - Point decompression from a given x coordinate
+ - Nonce generation via RFC6979 with support for extra data and version
+ information that can be used to prevent nonce reuse between signing
+ algorithms
It also provides an implementation of the Go standard library crypto/elliptic
Curve interface via the S256 function so that it may be used with other packages
@@ -49,7 +50,7 @@ use optimized secp256k1 elliptic curve cryptography.
Finally, a comprehensive suite of tests is provided to provide a high level of
quality assurance.
-Use of secp256k1 in Decred
+# Use of secp256k1 in Decred
At the time of this writing, the primary public key cryptography in widespread
use on the Decred network used to secure coins is based on elliptic curves
diff --git a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/ecdh.go b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/ecdh.go
index ebbdfc5411..96869a3cd9 100644
--- a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/ecdh.go
+++ b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/ecdh.go
@@ -1,5 +1,5 @@
// Copyright (c) 2015 The btcsuite developers
-// Copyright (c) 2015-2016 The Decred developers
+// Copyright (c) 2015-2023 The Decred developers
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
@@ -9,7 +9,7 @@ package secp256k1
// public key using Diffie-Hellman key exchange (ECDH) (RFC 5903).
// RFC5903 Section 9 states we should only return x.
//
-// It is recommended to securily hash the result before using as a cryptographic
+// It is recommended to securely hash the result before using as a cryptographic
// key.
func GenerateSharedSecret(privkey *PrivateKey, pubkey *PublicKey) []byte {
var point, result JacobianPoint
diff --git a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/ellipticadaptor.go b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/ellipticadaptor.go
index a271ff6b36..42022646b1 100644
--- a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/ellipticadaptor.go
+++ b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/ellipticadaptor.go
@@ -1,4 +1,4 @@
-// Copyright 2020-2021 The Decred developers
+// Copyright 2020-2022 The Decred developers
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
@@ -102,7 +102,7 @@ func (curve *KoblitzCurve) IsOnCurve(x, y *big.Int) bool {
//
// This is part of the elliptic.Curve interface implementation.
func (curve *KoblitzCurve) Add(x1, y1, x2, y2 *big.Int) (*big.Int, *big.Int) {
- // A point at infinity is the identity according to the group law for
+ // The point at infinity is the identity according to the group law for
// elliptic curve cryptography. Thus, ∞ + P = P and P + ∞ = P.
if x1.Sign() == 0 && y1.Sign() == 0 {
return x2, y2
@@ -249,7 +249,7 @@ var secp256k1 = &KoblitzCurve{
},
}
-// S256 returns a Curve which implements secp256k1.
+// S256 returns an elliptic.Curve which implements secp256k1.
func S256() *KoblitzCurve {
return secp256k1
}
diff --git a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/field.go b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/field.go
index 959a9a16cf..8d9ac74d53 100644
--- a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/field.go
+++ b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/field.go
@@ -1,6 +1,6 @@
// Copyright (c) 2013-2014 The btcsuite developers
-// Copyright (c) 2015-2020 The Decred developers
-// Copyright (c) 2013-2020 Dave Collins
+// Copyright (c) 2015-2022 The Decred developers
+// Copyright (c) 2013-2022 Dave Collins
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
@@ -103,7 +103,8 @@ const (
// FieldVal implements optimized fixed-precision arithmetic over the
// secp256k1 finite field. This means all arithmetic is performed modulo
-// 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f.
+//
+// 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f.
//
// WARNING: Since it is so important for the field arithmetic to be extremely
// fast for high performance crypto, this type does not perform any validation
@@ -172,9 +173,9 @@ type FieldVal struct {
// String returns the field value as a normalized human-readable hex string.
//
-// Preconditions: None
-// Output Normalized: Field is not modified -- same as input value
-// Output Max Magnitude: Field is not modified -- same as input value
+// Preconditions: None
+// Output Normalized: Field is not modified -- same as input value
+// Output Max Magnitude: Field is not modified -- same as input value
func (f FieldVal) String() string {
// f is a copy, so it's safe to normalize it without mutating the original.
f.Normalize()
@@ -185,9 +186,9 @@ func (f FieldVal) String() string {
// value is already set to zero. This function can be useful to clear an
// existing field value for reuse.
//
-// Preconditions: None
-// Output Normalized: Yes
-// Output Max Magnitude: 1
+// Preconditions: None
+// Output Normalized: Yes
+// Output Max Magnitude: 1
func (f *FieldVal) Zero() {
f.n[0] = 0
f.n[1] = 0
@@ -208,9 +209,9 @@ func (f *FieldVal) Zero() {
// f := new(FieldVal).Set(f2).Add(1) so that f = f2 + 1 where f2 is not
// modified.
//
-// Preconditions: None
-// Output Normalized: Same as input value
-// Output Max Magnitude: Same as input value
+// Preconditions: None
+// Output Normalized: Same as input value
+// Output Max Magnitude: Same as input value
func (f *FieldVal) Set(val *FieldVal) *FieldVal {
*f = *val
return f
@@ -223,9 +224,9 @@ func (f *FieldVal) Set(val *FieldVal) *FieldVal {
// The field value is returned to support chaining. This enables syntax such
// as f := new(FieldVal).SetInt(2).Mul(f2) so that f = 2 * f2.
//
-// Preconditions: None
-// Output Normalized: Yes
-// Output Max Magnitude: 1
+// Preconditions: None
+// Output Normalized: Yes
+// Output Max Magnitude: 1
func (f *FieldVal) SetInt(ui uint16) *FieldVal {
f.Zero()
f.n[0] = uint32(ui)
@@ -242,9 +243,9 @@ func (f *FieldVal) SetInt(ui uint16) *FieldVal {
// from a bool to numeric value in constant time and many constant-time
// operations require a numeric value.
//
-// Preconditions: None
-// Output Normalized: Yes if no overflow, no otherwise
-// Output Max Magnitude: 1
+// Preconditions: None
+// Output Normalized: Yes if no overflow, no otherwise
+// Output Max Magnitude: 1
func (f *FieldVal) SetBytes(b *[32]byte) uint32 {
// Pack the 256 total bits across the 10 uint32 words with a max of
// 26-bits per word. This could be done with a couple of for loops,
@@ -311,9 +312,9 @@ func (f *FieldVal) SetBytes(b *[32]byte) uint32 {
// or it if is acceptable to use this function with the described truncation and
// overflow behavior.
//
-// Preconditions: None
-// Output Normalized: Yes if no overflow, no otherwise
-// Output Max Magnitude: 1
+// Preconditions: None
+// Output Normalized: Yes if no overflow, no otherwise
+// Output Max Magnitude: 1
func (f *FieldVal) SetByteSlice(b []byte) bool {
var b32 [32]byte
b = b[:constantTimeMin(uint32(len(b)), 32)]
@@ -328,9 +329,9 @@ func (f *FieldVal) SetByteSlice(b []byte) bool {
// performs fast modular reduction over the secp256k1 prime by making use of the
// special form of the prime in constant time.
//
-// Preconditions: None
-// Output Normalized: Yes
-// Output Max Magnitude: 1
+// Preconditions: None
+// Output Normalized: Yes
+// Output Max Magnitude: 1
func (f *FieldVal) Normalize() *FieldVal {
// The field representation leaves 6 bits of overflow in each word so
// intermediate calculations can be performed without needing to
@@ -441,9 +442,9 @@ func (f *FieldVal) Normalize() *FieldVal {
// to write directly into part of a larger buffer without needing a separate
// allocation.
//
-// Preconditions:
-// - The field value MUST be normalized
-// - The target slice MUST have at least 32 bytes available
+// Preconditions:
+// - The field value MUST be normalized
+// - The target slice MUST have at least 32 bytes available
func (f *FieldVal) PutBytesUnchecked(b []byte) {
// Unpack the 256 total bits from the 10 uint32 words with a max of
// 26-bits per word. This could be done with a couple of for loops,
@@ -495,8 +496,8 @@ func (f *FieldVal) PutBytesUnchecked(b []byte) {
// array and returns that which can sometimes be more ergonomic in applications
// that aren't concerned about an additional copy.
//
-// Preconditions:
-// - The field value MUST be normalized
+// Preconditions:
+// - The field value MUST be normalized
func (f *FieldVal) PutBytes(b *[32]byte) {
f.PutBytesUnchecked(b[:])
}
@@ -508,8 +509,8 @@ func (f *FieldVal) PutBytes(b *[32]byte) {
// allowing the caller to reuse a buffer or write directly into part of a larger
// buffer.
//
-// Preconditions:
-// - The field value MUST be normalized
+// Preconditions:
+// - The field value MUST be normalized
func (f *FieldVal) Bytes() *[32]byte {
b := new([32]byte)
f.PutBytesUnchecked(b[:])
@@ -524,8 +525,8 @@ func (f *FieldVal) Bytes() *[32]byte {
// operations require a numeric value. See IsZero for the version that returns
// a bool.
//
-// Preconditions:
-// - The field value MUST be normalized
+// Preconditions:
+// - The field value MUST be normalized
func (f *FieldVal) IsZeroBit() uint32 {
// The value can only be zero if no bits are set in any of the words.
// This is a constant time implementation.
@@ -538,8 +539,8 @@ func (f *FieldVal) IsZeroBit() uint32 {
// IsZero returns whether or not the field value is equal to zero in constant
// time.
//
-// Preconditions:
-// - The field value MUST be normalized
+// Preconditions:
+// - The field value MUST be normalized
func (f *FieldVal) IsZero() bool {
// The value can only be zero if no bits are set in any of the words.
// This is a constant time implementation.
@@ -557,8 +558,8 @@ func (f *FieldVal) IsZero() bool {
// operations require a numeric value. See IsOne for the version that returns a
// bool.
//
-// Preconditions:
-// - The field value MUST be normalized
+// Preconditions:
+// - The field value MUST be normalized
func (f *FieldVal) IsOneBit() uint32 {
// The value can only be one if the single lowest significant bit is set in
// the first word and no other bits are set in any of the other words.
@@ -572,8 +573,8 @@ func (f *FieldVal) IsOneBit() uint32 {
// IsOne returns whether or not the field value is equal to one in constant
// time.
//
-// Preconditions:
-// - The field value MUST be normalized
+// Preconditions:
+// - The field value MUST be normalized
func (f *FieldVal) IsOne() bool {
// The value can only be one if the single lowest significant bit is set in
// the first word and no other bits are set in any of the other words.
@@ -592,8 +593,8 @@ func (f *FieldVal) IsOne() bool {
// operations require a numeric value. See IsOdd for the version that returns a
// bool.
//
-// Preconditions:
-// - The field value MUST be normalized
+// Preconditions:
+// - The field value MUST be normalized
func (f *FieldVal) IsOddBit() uint32 {
// Only odd numbers have the bottom bit set.
return f.n[0] & 1
@@ -602,8 +603,8 @@ func (f *FieldVal) IsOddBit() uint32 {
// IsOdd returns whether or not the field value is an odd number in constant
// time.
//
-// Preconditions:
-// - The field value MUST be normalized
+// Preconditions:
+// - The field value MUST be normalized
func (f *FieldVal) IsOdd() bool {
// Only odd numbers have the bottom bit set.
return f.n[0]&1 == 1
@@ -612,8 +613,8 @@ func (f *FieldVal) IsOdd() bool {
// Equals returns whether or not the two field values are the same in constant
// time.
//
-// Preconditions:
-// - Both field values being compared MUST be normalized
+// Preconditions:
+// - Both field values being compared MUST be normalized
func (f *FieldVal) Equals(val *FieldVal) bool {
// Xor only sets bits when they are different, so the two field values
// can only be the same if no bits are set after xoring each word.
@@ -633,10 +634,10 @@ func (f *FieldVal) Equals(val *FieldVal) bool {
// The field value is returned to support chaining. This enables syntax like:
// f.NegateVal(f2).AddInt(1) so that f = -f2 + 1.
//
-// Preconditions:
-// - The max magnitude MUST be 63
-// Output Normalized: No
-// Output Max Magnitude: Input magnitude + 1
+// Preconditions:
+// - The max magnitude MUST be 63
+// Output Normalized: No
+// Output Max Magnitude: Input magnitude + 1
func (f *FieldVal) NegateVal(val *FieldVal, magnitude uint32) *FieldVal {
// Negation in the field is just the prime minus the value. However,
// in order to allow negation against a field value without having to
@@ -677,10 +678,10 @@ func (f *FieldVal) NegateVal(val *FieldVal, magnitude uint32) *FieldVal {
// The field value is returned to support chaining. This enables syntax like:
// f.Negate().AddInt(1) so that f = -f + 1.
//
-// Preconditions:
-// - The max magnitude MUST be 63
-// Output Normalized: No
-// Output Max Magnitude: Input magnitude + 1
+// Preconditions:
+// - The max magnitude MUST be 63
+// Output Normalized: No
+// Output Max Magnitude: Input magnitude + 1
func (f *FieldVal) Negate(magnitude uint32) *FieldVal {
return f.NegateVal(f, magnitude)
}
@@ -692,10 +693,10 @@ func (f *FieldVal) Negate(magnitude uint32) *FieldVal {
// The field value is returned to support chaining. This enables syntax like:
// f.AddInt(1).Add(f2) so that f = f + 1 + f2.
//
-// Preconditions:
-// - The field value MUST have a max magnitude of 63
-// Output Normalized: No
-// Output Max Magnitude: Existing field magnitude + 1
+// Preconditions:
+// - The field value MUST have a max magnitude of 63
+// Output Normalized: No
+// Output Max Magnitude: Existing field magnitude + 1
func (f *FieldVal) AddInt(ui uint16) *FieldVal {
// Since the field representation intentionally provides overflow bits,
// it's ok to use carryless addition as the carry bit is safely part of
@@ -711,10 +712,10 @@ func (f *FieldVal) AddInt(ui uint16) *FieldVal {
// The field value is returned to support chaining. This enables syntax like:
// f.Add(f2).AddInt(1) so that f = f + f2 + 1.
//
-// Preconditions:
-// - The sum of the magnitudes of the two field values MUST be a max of 64
-// Output Normalized: No
-// Output Max Magnitude: Sum of the magnitude of the two individual field values
+// Preconditions:
+// - The sum of the magnitudes of the two field values MUST be a max of 64
+// Output Normalized: No
+// Output Max Magnitude: Sum of the magnitude of the two individual field values
func (f *FieldVal) Add(val *FieldVal) *FieldVal {
// Since the field representation intentionally provides overflow bits,
// it's ok to use carryless addition as the carry bit is safely part of
@@ -740,10 +741,10 @@ func (f *FieldVal) Add(val *FieldVal) *FieldVal {
// The field value is returned to support chaining. This enables syntax like:
// f3.Add2(f, f2).AddInt(1) so that f3 = f + f2 + 1.
//
-// Preconditions:
-// - The sum of the magnitudes of the two field values MUST be a max of 64
-// Output Normalized: No
-// Output Max Magnitude: Sum of the magnitude of the two field values
+// Preconditions:
+// - The sum of the magnitudes of the two field values MUST be a max of 64
+// Output Normalized: No
+// Output Max Magnitude: Sum of the magnitude of the two field values
func (f *FieldVal) Add2(val *FieldVal, val2 *FieldVal) *FieldVal {
// Since the field representation intentionally provides overflow bits,
// it's ok to use carryless addition as the carry bit is safely part of
@@ -772,10 +773,10 @@ func (f *FieldVal) Add2(val *FieldVal, val2 *FieldVal) *FieldVal {
// The field value is returned to support chaining. This enables syntax like:
// f.MulInt(2).Add(f2) so that f = 2 * f + f2.
//
-// Preconditions:
-// - The field value magnitude multiplied by given val MUST be a max of 64
-// Output Normalized: No
-// Output Max Magnitude: Existing field magnitude times the provided integer val
+// Preconditions:
+// - The field value magnitude multiplied by given val MUST be a max of 64
+// Output Normalized: No
+// Output Max Magnitude: Existing field magnitude times the provided integer val
func (f *FieldVal) MulInt(val uint8) *FieldVal {
// Since each word of the field representation can hold up to
// 32 - fieldBase extra bits which will be normalized out, it's safe
@@ -807,10 +808,10 @@ func (f *FieldVal) MulInt(val uint8) *FieldVal {
// The field value is returned to support chaining. This enables syntax like:
// f.Mul(f2).AddInt(1) so that f = (f * f2) + 1.
//
-// Preconditions:
-// - Both field values MUST have a max magnitude of 8
-// Output Normalized: No
-// Output Max Magnitude: 1
+// Preconditions:
+// - Both field values MUST have a max magnitude of 8
+// Output Normalized: No
+// Output Max Magnitude: 1
func (f *FieldVal) Mul(val *FieldVal) *FieldVal {
return f.Mul2(f, val)
}
@@ -824,10 +825,10 @@ func (f *FieldVal) Mul(val *FieldVal) *FieldVal {
// The field value is returned to support chaining. This enables syntax like:
// f3.Mul2(f, f2).AddInt(1) so that f3 = (f * f2) + 1.
//
-// Preconditions:
-// - Both input field values MUST have a max magnitude of 8
-// Output Normalized: No
-// Output Max Magnitude: 1
+// Preconditions:
+// - Both input field values MUST have a max magnitude of 8
+// Output Normalized: No
+// Output Max Magnitude: 1
func (f *FieldVal) Mul2(val *FieldVal, val2 *FieldVal) *FieldVal {
// This could be done with a couple of for loops and an array to store
// the intermediate terms, but this unrolled version is significantly
@@ -1101,10 +1102,10 @@ func (f *FieldVal) Mul2(val *FieldVal, val2 *FieldVal) *FieldVal {
// field must be a max of 8 to prevent overflow. The magnitude of the result
// will be 1.
//
-// Preconditions:
-// - The input field value MUST have a max magnitude of 8
-// Output Normalized: No
-// Output Max Magnitude: 1
+// Preconditions:
+// - The input field value MUST have a max magnitude of 8
+// Output Normalized: No
+// Output Max Magnitude: 1
func (f *FieldVal) SquareRootVal(val *FieldVal) bool {
// This uses the Tonelli-Shanks method for calculating the square root of
// the value when it exists. The key principles of the method follow.
@@ -1156,7 +1157,7 @@ func (f *FieldVal) SquareRootVal(val *FieldVal) bool {
// 10111111 11111111 11111111 00001100
//
// Notice that can be broken up into three windows of consecutive 1s (in
- // order of least to most signifcant) as:
+ // order of least to most significant) as:
//
// 6-bit window with two bits set (bits 4, 5, 6, 7 unset)
// 23-bit window with 22 bits set (bit 30 unset)
@@ -1262,10 +1263,10 @@ func (f *FieldVal) SquareRootVal(val *FieldVal) bool {
// The field value is returned to support chaining. This enables syntax like:
// f.Square().Mul(f2) so that f = f^2 * f2.
//
-// Preconditions:
-// - The field value MUST have a max magnitude of 8
-// Output Normalized: No
-// Output Max Magnitude: 1
+// Preconditions:
+// - The field value MUST have a max magnitude of 8
+// Output Normalized: No
+// Output Max Magnitude: 1
func (f *FieldVal) Square() *FieldVal {
return f.SquareVal(f)
}
@@ -1278,10 +1279,10 @@ func (f *FieldVal) Square() *FieldVal {
// The field value is returned to support chaining. This enables syntax like:
// f3.SquareVal(f).Mul(f) so that f3 = f^2 * f = f^3.
//
-// Preconditions:
-// - The input field value MUST have a max magnitude of 8
-// Output Normalized: No
-// Output Max Magnitude: 1
+// Preconditions:
+// - The input field value MUST have a max magnitude of 8
+// Output Normalized: No
+// Output Max Magnitude: 1
func (f *FieldVal) SquareVal(val *FieldVal) *FieldVal {
// This could be done with a couple of for loops and an array to store
// the intermediate terms, but this unrolled version is significantly
@@ -1503,10 +1504,10 @@ func (f *FieldVal) SquareVal(val *FieldVal) *FieldVal {
// The field value is returned to support chaining. This enables syntax like:
// f.Inverse().Mul(f2) so that f = f^-1 * f2.
//
-// Preconditions:
-// - The field value MUST have a max magnitude of 8
-// Output Normalized: No
-// Output Max Magnitude: 1
+// Preconditions:
+// - The field value MUST have a max magnitude of 8
+// Output Normalized: No
+// Output Max Magnitude: 1
func (f *FieldVal) Inverse() *FieldVal {
// Fermat's little theorem states that for a nonzero number a and prime
// prime p, a^(p-1) = 1 (mod p). Since the multiplicative inverse is
@@ -1614,8 +1615,8 @@ func (f *FieldVal) Inverse() *FieldVal {
// IsGtOrEqPrimeMinusOrder returns whether or not the field value exceeds the
// group order divided by 2 in constant time.
//
-// Preconditions:
-// - The field value MUST be normalized
+// Preconditions:
+// - The field value MUST be normalized
func (f *FieldVal) IsGtOrEqPrimeMinusOrder() bool {
// The secp256k1 prime is equivalent to 2^256 - 4294968273 and the group
// order is 2^256 - 432420386565659656852420866394968145599. Thus,
diff --git a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/genstatics.go b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/genstatics.go
deleted file mode 100644
index 00534c5efd..0000000000
--- a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/genstatics.go
+++ /dev/null
@@ -1,195 +0,0 @@
-// Copyright (c) 2014-2015 The btcsuite developers
-// Copyright (c) 2015-2021 The Decred developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-// This file is ignored during the regular build due to the following build tag.
-// This build tag is set during go generate.
-// +build gensecp256k1
-
-package secp256k1
-
-// References:
-// [GECC]: Guide to Elliptic Curve Cryptography (Hankerson, Menezes, Vanstone)
-
-import (
- "encoding/binary"
- "math/big"
-)
-
-// compressedBytePoints are dummy points used so the code which generates the
-// real values can compile.
-var compressedBytePoints = ""
-
-// SerializedBytePoints returns a serialized byte slice which contains all of
-// the possible points per 8-bit window. This is used to when generating
-// compressedbytepoints.go.
-func SerializedBytePoints() []byte {
- // Calculate G^(2^i) for i in 0..255. These are used to avoid recomputing
- // them for each digit of the 8-bit windows.
- doublingPoints := make([]JacobianPoint, curveParams.BitSize)
- var q JacobianPoint
- bigAffineToJacobian(curveParams.Gx, curveParams.Gy, &q)
- for i := 0; i < curveParams.BitSize; i++ {
- // Q = 2*Q.
- doublingPoints[i] = q
- DoubleNonConst(&q, &q)
- }
-
- // Separate the bits into byte-sized windows.
- curveByteSize := curveParams.BitSize / 8
- serialized := make([]byte, curveByteSize*256*2*10*4)
- offset := 0
- for byteNum := 0; byteNum < curveByteSize; byteNum++ {
- // Grab the 8 bits that make up this byte from doubling points.
- startingBit := 8 * (curveByteSize - byteNum - 1)
- windowPoints := doublingPoints[startingBit : startingBit+8]
-
- // Compute all points in this window, convert them to affine, and
- // serialize them.
- for i := 0; i < 256; i++ {
- var point JacobianPoint
- for bit := 0; bit < 8; bit++ {
- if i>>uint(bit)&1 == 1 {
- AddNonConst(&point, &windowPoints[bit], &point)
- }
- }
- point.ToAffine()
-
- for i := 0; i < len(point.X.n); i++ {
- binary.LittleEndian.PutUint32(serialized[offset:], point.X.n[i])
- offset += 4
- }
- for i := 0; i < len(point.Y.n); i++ {
- binary.LittleEndian.PutUint32(serialized[offset:], point.Y.n[i])
- offset += 4
- }
- }
- }
-
- return serialized
-}
-
-// sqrt returns the square root of the provided big integer using Newton's
-// method. It's only compiled and used during generation of pre-computed
-// values, so speed is not a huge concern.
-func sqrt(n *big.Int) *big.Int {
- // Initial guess = 2^(log_2(n)/2)
- guess := big.NewInt(2)
- guess.Exp(guess, big.NewInt(int64(n.BitLen()/2)), nil)
-
- // Now refine using Newton's method.
- big2 := big.NewInt(2)
- prevGuess := big.NewInt(0)
- for {
- prevGuess.Set(guess)
- guess.Add(guess, new(big.Int).Div(n, guess))
- guess.Div(guess, big2)
- if guess.Cmp(prevGuess) == 0 {
- break
- }
- }
- return guess
-}
-
-// EndomorphismVectors runs the first 3 steps of algorithm 3.74 from [GECC] to
-// generate the linearly independent vectors needed to generate a balanced
-// length-two representation of a multiplier such that k = k1 + k2λ (mod N) and
-// returns them. Since the values will always be the same given the fact that N
-// and λ are fixed, the final results can be accelerated by storing the
-// precomputed values.
-func EndomorphismVectors() (a1, b1, a2, b2 *big.Int) {
- bigMinus1 := big.NewInt(-1)
-
- // This section uses an extended Euclidean algorithm to generate a
- // sequence of equations:
- // s[i] * N + t[i] * λ = r[i]
-
- nSqrt := sqrt(curveParams.N)
- u, v := new(big.Int).Set(curveParams.N), new(big.Int).Set(endomorphismLambda)
- x1, y1 := big.NewInt(1), big.NewInt(0)
- x2, y2 := big.NewInt(0), big.NewInt(1)
- q, r := new(big.Int), new(big.Int)
- qu, qx1, qy1 := new(big.Int), new(big.Int), new(big.Int)
- s, t := new(big.Int), new(big.Int)
- ri, ti := new(big.Int), new(big.Int)
- a1, b1, a2, b2 = new(big.Int), new(big.Int), new(big.Int), new(big.Int)
- found, oneMore := false, false
- for u.Sign() != 0 {
- // q = v/u
- q.Div(v, u)
-
- // r = v - q*u
- qu.Mul(q, u)
- r.Sub(v, qu)
-
- // s = x2 - q*x1
- qx1.Mul(q, x1)
- s.Sub(x2, qx1)
-
- // t = y2 - q*y1
- qy1.Mul(q, y1)
- t.Sub(y2, qy1)
-
- // v = u, u = r, x2 = x1, x1 = s, y2 = y1, y1 = t
- v.Set(u)
- u.Set(r)
- x2.Set(x1)
- x1.Set(s)
- y2.Set(y1)
- y1.Set(t)
-
- // As soon as the remainder is less than the sqrt of n, the
- // values of a1 and b1 are known.
- if !found && r.Cmp(nSqrt) < 0 {
- // When this condition executes ri and ti represent the
- // r[i] and t[i] values such that i is the greatest
- // index for which r >= sqrt(n). Meanwhile, the current
- // r and t values are r[i+1] and t[i+1], respectively.
-
- // a1 = r[i+1], b1 = -t[i+1]
- a1.Set(r)
- b1.Mul(t, bigMinus1)
- found = true
- oneMore = true
-
- // Skip to the next iteration so ri and ti are not
- // modified.
- continue
-
- } else if oneMore {
- // When this condition executes ri and ti still
- // represent the r[i] and t[i] values while the current
- // r and t are r[i+2] and t[i+2], respectively.
-
- // sum1 = r[i]^2 + t[i]^2
- rSquared := new(big.Int).Mul(ri, ri)
- tSquared := new(big.Int).Mul(ti, ti)
- sum1 := new(big.Int).Add(rSquared, tSquared)
-
- // sum2 = r[i+2]^2 + t[i+2]^2
- r2Squared := new(big.Int).Mul(r, r)
- t2Squared := new(big.Int).Mul(t, t)
- sum2 := new(big.Int).Add(r2Squared, t2Squared)
-
- // if (r[i]^2 + t[i]^2) <= (r[i+2]^2 + t[i+2]^2)
- if sum1.Cmp(sum2) <= 0 {
- // a2 = r[i], b2 = -t[i]
- a2.Set(ri)
- b2.Mul(ti, bigMinus1)
- } else {
- // a2 = r[i+2], b2 = -t[i+2]
- a2.Set(r)
- b2.Mul(t, bigMinus1)
- }
-
- // All done.
- break
- }
-
- ri.Set(r)
- ti.Set(t)
- }
-
- return a1, b1, a2, b2
-}
diff --git a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/loadprecomputed.go b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/loadprecomputed.go
index d7d014a401..91c3d37769 100644
--- a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/loadprecomputed.go
+++ b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/loadprecomputed.go
@@ -1,5 +1,5 @@
// Copyright 2015 The btcsuite developers
-// Copyright (c) 2015-2021 The Decred developers
+// Copyright (c) 2015-2022 The Decred developers
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
@@ -8,17 +8,21 @@ package secp256k1
import (
"compress/zlib"
"encoding/base64"
- "encoding/binary"
- "io/ioutil"
+ "io"
"strings"
"sync"
)
-//go:generate go run -tags gensecp256k1 genprecomps.go
+//go:generate go run genprecomps.go
// bytePointTable describes a table used to house pre-computed values for
// accelerating scalar base multiplication.
-type bytePointTable [32][256][2]FieldVal
+type bytePointTable [32][256]JacobianPoint
+
+// compressedBytePointsFn is set to a real function by the code generation to
+// return the compressed pre-computed values for accelerating scalar base
+// multiplication.
+var compressedBytePointsFn func() string
// s256BytePoints houses pre-computed values used to accelerate scalar base
// multiplication such that they are only loaded on first use.
@@ -38,10 +42,10 @@ var s256BytePoints = func() func() *bytePointTable {
var data *bytePointTable
mustLoadBytePoints := func() {
// There will be no byte points to load when generating them.
- bp := compressedBytePoints
- if len(bp) == 0 {
+ if compressedBytePointsFn == nil {
return
}
+ bp := compressedBytePointsFn()
// Decompress the pre-computed table used to accelerate scalar base
// multiplication.
@@ -50,7 +54,7 @@ var s256BytePoints = func() func() *bytePointTable {
if err != nil {
panic(err)
}
- serialized, err := ioutil.ReadAll(r)
+ serialized, err := io.ReadAll(r)
if err != nil {
panic(err)
}
@@ -62,16 +66,12 @@ var s256BytePoints = func() func() *bytePointTable {
for byteNum := 0; byteNum < len(bytePoints); byteNum++ {
// All points in this window.
for i := 0; i < len(bytePoints[byteNum]); i++ {
- px := &bytePoints[byteNum][i][0]
- py := &bytePoints[byteNum][i][1]
- for i := 0; i < len(px.n); i++ {
- px.n[i] = binary.LittleEndian.Uint32(serialized[offset:])
- offset += 4
- }
- for i := 0; i < len(py.n); i++ {
- py.n[i] = binary.LittleEndian.Uint32(serialized[offset:])
- offset += 4
- }
+ p := &bytePoints[byteNum][i]
+ p.X.SetByteSlice(serialized[offset:])
+ offset += 32
+ p.Y.SetByteSlice(serialized[offset:])
+ offset += 32
+ p.Z.SetInt(1)
}
}
data = &bytePoints
diff --git a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/modnscalar.go b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/modnscalar.go
index 581b904abe..f66496ed5e 100644
--- a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/modnscalar.go
+++ b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/modnscalar.go
@@ -1,4 +1,4 @@
-// Copyright (c) 2020 The Decred developers
+// Copyright (c) 2020-2022 The Decred developers
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
@@ -100,7 +100,7 @@ var (
// arithmetic over the secp256k1 group order. This means all arithmetic is
// performed modulo:
//
-// 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141
+// 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141
//
// It only implements the arithmetic needed for elliptic curve operations,
// however, the operations that are not implemented can typically be worked
@@ -174,6 +174,19 @@ func (s *ModNScalar) Zero() {
s.n[7] = 0
}
+// IsZeroBit returns 1 when the scalar is equal to zero or 0 otherwise in
+// constant time.
+//
+// Note that a bool is not used here because it is not possible in Go to convert
+// from a bool to numeric value in constant time and many constant-time
+// operations require a numeric value. See IsZero for the version that returns
+// a bool.
+func (s *ModNScalar) IsZeroBit() uint32 {
+ // The scalar can only be zero if no bits are set in any of the words.
+ bits := s.n[0] | s.n[1] | s.n[2] | s.n[3] | s.n[4] | s.n[5] | s.n[6] | s.n[7]
+ return constantTimeEq(bits, 0)
+}
+
// IsZero returns whether or not the scalar is equal to zero in constant time.
func (s *ModNScalar) IsZero() bool {
// The scalar can only be zero if no bits are set in any of the words.
@@ -491,7 +504,7 @@ func (a *accumulator96) Add(v uint64) {
low := uint32(v & uint32Mask)
hi := uint32(v >> 32)
a.n[0] += low
- a.n[1] += constantTimeLess(a.n[0], low) // Carry if overflow in n[0].
+ hi += constantTimeLess(a.n[0], low) // Carry if overflow in n[0].
a.n[1] += hi
a.n[2] += constantTimeLess(a.n[1], hi) // Carry if overflow in n[1].
}
diff --git a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/privkey.go b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/privkey.go
index 3590346c68..ca3e8da281 100644
--- a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/privkey.go
+++ b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/privkey.go
@@ -1,13 +1,13 @@
// Copyright (c) 2013-2014 The btcsuite developers
-// Copyright (c) 2015-2020 The Decred developers
+// Copyright (c) 2015-2023 The Decred developers
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package secp256k1
import (
- "crypto/ecdsa"
- "crypto/rand"
+ cryptorand "crypto/rand"
+ "io"
)
// PrivateKey provides facilities for working with secp256k1 private keys within
@@ -27,27 +27,61 @@ func NewPrivateKey(key *ModNScalar) *PrivateKey {
// interpreted as an unsigned 256-bit big-endian integer in the range [0, N-1],
// where N is the order of the curve.
//
-// Note that this means passing a slice with more than 32 bytes is truncated and
-// that truncated value is reduced modulo N. It is up to the caller to either
-// provide a value in the appropriate range or choose to accept the described
-// behavior.
+// WARNING: This means passing a slice with more than 32 bytes is truncated and
+// that truncated value is reduced modulo N. Further, 0 is not a valid private
+// key. It is up to the caller to provide a value in the appropriate range of
+// [1, N-1]. Failure to do so will either result in an invalid private key or
+// potentially weak private keys that have bias that could be exploited.
//
-// Typically callers should simply make use of GeneratePrivateKey when creating
-// private keys which properly handles generation of appropriate values.
+// This function primarily exists to provide a mechanism for converting
+// serialized private keys that are already known to be good.
+//
+// Typically callers should make use of GeneratePrivateKey or
+// GeneratePrivateKeyFromRand when creating private keys since they properly
+// handle generation of appropriate values.
func PrivKeyFromBytes(privKeyBytes []byte) *PrivateKey {
var privKey PrivateKey
privKey.Key.SetByteSlice(privKeyBytes)
return &privKey
}
-// GeneratePrivateKey returns a private key that is suitable for use with
-// secp256k1.
-func GeneratePrivateKey() (*PrivateKey, error) {
- key, err := ecdsa.GenerateKey(S256(), rand.Reader)
- if err != nil {
- return nil, err
+// generatePrivateKey generates and returns a new private key that is suitable
+// for use with secp256k1 using the provided reader as a source of entropy. The
+// provided reader must be a source of cryptographically secure randomness to
+// avoid weak private keys.
+func generatePrivateKey(rand io.Reader) (*PrivateKey, error) {
+ // The group order is close enough to 2^256 that there is only roughly a 1
+ // in 2^128 chance of generating an invalid private key, so this loop will
+ // virtually never run more than a single iteration in practice.
+ var key PrivateKey
+ var b32 [32]byte
+ for valid := false; !valid; {
+ if _, err := io.ReadFull(rand, b32[:]); err != nil {
+ return nil, err
+ }
+
+ // The private key is only valid when it is in the range [1, N-1], where
+ // N is the order of the curve.
+ overflow := key.Key.SetBytes(&b32)
+ valid = (key.Key.IsZeroBit() | overflow) == 0
}
- return PrivKeyFromBytes(key.D.Bytes()), nil
+ zeroArray32(&b32)
+
+ return &key, nil
+}
+
+// GeneratePrivateKey generates and returns a new cryptographically secure
+// private key that is suitable for use with secp256k1.
+func GeneratePrivateKey() (*PrivateKey, error) {
+ return generatePrivateKey(cryptorand.Reader)
+}
+
+// GeneratePrivateKeyFromRand generates a private key that is suitable for use
+// with secp256k1 using the provided reader as a source of entropy. The
+// provided reader must be a source of cryptographically secure randomness, such
+// as [crypto/rand.Reader], to avoid weak private keys.
+func GeneratePrivateKeyFromRand(rand io.Reader) (*PrivateKey, error) {
+ return generatePrivateKey(rand)
}
// PubKey computes and returns the public key corresponding to this private key.
diff --git a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/pubkey.go b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/pubkey.go
index 67165833ff..54c54be5f1 100644
--- a/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/pubkey.go
+++ b/vendor/github.com/decred/dcrd/dcrec/secp256k1/v4/pubkey.go
@@ -1,5 +1,5 @@
// Copyright (c) 2013-2014 The btcsuite developers
-// Copyright (c) 2015-2021 The Decred developers
+// Copyright (c) 2015-2022 The Decred developers
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
@@ -92,11 +92,16 @@ func NewPublicKey(x, y *FieldVal) *PublicKey {
// hybrid formats as follows:
//
// Compressed:
-// <format byte = 0x02/0x03><32-byte X coordinate>
+//
+// <format byte = 0x02/0x03><32-byte X coordinate>
+//
// Uncompressed:
-// <format byte = 0x04><32-byte X coordinate><32-byte Y coordinate>
+//
+// <format byte = 0x04><32-byte X coordinate><32-byte Y coordinate>
+//
// Hybrid:
-// <format byte = 0x05/0x06><32-byte X coordinate><32-byte Y coordinate>
+//
+// <format byte = 0x05/0x06><32-byte X coordinate><32-byte Y coordinate>
//
// NOTE: The hybrid format makes little sense in practice an therefore this
// package will not produce public keys serialized in this format. However,
@@ -209,9 +214,9 @@ func (p PublicKey) SerializeCompressed() []byte {
return b[:]
}
-// IsEqual compares this PublicKey instance to the one passed, returning true if
-// both PublicKeys are equivalent. A PublicKey is equivalent to another, if they
-// both have the same X and Y coordinate.
+// IsEqual compares this public key instance to the one passed, returning true
+// if both public keys are equivalent. A public key is equivalent to another,
+// if they both have the same X and Y coordinates.
func (p *PublicKey) IsEqual(otherPubKey *PublicKey) bool {
return p.x.Equals(&otherPubKey.x) && p.y.Equals(&otherPubKey.y)
}
diff --git a/vendor/github.com/goccy/go-json/.golangci.yml b/vendor/github.com/goccy/go-json/.golangci.yml
index 44ae40f692..57ae5a528f 100644
--- a/vendor/github.com/goccy/go-json/.golangci.yml
+++ b/vendor/github.com/goccy/go-json/.golangci.yml
@@ -48,6 +48,14 @@ linters:
- nlreturn
- testpackage
- wsl
+ - varnamelen
+ - nilnil
+ - ireturn
+ - govet
+ - forcetypeassert
+ - cyclop
+ - containedctx
+ - revive
issues:
exclude-rules:
diff --git a/vendor/github.com/goccy/go-json/CHANGELOG.md b/vendor/github.com/goccy/go-json/CHANGELOG.md
index b7bc481cd8..d09bb89c31 100644
--- a/vendor/github.com/goccy/go-json/CHANGELOG.md
+++ b/vendor/github.com/goccy/go-json/CHANGELOG.md
@@ -1,3 +1,151 @@
+# v0.10.2 - 2023/03/20
+
+### New features
+
+* Support DebugDOT option for debugging encoder ( #440 )
+
+### Fix bugs
+
+* Fix combination of embedding structure and omitempty option ( #442 )
+
+# v0.10.1 - 2023/03/13
+
+### Fix bugs
+
+* Fix checkptr error for array decoder ( #415 )
+* Fix added buffer size check when decoding key ( #430 )
+* Fix handling of anonymous fields other than struct ( #431 )
+* Fix to not optimize when lower conversion can't handle byte-by-byte ( #432 )
+* Fix a problem that MarshalIndent does not work when UnorderedMap is specified ( #435 )
+* Fix mapDecoder.DecodeStream() for empty objects containing whitespace ( #425 )
+* Fix an issue that could not set the correct NextField for fields in the embedded structure ( #438 )
+
+# v0.10.0 - 2022/11/29
+
+### New features
+
+* Support JSON Path ( #250 )
+
+### Fix bugs
+
+* Fix marshaler for map's key ( #409 )
+
+# v0.9.11 - 2022/08/18
+
+### Fix bugs
+
+* Fix unexpected behavior when buffer ends with backslash ( #383 )
+* Fix stream decoding of escaped character ( #387 )
+
+# v0.9.10 - 2022/07/15
+
+### Fix bugs
+
+* Fix boundary exception of type caching ( #382 )
+
+# v0.9.9 - 2022/07/15
+
+### Fix bugs
+
+* Fix encoding of directed interface with typed nil ( #377 )
+* Fix embedded primitive type encoding using alias ( #378 )
+* Fix slice/array type encoding with types implementing MarshalJSON ( #379 )
+* Fix unicode decoding when the expected buffer state is not met after reading ( #380 )
+
+# v0.9.8 - 2022/06/30
+
+### Fix bugs
+
+* Fix decoding of surrogate-pair ( #365 )
+* Fix handling of embedded primitive type ( #366 )
+* Add validation of escape sequence for decoder ( #367 )
+* Fix stream tokenizing respecting UseNumber ( #369 )
+* Fix encoding when struct pointer type that implements Marshal JSON is embedded ( #375 )
+
+### Improve performance
+
+* Improve performance of linkRecursiveCode ( #368 )
+
+# v0.9.7 - 2022/04/22
+
+### Fix bugs
+
+#### Encoder
+
+* Add filtering process for encoding on slow path ( #355 )
+* Fix encoding of interface{} with pointer type ( #363 )
+
+#### Decoder
+
+* Fix map key decoder that implements UnmarshalJSON ( #353 )
+* Fix decoding of []uint8 type ( #361 )
+
+### New features
+
+* Add DebugWith option for encoder ( #356 )
+
+# v0.9.6 - 2022/03/22
+
+### Fix bugs
+
+* Correct the handling of the minimum value of int type for decoder ( #344 )
+* Fix bugs of stream decoder's bufferSize ( #349 )
+* Add a guard to use typeptr more safely ( #351 )
+
+### Improve decoder performance
+
+* Improve escapeString's performance ( #345 )
+
+### Others
+
+* Update go version for CI ( #347 )
+
+# v0.9.5 - 2022/03/04
+
+### Fix bugs
+
+* Fix panic when decoding time.Time with context ( #328 )
+* Fix reading the next character in buffer to nul consideration ( #338 )
+* Fix incorrect handling on skipValue ( #341 )
+
+### Improve decoder performance
+
+* Improve performance when a payload contains escape sequence ( #334 )
+
+# v0.9.4 - 2022/01/21
+
+* Fix IsNilForMarshaler for string type with omitempty ( #323 )
+* Fix the case where the embedded field is at the end ( #326 )
+
+# v0.9.3 - 2022/01/14
+
+* Fix logic of removing struct field for decoder ( #322 )
+
+# v0.9.2 - 2022/01/14
+
+* Add invalid decoder to delay type error judgment at decode ( #321 )
+
+# v0.9.1 - 2022/01/11
+
+* Fix encoding of MarshalText/MarshalJSON operation with head offset ( #319 )
+
+# v0.9.0 - 2022/01/05
+
+### New feature
+
+* Supports dynamic filtering of struct fields ( #314 )
+
+### Improve encoding performance
+
+* Improve map encoding performance ( #310 )
+* Optimize encoding path for escaped string ( #311 )
+* Add encoding option for performance ( #312 )
+
+### Fix bugs
+
+* Fix panic at encoding map value on 1.18 ( #310 )
+* Fix MarshalIndent for interface type ( #317 )
+
# v0.8.1 - 2021/12/05
* Fix operation conversion from PtrHead to Head in Recursive type ( #305 )
diff --git a/vendor/github.com/goccy/go-json/Makefile b/vendor/github.com/goccy/go-json/Makefile
index 363563ab9b..5bbfc4c9a2 100644
--- a/vendor/github.com/goccy/go-json/Makefile
+++ b/vendor/github.com/goccy/go-json/Makefile
@@ -22,7 +22,7 @@ cover-html: cover
.PHONY: lint
lint: golangci-lint
- golangci-lint run
+ $(BIN_DIR)/golangci-lint run
golangci-lint: | $(BIN_DIR)
@{ \
@@ -30,7 +30,7 @@ golangci-lint: | $(BIN_DIR)
GOLANGCI_LINT_TMP_DIR=$$(mktemp -d); \
cd $$GOLANGCI_LINT_TMP_DIR; \
go mod init tmp; \
- GOBIN=$(BIN_DIR) go get github.com/golangci/golangci-lint/cmd/golangci-lint@v1.36.0; \
+ GOBIN=$(BIN_DIR) go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.48.0; \
rm -rf $$GOLANGCI_LINT_TMP_DIR; \
}
diff --git a/vendor/github.com/goccy/go-json/README.md b/vendor/github.com/goccy/go-json/README.md
index 8cb729f769..7bacc54f9c 100644
--- a/vendor/github.com/goccy/go-json/README.md
+++ b/vendor/github.com/goccy/go-json/README.md
@@ -13,7 +13,7 @@ Fast JSON encoder/decoder compatible with encoding/json for Go
```
* version ( expected release date )
-* v0.8.0
+* v0.9.0
|
| while maintaining compatibility with encoding/json, we will add convenient APIs
|
@@ -21,9 +21,8 @@ Fast JSON encoder/decoder compatible with encoding/json for Go
* v1.0.0
```
-We are accepting requests for features that will be implemented between v0.8.0 and v.1.0.0.
+We are accepting requests for features that will be implemented between v0.9.0 and v.1.0.0.
If you have the API you need, please submit your issue [here](https://github.com/goccy/go-json/issues).
-For example, I'm thinking of supporting `context.Context` of `json.Marshaler` and decoding using JSON Path.
# Features
@@ -32,6 +31,7 @@ For example, I'm thinking of supporting `context.Context` of `json.Marshaler` an
- Flexible customization with options
- Coloring the encoded string
- Can propagate context.Context to `MarshalJSON` or `UnmarshalJSON`
+- Can dynamically filter the fields of the structure type-safely
# Installation
@@ -184,7 +184,7 @@ func Marshal(v interface{}) ([]byte, error) {
`json.Marshal` and `json.Unmarshal` receive `interface{}` value and they perform type determination dynamically to process.
In normal case, you need to use the `reflect` library to determine the type dynamically, but since `reflect.Type` is defined as `interface`, when you call the method of `reflect.Type`, The reflect's argument is escaped.
-Therefore, the arguments for `Marshal` and `Unmarshal` are always escape to the heap.
+Therefore, the arguments for `Marshal` and `Unmarshal` are always escaped to the heap.
However, `go-json` can use the feature of `reflect.Type` while avoiding escaping.
`reflect.Type` is defined as `interface`, but in reality `reflect.Type` is implemented only by the structure `rtype` defined in the `reflect` package.
diff --git a/vendor/github.com/goccy/go-json/decode.go b/vendor/github.com/goccy/go-json/decode.go
index d99749d05c..74c6ac3bca 100644
--- a/vendor/github.com/goccy/go-json/decode.go
+++ b/vendor/github.com/goccy/go-json/decode.go
@@ -83,6 +83,37 @@ func unmarshalContext(ctx context.Context, data []byte, v interface{}, optFuncs
return validateEndBuf(src, cursor)
}
+var (
+ pathDecoder = decoder.NewPathDecoder()
+)
+
+func extractFromPath(path *Path, data []byte, optFuncs ...DecodeOptionFunc) ([][]byte, error) {
+ if path.path.RootSelectorOnly {
+ return [][]byte{data}, nil
+ }
+ src := make([]byte, len(data)+1) // append nul byte to the end
+ copy(src, data)
+
+ ctx := decoder.TakeRuntimeContext()
+ ctx.Buf = src
+ ctx.Option.Flags = 0
+ ctx.Option.Flags |= decoder.PathOption
+ ctx.Option.Path = path.path
+ for _, optFunc := range optFuncs {
+ optFunc(ctx.Option)
+ }
+ paths, cursor, err := pathDecoder.DecodePath(ctx, 0, 0)
+ if err != nil {
+ decoder.ReleaseRuntimeContext(ctx)
+ return nil, err
+ }
+ decoder.ReleaseRuntimeContext(ctx)
+ if err := validateEndBuf(src, cursor); err != nil {
+ return nil, err
+ }
+ return paths, nil
+}
+
func unmarshalNoEscape(data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error {
src := make([]byte, len(data)+1) // append nul byte to the end
copy(src, data)
diff --git a/vendor/github.com/goccy/go-json/docker-compose.yml b/vendor/github.com/goccy/go-json/docker-compose.yml
index 48415e3d97..db40c79ad5 100644
--- a/vendor/github.com/goccy/go-json/docker-compose.yml
+++ b/vendor/github.com/goccy/go-json/docker-compose.yml
@@ -1,7 +1,7 @@
version: '2'
services:
go-json:
- image: golang:1.17
+ image: golang:1.18
volumes:
- '.:/go/src/go-json'
deploy:
diff --git a/vendor/github.com/goccy/go-json/encode.go b/vendor/github.com/goccy/go-json/encode.go
index 7f198bdca6..4bd899f38b 100644
--- a/vendor/github.com/goccy/go-json/encode.go
+++ b/vendor/github.com/goccy/go-json/encode.go
@@ -3,6 +3,7 @@ package json
import (
"context"
"io"
+ "os"
"unsafe"
"github.com/goccy/go-json/internal/encoder"
@@ -61,6 +62,8 @@ func (e *Encoder) encodeWithOption(ctx *encoder.RuntimeContext, v interface{}, o
if e.enabledHTMLEscape {
ctx.Option.Flag |= encoder.HTMLEscapeOption
}
+ ctx.Option.Flag |= encoder.NormalizeUTF8Option
+ ctx.Option.DebugOut = os.Stdout
for _, optFunc := range optFuncs {
optFunc(ctx.Option)
}
@@ -111,7 +114,7 @@ func (e *Encoder) SetIndent(prefix, indent string) {
func marshalContext(ctx context.Context, v interface{}, optFuncs ...EncodeOptionFunc) ([]byte, error) {
rctx := encoder.TakeRuntimeContext()
rctx.Option.Flag = 0
- rctx.Option.Flag = encoder.HTMLEscapeOption | encoder.ContextOption
+ rctx.Option.Flag = encoder.HTMLEscapeOption | encoder.NormalizeUTF8Option | encoder.ContextOption
rctx.Option.Context = ctx
for _, optFunc := range optFuncs {
optFunc(rctx.Option)
@@ -139,7 +142,7 @@ func marshal(v interface{}, optFuncs ...EncodeOptionFunc) ([]byte, error) {
ctx := encoder.TakeRuntimeContext()
ctx.Option.Flag = 0
- ctx.Option.Flag |= encoder.HTMLEscapeOption
+ ctx.Option.Flag |= (encoder.HTMLEscapeOption | encoder.NormalizeUTF8Option)
for _, optFunc := range optFuncs {
optFunc(ctx.Option)
}
@@ -166,7 +169,7 @@ func marshalNoEscape(v interface{}) ([]byte, error) {
ctx := encoder.TakeRuntimeContext()
ctx.Option.Flag = 0
- ctx.Option.Flag |= encoder.HTMLEscapeOption
+ ctx.Option.Flag |= (encoder.HTMLEscapeOption | encoder.NormalizeUTF8Option)
buf, err := encodeNoEscape(ctx, v)
if err != nil {
@@ -190,7 +193,7 @@ func marshalIndent(v interface{}, prefix, indent string, optFuncs ...EncodeOptio
ctx := encoder.TakeRuntimeContext()
ctx.Option.Flag = 0
- ctx.Option.Flag |= (encoder.HTMLEscapeOption | encoder.IndentOption)
+ ctx.Option.Flag |= (encoder.HTMLEscapeOption | encoder.NormalizeUTF8Option | encoder.IndentOption)
for _, optFunc := range optFuncs {
optFunc(ctx.Option)
}
@@ -220,7 +223,7 @@ func encode(ctx *encoder.RuntimeContext, v interface{}) ([]byte, error) {
typ := header.typ
typeptr := uintptr(unsafe.Pointer(typ))
- codeSet, err := encoder.CompileToGetCodeSet(typeptr)
+ codeSet, err := encoder.CompileToGetCodeSet(ctx, typeptr)
if err != nil {
return nil, err
}
@@ -248,7 +251,7 @@ func encodeNoEscape(ctx *encoder.RuntimeContext, v interface{}) ([]byte, error)
typ := header.typ
typeptr := uintptr(unsafe.Pointer(typ))
- codeSet, err := encoder.CompileToGetCodeSet(typeptr)
+ codeSet, err := encoder.CompileToGetCodeSet(ctx, typeptr)
if err != nil {
return nil, err
}
@@ -275,7 +278,7 @@ func encodeIndent(ctx *encoder.RuntimeContext, v interface{}, prefix, indent str
typ := header.typ
typeptr := uintptr(unsafe.Pointer(typ))
- codeSet, err := encoder.CompileToGetCodeSet(typeptr)
+ codeSet, err := encoder.CompileToGetCodeSet(ctx, typeptr)
if err != nil {
return nil, err
}
diff --git a/vendor/github.com/goccy/go-json/error.go b/vendor/github.com/goccy/go-json/error.go
index 94c1339a02..5b2dcee50e 100644
--- a/vendor/github.com/goccy/go-json/error.go
+++ b/vendor/github.com/goccy/go-json/error.go
@@ -37,3 +37,5 @@ type UnmarshalTypeError = errors.UnmarshalTypeError
type UnsupportedTypeError = errors.UnsupportedTypeError
type UnsupportedValueError = errors.UnsupportedValueError
+
+type PathError = errors.PathError
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go b/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go
index 030cb7a974..b6876cf0d0 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go
@@ -35,3 +35,7 @@ func (d *anonymousFieldDecoder) Decode(ctx *RuntimeContext, cursor, depth int64,
p = *(*unsafe.Pointer)(p)
return d.dec.Decode(ctx, cursor, depth, unsafe.Pointer(uintptr(p)+d.offset))
}
+
+func (d *anonymousFieldDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ return d.dec.DecodePath(ctx, cursor, depth)
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/array.go b/vendor/github.com/goccy/go-json/internal/decoder/array.go
index 21f1fd5852..4b23ed43fe 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/array.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/array.go
@@ -1,6 +1,7 @@
package decoder
import (
+ "fmt"
"unsafe"
"github.com/goccy/go-json/internal/errors"
@@ -18,7 +19,9 @@ type arrayDecoder struct {
}
func newArrayDecoder(dec Decoder, elemType *runtime.Type, alen int, structName, fieldName string) *arrayDecoder {
- zeroValue := *(*unsafe.Pointer)(unsafe_New(elemType))
+ // workaround to avoid checkptr errors. cannot use `*(*unsafe.Pointer)(unsafe_New(elemType))` directly.
+ zeroValuePtr := unsafe_New(elemType)
+ zeroValue := **(**unsafe.Pointer)(unsafe.Pointer(&zeroValuePtr))
return &arrayDecoder{
valueDecoder: dec,
elemType: elemType,
@@ -167,3 +170,7 @@ func (d *arrayDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe
}
}
}
+
+func (d *arrayDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ return nil, 0, fmt.Errorf("json: array decoder does not support decode path")
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/assign.go b/vendor/github.com/goccy/go-json/internal/decoder/assign.go
new file mode 100644
index 0000000000..c53e6ad9fc
--- /dev/null
+++ b/vendor/github.com/goccy/go-json/internal/decoder/assign.go
@@ -0,0 +1,438 @@
+package decoder
+
+import (
+ "fmt"
+ "reflect"
+ "strconv"
+)
+
+var (
+ nilValue = reflect.ValueOf(nil)
+)
+
+func AssignValue(src, dst reflect.Value) error {
+ if dst.Type().Kind() != reflect.Ptr {
+ return fmt.Errorf("invalid dst type. required pointer type: %T", dst.Type())
+ }
+ casted, err := castValue(dst.Elem().Type(), src)
+ if err != nil {
+ return err
+ }
+ dst.Elem().Set(casted)
+ return nil
+}
+
+func castValue(t reflect.Type, v reflect.Value) (reflect.Value, error) {
+ switch t.Kind() {
+ case reflect.Int:
+ vv, err := castInt(v)
+ if err != nil {
+ return nilValue, err
+ }
+ return reflect.ValueOf(int(vv.Int())), nil
+ case reflect.Int8:
+ vv, err := castInt(v)
+ if err != nil {
+ return nilValue, err
+ }
+ return reflect.ValueOf(int8(vv.Int())), nil
+ case reflect.Int16:
+ vv, err := castInt(v)
+ if err != nil {
+ return nilValue, err
+ }
+ return reflect.ValueOf(int16(vv.Int())), nil
+ case reflect.Int32:
+ vv, err := castInt(v)
+ if err != nil {
+ return nilValue, err
+ }
+ return reflect.ValueOf(int32(vv.Int())), nil
+ case reflect.Int64:
+ return castInt(v)
+ case reflect.Uint:
+ vv, err := castUint(v)
+ if err != nil {
+ return nilValue, err
+ }
+ return reflect.ValueOf(uint(vv.Uint())), nil
+ case reflect.Uint8:
+ vv, err := castUint(v)
+ if err != nil {
+ return nilValue, err
+ }
+ return reflect.ValueOf(uint8(vv.Uint())), nil
+ case reflect.Uint16:
+ vv, err := castUint(v)
+ if err != nil {
+ return nilValue, err
+ }
+ return reflect.ValueOf(uint16(vv.Uint())), nil
+ case reflect.Uint32:
+ vv, err := castUint(v)
+ if err != nil {
+ return nilValue, err
+ }
+ return reflect.ValueOf(uint32(vv.Uint())), nil
+ case reflect.Uint64:
+ return castUint(v)
+ case reflect.Uintptr:
+ vv, err := castUint(v)
+ if err != nil {
+ return nilValue, err
+ }
+ return reflect.ValueOf(uintptr(vv.Uint())), nil
+ case reflect.String:
+ return castString(v)
+ case reflect.Bool:
+ return castBool(v)
+ case reflect.Float32:
+ vv, err := castFloat(v)
+ if err != nil {
+ return nilValue, err
+ }
+ return reflect.ValueOf(float32(vv.Float())), nil
+ case reflect.Float64:
+ return castFloat(v)
+ case reflect.Array:
+ return castArray(t, v)
+ case reflect.Slice:
+ return castSlice(t, v)
+ case reflect.Map:
+ return castMap(t, v)
+ case reflect.Struct:
+ return castStruct(t, v)
+ }
+ return v, nil
+}
+
+func castInt(v reflect.Value) (reflect.Value, error) {
+ switch v.Type().Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return v, nil
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return reflect.ValueOf(int64(v.Uint())), nil
+ case reflect.String:
+ i64, err := strconv.ParseInt(v.String(), 10, 64)
+ if err != nil {
+ return nilValue, err
+ }
+ return reflect.ValueOf(i64), nil
+ case reflect.Bool:
+ if v.Bool() {
+ return reflect.ValueOf(int64(1)), nil
+ }
+ return reflect.ValueOf(int64(0)), nil
+ case reflect.Float32, reflect.Float64:
+ return reflect.ValueOf(int64(v.Float())), nil
+ case reflect.Array:
+ if v.Len() > 0 {
+ return castInt(v.Index(0))
+ }
+ return nilValue, fmt.Errorf("failed to cast to int64 from empty array")
+ case reflect.Slice:
+ if v.Len() > 0 {
+ return castInt(v.Index(0))
+ }
+ return nilValue, fmt.Errorf("failed to cast to int64 from empty slice")
+ case reflect.Interface:
+ return castInt(reflect.ValueOf(v.Interface()))
+ case reflect.Map:
+ return nilValue, fmt.Errorf("failed to cast to int64 from map")
+ case reflect.Struct:
+ return nilValue, fmt.Errorf("failed to cast to int64 from struct")
+ case reflect.Ptr:
+ return castInt(v.Elem())
+ }
+ return nilValue, fmt.Errorf("failed to cast to int64 from %s", v.Type().Kind())
+}
+
+func castUint(v reflect.Value) (reflect.Value, error) {
+ switch v.Type().Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return reflect.ValueOf(uint64(v.Int())), nil
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return v, nil
+ case reflect.String:
+ u64, err := strconv.ParseUint(v.String(), 10, 64)
+ if err != nil {
+ return nilValue, err
+ }
+ return reflect.ValueOf(u64), nil
+ case reflect.Bool:
+ if v.Bool() {
+ return reflect.ValueOf(uint64(1)), nil
+ }
+ return reflect.ValueOf(uint64(0)), nil
+ case reflect.Float32, reflect.Float64:
+ return reflect.ValueOf(uint64(v.Float())), nil
+ case reflect.Array:
+ if v.Len() > 0 {
+ return castUint(v.Index(0))
+ }
+ return nilValue, fmt.Errorf("failed to cast to uint64 from empty array")
+ case reflect.Slice:
+ if v.Len() > 0 {
+ return castUint(v.Index(0))
+ }
+ return nilValue, fmt.Errorf("failed to cast to uint64 from empty slice")
+ case reflect.Interface:
+ return castUint(reflect.ValueOf(v.Interface()))
+ case reflect.Map:
+ return nilValue, fmt.Errorf("failed to cast to uint64 from map")
+ case reflect.Struct:
+ return nilValue, fmt.Errorf("failed to cast to uint64 from struct")
+ case reflect.Ptr:
+ return castUint(v.Elem())
+ }
+ return nilValue, fmt.Errorf("failed to cast to uint64 from %s", v.Type().Kind())
+}
+
+func castString(v reflect.Value) (reflect.Value, error) {
+ switch v.Type().Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return reflect.ValueOf(fmt.Sprint(v.Int())), nil
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return reflect.ValueOf(fmt.Sprint(v.Uint())), nil
+ case reflect.String:
+ return v, nil
+ case reflect.Bool:
+ if v.Bool() {
+ return reflect.ValueOf("true"), nil
+ }
+ return reflect.ValueOf("false"), nil
+ case reflect.Float32, reflect.Float64:
+ return reflect.ValueOf(fmt.Sprint(v.Float())), nil
+ case reflect.Array:
+ if v.Len() > 0 {
+ return castString(v.Index(0))
+ }
+ return nilValue, fmt.Errorf("failed to cast to string from empty array")
+ case reflect.Slice:
+ if v.Len() > 0 {
+ return castString(v.Index(0))
+ }
+ return nilValue, fmt.Errorf("failed to cast to string from empty slice")
+ case reflect.Interface:
+ return castString(reflect.ValueOf(v.Interface()))
+ case reflect.Map:
+ return nilValue, fmt.Errorf("failed to cast to string from map")
+ case reflect.Struct:
+ return nilValue, fmt.Errorf("failed to cast to string from struct")
+ case reflect.Ptr:
+ return castString(v.Elem())
+ }
+ return nilValue, fmt.Errorf("failed to cast to string from %s", v.Type().Kind())
+}
+
+func castBool(v reflect.Value) (reflect.Value, error) {
+ switch v.Type().Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ switch v.Int() {
+ case 0:
+ return reflect.ValueOf(false), nil
+ case 1:
+ return reflect.ValueOf(true), nil
+ }
+ return nilValue, fmt.Errorf("failed to cast to bool from %d", v.Int())
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ switch v.Uint() {
+ case 0:
+ return reflect.ValueOf(false), nil
+ case 1:
+ return reflect.ValueOf(true), nil
+ }
+ return nilValue, fmt.Errorf("failed to cast to bool from %d", v.Uint())
+ case reflect.String:
+ b, err := strconv.ParseBool(v.String())
+ if err != nil {
+ return nilValue, err
+ }
+ return reflect.ValueOf(b), nil
+ case reflect.Bool:
+ return v, nil
+ case reflect.Float32, reflect.Float64:
+ switch v.Float() {
+ case 0:
+ return reflect.ValueOf(false), nil
+ case 1:
+ return reflect.ValueOf(true), nil
+ }
+ return nilValue, fmt.Errorf("failed to cast to bool from %f", v.Float())
+ case reflect.Array:
+ if v.Len() > 0 {
+ return castBool(v.Index(0))
+ }
+ return nilValue, fmt.Errorf("failed to cast to string from empty array")
+ case reflect.Slice:
+ if v.Len() > 0 {
+ return castBool(v.Index(0))
+ }
+ return nilValue, fmt.Errorf("failed to cast to string from empty slice")
+ case reflect.Interface:
+ return castBool(reflect.ValueOf(v.Interface()))
+ case reflect.Map:
+ return nilValue, fmt.Errorf("failed to cast to string from map")
+ case reflect.Struct:
+ return nilValue, fmt.Errorf("failed to cast to string from struct")
+ case reflect.Ptr:
+ return castBool(v.Elem())
+ }
+ return nilValue, fmt.Errorf("failed to cast to bool from %s", v.Type().Kind())
+}
+
+func castFloat(v reflect.Value) (reflect.Value, error) {
+ switch v.Type().Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return reflect.ValueOf(float64(v.Int())), nil
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return reflect.ValueOf(float64(v.Uint())), nil
+ case reflect.String:
+ f64, err := strconv.ParseFloat(v.String(), 64)
+ if err != nil {
+ return nilValue, err
+ }
+ return reflect.ValueOf(f64), nil
+ case reflect.Bool:
+ if v.Bool() {
+ return reflect.ValueOf(float64(1)), nil
+ }
+ return reflect.ValueOf(float64(0)), nil
+ case reflect.Float32, reflect.Float64:
+ return v, nil
+ case reflect.Array:
+ if v.Len() > 0 {
+ return castFloat(v.Index(0))
+ }
+ return nilValue, fmt.Errorf("failed to cast to float64 from empty array")
+ case reflect.Slice:
+ if v.Len() > 0 {
+ return castFloat(v.Index(0))
+ }
+ return nilValue, fmt.Errorf("failed to cast to float64 from empty slice")
+ case reflect.Interface:
+ return castFloat(reflect.ValueOf(v.Interface()))
+ case reflect.Map:
+ return nilValue, fmt.Errorf("failed to cast to float64 from map")
+ case reflect.Struct:
+ return nilValue, fmt.Errorf("failed to cast to float64 from struct")
+ case reflect.Ptr:
+ return castFloat(v.Elem())
+ }
+ return nilValue, fmt.Errorf("failed to cast to float64 from %s", v.Type().Kind())
+}
+
+func castArray(t reflect.Type, v reflect.Value) (reflect.Value, error) {
+ kind := v.Type().Kind()
+ if kind == reflect.Interface {
+ return castArray(t, reflect.ValueOf(v.Interface()))
+ }
+ if kind != reflect.Slice && kind != reflect.Array {
+ return nilValue, fmt.Errorf("failed to cast to array from %s", kind)
+ }
+ if t.Elem() == v.Type().Elem() {
+ return v, nil
+ }
+ if t.Len() != v.Len() {
+ return nilValue, fmt.Errorf("failed to cast [%d]array from slice of %d length", t.Len(), v.Len())
+ }
+ ret := reflect.New(t).Elem()
+ for i := 0; i < v.Len(); i++ {
+ vv, err := castValue(t.Elem(), v.Index(i))
+ if err != nil {
+ return nilValue, err
+ }
+ ret.Index(i).Set(vv)
+ }
+ return ret, nil
+}
+
+func castSlice(t reflect.Type, v reflect.Value) (reflect.Value, error) {
+ kind := v.Type().Kind()
+ if kind == reflect.Interface {
+ return castSlice(t, reflect.ValueOf(v.Interface()))
+ }
+ if kind != reflect.Slice && kind != reflect.Array {
+ return nilValue, fmt.Errorf("failed to cast to slice from %s", kind)
+ }
+ if t.Elem() == v.Type().Elem() {
+ return v, nil
+ }
+ ret := reflect.MakeSlice(t, v.Len(), v.Len())
+ for i := 0; i < v.Len(); i++ {
+ vv, err := castValue(t.Elem(), v.Index(i))
+ if err != nil {
+ return nilValue, err
+ }
+ ret.Index(i).Set(vv)
+ }
+ return ret, nil
+}
+
+func castMap(t reflect.Type, v reflect.Value) (reflect.Value, error) {
+ ret := reflect.MakeMap(t)
+ switch v.Type().Kind() {
+ case reflect.Map:
+ iter := v.MapRange()
+ for iter.Next() {
+ key, err := castValue(t.Key(), iter.Key())
+ if err != nil {
+ return nilValue, err
+ }
+ value, err := castValue(t.Elem(), iter.Value())
+ if err != nil {
+ return nilValue, err
+ }
+ ret.SetMapIndex(key, value)
+ }
+ return ret, nil
+ case reflect.Interface:
+ return castMap(t, reflect.ValueOf(v.Interface()))
+ case reflect.Slice:
+ if v.Len() > 0 {
+ return castMap(t, v.Index(0))
+ }
+ return nilValue, fmt.Errorf("failed to cast to map from empty slice")
+ }
+ return nilValue, fmt.Errorf("failed to cast to map from %s", v.Type().Kind())
+}
+
+func castStruct(t reflect.Type, v reflect.Value) (reflect.Value, error) {
+ ret := reflect.New(t).Elem()
+ switch v.Type().Kind() {
+ case reflect.Map:
+ iter := v.MapRange()
+ for iter.Next() {
+ key := iter.Key()
+ k, err := castString(key)
+ if err != nil {
+ return nilValue, err
+ }
+ fieldName := k.String()
+ field, ok := t.FieldByName(fieldName)
+ if ok {
+ value, err := castValue(field.Type, iter.Value())
+ if err != nil {
+ return nilValue, err
+ }
+ ret.FieldByName(fieldName).Set(value)
+ }
+ }
+ return ret, nil
+ case reflect.Struct:
+ for i := 0; i < v.Type().NumField(); i++ {
+ name := v.Type().Field(i).Name
+ ret.FieldByName(name).Set(v.FieldByName(name))
+ }
+ return ret, nil
+ case reflect.Interface:
+ return castStruct(t, reflect.ValueOf(v.Interface()))
+ case reflect.Slice:
+ if v.Len() > 0 {
+ return castStruct(t, v.Index(0))
+ }
+ return nilValue, fmt.Errorf("failed to cast to struct from empty slice")
+ default:
+ return nilValue, fmt.Errorf("failed to cast to struct from %s", v.Type().Kind())
+ }
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/bool.go b/vendor/github.com/goccy/go-json/internal/decoder/bool.go
index 455042a534..ba6cf5bc49 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/bool.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/bool.go
@@ -1,6 +1,7 @@
package decoder
import (
+ "fmt"
"unsafe"
"github.com/goccy/go-json/internal/errors"
@@ -76,3 +77,7 @@ func (d *boolDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.
}
return 0, errors.ErrUnexpectedEndOfJSON("bool", cursor)
}
+
+func (d *boolDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ return nil, 0, fmt.Errorf("json: bool decoder does not support decode path")
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/bytes.go b/vendor/github.com/goccy/go-json/internal/decoder/bytes.go
index 01a37fef4f..939bf43274 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/bytes.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/bytes.go
@@ -2,6 +2,7 @@ package decoder
import (
"encoding/base64"
+ "fmt"
"unsafe"
"github.com/goccy/go-json/internal/errors"
@@ -23,9 +24,8 @@ func byteUnmarshalerSliceDecoder(typ *runtime.Type, structName string, fieldName
unmarshalDecoder = newUnmarshalJSONDecoder(runtime.PtrTo(typ), structName, fieldName)
case runtime.PtrTo(typ).Implements(unmarshalTextType):
unmarshalDecoder = newUnmarshalTextDecoder(runtime.PtrTo(typ), structName, fieldName)
- }
- if unmarshalDecoder == nil {
- return nil
+ default:
+ unmarshalDecoder, _ = compileUint8(typ, structName, fieldName)
}
return newSliceDecoder(unmarshalDecoder, typ, 1, structName, fieldName)
}
@@ -79,6 +79,10 @@ func (d *bytesDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe
return cursor, nil
}
+func (d *bytesDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ return nil, 0, fmt.Errorf("json: []byte decoder does not support decode path")
+}
+
func (d *bytesDecoder) decodeStreamBinary(s *Stream, depth int64, p unsafe.Pointer) ([]byte, error) {
c := s.skipWhiteSpace()
if c == '[' {
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/compile.go b/vendor/github.com/goccy/go-json/internal/decoder/compile.go
index 08dd044e6a..fab6437647 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/compile.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/compile.go
@@ -9,7 +9,6 @@ import (
"unicode"
"unsafe"
- "github.com/goccy/go-json/internal/errors"
"github.com/goccy/go-json/internal/runtime"
)
@@ -25,7 +24,7 @@ func init() {
if typeAddr == nil {
typeAddr = &runtime.TypeAddr{}
}
- cachedDecoder = make([]Decoder, typeAddr.AddrRange>>typeAddr.AddrShift)
+ cachedDecoder = make([]Decoder, typeAddr.AddrRange>>typeAddr.AddrShift+1)
}
func loadDecoderMap() map[uintptr]Decoder {
@@ -126,13 +125,7 @@ func compile(typ *runtime.Type, structName, fieldName string, structTypeToDecode
case reflect.Func:
return compileFunc(typ, structName, fieldName)
}
- return nil, &errors.UnmarshalTypeError{
- Value: "object",
- Type: runtime.RType2Type(typ),
- Offset: 0,
- Struct: structName,
- Field: fieldName,
- }
+ return newInvalidDecoder(typ, structName, fieldName), nil
}
func isStringTagSupportedType(typ *runtime.Type) bool {
@@ -161,6 +154,9 @@ func compileMapKey(typ *runtime.Type, structName, fieldName string, structTypeTo
if runtime.PtrTo(typ).Implements(unmarshalTextType) {
return newUnmarshalTextDecoder(runtime.PtrTo(typ), structName, fieldName), nil
}
+ if typ.Kind() == reflect.String {
+ return newStringDecoder(structName, fieldName), nil
+ }
dec, err := compile(typ, structName, fieldName, structTypeToDecoder)
if err != nil {
return nil, err
@@ -174,17 +170,9 @@ func compileMapKey(typ *runtime.Type, structName, fieldName string, structTypeTo
case *ptrDecoder:
dec = t.dec
default:
- goto ERROR
+ return newInvalidDecoder(typ, structName, fieldName), nil
}
}
-ERROR:
- return nil, &errors.UnmarshalTypeError{
- Value: "object",
- Type: runtime.RType2Type(typ),
- Offset: 0,
- Struct: structName,
- Field: fieldName,
- }
}
func compilePtr(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
@@ -322,64 +310,21 @@ func compileFunc(typ *runtime.Type, strutName, fieldName string) (Decoder, error
return newFuncDecoder(typ, strutName, fieldName), nil
}
-func removeConflictFields(fieldMap map[string]*structFieldSet, conflictedMap map[string]struct{}, dec *structDecoder, field reflect.StructField) {
- for k, v := range dec.fieldMap {
- if _, exists := conflictedMap[k]; exists {
- // already conflicted key
- continue
- }
- set, exists := fieldMap[k]
- if !exists {
- fieldSet := &structFieldSet{
- dec: v.dec,
- offset: field.Offset + v.offset,
- isTaggedKey: v.isTaggedKey,
- key: k,
- keyLen: int64(len(k)),
- }
- fieldMap[k] = fieldSet
- lower := strings.ToLower(k)
- if _, exists := fieldMap[lower]; !exists {
- fieldMap[lower] = fieldSet
- }
+func typeToStructTags(typ *runtime.Type) runtime.StructTags {
+ tags := runtime.StructTags{}
+ fieldNum := typ.NumField()
+ for i := 0; i < fieldNum; i++ {
+ field := typ.Field(i)
+ if runtime.IsIgnoredStructField(field) {
continue
}
- if set.isTaggedKey {
- if v.isTaggedKey {
- // conflict tag key
- delete(fieldMap, k)
- delete(fieldMap, strings.ToLower(k))
- conflictedMap[k] = struct{}{}
- conflictedMap[strings.ToLower(k)] = struct{}{}
- }
- } else {
- if v.isTaggedKey {
- fieldSet := &structFieldSet{
- dec: v.dec,
- offset: field.Offset + v.offset,
- isTaggedKey: v.isTaggedKey,
- key: k,
- keyLen: int64(len(k)),
- }
- fieldMap[k] = fieldSet
- lower := strings.ToLower(k)
- if _, exists := fieldMap[lower]; !exists {
- fieldMap[lower] = fieldSet
- }
- } else {
- // conflict tag key
- delete(fieldMap, k)
- delete(fieldMap, strings.ToLower(k))
- conflictedMap[k] = struct{}{}
- conflictedMap[strings.ToLower(k)] = struct{}{}
- }
- }
+ tags = append(tags, runtime.StructTagFromField(field))
}
+ return tags
}
func compileStruct(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
fieldNum := typ.NumField()
- conflictedMap := map[string]struct{}{}
fieldMap := map[string]*structFieldSet{}
typeptr := uintptr(unsafe.Pointer(typ))
if dec, exists := structTypeToDecoder[typeptr]; exists {
@@ -388,6 +333,8 @@ func compileStruct(typ *runtime.Type, structName, fieldName string, structTypeTo
structDec := newStructDecoder(structName, fieldName, fieldMap)
structTypeToDecoder[typeptr] = structDec
structName = typ.Name()
+ tags := typeToStructTags(typ)
+ allFields := []*structFieldSet{}
for i := 0; i < fieldNum; i++ {
field := typ.Field(i)
if runtime.IsIgnoredStructField(field) {
@@ -405,7 +352,19 @@ func compileStruct(typ *runtime.Type, structName, fieldName string, structTypeTo
// recursive definition
continue
}
- removeConflictFields(fieldMap, conflictedMap, stDec, field)
+ for k, v := range stDec.fieldMap {
+ if tags.ExistsKey(k) {
+ continue
+ }
+ fieldSet := &structFieldSet{
+ dec: v.dec,
+ offset: field.Offset + v.offset,
+ isTaggedKey: v.isTaggedKey,
+ key: k,
+ keyLen: int64(len(k)),
+ }
+ allFields = append(allFields, fieldSet)
+ }
} else if pdec, ok := dec.(*ptrDecoder); ok {
contentDec := pdec.contentDecoder()
if pdec.typ == typ {
@@ -421,60 +380,38 @@ func compileStruct(typ *runtime.Type, structName, fieldName string, structTypeTo
}
if dec, ok := contentDec.(*structDecoder); ok {
for k, v := range dec.fieldMap {
- if _, exists := conflictedMap[k]; exists {
- // already conflicted key
+ if tags.ExistsKey(k) {
continue
}
- set, exists := fieldMap[k]
- if !exists {
- fieldSet := &structFieldSet{
- dec: newAnonymousFieldDecoder(pdec.typ, v.offset, v.dec),
- offset: field.Offset,
- isTaggedKey: v.isTaggedKey,
- key: k,
- keyLen: int64(len(k)),
- err: fieldSetErr,
- }
- fieldMap[k] = fieldSet
- lower := strings.ToLower(k)
- if _, exists := fieldMap[lower]; !exists {
- fieldMap[lower] = fieldSet
- }
- continue
- }
- if set.isTaggedKey {
- if v.isTaggedKey {
- // conflict tag key
- delete(fieldMap, k)
- delete(fieldMap, strings.ToLower(k))
- conflictedMap[k] = struct{}{}
- conflictedMap[strings.ToLower(k)] = struct{}{}
- }
- } else {
- if v.isTaggedKey {
- fieldSet := &structFieldSet{
- dec: newAnonymousFieldDecoder(pdec.typ, v.offset, v.dec),
- offset: field.Offset,
- isTaggedKey: v.isTaggedKey,
- key: k,
- keyLen: int64(len(k)),
- err: fieldSetErr,
- }
- fieldMap[k] = fieldSet
- lower := strings.ToLower(k)
- if _, exists := fieldMap[lower]; !exists {
- fieldMap[lower] = fieldSet
- }
- } else {
- // conflict tag key
- delete(fieldMap, k)
- delete(fieldMap, strings.ToLower(k))
- conflictedMap[k] = struct{}{}
- conflictedMap[strings.ToLower(k)] = struct{}{}
- }
+ fieldSet := &structFieldSet{
+ dec: newAnonymousFieldDecoder(pdec.typ, v.offset, v.dec),
+ offset: field.Offset,
+ isTaggedKey: v.isTaggedKey,
+ key: k,
+ keyLen: int64(len(k)),
+ err: fieldSetErr,
}
+ allFields = append(allFields, fieldSet)
+ }
+ } else {
+ fieldSet := &structFieldSet{
+ dec: pdec,
+ offset: field.Offset,
+ isTaggedKey: tag.IsTaggedKey,
+ key: field.Name,
+ keyLen: int64(len(field.Name)),
}
+ allFields = append(allFields, fieldSet)
+ }
+ } else {
+ fieldSet := &structFieldSet{
+ dec: dec,
+ offset: field.Offset,
+ isTaggedKey: tag.IsTaggedKey,
+ key: field.Name,
+ keyLen: int64(len(field.Name)),
}
+ allFields = append(allFields, fieldSet)
}
} else {
if tag.IsString && isStringTagSupportedType(runtime.Type2RType(field.Type)) {
@@ -493,11 +430,15 @@ func compileStruct(typ *runtime.Type, structName, fieldName string, structTypeTo
key: key,
keyLen: int64(len(key)),
}
- fieldMap[key] = fieldSet
- lower := strings.ToLower(key)
- if _, exists := fieldMap[lower]; !exists {
- fieldMap[lower] = fieldSet
- }
+ allFields = append(allFields, fieldSet)
+ }
+ }
+ for _, set := range filterDuplicatedFields(allFields) {
+ fieldMap[set.key] = set
+ lower := strings.ToLower(set.key)
+ if _, exists := fieldMap[lower]; !exists {
+ // first win
+ fieldMap[lower] = set
}
}
delete(structTypeToDecoder, typeptr)
@@ -505,6 +446,42 @@ func compileStruct(typ *runtime.Type, structName, fieldName string, structTypeTo
return structDec, nil
}
+func filterDuplicatedFields(allFields []*structFieldSet) []*structFieldSet {
+ fieldMap := map[string][]*structFieldSet{}
+ for _, field := range allFields {
+ fieldMap[field.key] = append(fieldMap[field.key], field)
+ }
+ duplicatedFieldMap := map[string]struct{}{}
+ for k, sets := range fieldMap {
+ sets = filterFieldSets(sets)
+ if len(sets) != 1 {
+ duplicatedFieldMap[k] = struct{}{}
+ }
+ }
+
+ filtered := make([]*structFieldSet, 0, len(allFields))
+ for _, field := range allFields {
+ if _, exists := duplicatedFieldMap[field.key]; exists {
+ continue
+ }
+ filtered = append(filtered, field)
+ }
+ return filtered
+}
+
+func filterFieldSets(sets []*structFieldSet) []*structFieldSet {
+ if len(sets) == 1 {
+ return sets
+ }
+ filtered := make([]*structFieldSet, 0, len(sets))
+ for _, set := range sets {
+ if set.isTaggedKey {
+ filtered = append(filtered, set)
+ }
+ }
+ return filtered
+}
+
func implementsUnmarshalJSONType(typ *runtime.Type) bool {
return typ.Implements(unmarshalJSONType) || typ.Implements(unmarshalJSONContextType)
}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/compile_norace.go b/vendor/github.com/goccy/go-json/internal/decoder/compile_norace.go
index 592f63737d..eb7e2b1345 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/compile_norace.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/compile_norace.go
@@ -1,3 +1,4 @@
+//go:build !race
// +build !race
package decoder
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/compile_race.go b/vendor/github.com/goccy/go-json/internal/decoder/compile_race.go
index b691bc947b..49cdda4a17 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/compile_race.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/compile_race.go
@@ -1,3 +1,4 @@
+//go:build race
// +build race
package decoder
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/float.go b/vendor/github.com/goccy/go-json/internal/decoder/float.go
index dfb7168da5..9b2eb8b35a 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/float.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/float.go
@@ -156,3 +156,15 @@ func (d *floatDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe
d.op(p, f64)
return cursor, nil
}
+
+func (d *floatDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ buf := ctx.Buf
+ bytes, c, err := d.decodeByte(buf, cursor)
+ if err != nil {
+ return nil, 0, err
+ }
+ if bytes == nil {
+ return [][]byte{nullbytes}, c, nil
+ }
+ return [][]byte{bytes}, c, nil
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/func.go b/vendor/github.com/goccy/go-json/internal/decoder/func.go
index ee35637115..4cc12ca81f 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/func.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/func.go
@@ -2,6 +2,7 @@ package decoder
import (
"bytes"
+ "fmt"
"unsafe"
"github.com/goccy/go-json/internal/errors"
@@ -139,3 +140,7 @@ func (d *funcDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.
}
return cursor, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor)
}
+
+func (d *funcDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ return nil, 0, fmt.Errorf("json: func decoder does not support decode path")
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/int.go b/vendor/github.com/goccy/go-json/internal/decoder/int.go
index 7edfb04117..1a7f081994 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/int.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/int.go
@@ -192,15 +192,15 @@ func (d *intDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) erro
}
switch d.kind {
case reflect.Int8:
- if i64 <= -1*(1<<7) || (1<<7) <= i64 {
+ if i64 < -1*(1<<7) || (1<<7) <= i64 {
return d.typeError(bytes, s.totalOffset())
}
case reflect.Int16:
- if i64 <= -1*(1<<15) || (1<<15) <= i64 {
+ if i64 < -1*(1<<15) || (1<<15) <= i64 {
return d.typeError(bytes, s.totalOffset())
}
case reflect.Int32:
- if i64 <= -1*(1<<31) || (1<<31) <= i64 {
+ if i64 < -1*(1<<31) || (1<<31) <= i64 {
return d.typeError(bytes, s.totalOffset())
}
}
@@ -225,18 +225,22 @@ func (d *intDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.P
}
switch d.kind {
case reflect.Int8:
- if i64 <= -1*(1<<7) || (1<<7) <= i64 {
+ if i64 < -1*(1<<7) || (1<<7) <= i64 {
return 0, d.typeError(bytes, cursor)
}
case reflect.Int16:
- if i64 <= -1*(1<<15) || (1<<15) <= i64 {
+ if i64 < -1*(1<<15) || (1<<15) <= i64 {
return 0, d.typeError(bytes, cursor)
}
case reflect.Int32:
- if i64 <= -1*(1<<31) || (1<<31) <= i64 {
+ if i64 < -1*(1<<31) || (1<<31) <= i64 {
return 0, d.typeError(bytes, cursor)
}
}
d.op(p, i64)
return cursor, nil
}
+
+func (d *intDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ return nil, 0, fmt.Errorf("json: int decoder does not support decode path")
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/interface.go b/vendor/github.com/goccy/go-json/internal/decoder/interface.go
index 4dbb4be4ac..45c69ab8c7 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/interface.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/interface.go
@@ -94,6 +94,7 @@ func (d *interfaceDecoder) numDecoder(s *Stream) Decoder {
var (
emptyInterfaceType = runtime.Type2RType(reflect.TypeOf((*interface{})(nil)).Elem())
+ EmptyInterfaceType = emptyInterfaceType
interfaceMapType = runtime.Type2RType(
reflect.TypeOf((*map[string]interface{})(nil)).Elem(),
)
@@ -456,3 +457,72 @@ func (d *interfaceDecoder) decodeEmptyInterface(ctx *RuntimeContext, cursor, dep
}
return cursor, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor)
}
+
+func NewPathDecoder() Decoder {
+ ifaceDecoder := &interfaceDecoder{
+ typ: emptyInterfaceType,
+ structName: "",
+ fieldName: "",
+ floatDecoder: newFloatDecoder("", "", func(p unsafe.Pointer, v float64) {
+ *(*interface{})(p) = v
+ }),
+ numberDecoder: newNumberDecoder("", "", func(p unsafe.Pointer, v json.Number) {
+ *(*interface{})(p) = v
+ }),
+ stringDecoder: newStringDecoder("", ""),
+ }
+ ifaceDecoder.sliceDecoder = newSliceDecoder(
+ ifaceDecoder,
+ emptyInterfaceType,
+ emptyInterfaceType.Size(),
+ "", "",
+ )
+ ifaceDecoder.mapDecoder = newMapDecoder(
+ interfaceMapType,
+ stringType,
+ ifaceDecoder.stringDecoder,
+ interfaceMapType.Elem(),
+ ifaceDecoder,
+ "", "",
+ )
+ return ifaceDecoder
+}
+
+var (
+ truebytes = []byte("true")
+ falsebytes = []byte("false")
+)
+
+func (d *interfaceDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ buf := ctx.Buf
+ cursor = skipWhiteSpace(buf, cursor)
+ switch buf[cursor] {
+ case '{':
+ return d.mapDecoder.DecodePath(ctx, cursor, depth)
+ case '[':
+ return d.sliceDecoder.DecodePath(ctx, cursor, depth)
+ case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+ return d.floatDecoder.DecodePath(ctx, cursor, depth)
+ case '"':
+ return d.stringDecoder.DecodePath(ctx, cursor, depth)
+ case 't':
+ if err := validateTrue(buf, cursor); err != nil {
+ return nil, 0, err
+ }
+ cursor += 4
+ return [][]byte{truebytes}, cursor, nil
+ case 'f':
+ if err := validateFalse(buf, cursor); err != nil {
+ return nil, 0, err
+ }
+ cursor += 5
+ return [][]byte{falsebytes}, cursor, nil
+ case 'n':
+ if err := validateNull(buf, cursor); err != nil {
+ return nil, 0, err
+ }
+ cursor += 4
+ return [][]byte{nullbytes}, cursor, nil
+ }
+ return nil, cursor, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor)
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/invalid.go b/vendor/github.com/goccy/go-json/internal/decoder/invalid.go
new file mode 100644
index 0000000000..4c9721b098
--- /dev/null
+++ b/vendor/github.com/goccy/go-json/internal/decoder/invalid.go
@@ -0,0 +1,55 @@
+package decoder
+
+import (
+ "reflect"
+ "unsafe"
+
+ "github.com/goccy/go-json/internal/errors"
+ "github.com/goccy/go-json/internal/runtime"
+)
+
+type invalidDecoder struct {
+ typ *runtime.Type
+ kind reflect.Kind
+ structName string
+ fieldName string
+}
+
+func newInvalidDecoder(typ *runtime.Type, structName, fieldName string) *invalidDecoder {
+ return &invalidDecoder{
+ typ: typ,
+ kind: typ.Kind(),
+ structName: structName,
+ fieldName: fieldName,
+ }
+}
+
+func (d *invalidDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
+ return &errors.UnmarshalTypeError{
+ Value: "object",
+ Type: runtime.RType2Type(d.typ),
+ Offset: s.totalOffset(),
+ Struct: d.structName,
+ Field: d.fieldName,
+ }
+}
+
+func (d *invalidDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
+ return 0, &errors.UnmarshalTypeError{
+ Value: "object",
+ Type: runtime.RType2Type(d.typ),
+ Offset: cursor,
+ Struct: d.structName,
+ Field: d.fieldName,
+ }
+}
+
+func (d *invalidDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ return nil, 0, &errors.UnmarshalTypeError{
+ Value: "object",
+ Type: runtime.RType2Type(d.typ),
+ Offset: cursor,
+ Struct: d.structName,
+ Field: d.fieldName,
+ }
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/map.go b/vendor/github.com/goccy/go-json/internal/decoder/map.go
index bb18ef995d..07a9caea65 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/map.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/map.go
@@ -87,13 +87,13 @@ func (d *mapDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) erro
if mapValue == nil {
mapValue = makemap(d.mapType, 0)
}
- if s.buf[s.cursor+1] == '}' {
+ s.cursor++
+ if s.skipWhiteSpace() == '}' {
*(*unsafe.Pointer)(p) = mapValue
- s.cursor += 2
+ s.cursor++
return nil
}
for {
- s.cursor++
k := unsafe_New(d.keyType)
if err := d.keyDecoder.DecodeStream(s, depth, k); err != nil {
return err
@@ -117,6 +117,7 @@ func (d *mapDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) erro
if !s.equalChar(',') {
return errors.ErrExpected("comma after object value", s.totalOffset())
}
+ s.cursor++
}
}
@@ -184,3 +185,96 @@ func (d *mapDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.P
cursor++
}
}
+
+func (d *mapDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ buf := ctx.Buf
+ depth++
+ if depth > maxDecodeNestingDepth {
+ return nil, 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
+ }
+
+ cursor = skipWhiteSpace(buf, cursor)
+ buflen := int64(len(buf))
+ if buflen < 2 {
+ return nil, 0, errors.ErrExpected("{} for map", cursor)
+ }
+ switch buf[cursor] {
+ case 'n':
+ if err := validateNull(buf, cursor); err != nil {
+ return nil, 0, err
+ }
+ cursor += 4
+ return [][]byte{nullbytes}, cursor, nil
+ case '{':
+ default:
+ return nil, 0, errors.ErrExpected("{ character for map value", cursor)
+ }
+ cursor++
+ cursor = skipWhiteSpace(buf, cursor)
+ if buf[cursor] == '}' {
+ cursor++
+ return nil, cursor, nil
+ }
+ keyDecoder, ok := d.keyDecoder.(*stringDecoder)
+ if !ok {
+ return nil, 0, &errors.UnmarshalTypeError{
+ Value: "string",
+ Type: reflect.TypeOf(""),
+ Offset: cursor,
+ Struct: d.structName,
+ Field: d.fieldName,
+ }
+ }
+ ret := [][]byte{}
+ for {
+ key, keyCursor, err := keyDecoder.decodeByte(buf, cursor)
+ if err != nil {
+ return nil, 0, err
+ }
+ cursor = skipWhiteSpace(buf, keyCursor)
+ if buf[cursor] != ':' {
+ return nil, 0, errors.ErrExpected("colon after object key", cursor)
+ }
+ cursor++
+ child, found, err := ctx.Option.Path.Field(string(key))
+ if err != nil {
+ return nil, 0, err
+ }
+ if found {
+ if child != nil {
+ oldPath := ctx.Option.Path.node
+ ctx.Option.Path.node = child
+ paths, c, err := d.valueDecoder.DecodePath(ctx, cursor, depth)
+ if err != nil {
+ return nil, 0, err
+ }
+ ctx.Option.Path.node = oldPath
+ ret = append(ret, paths...)
+ cursor = c
+ } else {
+ start := cursor
+ end, err := skipValue(buf, cursor, depth)
+ if err != nil {
+ return nil, 0, err
+ }
+ ret = append(ret, buf[start:end])
+ cursor = end
+ }
+ } else {
+ c, err := skipValue(buf, cursor, depth)
+ if err != nil {
+ return nil, 0, err
+ }
+ cursor = c
+ }
+ cursor = skipWhiteSpace(buf, cursor)
+ if buf[cursor] == '}' {
+ cursor++
+ return ret, cursor, nil
+ }
+ if buf[cursor] != ',' {
+ return nil, 0, errors.ErrExpected("comma after object value", cursor)
+ }
+ cursor++
+ }
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/number.go b/vendor/github.com/goccy/go-json/internal/decoder/number.go
index bf63773e30..10e5435e6c 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/number.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/number.go
@@ -51,6 +51,17 @@ func (d *numberDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsaf
return cursor, nil
}
+func (d *numberDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ bytes, c, err := d.decodeByte(ctx.Buf, cursor)
+ if err != nil {
+ return nil, 0, err
+ }
+ if bytes == nil {
+ return [][]byte{nullbytes}, c, nil
+ }
+ return [][]byte{bytes}, c, nil
+}
+
func (d *numberDecoder) decodeStreamByte(s *Stream) ([]byte, error) {
start := s.cursor
for {
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/option.go b/vendor/github.com/goccy/go-json/internal/decoder/option.go
index e41f876b03..502f772eba 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/option.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/option.go
@@ -7,9 +7,11 @@ type OptionFlags uint8
const (
FirstWinOption OptionFlags = 1 << iota
ContextOption
+ PathOption
)
type Option struct {
Flags OptionFlags
Context context.Context
+ Path *Path
}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/path.go b/vendor/github.com/goccy/go-json/internal/decoder/path.go
new file mode 100644
index 0000000000..a15ff69e3c
--- /dev/null
+++ b/vendor/github.com/goccy/go-json/internal/decoder/path.go
@@ -0,0 +1,670 @@
+package decoder
+
+import (
+ "fmt"
+ "reflect"
+ "strconv"
+
+ "github.com/goccy/go-json/internal/errors"
+ "github.com/goccy/go-json/internal/runtime"
+)
+
+type PathString string
+
+func (s PathString) Build() (*Path, error) {
+ builder := new(PathBuilder)
+ return builder.Build([]rune(s))
+}
+
+type PathBuilder struct {
+ root PathNode
+ node PathNode
+ singleQuotePathSelector bool
+ doubleQuotePathSelector bool
+}
+
+func (b *PathBuilder) Build(buf []rune) (*Path, error) {
+ node, err := b.build(buf)
+ if err != nil {
+ return nil, err
+ }
+ return &Path{
+ node: node,
+ RootSelectorOnly: node == nil,
+ SingleQuotePathSelector: b.singleQuotePathSelector,
+ DoubleQuotePathSelector: b.doubleQuotePathSelector,
+ }, nil
+}
+
+func (b *PathBuilder) build(buf []rune) (PathNode, error) {
+ if len(buf) == 0 {
+ return nil, errors.ErrEmptyPath()
+ }
+ if buf[0] != '$' {
+ return nil, errors.ErrInvalidPath("JSON Path must start with a $ character")
+ }
+ if len(buf) == 1 {
+ return nil, nil
+ }
+ buf = buf[1:]
+ offset, err := b.buildNext(buf)
+ if err != nil {
+ return nil, err
+ }
+ if len(buf) > offset {
+ return nil, errors.ErrInvalidPath("remain invalid path %q", buf[offset:])
+ }
+ return b.root, nil
+}
+
+func (b *PathBuilder) buildNextCharIfExists(buf []rune, cursor int) (int, error) {
+ if len(buf) > cursor {
+ offset, err := b.buildNext(buf[cursor:])
+ if err != nil {
+ return 0, err
+ }
+ return cursor + 1 + offset, nil
+ }
+ return cursor, nil
+}
+
+func (b *PathBuilder) buildNext(buf []rune) (int, error) {
+ switch buf[0] {
+ case '.':
+ if len(buf) == 1 {
+ return 0, errors.ErrInvalidPath("JSON Path ends with dot character")
+ }
+ offset, err := b.buildSelector(buf[1:])
+ if err != nil {
+ return 0, err
+ }
+ return offset + 1, nil
+ case '[':
+ if len(buf) == 1 {
+ return 0, errors.ErrInvalidPath("JSON Path ends with left bracket character")
+ }
+ offset, err := b.buildIndex(buf[1:])
+ if err != nil {
+ return 0, err
+ }
+ return offset + 1, nil
+ default:
+ return 0, errors.ErrInvalidPath("expect dot or left bracket character. but found %c character", buf[0])
+ }
+}
+
+func (b *PathBuilder) buildSelector(buf []rune) (int, error) {
+ switch buf[0] {
+ case '.':
+ if len(buf) == 1 {
+ return 0, errors.ErrInvalidPath("JSON Path ends with double dot character")
+ }
+ offset, err := b.buildPathRecursive(buf[1:])
+ if err != nil {
+ return 0, err
+ }
+ return 1 + offset, nil
+ case '[', ']', '$', '*':
+ return 0, errors.ErrInvalidPath("found invalid path character %c after dot", buf[0])
+ }
+ for cursor := 0; cursor < len(buf); cursor++ {
+ switch buf[cursor] {
+ case '$', '*', ']':
+ return 0, errors.ErrInvalidPath("found %c character in field selector context", buf[cursor])
+ case '.':
+ if cursor+1 >= len(buf) {
+ return 0, errors.ErrInvalidPath("JSON Path ends with dot character")
+ }
+ selector := buf[:cursor]
+ b.addSelectorNode(string(selector))
+ offset, err := b.buildSelector(buf[cursor+1:])
+ if err != nil {
+ return 0, err
+ }
+ return cursor + 1 + offset, nil
+ case '[':
+ if cursor+1 >= len(buf) {
+ return 0, errors.ErrInvalidPath("JSON Path ends with left bracket character")
+ }
+ selector := buf[:cursor]
+ b.addSelectorNode(string(selector))
+ offset, err := b.buildIndex(buf[cursor+1:])
+ if err != nil {
+ return 0, err
+ }
+ return cursor + 1 + offset, nil
+ case '"':
+ if cursor+1 >= len(buf) {
+ return 0, errors.ErrInvalidPath("JSON Path ends with double quote character")
+ }
+ offset, err := b.buildQuoteSelector(buf[cursor+1:], DoubleQuotePathSelector)
+ if err != nil {
+ return 0, err
+ }
+ return cursor + 1 + offset, nil
+ }
+ }
+ b.addSelectorNode(string(buf))
+ return len(buf), nil
+}
+
+func (b *PathBuilder) buildQuoteSelector(buf []rune, sel QuotePathSelector) (int, error) {
+ switch buf[0] {
+ case '[', ']', '$', '.', '*', '\'', '"':
+ return 0, errors.ErrInvalidPath("found invalid path character %c after quote", buf[0])
+ }
+ for cursor := 0; cursor < len(buf); cursor++ {
+ switch buf[cursor] {
+ case '\'':
+ if sel != SingleQuotePathSelector {
+ return 0, errors.ErrInvalidPath("found double quote character in field selector with single quote context")
+ }
+ if len(buf) <= cursor+1 {
+ return 0, errors.ErrInvalidPath("JSON Path ends with single quote character in field selector context")
+ }
+ if buf[cursor+1] != ']' {
+ return 0, errors.ErrInvalidPath("expect right bracket for field selector with single quote but found %c", buf[cursor+1])
+ }
+ selector := buf[:cursor]
+ b.addSelectorNode(string(selector))
+ b.singleQuotePathSelector = true
+ return b.buildNextCharIfExists(buf, cursor+2)
+ case '"':
+ if sel != DoubleQuotePathSelector {
+ return 0, errors.ErrInvalidPath("found single quote character in field selector with double quote context")
+ }
+ selector := buf[:cursor]
+ b.addSelectorNode(string(selector))
+ b.doubleQuotePathSelector = true
+ return b.buildNextCharIfExists(buf, cursor+1)
+ }
+ }
+ return 0, errors.ErrInvalidPath("couldn't find quote character in selector quote path context")
+}
+
+func (b *PathBuilder) buildPathRecursive(buf []rune) (int, error) {
+ switch buf[0] {
+ case '.', '[', ']', '$', '*':
+ return 0, errors.ErrInvalidPath("found invalid path character %c after double dot", buf[0])
+ }
+ for cursor := 0; cursor < len(buf); cursor++ {
+ switch buf[cursor] {
+ case '$', '*', ']':
+ return 0, errors.ErrInvalidPath("found %c character in field selector context", buf[cursor])
+ case '.':
+ if cursor+1 >= len(buf) {
+ return 0, errors.ErrInvalidPath("JSON Path ends with dot character")
+ }
+ selector := buf[:cursor]
+ b.addRecursiveNode(string(selector))
+ offset, err := b.buildSelector(buf[cursor+1:])
+ if err != nil {
+ return 0, err
+ }
+ return cursor + 1 + offset, nil
+ case '[':
+ if cursor+1 >= len(buf) {
+ return 0, errors.ErrInvalidPath("JSON Path ends with left bracket character")
+ }
+ selector := buf[:cursor]
+ b.addRecursiveNode(string(selector))
+ offset, err := b.buildIndex(buf[cursor+1:])
+ if err != nil {
+ return 0, err
+ }
+ return cursor + 1 + offset, nil
+ }
+ }
+ b.addRecursiveNode(string(buf))
+ return len(buf), nil
+}
+
+func (b *PathBuilder) buildIndex(buf []rune) (int, error) {
+ switch buf[0] {
+ case '.', '[', ']', '$':
+ return 0, errors.ErrInvalidPath("found invalid path character %c after left bracket", buf[0])
+ case '\'':
+ if len(buf) == 1 {
+ return 0, errors.ErrInvalidPath("JSON Path ends with single quote character")
+ }
+ offset, err := b.buildQuoteSelector(buf[1:], SingleQuotePathSelector)
+ if err != nil {
+ return 0, err
+ }
+ return 1 + offset, nil
+ case '*':
+ if len(buf) == 1 {
+ return 0, errors.ErrInvalidPath("JSON Path ends with star character")
+ }
+ if buf[1] != ']' {
+ return 0, errors.ErrInvalidPath("expect right bracket character for index all path but found %c character", buf[1])
+ }
+ b.addIndexAllNode()
+ offset := len("*]")
+ if len(buf) > 2 {
+ buildOffset, err := b.buildNext(buf[2:])
+ if err != nil {
+ return 0, err
+ }
+ return offset + buildOffset, nil
+ }
+ return offset, nil
+ }
+
+ for cursor := 0; cursor < len(buf); cursor++ {
+ switch buf[cursor] {
+ case ']':
+ index, err := strconv.ParseInt(string(buf[:cursor]), 10, 64)
+ if err != nil {
+ return 0, errors.ErrInvalidPath("%q is unexpected index path", buf[:cursor])
+ }
+ b.addIndexNode(int(index))
+ return b.buildNextCharIfExists(buf, cursor+1)
+ }
+ }
+ return 0, errors.ErrInvalidPath("couldn't find right bracket character in index path context")
+}
+
+func (b *PathBuilder) addIndexAllNode() {
+ node := newPathIndexAllNode()
+ if b.root == nil {
+ b.root = node
+ b.node = node
+ } else {
+ b.node = b.node.chain(node)
+ }
+}
+
+func (b *PathBuilder) addRecursiveNode(selector string) {
+ node := newPathRecursiveNode(selector)
+ if b.root == nil {
+ b.root = node
+ b.node = node
+ } else {
+ b.node = b.node.chain(node)
+ }
+}
+
+func (b *PathBuilder) addSelectorNode(name string) {
+ node := newPathSelectorNode(name)
+ if b.root == nil {
+ b.root = node
+ b.node = node
+ } else {
+ b.node = b.node.chain(node)
+ }
+}
+
+func (b *PathBuilder) addIndexNode(idx int) {
+ node := newPathIndexNode(idx)
+ if b.root == nil {
+ b.root = node
+ b.node = node
+ } else {
+ b.node = b.node.chain(node)
+ }
+}
+
+type QuotePathSelector int
+
+const (
+ SingleQuotePathSelector QuotePathSelector = 1
+ DoubleQuotePathSelector QuotePathSelector = 2
+)
+
+type Path struct {
+ node PathNode
+ RootSelectorOnly bool
+ SingleQuotePathSelector bool
+ DoubleQuotePathSelector bool
+}
+
+func (p *Path) Field(sel string) (PathNode, bool, error) {
+ if p.node == nil {
+ return nil, false, nil
+ }
+ return p.node.Field(sel)
+}
+
+func (p *Path) Get(src, dst reflect.Value) error {
+ if p.node == nil {
+ return nil
+ }
+ return p.node.Get(src, dst)
+}
+
+func (p *Path) String() string {
+ if p.node == nil {
+ return "$"
+ }
+ return p.node.String()
+}
+
+type PathNode interface {
+ fmt.Stringer
+ Index(idx int) (PathNode, bool, error)
+ Field(fieldName string) (PathNode, bool, error)
+ Get(src, dst reflect.Value) error
+ chain(PathNode) PathNode
+ target() bool
+ single() bool
+}
+
+type BasePathNode struct {
+ child PathNode
+}
+
+func (n *BasePathNode) chain(node PathNode) PathNode {
+ n.child = node
+ return node
+}
+
+func (n *BasePathNode) target() bool {
+ return n.child == nil
+}
+
+func (n *BasePathNode) single() bool {
+ return true
+}
+
+type PathSelectorNode struct {
+ *BasePathNode
+ selector string
+}
+
+func newPathSelectorNode(selector string) *PathSelectorNode {
+ return &PathSelectorNode{
+ BasePathNode: &BasePathNode{},
+ selector: selector,
+ }
+}
+
+func (n *PathSelectorNode) Index(idx int) (PathNode, bool, error) {
+ return nil, false, &errors.PathError{}
+}
+
+func (n *PathSelectorNode) Field(fieldName string) (PathNode, bool, error) {
+ if n.selector == fieldName {
+ return n.child, true, nil
+ }
+ return nil, false, nil
+}
+
+func (n *PathSelectorNode) Get(src, dst reflect.Value) error {
+ switch src.Type().Kind() {
+ case reflect.Map:
+ iter := src.MapRange()
+ for iter.Next() {
+ key, ok := iter.Key().Interface().(string)
+ if !ok {
+ return fmt.Errorf("invalid map key type %T", src.Type().Key())
+ }
+ child, found, err := n.Field(key)
+ if err != nil {
+ return err
+ }
+ if found {
+ if child != nil {
+ return child.Get(iter.Value(), dst)
+ }
+ return AssignValue(iter.Value(), dst)
+ }
+ }
+ case reflect.Struct:
+ typ := src.Type()
+ for i := 0; i < typ.Len(); i++ {
+ tag := runtime.StructTagFromField(typ.Field(i))
+ child, found, err := n.Field(tag.Key)
+ if err != nil {
+ return err
+ }
+ if found {
+ if child != nil {
+ return child.Get(src.Field(i), dst)
+ }
+ return AssignValue(src.Field(i), dst)
+ }
+ }
+ case reflect.Ptr:
+ return n.Get(src.Elem(), dst)
+ case reflect.Interface:
+ return n.Get(reflect.ValueOf(src.Interface()), dst)
+ case reflect.Float64, reflect.String, reflect.Bool:
+ return AssignValue(src, dst)
+ }
+ return fmt.Errorf("failed to get %s value from %s", n.selector, src.Type())
+}
+
+func (n *PathSelectorNode) String() string {
+ s := fmt.Sprintf(".%s", n.selector)
+ if n.child != nil {
+ s += n.child.String()
+ }
+ return s
+}
+
+type PathIndexNode struct {
+ *BasePathNode
+ selector int
+}
+
+func newPathIndexNode(selector int) *PathIndexNode {
+ return &PathIndexNode{
+ BasePathNode: &BasePathNode{},
+ selector: selector,
+ }
+}
+
+func (n *PathIndexNode) Index(idx int) (PathNode, bool, error) {
+ if n.selector == idx {
+ return n.child, true, nil
+ }
+ return nil, false, nil
+}
+
+func (n *PathIndexNode) Field(fieldName string) (PathNode, bool, error) {
+ return nil, false, &errors.PathError{}
+}
+
+func (n *PathIndexNode) Get(src, dst reflect.Value) error {
+ switch src.Type().Kind() {
+ case reflect.Array, reflect.Slice:
+ if src.Len() > n.selector {
+ if n.child != nil {
+ return n.child.Get(src.Index(n.selector), dst)
+ }
+ return AssignValue(src.Index(n.selector), dst)
+ }
+ case reflect.Ptr:
+ return n.Get(src.Elem(), dst)
+ case reflect.Interface:
+ return n.Get(reflect.ValueOf(src.Interface()), dst)
+ }
+ return fmt.Errorf("failed to get [%d] value from %s", n.selector, src.Type())
+}
+
+func (n *PathIndexNode) String() string {
+ s := fmt.Sprintf("[%d]", n.selector)
+ if n.child != nil {
+ s += n.child.String()
+ }
+ return s
+}
+
+type PathIndexAllNode struct {
+ *BasePathNode
+}
+
+func newPathIndexAllNode() *PathIndexAllNode {
+ return &PathIndexAllNode{
+ BasePathNode: &BasePathNode{},
+ }
+}
+
+func (n *PathIndexAllNode) Index(idx int) (PathNode, bool, error) {
+ return n.child, true, nil
+}
+
+func (n *PathIndexAllNode) Field(fieldName string) (PathNode, bool, error) {
+ return nil, false, &errors.PathError{}
+}
+
+func (n *PathIndexAllNode) Get(src, dst reflect.Value) error {
+ switch src.Type().Kind() {
+ case reflect.Array, reflect.Slice:
+ var arr []interface{}
+ for i := 0; i < src.Len(); i++ {
+ var v interface{}
+ rv := reflect.ValueOf(&v)
+ if n.child != nil {
+ if err := n.child.Get(src.Index(i), rv); err != nil {
+ return err
+ }
+ } else {
+ if err := AssignValue(src.Index(i), rv); err != nil {
+ return err
+ }
+ }
+ arr = append(arr, v)
+ }
+ if err := AssignValue(reflect.ValueOf(arr), dst); err != nil {
+ return err
+ }
+ return nil
+ case reflect.Ptr:
+ return n.Get(src.Elem(), dst)
+ case reflect.Interface:
+ return n.Get(reflect.ValueOf(src.Interface()), dst)
+ }
+ return fmt.Errorf("failed to get all value from %s", src.Type())
+}
+
+func (n *PathIndexAllNode) String() string {
+ s := "[*]"
+ if n.child != nil {
+ s += n.child.String()
+ }
+ return s
+}
+
+type PathRecursiveNode struct {
+ *BasePathNode
+ selector string
+}
+
+func newPathRecursiveNode(selector string) *PathRecursiveNode {
+ node := newPathSelectorNode(selector)
+ return &PathRecursiveNode{
+ BasePathNode: &BasePathNode{
+ child: node,
+ },
+ selector: selector,
+ }
+}
+
+func (n *PathRecursiveNode) Field(fieldName string) (PathNode, bool, error) {
+ if n.selector == fieldName {
+ return n.child, true, nil
+ }
+ return nil, false, nil
+}
+
+func (n *PathRecursiveNode) Index(_ int) (PathNode, bool, error) {
+ return n, true, nil
+}
+
+func valueToSliceValue(v interface{}) []interface{} {
+ rv := reflect.ValueOf(v)
+ ret := []interface{}{}
+ if rv.Type().Kind() == reflect.Slice || rv.Type().Kind() == reflect.Array {
+ for i := 0; i < rv.Len(); i++ {
+ ret = append(ret, rv.Index(i).Interface())
+ }
+ return ret
+ }
+ return []interface{}{v}
+}
+
+func (n *PathRecursiveNode) Get(src, dst reflect.Value) error {
+ if n.child == nil {
+ return fmt.Errorf("failed to get by recursive path ..%s", n.selector)
+ }
+ var arr []interface{}
+ switch src.Type().Kind() {
+ case reflect.Map:
+ iter := src.MapRange()
+ for iter.Next() {
+ key, ok := iter.Key().Interface().(string)
+ if !ok {
+ return fmt.Errorf("invalid map key type %T", src.Type().Key())
+ }
+ child, found, err := n.Field(key)
+ if err != nil {
+ return err
+ }
+ if found {
+ var v interface{}
+ rv := reflect.ValueOf(&v)
+ _ = child.Get(iter.Value(), rv)
+ arr = append(arr, valueToSliceValue(v)...)
+ } else {
+ var v interface{}
+ rv := reflect.ValueOf(&v)
+ _ = n.Get(iter.Value(), rv)
+ if v != nil {
+ arr = append(arr, valueToSliceValue(v)...)
+ }
+ }
+ }
+ _ = AssignValue(reflect.ValueOf(arr), dst)
+ return nil
+ case reflect.Struct:
+ typ := src.Type()
+ for i := 0; i < typ.Len(); i++ {
+ tag := runtime.StructTagFromField(typ.Field(i))
+ child, found, err := n.Field(tag.Key)
+ if err != nil {
+ return err
+ }
+ if found {
+ var v interface{}
+ rv := reflect.ValueOf(&v)
+ _ = child.Get(src.Field(i), rv)
+ arr = append(arr, valueToSliceValue(v)...)
+ } else {
+ var v interface{}
+ rv := reflect.ValueOf(&v)
+ _ = n.Get(src.Field(i), rv)
+ if v != nil {
+ arr = append(arr, valueToSliceValue(v)...)
+ }
+ }
+ }
+ _ = AssignValue(reflect.ValueOf(arr), dst)
+ return nil
+ case reflect.Array, reflect.Slice:
+ for i := 0; i < src.Len(); i++ {
+ var v interface{}
+ rv := reflect.ValueOf(&v)
+ _ = n.Get(src.Index(i), rv)
+ if v != nil {
+ arr = append(arr, valueToSliceValue(v)...)
+ }
+ }
+ _ = AssignValue(reflect.ValueOf(arr), dst)
+ return nil
+ case reflect.Ptr:
+ return n.Get(src.Elem(), dst)
+ case reflect.Interface:
+ return n.Get(reflect.ValueOf(src.Interface()), dst)
+ }
+ return fmt.Errorf("failed to get %s value from %s", n.selector, src.Type())
+}
+
+func (n *PathRecursiveNode) String() string {
+ s := fmt.Sprintf("..%s", n.selector)
+ if n.child != nil {
+ s += n.child.String()
+ }
+ return s
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/ptr.go b/vendor/github.com/goccy/go-json/internal/decoder/ptr.go
index 2c83b9c445..de12e105c6 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/ptr.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/ptr.go
@@ -1,6 +1,7 @@
package decoder
import (
+ "fmt"
"unsafe"
"github.com/goccy/go-json/internal/runtime"
@@ -34,6 +35,10 @@ func (d *ptrDecoder) contentDecoder() Decoder {
//go:linkname unsafe_New reflect.unsafe_New
func unsafe_New(*runtime.Type) unsafe.Pointer
+func UnsafeNew(t *runtime.Type) unsafe.Pointer {
+ return unsafe_New(t)
+}
+
func (d *ptrDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
if s.skipWhiteSpace() == nul {
s.read()
@@ -85,3 +90,7 @@ func (d *ptrDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.P
cursor = c
return cursor, nil
}
+
+func (d *ptrDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ return nil, 0, fmt.Errorf("json: ptr decoder does not support decode path")
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/slice.go b/vendor/github.com/goccy/go-json/internal/decoder/slice.go
index 85b6e1119e..30a23e4b51 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/slice.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/slice.go
@@ -299,3 +299,82 @@ func (d *sliceDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe
}
}
}
+
+func (d *sliceDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ buf := ctx.Buf
+ depth++
+ if depth > maxDecodeNestingDepth {
+ return nil, 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
+ }
+
+ ret := [][]byte{}
+ for {
+ switch buf[cursor] {
+ case ' ', '\n', '\t', '\r':
+ cursor++
+ continue
+ case 'n':
+ if err := validateNull(buf, cursor); err != nil {
+ return nil, 0, err
+ }
+ cursor += 4
+ return [][]byte{nullbytes}, cursor, nil
+ case '[':
+ cursor++
+ cursor = skipWhiteSpace(buf, cursor)
+ if buf[cursor] == ']' {
+ cursor++
+ return ret, cursor, nil
+ }
+ idx := 0
+ for {
+ child, found, err := ctx.Option.Path.node.Index(idx)
+ if err != nil {
+ return nil, 0, err
+ }
+ if found {
+ if child != nil {
+ oldPath := ctx.Option.Path.node
+ ctx.Option.Path.node = child
+ paths, c, err := d.valueDecoder.DecodePath(ctx, cursor, depth)
+ if err != nil {
+ return nil, 0, err
+ }
+ ctx.Option.Path.node = oldPath
+ ret = append(ret, paths...)
+ cursor = c
+ } else {
+ start := cursor
+ end, err := skipValue(buf, cursor, depth)
+ if err != nil {
+ return nil, 0, err
+ }
+ ret = append(ret, buf[start:end])
+ cursor = end
+ }
+ } else {
+ c, err := skipValue(buf, cursor, depth)
+ if err != nil {
+ return nil, 0, err
+ }
+ cursor = c
+ }
+ cursor = skipWhiteSpace(buf, cursor)
+ switch buf[cursor] {
+ case ']':
+ cursor++
+ return ret, cursor, nil
+ case ',':
+ idx++
+ default:
+ return nil, 0, errors.ErrInvalidCharacter(buf[cursor], "slice", cursor)
+ }
+ cursor++
+ }
+ case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+ return nil, 0, d.errNumber(cursor)
+ default:
+ return nil, 0, errors.ErrUnexpectedEndOfJSON("slice", cursor)
+ }
+ }
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/stream.go b/vendor/github.com/goccy/go-json/internal/decoder/stream.go
index c274683480..a383f72596 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/stream.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/stream.go
@@ -103,7 +103,7 @@ func (s *Stream) statForRetry() ([]byte, int64, unsafe.Pointer) {
func (s *Stream) Reset() {
s.reset()
- s.bufSize = initBufSize
+ s.bufSize = int64(len(s.buf))
}
func (s *Stream) More() bool {
@@ -138,8 +138,11 @@ func (s *Stream) Token() (interface{}, error) {
s.cursor++
case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
bytes := floatBytes(s)
- s := *(*string)(unsafe.Pointer(&bytes))
- f64, err := strconv.ParseFloat(s, 64)
+ str := *(*string)(unsafe.Pointer(&bytes))
+ if s.UseNumber {
+ return json.Number(str), nil
+ }
+ f64, err := strconv.ParseFloat(str, 64)
if err != nil {
return nil, err
}
@@ -277,7 +280,7 @@ func (s *Stream) skipObject(depth int64) error {
if char(p, cursor) == nul {
s.cursor = cursor
if s.read() {
- _, cursor, p = s.statForRetry()
+ _, cursor, p = s.stat()
continue
}
return errors.ErrUnexpectedEndOfJSON("string of object", cursor)
@@ -340,7 +343,7 @@ func (s *Stream) skipArray(depth int64) error {
if char(p, cursor) == nul {
s.cursor = cursor
if s.read() {
- _, cursor, p = s.statForRetry()
+ _, cursor, p = s.stat()
continue
}
return errors.ErrUnexpectedEndOfJSON("string of object", cursor)
@@ -398,7 +401,7 @@ func (s *Stream) skipValue(depth int64) error {
if char(p, cursor) == nul {
s.cursor = cursor
if s.read() {
- _, cursor, p = s.statForRetry()
+ _, cursor, p = s.stat()
continue
}
return errors.ErrUnexpectedEndOfJSON("value of string", s.totalOffset())
@@ -423,7 +426,6 @@ func (s *Stream) skipValue(depth int64) error {
continue
} else if c == nul {
if s.read() {
- s.cursor-- // for retry current character
_, cursor, p = s.stat()
continue
}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/string.go b/vendor/github.com/goccy/go-json/internal/decoder/string.go
index 65b1004889..32602c908a 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/string.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/string.go
@@ -1,6 +1,8 @@
package decoder
import (
+ "bytes"
+ "fmt"
"reflect"
"unicode"
"unicode/utf16"
@@ -58,6 +60,17 @@ func (d *stringDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsaf
return cursor, nil
}
+func (d *stringDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ bytes, c, err := d.decodeByte(ctx.Buf, cursor)
+ if err != nil {
+ return nil, 0, err
+ }
+ if bytes == nil {
+ return [][]byte{nullbytes}, c, nil
+ }
+ return [][]byte{bytes}, c, nil
+}
+
var (
hexToInt = [256]int{
'0': 0,
@@ -93,24 +106,30 @@ func unicodeToRune(code []byte) rune {
return r
}
+func readAtLeast(s *Stream, n int64, p *unsafe.Pointer) bool {
+ for s.cursor+n >= s.length {
+ if !s.read() {
+ return false
+ }
+ *p = s.bufptr()
+ }
+ return true
+}
+
func decodeUnicodeRune(s *Stream, p unsafe.Pointer) (rune, int64, unsafe.Pointer, error) {
const defaultOffset = 5
const surrogateOffset = 11
- if s.cursor+defaultOffset >= s.length {
- if !s.read() {
- return rune(0), 0, nil, errors.ErrInvalidCharacter(s.char(), "escaped string", s.totalOffset())
- }
- p = s.bufptr()
+ if !readAtLeast(s, defaultOffset, &p) {
+ return rune(0), 0, nil, errors.ErrInvalidCharacter(s.char(), "escaped string", s.totalOffset())
}
r := unicodeToRune(s.buf[s.cursor+1 : s.cursor+defaultOffset])
if utf16.IsSurrogate(r) {
- if s.cursor+surrogateOffset >= s.length {
- s.read()
- p = s.bufptr()
+ if !readAtLeast(s, surrogateOffset, &p) {
+ return unicode.ReplacementChar, defaultOffset, p, nil
}
- if s.cursor+surrogateOffset >= s.length || s.buf[s.cursor+defaultOffset] != '\\' || s.buf[s.cursor+defaultOffset+1] != 'u' {
+ if s.buf[s.cursor+defaultOffset] != '\\' || s.buf[s.cursor+defaultOffset+1] != 'u' {
return unicode.ReplacementChar, defaultOffset, p, nil
}
r2 := unicodeToRune(s.buf[s.cursor+defaultOffset+2 : s.cursor+surrogateOffset])
@@ -163,6 +182,7 @@ RETRY:
if !s.read() {
return nil, errors.ErrInvalidCharacter(s.char(), "escaped string", s.totalOffset())
}
+ p = s.bufptr()
goto RETRY
default:
return nil, errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
@@ -308,49 +328,36 @@ func (d *stringDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, err
cursor++
start := cursor
b := (*sliceHeader)(unsafe.Pointer(&buf)).data
+ escaped := 0
for {
switch char(b, cursor) {
case '\\':
+ escaped++
cursor++
switch char(b, cursor) {
- case '"':
- buf[cursor] = '"'
- buf = append(buf[:cursor-1], buf[cursor:]...)
- case '\\':
- buf[cursor] = '\\'
- buf = append(buf[:cursor-1], buf[cursor:]...)
- case '/':
- buf[cursor] = '/'
- buf = append(buf[:cursor-1], buf[cursor:]...)
- case 'b':
- buf[cursor] = '\b'
- buf = append(buf[:cursor-1], buf[cursor:]...)
- case 'f':
- buf[cursor] = '\f'
- buf = append(buf[:cursor-1], buf[cursor:]...)
- case 'n':
- buf[cursor] = '\n'
- buf = append(buf[:cursor-1], buf[cursor:]...)
- case 'r':
- buf[cursor] = '\r'
- buf = append(buf[:cursor-1], buf[cursor:]...)
- case 't':
- buf[cursor] = '\t'
- buf = append(buf[:cursor-1], buf[cursor:]...)
+ case '"', '\\', '/', 'b', 'f', 'n', 'r', 't':
+ cursor++
case 'u':
buflen := int64(len(buf))
if cursor+5 >= buflen {
return nil, 0, errors.ErrUnexpectedEndOfJSON("escaped string", cursor)
}
- code := unicodeToRune(buf[cursor+1 : cursor+5])
- unicode := []byte(string(code))
- buf = append(append(buf[:cursor-1], unicode...), buf[cursor+5:]...)
+ for i := int64(1); i <= 4; i++ {
+ c := char(b, cursor+i)
+ if !(('0' <= c && c <= '9') || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F')) {
+ return nil, 0, errors.ErrSyntax(fmt.Sprintf("json: invalid character %c in \\u hexadecimal character escape", c), cursor+i)
+ }
+ }
+ cursor += 5
default:
return nil, 0, errors.ErrUnexpectedEndOfJSON("escaped string", cursor)
}
continue
case '"':
literal := buf[start:cursor]
+ if escaped > 0 {
+ literal = literal[:unescapeString(literal)]
+ }
cursor++
return literal, cursor, nil
case nul:
@@ -369,3 +376,77 @@ func (d *stringDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, err
}
}
}
+
+var unescapeMap = [256]byte{
+ '"': '"',
+ '\\': '\\',
+ '/': '/',
+ 'b': '\b',
+ 'f': '\f',
+ 'n': '\n',
+ 'r': '\r',
+ 't': '\t',
+}
+
+func unsafeAdd(ptr unsafe.Pointer, offset int) unsafe.Pointer {
+ return unsafe.Pointer(uintptr(ptr) + uintptr(offset))
+}
+
+func unescapeString(buf []byte) int {
+ p := (*sliceHeader)(unsafe.Pointer(&buf)).data
+ end := unsafeAdd(p, len(buf))
+ src := unsafeAdd(p, bytes.IndexByte(buf, '\\'))
+ dst := src
+ for src != end {
+ c := char(src, 0)
+ if c == '\\' {
+ escapeChar := char(src, 1)
+ if escapeChar != 'u' {
+ *(*byte)(dst) = unescapeMap[escapeChar]
+ src = unsafeAdd(src, 2)
+ dst = unsafeAdd(dst, 1)
+ } else {
+ v1 := hexToInt[char(src, 2)]
+ v2 := hexToInt[char(src, 3)]
+ v3 := hexToInt[char(src, 4)]
+ v4 := hexToInt[char(src, 5)]
+ code := rune((v1 << 12) | (v2 << 8) | (v3 << 4) | v4)
+ if code >= 0xd800 && code < 0xdc00 && uintptr(unsafeAdd(src, 11)) < uintptr(end) {
+ if char(src, 6) == '\\' && char(src, 7) == 'u' {
+ v1 := hexToInt[char(src, 8)]
+ v2 := hexToInt[char(src, 9)]
+ v3 := hexToInt[char(src, 10)]
+ v4 := hexToInt[char(src, 11)]
+ lo := rune((v1 << 12) | (v2 << 8) | (v3 << 4) | v4)
+ if lo >= 0xdc00 && lo < 0xe000 {
+ code = (code-0xd800)<<10 | (lo - 0xdc00) + 0x10000
+ src = unsafeAdd(src, 6)
+ }
+ }
+ }
+ var b [utf8.UTFMax]byte
+ n := utf8.EncodeRune(b[:], code)
+ switch n {
+ case 4:
+ *(*byte)(unsafeAdd(dst, 3)) = b[3]
+ fallthrough
+ case 3:
+ *(*byte)(unsafeAdd(dst, 2)) = b[2]
+ fallthrough
+ case 2:
+ *(*byte)(unsafeAdd(dst, 1)) = b[1]
+ fallthrough
+ case 1:
+ *(*byte)(unsafeAdd(dst, 0)) = b[0]
+ }
+ src = unsafeAdd(src, 6)
+ dst = unsafeAdd(dst, n)
+ }
+ } else {
+ *(*byte)(dst) = c
+ src = unsafeAdd(src, 1)
+ dst = unsafeAdd(dst, 1)
+ }
+ }
+ return int(uintptr(dst) - uintptr(p))
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/struct.go b/vendor/github.com/goccy/go-json/internal/decoder/struct.go
index 2c64680458..313da153b3 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/struct.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/struct.go
@@ -51,6 +51,14 @@ func init() {
}
}
+func toASCIILower(s string) string {
+ b := []byte(s)
+ for i := range b {
+ b[i] = largeToSmallTable[b[i]]
+ }
+ return string(b)
+}
+
func newStructDecoder(structName, fieldName string, fieldMap map[string]*structFieldSet) *structDecoder {
return &structDecoder{
fieldMap: fieldMap,
@@ -91,6 +99,10 @@ func (d *structDecoder) tryOptimize() {
for k, v := range d.fieldMap {
key := strings.ToLower(k)
if key != k {
+ if key != toASCIILower(k) {
+ d.isTriedOptimize = true
+ return
+ }
// already exists same key (e.g. Hello and HELLO has same lower case key
if _, exists := conflicted[key]; exists {
d.isTriedOptimize = true
@@ -158,49 +170,53 @@ func (d *structDecoder) tryOptimize() {
}
// decode from '\uXXXX'
-func decodeKeyCharByUnicodeRune(buf []byte, cursor int64) ([]byte, int64) {
+func decodeKeyCharByUnicodeRune(buf []byte, cursor int64) ([]byte, int64, error) {
const defaultOffset = 4
const surrogateOffset = 6
+ if cursor+defaultOffset >= int64(len(buf)) {
+ return nil, 0, errors.ErrUnexpectedEndOfJSON("escaped string", cursor)
+ }
+
r := unicodeToRune(buf[cursor : cursor+defaultOffset])
if utf16.IsSurrogate(r) {
cursor += defaultOffset
if cursor+surrogateOffset >= int64(len(buf)) || buf[cursor] != '\\' || buf[cursor+1] != 'u' {
- return []byte(string(unicode.ReplacementChar)), cursor + defaultOffset - 1
+ return []byte(string(unicode.ReplacementChar)), cursor + defaultOffset - 1, nil
}
cursor += 2
r2 := unicodeToRune(buf[cursor : cursor+defaultOffset])
if r := utf16.DecodeRune(r, r2); r != unicode.ReplacementChar {
- return []byte(string(r)), cursor + defaultOffset - 1
+ return []byte(string(r)), cursor + defaultOffset - 1, nil
}
}
- return []byte(string(r)), cursor + defaultOffset - 1
+ return []byte(string(r)), cursor + defaultOffset - 1, nil
}
-func decodeKeyCharByEscapedChar(buf []byte, cursor int64) ([]byte, int64) {
+func decodeKeyCharByEscapedChar(buf []byte, cursor int64) ([]byte, int64, error) {
c := buf[cursor]
cursor++
switch c {
case '"':
- return []byte{'"'}, cursor
+ return []byte{'"'}, cursor, nil
case '\\':
- return []byte{'\\'}, cursor
+ return []byte{'\\'}, cursor, nil
case '/':
- return []byte{'/'}, cursor
+ return []byte{'/'}, cursor, nil
case 'b':
- return []byte{'\b'}, cursor
+ return []byte{'\b'}, cursor, nil
case 'f':
- return []byte{'\f'}, cursor
+ return []byte{'\f'}, cursor, nil
case 'n':
- return []byte{'\n'}, cursor
+ return []byte{'\n'}, cursor, nil
case 'r':
- return []byte{'\r'}, cursor
+ return []byte{'\r'}, cursor, nil
case 't':
- return []byte{'\t'}, cursor
+ return []byte{'\t'}, cursor, nil
case 'u':
return decodeKeyCharByUnicodeRune(buf, cursor)
}
- return nil, cursor
+ return nil, cursor, nil
}
func decodeKeyByBitmapUint8(d *structDecoder, buf []byte, cursor int64) (int64, *structFieldSet, error) {
@@ -242,7 +258,10 @@ func decodeKeyByBitmapUint8(d *structDecoder, buf []byte, cursor int64) (int64,
return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor)
case '\\':
cursor++
- chars, nextCursor := decodeKeyCharByEscapedChar(buf, cursor)
+ chars, nextCursor, err := decodeKeyCharByEscapedChar(buf, cursor)
+ if err != nil {
+ return 0, nil, err
+ }
for _, c := range chars {
curBit &= bitmap[keyIdx][largeToSmallTable[c]]
if curBit == 0 {
@@ -305,7 +324,10 @@ func decodeKeyByBitmapUint16(d *structDecoder, buf []byte, cursor int64) (int64,
return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor)
case '\\':
cursor++
- chars, nextCursor := decodeKeyCharByEscapedChar(buf, cursor)
+ chars, nextCursor, err := decodeKeyCharByEscapedChar(buf, cursor)
+ if err != nil {
+ return 0, nil, err
+ }
for _, c := range chars {
curBit &= bitmap[keyIdx][largeToSmallTable[c]]
if curBit == 0 {
@@ -817,3 +839,7 @@ func (d *structDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsaf
cursor++
}
}
+
+func (d *structDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ return nil, 0, fmt.Errorf("json: struct decoder does not support decode path")
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/type.go b/vendor/github.com/goccy/go-json/internal/decoder/type.go
index 70e9907c83..beaf3ab866 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/type.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/type.go
@@ -10,6 +10,7 @@ import (
type Decoder interface {
Decode(*RuntimeContext, int64, int64, unsafe.Pointer) (int64, error)
+ DecodePath(*RuntimeContext, int64, int64) ([][]byte, int64, error)
DecodeStream(*Stream, int64, unsafe.Pointer) error
}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/uint.go b/vendor/github.com/goccy/go-json/internal/decoder/uint.go
index a62c514928..4131731b8e 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/uint.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/uint.go
@@ -188,3 +188,7 @@ func (d *uintDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.
d.op(p, u64)
return cursor, nil
}
+
+func (d *uintDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ return nil, 0, fmt.Errorf("json: uint decoder does not support decode path")
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go
index d90f39cc5b..4cd6dbd573 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go
@@ -1,7 +1,9 @@
package decoder
import (
+ "context"
"encoding/json"
+ "fmt"
"unsafe"
"github.com/goccy/go-json/internal/errors"
@@ -46,13 +48,20 @@ func (d *unmarshalJSONDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Poi
typ: d.typ,
ptr: p,
}))
- if (s.Option.Flags & ContextOption) != 0 {
- if err := v.(unmarshalerContext).UnmarshalJSON(s.Option.Context, dst); err != nil {
+ switch v := v.(type) {
+ case unmarshalerContext:
+ var ctx context.Context
+ if (s.Option.Flags & ContextOption) != 0 {
+ ctx = s.Option.Context
+ } else {
+ ctx = context.Background()
+ }
+ if err := v.UnmarshalJSON(ctx, dst); err != nil {
d.annotateError(s.cursor, err)
return err
}
- } else {
- if err := v.(json.Unmarshaler).UnmarshalJSON(dst); err != nil {
+ case json.Unmarshaler:
+ if err := v.UnmarshalJSON(dst); err != nil {
d.annotateError(s.cursor, err)
return err
}
@@ -89,3 +98,7 @@ func (d *unmarshalJSONDecoder) Decode(ctx *RuntimeContext, cursor, depth int64,
}
return end, nil
}
+
+func (d *unmarshalJSONDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ return nil, 0, fmt.Errorf("json: unmarshal json decoder does not support decode path")
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go
index 1ef2877829..6d37993f07 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go
@@ -3,6 +3,7 @@ package decoder
import (
"bytes"
"encoding"
+ "fmt"
"unicode"
"unicode/utf16"
"unicode/utf8"
@@ -142,6 +143,10 @@ func (d *unmarshalTextDecoder) Decode(ctx *RuntimeContext, cursor, depth int64,
return end, nil
}
+func (d *unmarshalTextDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ return nil, 0, fmt.Errorf("json: unmarshal text decoder does not support decode path")
+}
+
func unquoteBytes(s []byte) (t []byte, ok bool) {
length := len(s)
if length < 2 || s[0] != '"' || s[length-1] != '"' {
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go b/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go
index 66227ae021..0c4e2e6eac 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go
@@ -1,6 +1,7 @@
package decoder
import (
+ "fmt"
"reflect"
"unsafe"
@@ -66,3 +67,7 @@ func (d *wrappedStringDecoder) Decode(ctx *RuntimeContext, cursor, depth int64,
ctx.Buf = oldBuf
return c, nil
}
+
+func (d *wrappedStringDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+ return nil, 0, fmt.Errorf("json: wrapped string decoder does not support decode path")
+}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/code.go b/vendor/github.com/goccy/go-json/internal/encoder/code.go
index aee01015a3..5b08faefc7 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/code.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/code.go
@@ -2,6 +2,7 @@ package encoder
import (
"fmt"
+ "reflect"
"unsafe"
"github.com/goccy/go-json/internal/runtime"
@@ -10,6 +11,7 @@ import (
type Code interface {
Kind() CodeKind
ToOpcode(*compileContext) Opcodes
+ Filter(*FieldQuery) Code
}
type AnonymousCode interface {
@@ -82,6 +84,10 @@ func (c *IntCode) ToOpcode(ctx *compileContext) Opcodes {
return Opcodes{code}
}
+func (c *IntCode) Filter(_ *FieldQuery) Code {
+ return c
+}
+
type UintCode struct {
typ *runtime.Type
bitSize uint8
@@ -108,6 +114,10 @@ func (c *UintCode) ToOpcode(ctx *compileContext) Opcodes {
return Opcodes{code}
}
+func (c *UintCode) Filter(_ *FieldQuery) Code {
+ return c
+}
+
type FloatCode struct {
typ *runtime.Type
bitSize uint8
@@ -140,6 +150,10 @@ func (c *FloatCode) ToOpcode(ctx *compileContext) Opcodes {
return Opcodes{code}
}
+func (c *FloatCode) Filter(_ *FieldQuery) Code {
+ return c
+}
+
type StringCode struct {
typ *runtime.Type
isPtr bool
@@ -169,6 +183,10 @@ func (c *StringCode) ToOpcode(ctx *compileContext) Opcodes {
return Opcodes{code}
}
+func (c *StringCode) Filter(_ *FieldQuery) Code {
+ return c
+}
+
type BoolCode struct {
typ *runtime.Type
isPtr bool
@@ -190,6 +208,10 @@ func (c *BoolCode) ToOpcode(ctx *compileContext) Opcodes {
return Opcodes{code}
}
+func (c *BoolCode) Filter(_ *FieldQuery) Code {
+ return c
+}
+
type BytesCode struct {
typ *runtime.Type
isPtr bool
@@ -211,6 +233,10 @@ func (c *BytesCode) ToOpcode(ctx *compileContext) Opcodes {
return Opcodes{code}
}
+func (c *BytesCode) Filter(_ *FieldQuery) Code {
+ return c
+}
+
type SliceCode struct {
typ *runtime.Type
value Code
@@ -245,6 +271,10 @@ func (c *SliceCode) ToOpcode(ctx *compileContext) Opcodes {
return Opcodes{header}.Add(codes...).Add(elemCode).Add(end)
}
+func (c *SliceCode) Filter(_ *FieldQuery) Code {
+ return c
+}
+
type ArrayCode struct {
typ *runtime.Type
value Code
@@ -286,6 +316,10 @@ func (c *ArrayCode) ToOpcode(ctx *compileContext) Opcodes {
return Opcodes{header}.Add(codes...).Add(elemCode).Add(end)
}
+func (c *ArrayCode) Filter(_ *FieldQuery) Code {
+ return c
+}
+
type MapCode struct {
typ *runtime.Type
key Code
@@ -332,6 +366,10 @@ func (c *MapCode) ToOpcode(ctx *compileContext) Opcodes {
return Opcodes{header}.Add(keyCodes...).Add(value).Add(valueCodes...).Add(key).Add(end)
}
+func (c *MapCode) Filter(_ *FieldQuery) Code {
+ return c
+}
+
type StructCode struct {
typ *runtime.Type
fields []*StructFieldCode
@@ -346,7 +384,7 @@ func (c *StructCode) Kind() CodeKind {
}
func (c *StructCode) lastFieldCode(field *StructFieldCode, firstField *Opcode) *Opcode {
- if field.isAnonymous {
+ if isEmbeddedStruct(field) {
return c.lastAnonymousFieldCode(firstField)
}
lastField := firstField
@@ -359,7 +397,10 @@ func (c *StructCode) lastFieldCode(field *StructFieldCode, firstField *Opcode) *
func (c *StructCode) lastAnonymousFieldCode(firstField *Opcode) *Opcode {
// firstField is special StructHead operation for anonymous structure.
// So, StructHead's next operation is truly struct head operation.
- lastField := firstField.Next
+ for firstField.Op == OpStructHead || firstField.Op == OpStructField {
+ firstField = firstField.Next
+ }
+ lastField := firstField
for lastField.NextField != nil {
lastField = lastField.NextField
}
@@ -401,10 +442,6 @@ func (c *StructCode) ToOpcode(ctx *compileContext) Opcodes {
endField := fieldCodes.Last()
if len(codes) > 0 {
codes.First().End = endField
- } else if field.isAnonymous {
- firstField.End = endField
- lastField := c.lastAnonymousFieldCode(firstField)
- lastField.NextField = endField
} else {
firstField.End = endField
}
@@ -520,6 +557,45 @@ func (c *StructCode) enableIndirect() {
structCode.enableIndirect()
}
+func (c *StructCode) Filter(query *FieldQuery) Code {
+ fieldMap := map[string]*FieldQuery{}
+ for _, field := range query.Fields {
+ fieldMap[field.Name] = field
+ }
+ fields := make([]*StructFieldCode, 0, len(c.fields))
+ for _, field := range c.fields {
+ query, exists := fieldMap[field.key]
+ if !exists {
+ continue
+ }
+ fieldCode := &StructFieldCode{
+ typ: field.typ,
+ key: field.key,
+ tag: field.tag,
+ value: field.value,
+ offset: field.offset,
+ isAnonymous: field.isAnonymous,
+ isTaggedKey: field.isTaggedKey,
+ isNilableType: field.isNilableType,
+ isNilCheck: field.isNilCheck,
+ isAddrForMarshaler: field.isAddrForMarshaler,
+ isNextOpPtrType: field.isNextOpPtrType,
+ }
+ if len(query.Fields) > 0 {
+ fieldCode.value = fieldCode.value.Filter(query)
+ }
+ fields = append(fields, fieldCode)
+ }
+ return &StructCode{
+ typ: c.typ,
+ fields: fields,
+ isPtr: c.isPtr,
+ disableIndirectConversion: c.disableIndirectConversion,
+ isIndirect: c.isIndirect,
+ isRecursive: c.isRecursive,
+ }
+}
+
type StructFieldCode struct {
typ *runtime.Type
key string
@@ -532,6 +608,7 @@ type StructFieldCode struct {
isNilCheck bool
isAddrForMarshaler bool
isNextOpPtrType bool
+ isMarshalerContext bool
}
func (c *StructFieldCode) getStruct() *StructCode {
@@ -574,8 +651,12 @@ func (c *StructFieldCode) headerOpcodes(ctx *compileContext, field *Opcode, valu
value := valueCodes.First()
op := optimizeStructHeader(value, c.tag)
field.Op = op
+ if value.Flags&MarshalerContextFlags != 0 {
+ field.Flags |= MarshalerContextFlags
+ }
field.NumBitSize = value.NumBitSize
field.PtrNum = value.PtrNum
+ field.FieldQuery = value.FieldQuery
fieldCodes := Opcodes{field}
if op.IsMultipleOpHead() {
field.Next = value
@@ -590,8 +671,12 @@ func (c *StructFieldCode) fieldOpcodes(ctx *compileContext, field *Opcode, value
value := valueCodes.First()
op := optimizeStructField(value, c.tag)
field.Op = op
+ if value.Flags&MarshalerContextFlags != 0 {
+ field.Flags |= MarshalerContextFlags
+ }
field.NumBitSize = value.NumBitSize
field.PtrNum = value.PtrNum
+ field.FieldQuery = value.FieldQuery
fieldCodes := Opcodes{field}
if op.IsMultipleOpField() {
@@ -611,7 +696,15 @@ func (c *StructFieldCode) addStructEndCode(ctx *compileContext, codes Opcodes) O
Indent: ctx.indent,
}
codes.Last().Next = end
- codes.First().NextField = end
+ code := codes.First()
+ for code.Op == OpStructField || code.Op == OpStructHead {
+ code = code.Next
+ }
+ for code.NextField != nil {
+ code = code.NextField
+ }
+ code.NextField = end
+
codes = codes.Add(end)
ctx.incOpcodeIndex()
return codes
@@ -645,6 +738,9 @@ func (c *StructFieldCode) flags() OpFlags {
if c.isAnonymous {
flags |= AnonymousKeyFlags
}
+ if c.isMarshalerContext {
+ flags |= MarshalerContextFlags
+ }
return flags
}
@@ -725,8 +821,9 @@ func isEnableStructEndOptimization(value Code) bool {
}
type InterfaceCode struct {
- typ *runtime.Type
- isPtr bool
+ typ *runtime.Type
+ fieldQuery *FieldQuery
+ isPtr bool
}
func (c *InterfaceCode) Kind() CodeKind {
@@ -741,6 +838,7 @@ func (c *InterfaceCode) ToOpcode(ctx *compileContext) Opcodes {
default:
code = newOpCode(ctx, c.typ, OpInterface)
}
+ code.FieldQuery = c.fieldQuery
if c.typ.NumMethod() > 0 {
code.Flags |= NonEmptyInterfaceFlags
}
@@ -748,8 +846,17 @@ func (c *InterfaceCode) ToOpcode(ctx *compileContext) Opcodes {
return Opcodes{code}
}
+func (c *InterfaceCode) Filter(query *FieldQuery) Code {
+ return &InterfaceCode{
+ typ: c.typ,
+ fieldQuery: query,
+ isPtr: c.isPtr,
+ }
+}
+
type MarshalJSONCode struct {
typ *runtime.Type
+ fieldQuery *FieldQuery
isAddrForMarshaler bool
isNilableType bool
isMarshalerContext bool
@@ -761,6 +868,7 @@ func (c *MarshalJSONCode) Kind() CodeKind {
func (c *MarshalJSONCode) ToOpcode(ctx *compileContext) Opcodes {
code := newOpCode(ctx, c.typ, OpMarshalJSON)
+ code.FieldQuery = c.fieldQuery
if c.isAddrForMarshaler {
code.Flags |= AddrForMarshalerFlags
}
@@ -776,8 +884,19 @@ func (c *MarshalJSONCode) ToOpcode(ctx *compileContext) Opcodes {
return Opcodes{code}
}
+func (c *MarshalJSONCode) Filter(query *FieldQuery) Code {
+ return &MarshalJSONCode{
+ typ: c.typ,
+ fieldQuery: query,
+ isAddrForMarshaler: c.isAddrForMarshaler,
+ isNilableType: c.isNilableType,
+ isMarshalerContext: c.isMarshalerContext,
+ }
+}
+
type MarshalTextCode struct {
typ *runtime.Type
+ fieldQuery *FieldQuery
isAddrForMarshaler bool
isNilableType bool
}
@@ -788,6 +907,7 @@ func (c *MarshalTextCode) Kind() CodeKind {
func (c *MarshalTextCode) ToOpcode(ctx *compileContext) Opcodes {
code := newOpCode(ctx, c.typ, OpMarshalText)
+ code.FieldQuery = c.fieldQuery
if c.isAddrForMarshaler {
code.Flags |= AddrForMarshalerFlags
}
@@ -800,6 +920,15 @@ func (c *MarshalTextCode) ToOpcode(ctx *compileContext) Opcodes {
return Opcodes{code}
}
+func (c *MarshalTextCode) Filter(query *FieldQuery) Code {
+ return &MarshalTextCode{
+ typ: c.typ,
+ fieldQuery: query,
+ isAddrForMarshaler: c.isAddrForMarshaler,
+ isNilableType: c.isNilableType,
+ }
+}
+
type PtrCode struct {
typ *runtime.Type
value Code
@@ -830,6 +959,14 @@ func (c *PtrCode) ToAnonymousOpcode(ctx *compileContext) Opcodes {
return codes
}
+func (c *PtrCode) Filter(query *FieldQuery) Code {
+ return &PtrCode{
+ typ: c.typ,
+ value: c.value.Filter(query),
+ ptrNum: c.ptrNum,
+ }
+}
+
func convertPtrOp(code *Opcode) OpType {
ptrHeadOp := code.Op.HeadToPtrHead()
if code.Op != ptrHeadOp {
@@ -873,3 +1010,14 @@ func convertPtrOp(code *Opcode) OpType {
}
return code.Op
}
+
+func isEmbeddedStruct(field *StructFieldCode) bool {
+ if !field.isAnonymous {
+ return false
+ }
+ t := field.typ
+ if t.Kind() == reflect.Ptr {
+ t = t.Elem()
+ }
+ return t.Kind() == reflect.Struct
+}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compiler.go b/vendor/github.com/goccy/go-json/internal/encoder/compiler.go
index cbcdb65eea..3ae39ba8c7 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/compiler.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/compiler.go
@@ -31,7 +31,7 @@ func init() {
if typeAddr == nil {
typeAddr = &runtime.TypeAddr{}
}
- cachedOpcodeSets = make([]*OpcodeSet, typeAddr.AddrRange>>typeAddr.AddrShift)
+ cachedOpcodeSets = make([]*OpcodeSet, typeAddr.AddrRange>>typeAddr.AddrShift+1)
}
func loadOpcodeMap() map[uintptr]*OpcodeSet {
@@ -63,6 +63,27 @@ func compileToGetCodeSetSlowPath(typeptr uintptr) (*OpcodeSet, error) {
return codeSet, nil
}
+func getFilteredCodeSetIfNeeded(ctx *RuntimeContext, codeSet *OpcodeSet) (*OpcodeSet, error) {
+ if (ctx.Option.Flag & ContextOption) == 0 {
+ return codeSet, nil
+ }
+ query := FieldQueryFromContext(ctx.Option.Context)
+ if query == nil {
+ return codeSet, nil
+ }
+ ctx.Option.Flag |= FieldQueryOption
+ cacheCodeSet := codeSet.getQueryCache(query.Hash())
+ if cacheCodeSet != nil {
+ return cacheCodeSet, nil
+ }
+ queryCodeSet, err := newCompiler().codeToOpcodeSet(codeSet.Type, codeSet.Code.Filter(query))
+ if err != nil {
+ return nil, err
+ }
+ codeSet.setQueryCache(query.Hash(), queryCodeSet)
+ return queryCodeSet, nil
+}
+
type Compiler struct {
structTypeToCode map[uintptr]*StructCode
}
@@ -80,6 +101,10 @@ func (c *Compiler) compile(typeptr uintptr) (*OpcodeSet, error) {
if err != nil {
return nil, err
}
+ return c.codeToOpcodeSet(typ, code)
+}
+
+func (c *Compiler) codeToOpcodeSet(typ *runtime.Type, code Code) (*OpcodeSet, error) {
noescapeKeyCode := c.codeToOpcode(&compileContext{
structTypeToCodes: map[uintptr]Opcodes{},
recursiveCodes: &Opcodes{},
@@ -107,6 +132,8 @@ func (c *Compiler) compile(typeptr uintptr) (*OpcodeSet, error) {
InterfaceEscapeKeyCode: interfaceEscapeKeyCode,
CodeLength: codeLength,
EndCode: ToEndCode(interfaceNoescapeKeyCode),
+ Code: code,
+ QueryCache: map[string]*OpcodeSet{},
}, nil
}
@@ -460,7 +487,10 @@ func (c *Compiler) listElemCode(typ *runtime.Type) (Code, error) {
case typ.Kind() == reflect.Map:
return c.ptrCode(runtime.PtrTo(typ))
default:
- code, err := c.typeToCodeWithPtr(typ, false)
+ // isPtr was originally used to indicate whether the type of top level is pointer.
+ // However, since the slice/array element is a specification that can get the pointer address, explicitly set isPtr to true.
+ // See here for related issues: https://github.com/goccy/go-json/issues/370
+ code, err := c.typeToCodeWithPtr(typ, true)
if err != nil {
return nil, err
}
@@ -476,8 +506,6 @@ func (c *Compiler) listElemCode(typ *runtime.Type) (Code, error) {
func (c *Compiler) mapKeyCode(typ *runtime.Type) (Code, error) {
switch {
- case c.implementsMarshalJSON(typ):
- return c.marshalJSONCode(typ)
case c.implementsMarshalText(typ):
return c.marshalTextCode(typ)
}
@@ -589,6 +617,13 @@ func (c *Compiler) structCode(typ *runtime.Type, isPtr bool) (*StructCode, error
return code, nil
}
+func toElemType(t *runtime.Type) *runtime.Type {
+ for t.Kind() == reflect.Ptr {
+ t = t.Elem()
+ }
+ return t
+}
+
func (c *Compiler) structFieldCode(structCode *StructCode, tag *runtime.StructTag, isPtr, isOnlyOneFirstField bool) (*StructFieldCode, error) {
field := tag.Field
fieldType := runtime.Type2RType(field.Type)
@@ -598,7 +633,7 @@ func (c *Compiler) structFieldCode(structCode *StructCode, tag *runtime.StructTa
key: tag.Key,
tag: tag,
offset: field.Offset,
- isAnonymous: field.Anonymous && !tag.IsTaggedKey,
+ isAnonymous: field.Anonymous && !tag.IsTaggedKey && toElemType(fieldType).Kind() == reflect.Struct,
isTaggedKey: tag.IsTaggedKey,
isNilableType: c.isNilableType(fieldType),
isNilCheck: true,
@@ -826,6 +861,9 @@ func (c *Compiler) implementsMarshalText(typ *runtime.Type) bool {
}
func (c *Compiler) isNilableType(typ *runtime.Type) bool {
+ if !runtime.IfaceIndir(typ) {
+ return true
+ }
switch typ.Kind() {
case reflect.Ptr:
return true
@@ -858,29 +896,40 @@ func (c *Compiler) codeToOpcode(ctx *compileContext, typ *runtime.Type, code Cod
}
func (c *Compiler) linkRecursiveCode(ctx *compileContext) {
+ recursiveCodes := map[uintptr]*CompiledCode{}
for _, recursive := range *ctx.recursiveCodes {
typeptr := uintptr(unsafe.Pointer(recursive.Type))
codes := ctx.structTypeToCodes[typeptr]
- compiled := recursive.Jmp
- compiled.Code = copyOpcode(codes.First())
- code := compiled.Code
- code.End.Next = newEndOp(&compileContext{}, recursive.Type)
+ if recursiveCode, ok := recursiveCodes[typeptr]; ok {
+ *recursive.Jmp = *recursiveCode
+ continue
+ }
+
+ code := copyOpcode(codes.First())
code.Op = code.Op.PtrHeadToHead()
+ lastCode := newEndOp(&compileContext{}, recursive.Type)
+ lastCode.Op = OpRecursiveEnd
- beforeLastCode := code.End
- lastCode := beforeLastCode.Next
+ // OpRecursiveEnd must set before call TotalLength
+ code.End.Next = lastCode
totalLength := code.TotalLength()
+
+ // Idx, ElemIdx, Length must set after call TotalLength
lastCode.Idx = uint32((totalLength + 1) * uintptrSize)
lastCode.ElemIdx = lastCode.Idx + uintptrSize
lastCode.Length = lastCode.Idx + 2*uintptrSize
- code.End.Next.Op = OpRecursiveEnd
// extend length to alloc slot for elemIdx + length
curTotalLength := uintptr(recursive.TotalLength()) + 3
nextTotalLength := uintptr(totalLength) + 3
+
+ compiled := recursive.Jmp
+ compiled.Code = code
compiled.CurLen = curTotalLength
compiled.NextLen = nextTotalLength
compiled.Linked = true
+
+ recursiveCodes[typeptr] = compiled
}
}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compiler_norace.go b/vendor/github.com/goccy/go-json/internal/encoder/compiler_norace.go
index afc5b6623a..20c93cbf70 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/compiler_norace.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/compiler_norace.go
@@ -3,18 +3,30 @@
package encoder
-func CompileToGetCodeSet(typeptr uintptr) (*OpcodeSet, error) {
- if typeptr > typeAddr.MaxTypeAddr {
- return compileToGetCodeSetSlowPath(typeptr)
+func CompileToGetCodeSet(ctx *RuntimeContext, typeptr uintptr) (*OpcodeSet, error) {
+ if typeptr > typeAddr.MaxTypeAddr || typeptr < typeAddr.BaseTypeAddr {
+ codeSet, err := compileToGetCodeSetSlowPath(typeptr)
+ if err != nil {
+ return nil, err
+ }
+ return getFilteredCodeSetIfNeeded(ctx, codeSet)
}
index := (typeptr - typeAddr.BaseTypeAddr) >> typeAddr.AddrShift
if codeSet := cachedOpcodeSets[index]; codeSet != nil {
- return codeSet, nil
+ filtered, err := getFilteredCodeSetIfNeeded(ctx, codeSet)
+ if err != nil {
+ return nil, err
+ }
+ return filtered, nil
}
codeSet, err := newCompiler().compile(typeptr)
if err != nil {
return nil, err
}
+ filtered, err := getFilteredCodeSetIfNeeded(ctx, codeSet)
+ if err != nil {
+ return nil, err
+ }
cachedOpcodeSets[index] = codeSet
- return codeSet, nil
+ return filtered, nil
}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compiler_race.go b/vendor/github.com/goccy/go-json/internal/encoder/compiler_race.go
index 846a898dda..13ba23fdff 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/compiler_race.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/compiler_race.go
@@ -9,15 +9,24 @@ import (
var setsMu sync.RWMutex
-func CompileToGetCodeSet(typeptr uintptr) (*OpcodeSet, error) {
- if typeptr > typeAddr.MaxTypeAddr {
- return compileToGetCodeSetSlowPath(typeptr)
+func CompileToGetCodeSet(ctx *RuntimeContext, typeptr uintptr) (*OpcodeSet, error) {
+ if typeptr > typeAddr.MaxTypeAddr || typeptr < typeAddr.BaseTypeAddr {
+ codeSet, err := compileToGetCodeSetSlowPath(typeptr)
+ if err != nil {
+ return nil, err
+ }
+ return getFilteredCodeSetIfNeeded(ctx, codeSet)
}
index := (typeptr - typeAddr.BaseTypeAddr) >> typeAddr.AddrShift
setsMu.RLock()
if codeSet := cachedOpcodeSets[index]; codeSet != nil {
+ filtered, err := getFilteredCodeSetIfNeeded(ctx, codeSet)
+ if err != nil {
+ setsMu.RUnlock()
+ return nil, err
+ }
setsMu.RUnlock()
- return codeSet, nil
+ return filtered, nil
}
setsMu.RUnlock()
@@ -25,8 +34,12 @@ func CompileToGetCodeSet(typeptr uintptr) (*OpcodeSet, error) {
if err != nil {
return nil, err
}
+ filtered, err := getFilteredCodeSetIfNeeded(ctx, codeSet)
+ if err != nil {
+ return nil, err
+ }
setsMu.Lock()
cachedOpcodeSets[index] = codeSet
setsMu.Unlock()
- return codeSet, nil
+ return filtered, nil
}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/decode_rune.go b/vendor/github.com/goccy/go-json/internal/encoder/decode_rune.go
new file mode 100644
index 0000000000..35c959d481
--- /dev/null
+++ b/vendor/github.com/goccy/go-json/internal/encoder/decode_rune.go
@@ -0,0 +1,126 @@
+package encoder
+
+import "unicode/utf8"
+
+const (
+ // The default lowest and highest continuation byte.
+ locb = 128 //0b10000000
+ hicb = 191 //0b10111111
+
+ // These names of these constants are chosen to give nice alignment in the
+ // table below. The first nibble is an index into acceptRanges or F for
+ // special one-byte cases. The second nibble is the Rune length or the
+ // Status for the special one-byte case.
+ xx = 0xF1 // invalid: size 1
+ as = 0xF0 // ASCII: size 1
+ s1 = 0x02 // accept 0, size 2
+ s2 = 0x13 // accept 1, size 3
+ s3 = 0x03 // accept 0, size 3
+ s4 = 0x23 // accept 2, size 3
+ s5 = 0x34 // accept 3, size 4
+ s6 = 0x04 // accept 0, size 4
+ s7 = 0x44 // accept 4, size 4
+)
+
+// first is information about the first byte in a UTF-8 sequence.
+var first = [256]uint8{
+ // 1 2 3 4 5 6 7 8 9 A B C D E F
+ as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x00-0x0F
+ as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x10-0x1F
+ as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x20-0x2F
+ as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x30-0x3F
+ as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x40-0x4F
+ as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x50-0x5F
+ as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x60-0x6F
+ as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x70-0x7F
+ // 1 2 3 4 5 6 7 8 9 A B C D E F
+ xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0x80-0x8F
+ xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0x90-0x9F
+ xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xA0-0xAF
+ xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xB0-0xBF
+ xx, xx, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // 0xC0-0xCF
+ s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // 0xD0-0xDF
+ s2, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s4, s3, s3, // 0xE0-0xEF
+ s5, s6, s6, s6, s7, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xF0-0xFF
+}
+
+const (
+ lineSep = byte(168) //'\u2028'
+ paragraphSep = byte(169) //'\u2029'
+)
+
+type decodeRuneState int
+
+const (
+ validUTF8State decodeRuneState = iota
+ runeErrorState
+ lineSepState
+ paragraphSepState
+)
+
+func decodeRuneInString(s string) (decodeRuneState, int) {
+ n := len(s)
+ s0 := s[0]
+ x := first[s0]
+ if x >= as {
+ // The following code simulates an additional check for x == xx and
+ // handling the ASCII and invalid cases accordingly. This mask-and-or
+ // approach prevents an additional branch.
+ mask := rune(x) << 31 >> 31 // Create 0x0000 or 0xFFFF.
+ if rune(s[0])&^mask|utf8.RuneError&mask == utf8.RuneError {
+ return runeErrorState, 1
+ }
+ return validUTF8State, 1
+ }
+ sz := int(x & 7)
+ if n < sz {
+ return runeErrorState, 1
+ }
+ s1 := s[1]
+ switch x >> 4 {
+ case 0:
+ if s1 < locb || hicb < s1 {
+ return runeErrorState, 1
+ }
+ case 1:
+ if s1 < 0xA0 || hicb < s1 {
+ return runeErrorState, 1
+ }
+ case 2:
+ if s1 < locb || 0x9F < s1 {
+ return runeErrorState, 1
+ }
+ case 3:
+ if s1 < 0x90 || hicb < s1 {
+ return runeErrorState, 1
+ }
+ case 4:
+ if s1 < locb || 0x8F < s1 {
+ return runeErrorState, 1
+ }
+ }
+ if sz <= 2 {
+ return validUTF8State, 2
+ }
+ s2 := s[2]
+ if s2 < locb || hicb < s2 {
+ return runeErrorState, 1
+ }
+ if sz <= 3 {
+ // separator character prefixes: [2]byte{226, 128}
+ if s0 == 226 && s1 == 128 {
+ switch s2 {
+ case lineSep:
+ return lineSepState, 3
+ case paragraphSep:
+ return paragraphSepState, 3
+ }
+ }
+ return validUTF8State, 3
+ }
+ s3 := s[3]
+ if s3 < locb || hicb < s3 {
+ return runeErrorState, 1
+ }
+ return validUTF8State, 4
+}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/encoder.go b/vendor/github.com/goccy/go-json/internal/encoder/encoder.go
index b7fa99a966..14eb6a0d64 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/encoder.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/encoder.go
@@ -101,6 +101,22 @@ type OpcodeSet struct {
InterfaceEscapeKeyCode *Opcode
CodeLength int
EndCode *Opcode
+ Code Code
+ QueryCache map[string]*OpcodeSet
+ cacheMu sync.RWMutex
+}
+
+func (s *OpcodeSet) getQueryCache(hash string) *OpcodeSet {
+ s.cacheMu.RLock()
+ codeSet := s.QueryCache[hash]
+ s.cacheMu.RUnlock()
+ return codeSet
+}
+
+func (s *OpcodeSet) setQueryCache(hash string, codeSet *OpcodeSet) {
+ s.cacheMu.Lock()
+ s.QueryCache[hash] = codeSet
+ s.cacheMu.Unlock()
}
type CompiledCode struct {
@@ -222,33 +238,56 @@ func (m *Mapslice) Swap(i, j int) {
m.Items[i], m.Items[j] = m.Items[j], m.Items[i]
}
+//nolint:structcheck,unused
+type mapIter struct {
+ key unsafe.Pointer
+ elem unsafe.Pointer
+ t unsafe.Pointer
+ h unsafe.Pointer
+ buckets unsafe.Pointer
+ bptr unsafe.Pointer
+ overflow unsafe.Pointer
+ oldoverflow unsafe.Pointer
+ startBucket uintptr
+ offset uint8
+ wrapped bool
+ B uint8
+ i uint8
+ bucket uintptr
+ checkBucket uintptr
+}
+
type MapContext struct {
- Pos []int
+ Start int
+ First int
+ Idx int
Slice *Mapslice
Buf []byte
+ Len int
+ Iter mapIter
}
var mapContextPool = sync.Pool{
New: func() interface{} {
- return &MapContext{}
+ return &MapContext{
+ Slice: &Mapslice{},
+ }
},
}
-func NewMapContext(mapLen int) *MapContext {
+func NewMapContext(mapLen int, unorderedMap bool) *MapContext {
ctx := mapContextPool.Get().(*MapContext)
- if ctx.Slice == nil {
- ctx.Slice = &Mapslice{
- Items: make([]MapItem, 0, mapLen),
+ if !unorderedMap {
+ if len(ctx.Slice.Items) < mapLen {
+ ctx.Slice.Items = make([]MapItem, mapLen)
+ } else {
+ ctx.Slice.Items = ctx.Slice.Items[:mapLen]
}
}
- if cap(ctx.Pos) < (mapLen*2 + 1) {
- ctx.Pos = make([]int, 0, mapLen*2+1)
- ctx.Slice.Items = make([]MapItem, 0, mapLen)
- } else {
- ctx.Pos = ctx.Pos[:0]
- ctx.Slice.Items = ctx.Slice.Items[:0]
- }
ctx.Buf = ctx.Buf[:0]
+ ctx.Iter = mapIter{}
+ ctx.Idx = 0
+ ctx.Len = mapLen
return ctx
}
@@ -256,17 +295,17 @@ func ReleaseMapContext(c *MapContext) {
mapContextPool.Put(c)
}
-//go:linkname MapIterInit reflect.mapiterinit
+//go:linkname MapIterInit runtime.mapiterinit
//go:noescape
-func MapIterInit(mapType *runtime.Type, m unsafe.Pointer) unsafe.Pointer
+func MapIterInit(mapType *runtime.Type, m unsafe.Pointer, it *mapIter)
//go:linkname MapIterKey reflect.mapiterkey
//go:noescape
-func MapIterKey(it unsafe.Pointer) unsafe.Pointer
+func MapIterKey(it *mapIter) unsafe.Pointer
//go:linkname MapIterNext reflect.mapiternext
//go:noescape
-func MapIterNext(it unsafe.Pointer)
+func MapIterNext(it *mapIter)
//go:linkname MapLen reflect.maplen
//go:noescape
@@ -374,7 +413,11 @@ func AppendMarshalJSON(ctx *RuntimeContext, code *Opcode, b []byte, v interface{
if !ok {
return AppendNull(ctx, b), nil
}
- b, err := marshaler.MarshalJSON(ctx.Option.Context)
+ stdctx := ctx.Option.Context
+ if ctx.Option.Flag&FieldQueryOption != 0 {
+ stdctx = SetFieldQueryToContext(stdctx, code.FieldQuery)
+ }
+ b, err := marshaler.MarshalJSON(stdctx)
if err != nil {
return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
}
@@ -546,6 +589,8 @@ func IsNilForMarshaler(v interface{}) bool {
return rv.IsNil()
case reflect.Slice:
return rv.IsNil() || rv.Len() == 0
+ case reflect.String:
+ return rv.Len() == 0
}
return false
}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/map112.go b/vendor/github.com/goccy/go-json/internal/encoder/map112.go
index 31858d0001..e96ffadf7a 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/map112.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/map112.go
@@ -1,3 +1,4 @@
+//go:build !go1.13
// +build !go1.13
package encoder
@@ -5,4 +6,4 @@ package encoder
import "unsafe"
//go:linkname MapIterValue reflect.mapitervalue
-func MapIterValue(it unsafe.Pointer) unsafe.Pointer
+func MapIterValue(it *mapIter) unsafe.Pointer
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/map113.go b/vendor/github.com/goccy/go-json/internal/encoder/map113.go
index f49c27bedb..9b69dcc360 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/map113.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/map113.go
@@ -1,3 +1,4 @@
+//go:build go1.13
// +build go1.13
package encoder
@@ -5,4 +6,4 @@ package encoder
import "unsafe"
//go:linkname MapIterValue reflect.mapiterelem
-func MapIterValue(it unsafe.Pointer) unsafe.Pointer
+func MapIterValue(it *mapIter) unsafe.Pointer
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/opcode.go b/vendor/github.com/goccy/go-json/internal/encoder/opcode.go
index cfd2d5a1b3..df22f55423 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/opcode.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/opcode.go
@@ -1,7 +1,9 @@
package encoder
import (
+ "bytes"
"fmt"
+ "sort"
"strings"
"unsafe"
@@ -39,10 +41,9 @@ type Opcode struct {
Type *runtime.Type // go type
Jmp *CompiledCode // for recursive call
- ElemIdx uint32 // offset to access array/slice/map elem
- Length uint32 // offset to access slice/map length or array length
- MapIter uint32 // offset to access map iterator
- MapPos uint32 // offset to access position list for sorted map
+ FieldQuery *FieldQuery // field query for Interface / MarshalJSON / MarshalText
+ ElemIdx uint32 // offset to access array/slice elem
+ Length uint32 // offset to access slice length or array length
Indent uint32 // indent number
Size uint32 // array/slice elem size
DisplayIdx uint32 // opcode index
@@ -91,8 +92,6 @@ func (c *Opcode) MaxIdx() uint32 {
c.Idx,
c.ElemIdx,
c.Length,
- c.MapIter,
- c.MapPos,
c.Size,
} {
if max < value {
@@ -337,12 +336,11 @@ func copyOpcode(code *Opcode) *Opcode {
Idx: c.Idx,
Offset: c.Offset,
Type: c.Type,
+ FieldQuery: c.FieldQuery,
DisplayIdx: c.DisplayIdx,
DisplayKey: c.DisplayKey,
ElemIdx: c.ElemIdx,
Length: c.Length,
- MapIter: c.MapIter,
- MapPos: c.MapPos,
Size: c.Size,
Indent: c.Indent,
Jmp: c.Jmp,
@@ -367,7 +365,7 @@ func copyOpcode(code *Opcode) *Opcode {
func setTotalLengthToInterfaceOp(code *Opcode) {
for c := code; !c.IsEnd(); {
- if c.Op == OpInterface {
+ if c.Op == OpInterface || c.Op == OpInterfacePtr {
c.Length = uint32(code.TotalLength())
}
c = c.IterNext()
@@ -448,26 +446,21 @@ func (c *Opcode) dumpHead(code *Opcode) string {
func (c *Opcode) dumpMapHead(code *Opcode) string {
return fmt.Sprintf(
- `[%03d]%s%s ([idx:%d][elemIdx:%d][length:%d][mapIter:%d])`,
+ `[%03d]%s%s ([idx:%d])`,
code.DisplayIdx,
strings.Repeat("-", int(code.Indent)),
code.Op,
code.Idx/uintptrSize,
- code.ElemIdx/uintptrSize,
- code.Length/uintptrSize,
- code.MapIter/uintptrSize,
)
}
func (c *Opcode) dumpMapEnd(code *Opcode) string {
return fmt.Sprintf(
- `[%03d]%s%s ([idx:%d][mapPos:%d][length:%d])`,
+ `[%03d]%s%s ([idx:%d])`,
code.DisplayIdx,
strings.Repeat("-", int(code.Indent)),
code.Op,
code.Idx/uintptrSize,
- code.MapPos/uintptrSize,
- code.Length/uintptrSize,
)
}
@@ -504,25 +497,21 @@ func (c *Opcode) dumpField(code *Opcode) string {
func (c *Opcode) dumpKey(code *Opcode) string {
return fmt.Sprintf(
- `[%03d]%s%s ([idx:%d][elemIdx:%d][length:%d][mapIter:%d])`,
+ `[%03d]%s%s ([idx:%d])`,
code.DisplayIdx,
strings.Repeat("-", int(code.Indent)),
code.Op,
code.Idx/uintptrSize,
- code.ElemIdx/uintptrSize,
- code.Length/uintptrSize,
- code.MapIter/uintptrSize,
)
}
func (c *Opcode) dumpValue(code *Opcode) string {
return fmt.Sprintf(
- `[%03d]%s%s ([idx:%d][mapIter:%d])`,
+ `[%03d]%s%s ([idx:%d])`,
code.DisplayIdx,
strings.Repeat("-", int(code.Indent)),
code.Op,
code.Idx/uintptrSize,
- code.MapIter/uintptrSize,
)
}
@@ -568,6 +557,87 @@ func (c *Opcode) Dump() string {
return strings.Join(codes, "\n")
}
+func (c *Opcode) DumpDOT() string {
+ type edge struct {
+ from, to *Opcode
+ label string
+ weight int
+ }
+ var edges []edge
+
+ b := &bytes.Buffer{}
+ fmt.Fprintf(b, "digraph \"%p\" {\n", c.Type)
+ fmt.Fprintln(b, "mclimit=1.5;\nrankdir=TD;\nordering=out;\nnode[shape=box];")
+ for code := c; !code.IsEnd(); {
+ label := code.Op.String()
+ fmt.Fprintf(b, "\"%p\" [label=%q];\n", code, label)
+ if p := code.Next; p != nil {
+ edges = append(edges, edge{
+ from: code,
+ to: p,
+ label: "Next",
+ weight: 10,
+ })
+ }
+ if p := code.NextField; p != nil {
+ edges = append(edges, edge{
+ from: code,
+ to: p,
+ label: "NextField",
+ weight: 2,
+ })
+ }
+ if p := code.End; p != nil {
+ edges = append(edges, edge{
+ from: code,
+ to: p,
+ label: "End",
+ weight: 1,
+ })
+ }
+ if p := code.Jmp; p != nil {
+ edges = append(edges, edge{
+ from: code,
+ to: p.Code,
+ label: "Jmp",
+ weight: 1,
+ })
+ }
+
+ switch code.Op.CodeType() {
+ case CodeSliceHead:
+ code = code.Next
+ case CodeMapHead:
+ code = code.Next
+ case CodeArrayElem, CodeSliceElem:
+ code = code.End
+ case CodeMapKey:
+ code = code.End
+ case CodeMapValue:
+ code = code.Next
+ case CodeMapEnd:
+ code = code.Next
+ case CodeStructField:
+ code = code.Next
+ case CodeStructEnd:
+ code = code.Next
+ default:
+ code = code.Next
+ }
+ if code.IsEnd() {
+ fmt.Fprintf(b, "\"%p\" [label=%q];\n", code, code.Op.String())
+ }
+ }
+ sort.Slice(edges, func(i, j int) bool {
+ return edges[i].to.DisplayIdx < edges[j].to.DisplayIdx
+ })
+ for _, e := range edges {
+ fmt.Fprintf(b, "\"%p\" -> \"%p\" [label=%q][weight=%d];\n", e.from, e.to, e.label, e.weight)
+ }
+ fmt.Fprint(b, "}")
+ return b.String()
+}
+
func newSliceHeaderCode(ctx *compileContext, typ *runtime.Type) *Opcode {
idx := opcodeOffset(ctx.ptrIndex)
ctx.incPtrIndex()
@@ -629,19 +699,11 @@ func newArrayElemCode(ctx *compileContext, typ *runtime.Type, head *Opcode, leng
func newMapHeaderCode(ctx *compileContext, typ *runtime.Type) *Opcode {
idx := opcodeOffset(ctx.ptrIndex)
ctx.incPtrIndex()
- elemIdx := opcodeOffset(ctx.ptrIndex)
- ctx.incPtrIndex()
- length := opcodeOffset(ctx.ptrIndex)
- ctx.incPtrIndex()
- mapIter := opcodeOffset(ctx.ptrIndex)
return &Opcode{
Op: OpMap,
Type: typ,
Idx: idx,
DisplayIdx: ctx.opcodeIndex,
- ElemIdx: elemIdx,
- Length: length,
- MapIter: mapIter,
Indent: ctx.indent,
}
}
@@ -650,11 +712,8 @@ func newMapKeyCode(ctx *compileContext, typ *runtime.Type, head *Opcode) *Opcode
return &Opcode{
Op: OpMapKey,
Type: typ,
- Idx: opcodeOffset(ctx.ptrIndex),
+ Idx: head.Idx,
DisplayIdx: ctx.opcodeIndex,
- ElemIdx: head.ElemIdx,
- Length: head.Length,
- MapIter: head.MapIter,
Indent: ctx.indent,
}
}
@@ -663,28 +722,20 @@ func newMapValueCode(ctx *compileContext, typ *runtime.Type, head *Opcode) *Opco
return &Opcode{
Op: OpMapValue,
Type: typ,
- Idx: opcodeOffset(ctx.ptrIndex),
+ Idx: head.Idx,
DisplayIdx: ctx.opcodeIndex,
- ElemIdx: head.ElemIdx,
- Length: head.Length,
- MapIter: head.MapIter,
Indent: ctx.indent,
}
}
func newMapEndCode(ctx *compileContext, typ *runtime.Type, head *Opcode) *Opcode {
- mapPos := opcodeOffset(ctx.ptrIndex)
- ctx.incPtrIndex()
- idx := opcodeOffset(ctx.ptrIndex)
return &Opcode{
Op: OpMapEnd,
Type: typ,
- Idx: idx,
- Next: newEndOp(ctx, typ),
+ Idx: head.Idx,
DisplayIdx: ctx.opcodeIndex,
- Length: head.Length,
- MapPos: mapPos,
Indent: ctx.indent,
+ Next: newEndOp(ctx, typ),
}
}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/option.go b/vendor/github.com/goccy/go-json/internal/encoder/option.go
index f5f1f044e3..12c58e46c0 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/option.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/option.go
@@ -1,6 +1,9 @@
package encoder
-import "context"
+import (
+ "context"
+ "io"
+)
type OptionFlag uint8
@@ -11,12 +14,16 @@ const (
DebugOption
ColorizeOption
ContextOption
+ NormalizeUTF8Option
+ FieldQueryOption
)
type Option struct {
Flag OptionFlag
ColorScheme *ColorScheme
Context context.Context
+ DebugOut io.Writer
+ DebugDOTOut io.WriteCloser
}
type EncodeFormat struct {
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/query.go b/vendor/github.com/goccy/go-json/internal/encoder/query.go
new file mode 100644
index 0000000000..1e1850cc15
--- /dev/null
+++ b/vendor/github.com/goccy/go-json/internal/encoder/query.go
@@ -0,0 +1,135 @@
+package encoder
+
+import (
+ "context"
+ "fmt"
+ "reflect"
+)
+
+var (
+ Marshal func(interface{}) ([]byte, error)
+ Unmarshal func([]byte, interface{}) error
+)
+
+type FieldQuery struct {
+ Name string
+ Fields []*FieldQuery
+ hash string
+}
+
+func (q *FieldQuery) Hash() string {
+ if q.hash != "" {
+ return q.hash
+ }
+ b, _ := Marshal(q)
+ q.hash = string(b)
+ return q.hash
+}
+
+func (q *FieldQuery) MarshalJSON() ([]byte, error) {
+ if q.Name != "" {
+ if len(q.Fields) > 0 {
+ return Marshal(map[string][]*FieldQuery{q.Name: q.Fields})
+ }
+ return Marshal(q.Name)
+ }
+ return Marshal(q.Fields)
+}
+
+func (q *FieldQuery) QueryString() (FieldQueryString, error) {
+ b, err := Marshal(q)
+ if err != nil {
+ return "", err
+ }
+ return FieldQueryString(b), nil
+}
+
+type FieldQueryString string
+
+func (s FieldQueryString) Build() (*FieldQuery, error) {
+ var query interface{}
+ if err := Unmarshal([]byte(s), &query); err != nil {
+ return nil, err
+ }
+ return s.build(reflect.ValueOf(query))
+}
+
+func (s FieldQueryString) build(v reflect.Value) (*FieldQuery, error) {
+ switch v.Type().Kind() {
+ case reflect.String:
+ return s.buildString(v)
+ case reflect.Map:
+ return s.buildMap(v)
+ case reflect.Slice:
+ return s.buildSlice(v)
+ case reflect.Interface:
+ return s.build(reflect.ValueOf(v.Interface()))
+ }
+ return nil, fmt.Errorf("failed to build field query")
+}
+
+func (s FieldQueryString) buildString(v reflect.Value) (*FieldQuery, error) {
+ b := []byte(v.String())
+ switch b[0] {
+ case '[', '{':
+ var query interface{}
+ if err := Unmarshal(b, &query); err != nil {
+ return nil, err
+ }
+ if str, ok := query.(string); ok {
+ return &FieldQuery{Name: str}, nil
+ }
+ return s.build(reflect.ValueOf(query))
+ }
+ return &FieldQuery{Name: string(b)}, nil
+}
+
+func (s FieldQueryString) buildSlice(v reflect.Value) (*FieldQuery, error) {
+ fields := make([]*FieldQuery, 0, v.Len())
+ for i := 0; i < v.Len(); i++ {
+ def, err := s.build(v.Index(i))
+ if err != nil {
+ return nil, err
+ }
+ fields = append(fields, def)
+ }
+ return &FieldQuery{Fields: fields}, nil
+}
+
+func (s FieldQueryString) buildMap(v reflect.Value) (*FieldQuery, error) {
+ keys := v.MapKeys()
+ if len(keys) != 1 {
+ return nil, fmt.Errorf("failed to build field query object")
+ }
+ key := keys[0]
+ if key.Type().Kind() != reflect.String {
+ return nil, fmt.Errorf("failed to build field query. invalid object key type")
+ }
+ name := key.String()
+ def, err := s.build(v.MapIndex(key))
+ if err != nil {
+ return nil, err
+ }
+ return &FieldQuery{
+ Name: name,
+ Fields: def.Fields,
+ }, nil
+}
+
+type queryKey struct{}
+
+func FieldQueryFromContext(ctx context.Context) *FieldQuery {
+ query := ctx.Value(queryKey{})
+ if query == nil {
+ return nil
+ }
+ q, ok := query.(*FieldQuery)
+ if !ok {
+ return nil
+ }
+ return q
+}
+
+func SetFieldQueryToContext(ctx context.Context, query *FieldQuery) context.Context {
+ return context.WithValue(ctx, queryKey{}, query)
+}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/string.go b/vendor/github.com/goccy/go-json/internal/encoder/string.go
index a699dba19c..e4152b27c7 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/string.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/string.go
@@ -3,7 +3,6 @@ package encoder
import (
"math/bits"
"reflect"
- "unicode/utf8"
"unsafe"
)
@@ -12,390 +11,8 @@ const (
msb = 0x8080808080808080
)
-var needEscapeWithHTML = [256]bool{
- '"': true,
- '&': true,
- '<': true,
- '>': true,
- '\\': true,
- 0x00: true,
- 0x01: true,
- 0x02: true,
- 0x03: true,
- 0x04: true,
- 0x05: true,
- 0x06: true,
- 0x07: true,
- 0x08: true,
- 0x09: true,
- 0x0a: true,
- 0x0b: true,
- 0x0c: true,
- 0x0d: true,
- 0x0e: true,
- 0x0f: true,
- 0x10: true,
- 0x11: true,
- 0x12: true,
- 0x13: true,
- 0x14: true,
- 0x15: true,
- 0x16: true,
- 0x17: true,
- 0x18: true,
- 0x19: true,
- 0x1a: true,
- 0x1b: true,
- 0x1c: true,
- 0x1d: true,
- 0x1e: true,
- 0x1f: true,
- /* 0x20 - 0x7f */
- 0x80: true,
- 0x81: true,
- 0x82: true,
- 0x83: true,
- 0x84: true,
- 0x85: true,
- 0x86: true,
- 0x87: true,
- 0x88: true,
- 0x89: true,
- 0x8a: true,
- 0x8b: true,
- 0x8c: true,
- 0x8d: true,
- 0x8e: true,
- 0x8f: true,
- 0x90: true,
- 0x91: true,
- 0x92: true,
- 0x93: true,
- 0x94: true,
- 0x95: true,
- 0x96: true,
- 0x97: true,
- 0x98: true,
- 0x99: true,
- 0x9a: true,
- 0x9b: true,
- 0x9c: true,
- 0x9d: true,
- 0x9e: true,
- 0x9f: true,
- 0xa0: true,
- 0xa1: true,
- 0xa2: true,
- 0xa3: true,
- 0xa4: true,
- 0xa5: true,
- 0xa6: true,
- 0xa7: true,
- 0xa8: true,
- 0xa9: true,
- 0xaa: true,
- 0xab: true,
- 0xac: true,
- 0xad: true,
- 0xae: true,
- 0xaf: true,
- 0xb0: true,
- 0xb1: true,
- 0xb2: true,
- 0xb3: true,
- 0xb4: true,
- 0xb5: true,
- 0xb6: true,
- 0xb7: true,
- 0xb8: true,
- 0xb9: true,
- 0xba: true,
- 0xbb: true,
- 0xbc: true,
- 0xbd: true,
- 0xbe: true,
- 0xbf: true,
- 0xc0: true,
- 0xc1: true,
- 0xc2: true,
- 0xc3: true,
- 0xc4: true,
- 0xc5: true,
- 0xc6: true,
- 0xc7: true,
- 0xc8: true,
- 0xc9: true,
- 0xca: true,
- 0xcb: true,
- 0xcc: true,
- 0xcd: true,
- 0xce: true,
- 0xcf: true,
- 0xd0: true,
- 0xd1: true,
- 0xd2: true,
- 0xd3: true,
- 0xd4: true,
- 0xd5: true,
- 0xd6: true,
- 0xd7: true,
- 0xd8: true,
- 0xd9: true,
- 0xda: true,
- 0xdb: true,
- 0xdc: true,
- 0xdd: true,
- 0xde: true,
- 0xdf: true,
- 0xe0: true,
- 0xe1: true,
- 0xe2: true,
- 0xe3: true,
- 0xe4: true,
- 0xe5: true,
- 0xe6: true,
- 0xe7: true,
- 0xe8: true,
- 0xe9: true,
- 0xea: true,
- 0xeb: true,
- 0xec: true,
- 0xed: true,
- 0xee: true,
- 0xef: true,
- 0xf0: true,
- 0xf1: true,
- 0xf2: true,
- 0xf3: true,
- 0xf4: true,
- 0xf5: true,
- 0xf6: true,
- 0xf7: true,
- 0xf8: true,
- 0xf9: true,
- 0xfa: true,
- 0xfb: true,
- 0xfc: true,
- 0xfd: true,
- 0xfe: true,
- 0xff: true,
-}
-
-var needEscape = [256]bool{
- '"': true,
- '\\': true,
- 0x00: true,
- 0x01: true,
- 0x02: true,
- 0x03: true,
- 0x04: true,
- 0x05: true,
- 0x06: true,
- 0x07: true,
- 0x08: true,
- 0x09: true,
- 0x0a: true,
- 0x0b: true,
- 0x0c: true,
- 0x0d: true,
- 0x0e: true,
- 0x0f: true,
- 0x10: true,
- 0x11: true,
- 0x12: true,
- 0x13: true,
- 0x14: true,
- 0x15: true,
- 0x16: true,
- 0x17: true,
- 0x18: true,
- 0x19: true,
- 0x1a: true,
- 0x1b: true,
- 0x1c: true,
- 0x1d: true,
- 0x1e: true,
- 0x1f: true,
- /* 0x20 - 0x7f */
- 0x80: true,
- 0x81: true,
- 0x82: true,
- 0x83: true,
- 0x84: true,
- 0x85: true,
- 0x86: true,
- 0x87: true,
- 0x88: true,
- 0x89: true,
- 0x8a: true,
- 0x8b: true,
- 0x8c: true,
- 0x8d: true,
- 0x8e: true,
- 0x8f: true,
- 0x90: true,
- 0x91: true,
- 0x92: true,
- 0x93: true,
- 0x94: true,
- 0x95: true,
- 0x96: true,
- 0x97: true,
- 0x98: true,
- 0x99: true,
- 0x9a: true,
- 0x9b: true,
- 0x9c: true,
- 0x9d: true,
- 0x9e: true,
- 0x9f: true,
- 0xa0: true,
- 0xa1: true,
- 0xa2: true,
- 0xa3: true,
- 0xa4: true,
- 0xa5: true,
- 0xa6: true,
- 0xa7: true,
- 0xa8: true,
- 0xa9: true,
- 0xaa: true,
- 0xab: true,
- 0xac: true,
- 0xad: true,
- 0xae: true,
- 0xaf: true,
- 0xb0: true,
- 0xb1: true,
- 0xb2: true,
- 0xb3: true,
- 0xb4: true,
- 0xb5: true,
- 0xb6: true,
- 0xb7: true,
- 0xb8: true,
- 0xb9: true,
- 0xba: true,
- 0xbb: true,
- 0xbc: true,
- 0xbd: true,
- 0xbe: true,
- 0xbf: true,
- 0xc0: true,
- 0xc1: true,
- 0xc2: true,
- 0xc3: true,
- 0xc4: true,
- 0xc5: true,
- 0xc6: true,
- 0xc7: true,
- 0xc8: true,
- 0xc9: true,
- 0xca: true,
- 0xcb: true,
- 0xcc: true,
- 0xcd: true,
- 0xce: true,
- 0xcf: true,
- 0xd0: true,
- 0xd1: true,
- 0xd2: true,
- 0xd3: true,
- 0xd4: true,
- 0xd5: true,
- 0xd6: true,
- 0xd7: true,
- 0xd8: true,
- 0xd9: true,
- 0xda: true,
- 0xdb: true,
- 0xdc: true,
- 0xdd: true,
- 0xde: true,
- 0xdf: true,
- 0xe0: true,
- 0xe1: true,
- 0xe2: true,
- 0xe3: true,
- 0xe4: true,
- 0xe5: true,
- 0xe6: true,
- 0xe7: true,
- 0xe8: true,
- 0xe9: true,
- 0xea: true,
- 0xeb: true,
- 0xec: true,
- 0xed: true,
- 0xee: true,
- 0xef: true,
- 0xf0: true,
- 0xf1: true,
- 0xf2: true,
- 0xf3: true,
- 0xf4: true,
- 0xf5: true,
- 0xf6: true,
- 0xf7: true,
- 0xf8: true,
- 0xf9: true,
- 0xfa: true,
- 0xfb: true,
- 0xfc: true,
- 0xfd: true,
- 0xfe: true,
- 0xff: true,
-}
-
var hex = "0123456789abcdef"
-// escapeIndex finds the index of the first char in `s` that requires escaping.
-// A char requires escaping if it's outside of the range of [0x20, 0x7F] or if
-// it includes a double quote or backslash.
-// If no chars in `s` require escaping, the return value is -1.
-func escapeIndex(s string) int {
- chunks := stringToUint64Slice(s)
- for _, n := range chunks {
- // combine masks before checking for the MSB of each byte. We include
- // `n` in the mask to check whether any of the *input* byte MSBs were
- // set (i.e. the byte was outside the ASCII range).
- mask := n | below(n, 0x20) | contains(n, '"') | contains(n, '\\')
- if (mask & msb) != 0 {
- return bits.TrailingZeros64(mask&msb) / 8
- }
- }
-
- valLen := len(s)
- for i := len(chunks) * 8; i < valLen; i++ {
- if needEscape[s[i]] {
- return i
- }
- }
-
- return -1
-}
-
-// below return a mask that can be used to determine if any of the bytes
-// in `n` are below `b`. If a byte's MSB is set in the mask then that byte was
-// below `b`. The result is only valid if `b`, and each byte in `n`, is below
-// 0x80.
-func below(n uint64, b byte) uint64 {
- return n - expand(b)
-}
-
-// contains returns a mask that can be used to determine if any of the
-// bytes in `n` are equal to `b`. If a byte's MSB is set in the mask then
-// that byte is equal to `b`. The result is only valid if `b`, and each
-// byte in `n`, is below 0x80.
-func contains(n uint64, b byte) uint64 {
- return (n ^ expand(b)) - lsb
-}
-
-// expand puts the specified byte into each of the 8 bytes of a uint64.
-func expand(b byte) uint64 {
- return lsb * uint64(b)
-}
-
//nolint:govet
func stringToUint64Slice(s string) []uint64 {
return *(*[]uint64)(unsafe.Pointer(&reflect.SliceHeader{
@@ -406,9 +23,19 @@ func stringToUint64Slice(s string) []uint64 {
}
func AppendString(ctx *RuntimeContext, buf []byte, s string) []byte {
- if ctx.Option.Flag&HTMLEscapeOption == 0 {
- return appendString(buf, s)
+ if ctx.Option.Flag&HTMLEscapeOption != 0 {
+ if ctx.Option.Flag&NormalizeUTF8Option != 0 {
+ return appendNormalizedHTMLString(buf, s)
+ }
+ return appendHTMLString(buf, s)
+ }
+ if ctx.Option.Flag&NormalizeUTF8Option != 0 {
+ return appendNormalizedString(buf, s)
}
+ return appendString(buf, s)
+}
+
+func appendNormalizedHTMLString(buf []byte, s string) []byte {
valLen := len(s)
if valLen == 0 {
return append(buf, `""`...)
@@ -435,7 +62,7 @@ func AppendString(ctx *RuntimeContext, buf []byte, s string) []byte {
}
}
for i := len(chunks) * 8; i < valLen; i++ {
- if needEscapeWithHTML[s[i]] {
+ if needEscapeHTMLNormalizeUTF8[s[i]] {
j = i
goto ESCAPE_END
}
@@ -447,7 +74,7 @@ ESCAPE_END:
for j < valLen {
c := s[j]
- if !needEscapeWithHTML[c] {
+ if !needEscapeHTMLNormalizeUTF8[c] {
// fast path: most of the time, printable ascii characters are used
j++
continue
@@ -489,10 +116,9 @@ ESCAPE_END:
i = j + 1
j = j + 1
continue
- }
- // This encodes bytes < 0x20 except for \t, \n and \r.
- if c < 0x20 {
+ case 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0B, 0x0C, 0x0E, 0x0F, // 0x00-0x0F
+ 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F: // 0x10-0x1F
buf = append(buf, s[i:j]...)
buf = append(buf, `\u00`...)
buf = append(buf, hex[c>>4], hex[c&0xF])
@@ -500,19 +126,14 @@ ESCAPE_END:
j = j + 1
continue
}
-
- r, size := utf8.DecodeRuneInString(s[j:])
-
- if r == utf8.RuneError && size == 1 {
+ state, size := decodeRuneInString(s[j:])
+ switch state {
+ case runeErrorState:
buf = append(buf, s[i:j]...)
buf = append(buf, `\ufffd`...)
- i = j + size
- j = j + size
+ i = j + 1
+ j = j + 1
continue
- }
-
- switch r {
- case '\u2028', '\u2029':
// U+2028 is LINE SEPARATOR.
// U+2029 is PARAGRAPH SEPARATOR.
// They are both technically valid characters in JSON strings,
@@ -520,39 +141,65 @@ ESCAPE_END:
// and can lead to security holes there. It is valid JSON to
// escape them, so we do so unconditionally.
// See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
+ case lineSepState:
+ buf = append(buf, s[i:j]...)
+ buf = append(buf, `\u2028`...)
+ i = j + 3
+ j = j + 3
+ continue
+ case paragraphSepState:
buf = append(buf, s[i:j]...)
- buf = append(buf, `\u202`...)
- buf = append(buf, hex[r&0xF])
- i = j + size
- j = j + size
+ buf = append(buf, `\u2029`...)
+ i = j + 3
+ j = j + 3
continue
}
-
j += size
}
return append(append(buf, s[i:]...), '"')
}
-func appendString(buf []byte, s string) []byte {
+func appendHTMLString(buf []byte, s string) []byte {
valLen := len(s)
if valLen == 0 {
return append(buf, `""`...)
}
buf = append(buf, '"')
- var escapeIdx int
+ var (
+ i, j int
+ )
if valLen >= 8 {
- if escapeIdx = escapeIndex(s); escapeIdx < 0 {
- return append(append(buf, s...), '"')
+ chunks := stringToUint64Slice(s)
+ for _, n := range chunks {
+ // combine masks before checking for the MSB of each byte. We include
+ // `n` in the mask to check whether any of the *input* byte MSBs were
+ // set (i.e. the byte was outside the ASCII range).
+ mask := n | (n - (lsb * 0x20)) |
+ ((n ^ (lsb * '"')) - lsb) |
+ ((n ^ (lsb * '\\')) - lsb) |
+ ((n ^ (lsb * '<')) - lsb) |
+ ((n ^ (lsb * '>')) - lsb) |
+ ((n ^ (lsb * '&')) - lsb)
+ if (mask & msb) != 0 {
+ j = bits.TrailingZeros64(mask&msb) / 8
+ goto ESCAPE_END
+ }
+ }
+ for i := len(chunks) * 8; i < valLen; i++ {
+ if needEscapeHTML[s[i]] {
+ j = i
+ goto ESCAPE_END
+ }
}
+ // no found any escape characters.
+ return append(append(buf, s...), '"')
}
-
- i := 0
- j := escapeIdx
+ESCAPE_END:
for j < valLen {
c := s[j]
- if c >= 0x20 && c <= 0x7f && c != '\\' && c != '"' {
+ if !needEscapeHTML[c] {
// fast path: most of the time, printable ascii characters are used
j++
continue
@@ -594,10 +241,9 @@ func appendString(buf []byte, s string) []byte {
i = j + 1
j = j + 1
continue
- }
- // This encodes bytes < 0x20 except for \t, \n and \r.
- if c < 0x20 {
+ case 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0B, 0x0C, 0x0E, 0x0F, // 0x00-0x0F
+ 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F: // 0x10-0x1F
buf = append(buf, s[i:j]...)
buf = append(buf, `\u00`...)
buf = append(buf, hex[c>>4], hex[c&0xF])
@@ -605,19 +251,101 @@ func appendString(buf []byte, s string) []byte {
j = j + 1
continue
}
+ j++
+ }
+
+ return append(append(buf, s[i:]...), '"')
+}
+
+func appendNormalizedString(buf []byte, s string) []byte {
+ valLen := len(s)
+ if valLen == 0 {
+ return append(buf, `""`...)
+ }
+ buf = append(buf, '"')
+ var (
+ i, j int
+ )
+ if valLen >= 8 {
+ chunks := stringToUint64Slice(s)
+ for _, n := range chunks {
+ // combine masks before checking for the MSB of each byte. We include
+ // `n` in the mask to check whether any of the *input* byte MSBs were
+ // set (i.e. the byte was outside the ASCII range).
+ mask := n | (n - (lsb * 0x20)) |
+ ((n ^ (lsb * '"')) - lsb) |
+ ((n ^ (lsb * '\\')) - lsb)
+ if (mask & msb) != 0 {
+ j = bits.TrailingZeros64(mask&msb) / 8
+ goto ESCAPE_END
+ }
+ }
+ valLen := len(s)
+ for i := len(chunks) * 8; i < valLen; i++ {
+ if needEscapeNormalizeUTF8[s[i]] {
+ j = i
+ goto ESCAPE_END
+ }
+ }
+ return append(append(buf, s...), '"')
+ }
+ESCAPE_END:
+ for j < valLen {
+ c := s[j]
- r, size := utf8.DecodeRuneInString(s[j:])
+ if !needEscapeNormalizeUTF8[c] {
+ // fast path: most of the time, printable ascii characters are used
+ j++
+ continue
+ }
- if r == utf8.RuneError && size == 1 {
+ switch c {
+ case '\\', '"':
buf = append(buf, s[i:j]...)
- buf = append(buf, `\ufffd`...)
- i = j + size
- j = j + size
+ buf = append(buf, '\\', c)
+ i = j + 1
+ j = j + 1
+ continue
+
+ case '\n':
+ buf = append(buf, s[i:j]...)
+ buf = append(buf, '\\', 'n')
+ i = j + 1
+ j = j + 1
+ continue
+
+ case '\r':
+ buf = append(buf, s[i:j]...)
+ buf = append(buf, '\\', 'r')
+ i = j + 1
+ j = j + 1
+ continue
+
+ case '\t':
+ buf = append(buf, s[i:j]...)
+ buf = append(buf, '\\', 't')
+ i = j + 1
+ j = j + 1
+ continue
+
+ case 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0B, 0x0C, 0x0E, 0x0F, // 0x00-0x0F
+ 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F: // 0x10-0x1F
+ buf = append(buf, s[i:j]...)
+ buf = append(buf, `\u00`...)
+ buf = append(buf, hex[c>>4], hex[c&0xF])
+ i = j + 1
+ j = j + 1
continue
}
- switch r {
- case '\u2028', '\u2029':
+ state, size := decodeRuneInString(s[j:])
+ switch state {
+ case runeErrorState:
+ buf = append(buf, s[i:j]...)
+ buf = append(buf, `\ufffd`...)
+ i = j + 1
+ j = j + 1
+ continue
// U+2028 is LINE SEPARATOR.
// U+2029 is PARAGRAPH SEPARATOR.
// They are both technically valid characters in JSON strings,
@@ -625,16 +353,107 @@ func appendString(buf []byte, s string) []byte {
// and can lead to security holes there. It is valid JSON to
// escape them, so we do so unconditionally.
// See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
+ case lineSepState:
+ buf = append(buf, s[i:j]...)
+ buf = append(buf, `\u2028`...)
+ i = j + 3
+ j = j + 3
+ continue
+ case paragraphSepState:
buf = append(buf, s[i:j]...)
- buf = append(buf, `\u202`...)
- buf = append(buf, hex[r&0xF])
- i = j + size
- j = j + size
+ buf = append(buf, `\u2029`...)
+ i = j + 3
+ j = j + 3
continue
}
-
j += size
}
return append(append(buf, s[i:]...), '"')
}
+
+func appendString(buf []byte, s string) []byte {
+ valLen := len(s)
+ if valLen == 0 {
+ return append(buf, `""`...)
+ }
+ buf = append(buf, '"')
+ var (
+ i, j int
+ )
+ if valLen >= 8 {
+ chunks := stringToUint64Slice(s)
+ for _, n := range chunks {
+ // combine masks before checking for the MSB of each byte. We include
+ // `n` in the mask to check whether any of the *input* byte MSBs were
+ // set (i.e. the byte was outside the ASCII range).
+ mask := n | (n - (lsb * 0x20)) |
+ ((n ^ (lsb * '"')) - lsb) |
+ ((n ^ (lsb * '\\')) - lsb)
+ if (mask & msb) != 0 {
+ j = bits.TrailingZeros64(mask&msb) / 8
+ goto ESCAPE_END
+ }
+ }
+ valLen := len(s)
+ for i := len(chunks) * 8; i < valLen; i++ {
+ if needEscape[s[i]] {
+ j = i
+ goto ESCAPE_END
+ }
+ }
+ return append(append(buf, s...), '"')
+ }
+ESCAPE_END:
+ for j < valLen {
+ c := s[j]
+
+ if !needEscape[c] {
+ // fast path: most of the time, printable ascii characters are used
+ j++
+ continue
+ }
+
+ switch c {
+ case '\\', '"':
+ buf = append(buf, s[i:j]...)
+ buf = append(buf, '\\', c)
+ i = j + 1
+ j = j + 1
+ continue
+
+ case '\n':
+ buf = append(buf, s[i:j]...)
+ buf = append(buf, '\\', 'n')
+ i = j + 1
+ j = j + 1
+ continue
+
+ case '\r':
+ buf = append(buf, s[i:j]...)
+ buf = append(buf, '\\', 'r')
+ i = j + 1
+ j = j + 1
+ continue
+
+ case '\t':
+ buf = append(buf, s[i:j]...)
+ buf = append(buf, '\\', 't')
+ i = j + 1
+ j = j + 1
+ continue
+
+ case 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0B, 0x0C, 0x0E, 0x0F, // 0x00-0x0F
+ 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F: // 0x10-0x1F
+ buf = append(buf, s[i:j]...)
+ buf = append(buf, `\u00`...)
+ buf = append(buf, hex[c>>4], hex[c&0xF])
+ i = j + 1
+ j = j + 1
+ continue
+ }
+ j++
+ }
+
+ return append(append(buf, s[i:]...), '"')
+}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/string_table.go b/vendor/github.com/goccy/go-json/internal/encoder/string_table.go
new file mode 100644
index 0000000000..ebe42c92df
--- /dev/null
+++ b/vendor/github.com/goccy/go-json/internal/encoder/string_table.go
@@ -0,0 +1,415 @@
+package encoder
+
+var needEscapeHTMLNormalizeUTF8 = [256]bool{
+ '"': true,
+ '&': true,
+ '<': true,
+ '>': true,
+ '\\': true,
+ 0x00: true,
+ 0x01: true,
+ 0x02: true,
+ 0x03: true,
+ 0x04: true,
+ 0x05: true,
+ 0x06: true,
+ 0x07: true,
+ 0x08: true,
+ 0x09: true,
+ 0x0a: true,
+ 0x0b: true,
+ 0x0c: true,
+ 0x0d: true,
+ 0x0e: true,
+ 0x0f: true,
+ 0x10: true,
+ 0x11: true,
+ 0x12: true,
+ 0x13: true,
+ 0x14: true,
+ 0x15: true,
+ 0x16: true,
+ 0x17: true,
+ 0x18: true,
+ 0x19: true,
+ 0x1a: true,
+ 0x1b: true,
+ 0x1c: true,
+ 0x1d: true,
+ 0x1e: true,
+ 0x1f: true,
+ /* 0x20 - 0x7f */
+ 0x80: true,
+ 0x81: true,
+ 0x82: true,
+ 0x83: true,
+ 0x84: true,
+ 0x85: true,
+ 0x86: true,
+ 0x87: true,
+ 0x88: true,
+ 0x89: true,
+ 0x8a: true,
+ 0x8b: true,
+ 0x8c: true,
+ 0x8d: true,
+ 0x8e: true,
+ 0x8f: true,
+ 0x90: true,
+ 0x91: true,
+ 0x92: true,
+ 0x93: true,
+ 0x94: true,
+ 0x95: true,
+ 0x96: true,
+ 0x97: true,
+ 0x98: true,
+ 0x99: true,
+ 0x9a: true,
+ 0x9b: true,
+ 0x9c: true,
+ 0x9d: true,
+ 0x9e: true,
+ 0x9f: true,
+ 0xa0: true,
+ 0xa1: true,
+ 0xa2: true,
+ 0xa3: true,
+ 0xa4: true,
+ 0xa5: true,
+ 0xa6: true,
+ 0xa7: true,
+ 0xa8: true,
+ 0xa9: true,
+ 0xaa: true,
+ 0xab: true,
+ 0xac: true,
+ 0xad: true,
+ 0xae: true,
+ 0xaf: true,
+ 0xb0: true,
+ 0xb1: true,
+ 0xb2: true,
+ 0xb3: true,
+ 0xb4: true,
+ 0xb5: true,
+ 0xb6: true,
+ 0xb7: true,
+ 0xb8: true,
+ 0xb9: true,
+ 0xba: true,
+ 0xbb: true,
+ 0xbc: true,
+ 0xbd: true,
+ 0xbe: true,
+ 0xbf: true,
+ 0xc0: true,
+ 0xc1: true,
+ 0xc2: true,
+ 0xc3: true,
+ 0xc4: true,
+ 0xc5: true,
+ 0xc6: true,
+ 0xc7: true,
+ 0xc8: true,
+ 0xc9: true,
+ 0xca: true,
+ 0xcb: true,
+ 0xcc: true,
+ 0xcd: true,
+ 0xce: true,
+ 0xcf: true,
+ 0xd0: true,
+ 0xd1: true,
+ 0xd2: true,
+ 0xd3: true,
+ 0xd4: true,
+ 0xd5: true,
+ 0xd6: true,
+ 0xd7: true,
+ 0xd8: true,
+ 0xd9: true,
+ 0xda: true,
+ 0xdb: true,
+ 0xdc: true,
+ 0xdd: true,
+ 0xde: true,
+ 0xdf: true,
+ 0xe0: true,
+ 0xe1: true,
+ 0xe2: true,
+ 0xe3: true,
+ 0xe4: true,
+ 0xe5: true,
+ 0xe6: true,
+ 0xe7: true,
+ 0xe8: true,
+ 0xe9: true,
+ 0xea: true,
+ 0xeb: true,
+ 0xec: true,
+ 0xed: true,
+ 0xee: true,
+ 0xef: true,
+ 0xf0: true,
+ 0xf1: true,
+ 0xf2: true,
+ 0xf3: true,
+ 0xf4: true,
+ 0xf5: true,
+ 0xf6: true,
+ 0xf7: true,
+ 0xf8: true,
+ 0xf9: true,
+ 0xfa: true,
+ 0xfb: true,
+ 0xfc: true,
+ 0xfd: true,
+ 0xfe: true,
+ 0xff: true,
+}
+
+var needEscapeNormalizeUTF8 = [256]bool{
+ '"': true,
+ '\\': true,
+ 0x00: true,
+ 0x01: true,
+ 0x02: true,
+ 0x03: true,
+ 0x04: true,
+ 0x05: true,
+ 0x06: true,
+ 0x07: true,
+ 0x08: true,
+ 0x09: true,
+ 0x0a: true,
+ 0x0b: true,
+ 0x0c: true,
+ 0x0d: true,
+ 0x0e: true,
+ 0x0f: true,
+ 0x10: true,
+ 0x11: true,
+ 0x12: true,
+ 0x13: true,
+ 0x14: true,
+ 0x15: true,
+ 0x16: true,
+ 0x17: true,
+ 0x18: true,
+ 0x19: true,
+ 0x1a: true,
+ 0x1b: true,
+ 0x1c: true,
+ 0x1d: true,
+ 0x1e: true,
+ 0x1f: true,
+ /* 0x20 - 0x7f */
+ 0x80: true,
+ 0x81: true,
+ 0x82: true,
+ 0x83: true,
+ 0x84: true,
+ 0x85: true,
+ 0x86: true,
+ 0x87: true,
+ 0x88: true,
+ 0x89: true,
+ 0x8a: true,
+ 0x8b: true,
+ 0x8c: true,
+ 0x8d: true,
+ 0x8e: true,
+ 0x8f: true,
+ 0x90: true,
+ 0x91: true,
+ 0x92: true,
+ 0x93: true,
+ 0x94: true,
+ 0x95: true,
+ 0x96: true,
+ 0x97: true,
+ 0x98: true,
+ 0x99: true,
+ 0x9a: true,
+ 0x9b: true,
+ 0x9c: true,
+ 0x9d: true,
+ 0x9e: true,
+ 0x9f: true,
+ 0xa0: true,
+ 0xa1: true,
+ 0xa2: true,
+ 0xa3: true,
+ 0xa4: true,
+ 0xa5: true,
+ 0xa6: true,
+ 0xa7: true,
+ 0xa8: true,
+ 0xa9: true,
+ 0xaa: true,
+ 0xab: true,
+ 0xac: true,
+ 0xad: true,
+ 0xae: true,
+ 0xaf: true,
+ 0xb0: true,
+ 0xb1: true,
+ 0xb2: true,
+ 0xb3: true,
+ 0xb4: true,
+ 0xb5: true,
+ 0xb6: true,
+ 0xb7: true,
+ 0xb8: true,
+ 0xb9: true,
+ 0xba: true,
+ 0xbb: true,
+ 0xbc: true,
+ 0xbd: true,
+ 0xbe: true,
+ 0xbf: true,
+ 0xc0: true,
+ 0xc1: true,
+ 0xc2: true,
+ 0xc3: true,
+ 0xc4: true,
+ 0xc5: true,
+ 0xc6: true,
+ 0xc7: true,
+ 0xc8: true,
+ 0xc9: true,
+ 0xca: true,
+ 0xcb: true,
+ 0xcc: true,
+ 0xcd: true,
+ 0xce: true,
+ 0xcf: true,
+ 0xd0: true,
+ 0xd1: true,
+ 0xd2: true,
+ 0xd3: true,
+ 0xd4: true,
+ 0xd5: true,
+ 0xd6: true,
+ 0xd7: true,
+ 0xd8: true,
+ 0xd9: true,
+ 0xda: true,
+ 0xdb: true,
+ 0xdc: true,
+ 0xdd: true,
+ 0xde: true,
+ 0xdf: true,
+ 0xe0: true,
+ 0xe1: true,
+ 0xe2: true,
+ 0xe3: true,
+ 0xe4: true,
+ 0xe5: true,
+ 0xe6: true,
+ 0xe7: true,
+ 0xe8: true,
+ 0xe9: true,
+ 0xea: true,
+ 0xeb: true,
+ 0xec: true,
+ 0xed: true,
+ 0xee: true,
+ 0xef: true,
+ 0xf0: true,
+ 0xf1: true,
+ 0xf2: true,
+ 0xf3: true,
+ 0xf4: true,
+ 0xf5: true,
+ 0xf6: true,
+ 0xf7: true,
+ 0xf8: true,
+ 0xf9: true,
+ 0xfa: true,
+ 0xfb: true,
+ 0xfc: true,
+ 0xfd: true,
+ 0xfe: true,
+ 0xff: true,
+}
+
+var needEscapeHTML = [256]bool{
+ '"': true,
+ '&': true,
+ '<': true,
+ '>': true,
+ '\\': true,
+ 0x00: true,
+ 0x01: true,
+ 0x02: true,
+ 0x03: true,
+ 0x04: true,
+ 0x05: true,
+ 0x06: true,
+ 0x07: true,
+ 0x08: true,
+ 0x09: true,
+ 0x0a: true,
+ 0x0b: true,
+ 0x0c: true,
+ 0x0d: true,
+ 0x0e: true,
+ 0x0f: true,
+ 0x10: true,
+ 0x11: true,
+ 0x12: true,
+ 0x13: true,
+ 0x14: true,
+ 0x15: true,
+ 0x16: true,
+ 0x17: true,
+ 0x18: true,
+ 0x19: true,
+ 0x1a: true,
+ 0x1b: true,
+ 0x1c: true,
+ 0x1d: true,
+ 0x1e: true,
+ 0x1f: true,
+ /* 0x20 - 0xff */
+}
+
+var needEscape = [256]bool{
+ '"': true,
+ '\\': true,
+ 0x00: true,
+ 0x01: true,
+ 0x02: true,
+ 0x03: true,
+ 0x04: true,
+ 0x05: true,
+ 0x06: true,
+ 0x07: true,
+ 0x08: true,
+ 0x09: true,
+ 0x0a: true,
+ 0x0b: true,
+ 0x0c: true,
+ 0x0d: true,
+ 0x0e: true,
+ 0x0f: true,
+ 0x10: true,
+ 0x11: true,
+ 0x12: true,
+ 0x13: true,
+ 0x14: true,
+ 0x15: true,
+ 0x16: true,
+ 0x17: true,
+ 0x18: true,
+ 0x19: true,
+ 0x1a: true,
+ 0x1b: true,
+ 0x1c: true,
+ 0x1d: true,
+ 0x1e: true,
+ 0x1f: true,
+ /* 0x20 - 0xff */
+}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm/debug_vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm/debug_vm.go
index 05509feda2..82b6dd47f8 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm/debug_vm.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/vm/debug_vm.go
@@ -2,6 +2,7 @@ package vm
import (
"fmt"
+ "io"
"github.com/goccy/go-json/internal/encoder"
)
@@ -14,18 +15,24 @@ func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet)
} else {
code = codeSet.NoescapeKeyCode
}
+ if wc := ctx.Option.DebugDOTOut; wc != nil {
+ _, _ = io.WriteString(wc, code.DumpDOT())
+ wc.Close()
+ ctx.Option.DebugDOTOut = nil
+ }
if err := recover(); err != nil {
- fmt.Println("=============[DEBUG]===============")
- fmt.Println("* [TYPE]")
- fmt.Println(codeSet.Type)
- fmt.Printf("\n")
- fmt.Println("* [ALL OPCODE]")
- fmt.Println(code.Dump())
- fmt.Printf("\n")
- fmt.Println("* [CONTEXT]")
- fmt.Printf("%+v\n", ctx)
- fmt.Println("===================================")
+ w := ctx.Option.DebugOut
+ fmt.Fprintln(w, "=============[DEBUG]===============")
+ fmt.Fprintln(w, "* [TYPE]")
+ fmt.Fprintln(w, codeSet.Type)
+ fmt.Fprintf(w, "\n")
+ fmt.Fprintln(w, "* [ALL OPCODE]")
+ fmt.Fprintln(w, code.Dump())
+ fmt.Fprintf(w, "\n")
+ fmt.Fprintln(w, "* [CONTEXT]")
+ fmt.Fprintf(w, "%+v\n", ctx)
+ fmt.Fprintln(w, "===================================")
panic(err)
}
}()
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm/vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm/vm.go
index b78b5eb049..645d20f9fb 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm/vm.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/vm/vm.go
@@ -3,6 +3,7 @@ package vm
import (
"math"
+ "reflect"
"sort"
"unsafe"
@@ -194,12 +195,15 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
typ = iface.typ
}
if ifacePtr == nil {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
+ isDirectedNil := typ != nil && typ.Kind() == reflect.Struct && !runtime.IfaceIndir(typ)
+ if !isDirectedNil {
+ b = appendNullComma(ctx, b)
+ code = code.Next
+ break
+ }
}
ctx.KeepRefs = append(ctx.KeepRefs, up)
- ifaceCodeSet, err := encoder.CompileToGetCodeSet(uintptr(unsafe.Pointer(typ)))
+ ifaceCodeSet, err := encoder.CompileToGetCodeSet(ctx, uintptr(unsafe.Pointer(typ)))
if err != nil {
return nil, err
}
@@ -218,8 +222,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
oldOffset := ptrOffset
ptrOffset += totalLength * uintptrSize
oldBaseIndent := ctx.BaseIndent
- indentDiffFromTop := c.Indent - 1
- ctx.BaseIndent += code.Indent - indentDiffFromTop
+ ctx.BaseIndent += code.Indent
newLen := offsetNum + totalLength + nextTotalLength
if curlen < newLen {
@@ -403,48 +406,42 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
break
}
b = appendStructHead(ctx, b)
- iter := mapiterinit(code.Type, uptr)
- ctx.KeepRefs = append(ctx.KeepRefs, iter)
- store(ctxptr, code.ElemIdx, 0)
- store(ctxptr, code.Length, uintptr(mlen))
- store(ctxptr, code.MapIter, uintptr(iter))
- if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
+ unorderedMap := (ctx.Option.Flag & encoder.UnorderedMapOption) != 0
+ mapCtx := encoder.NewMapContext(mlen, unorderedMap)
+ mapiterinit(code.Type, uptr, &mapCtx.Iter)
+ store(ctxptr, code.Idx, uintptr(unsafe.Pointer(mapCtx)))
+ ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx))
+ if unorderedMap {
b = appendMapKeyIndent(ctx, code.Next, b)
} else {
- mapCtx := encoder.NewMapContext(mlen)
- mapCtx.Pos = append(mapCtx.Pos, len(b))
- ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx))
- store(ctxptr, code.End.MapPos, uintptr(unsafe.Pointer(mapCtx)))
+ mapCtx.Start = len(b)
+ mapCtx.First = len(b)
}
- key := mapiterkey(iter)
+ key := mapiterkey(&mapCtx.Iter)
store(ctxptr, code.Next.Idx, uintptr(key))
code = code.Next
case encoder.OpMapKey:
- idx := load(ctxptr, code.ElemIdx)
- length := load(ctxptr, code.Length)
+ mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
+ idx := mapCtx.Idx
idx++
if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
- if idx < length {
+ if idx < mapCtx.Len {
b = appendMapKeyIndent(ctx, code, b)
- store(ctxptr, code.ElemIdx, idx)
- ptr := load(ctxptr, code.MapIter)
- iter := ptrToUnsafePtr(ptr)
- key := mapiterkey(iter)
+ mapCtx.Idx = int(idx)
+ key := mapiterkey(&mapCtx.Iter)
store(ctxptr, code.Next.Idx, uintptr(key))
code = code.Next
} else {
b = appendObjectEnd(ctx, code, b)
+ encoder.ReleaseMapContext(mapCtx)
code = code.End.Next
}
} else {
- ptr := load(ctxptr, code.End.MapPos)
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(ptr))
- mapCtx.Pos = append(mapCtx.Pos, len(b))
- if idx < length {
- ptr := load(ctxptr, code.MapIter)
- iter := ptrToUnsafePtr(ptr)
- store(ctxptr, code.ElemIdx, idx)
- key := mapiterkey(iter)
+ mapCtx.Slice.Items[mapCtx.Idx].Value = b[mapCtx.Start:len(b)]
+ if idx < mapCtx.Len {
+ mapCtx.Idx = int(idx)
+ mapCtx.Start = len(b)
+ key := mapiterkey(&mapCtx.Iter)
store(ctxptr, code.Next.Idx, uintptr(key))
code = code.Next
} else {
@@ -452,46 +449,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
}
}
case encoder.OpMapValue:
+ mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
b = appendColon(ctx, b)
} else {
- ptr := load(ctxptr, code.End.MapPos)
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(ptr))
- mapCtx.Pos = append(mapCtx.Pos, len(b))
+ mapCtx.Slice.Items[mapCtx.Idx].Key = b[mapCtx.Start:len(b)]
+ mapCtx.Start = len(b)
}
- ptr := load(ctxptr, code.MapIter)
- iter := ptrToUnsafePtr(ptr)
- value := mapitervalue(iter)
+ value := mapitervalue(&mapCtx.Iter)
store(ctxptr, code.Next.Idx, uintptr(value))
- mapiternext(iter)
+ mapiternext(&mapCtx.Iter)
code = code.Next
case encoder.OpMapEnd:
// this operation only used by sorted map.
- length := int(load(ctxptr, code.Length))
- ptr := load(ctxptr, code.MapPos)
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(ptr))
- pos := mapCtx.Pos
- for i := 0; i < length; i++ {
- startKey := pos[i*2]
- startValue := pos[i*2+1]
- var endValue int
- if i+1 < length {
- endValue = pos[i*2+2]
- } else {
- endValue = len(b)
- }
- mapCtx.Slice.Items = append(mapCtx.Slice.Items, encoder.MapItem{
- Key: b[startKey:startValue],
- Value: b[startValue:endValue],
- })
- }
+ mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
sort.Sort(mapCtx.Slice)
buf := mapCtx.Buf
for _, item := range mapCtx.Slice.Items {
buf = appendMapKeyValue(ctx, code, buf, item.Key, item.Value)
}
buf = appendMapEnd(ctx, code, buf)
- b = b[:pos[0]]
+ b = b[:mapCtx.First]
b = append(b, buf...)
mapCtx.Buf = buf
encoder.ReleaseMapContext(mapCtx)
@@ -731,14 +709,15 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
if code.Flags&encoder.AnonymousHeadFlags == 0 {
b = appendStructHead(ctx, b)
}
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
+ p += uintptr(code.Offset)
+ u64 := ptrToUint64(p, code.NumBitSize)
v := u64 & ((1 << code.NumBitSize) - 1)
if v == 0 {
code = code.NextField
} else {
b = appendStructKey(ctx, code, b)
b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
+ b = appendInt(ctx, b, p, code)
b = append(b, '"')
b = appendComma(ctx, b)
code = code.Next
@@ -2979,9 +2958,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
b = appendStructHead(ctx, b)
}
b = appendStructKey(ctx, code, b)
+ p += uintptr(code.Offset)
if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalJSON {
- p = ptrToPtr(p + uintptr(code.Offset))
+ p = ptrToPtr(p)
}
}
if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
@@ -3020,9 +3000,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
if code.Flags&encoder.AnonymousHeadFlags == 0 {
b = appendStructHead(ctx, b)
}
+ p += uintptr(code.Offset)
if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON {
- p = ptrToPtr(p + uintptr(code.Offset))
+ p = ptrToPtr(p)
}
}
iface := ptrToInterface(code, p)
@@ -3140,9 +3121,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
b = appendStructHead(ctx, b)
}
b = appendStructKey(ctx, code, b)
+ p += uintptr(code.Offset)
if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalText {
- p = ptrToPtr(p + uintptr(code.Offset))
+ p = ptrToPtr(p)
}
}
if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
@@ -3181,9 +3163,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
if code.Flags&encoder.AnonymousHeadFlags == 0 {
b = appendStructHead(ctx, b)
}
+ p += uintptr(code.Offset)
if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText {
- p = ptrToPtr(p + uintptr(code.Offset))
+ p = ptrToPtr(p)
}
}
if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color/debug_vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/debug_vm.go
index 6a6a33d220..925f61ed8e 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_color/debug_vm.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/debug_vm.go
@@ -16,16 +16,17 @@ func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet)
defer func() {
if err := recover(); err != nil {
- fmt.Println("=============[DEBUG]===============")
- fmt.Println("* [TYPE]")
- fmt.Println(codeSet.Type)
- fmt.Printf("\n")
- fmt.Println("* [ALL OPCODE]")
- fmt.Println(code.Dump())
- fmt.Printf("\n")
- fmt.Println("* [CONTEXT]")
- fmt.Printf("%+v\n", ctx)
- fmt.Println("===================================")
+ w := ctx.Option.DebugOut
+ fmt.Fprintln(w, "=============[DEBUG]===============")
+ fmt.Fprintln(w, "* [TYPE]")
+ fmt.Fprintln(w, codeSet.Type)
+ fmt.Fprintf(w, "\n")
+ fmt.Fprintln(w, "* [ALL OPCODE]")
+ fmt.Fprintln(w, code.Dump())
+ fmt.Fprintf(w, "\n")
+ fmt.Fprintln(w, "* [CONTEXT]")
+ fmt.Fprintf(w, "%+v\n", ctx)
+ fmt.Fprintln(w, "===================================")
panic(err)
}
}()
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color/vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/vm.go
index c7c681820b..a63e83e550 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_color/vm.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/vm.go
@@ -3,6 +3,7 @@ package vm_color
import (
"math"
+ "reflect"
"sort"
"unsafe"
@@ -194,12 +195,15 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
typ = iface.typ
}
if ifacePtr == nil {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
+ isDirectedNil := typ != nil && typ.Kind() == reflect.Struct && !runtime.IfaceIndir(typ)
+ if !isDirectedNil {
+ b = appendNullComma(ctx, b)
+ code = code.Next
+ break
+ }
}
ctx.KeepRefs = append(ctx.KeepRefs, up)
- ifaceCodeSet, err := encoder.CompileToGetCodeSet(uintptr(unsafe.Pointer(typ)))
+ ifaceCodeSet, err := encoder.CompileToGetCodeSet(ctx, uintptr(unsafe.Pointer(typ)))
if err != nil {
return nil, err
}
@@ -218,8 +222,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
oldOffset := ptrOffset
ptrOffset += totalLength * uintptrSize
oldBaseIndent := ctx.BaseIndent
- indentDiffFromTop := c.Indent - 1
- ctx.BaseIndent += code.Indent - indentDiffFromTop
+ ctx.BaseIndent += code.Indent
newLen := offsetNum + totalLength + nextTotalLength
if curlen < newLen {
@@ -403,48 +406,42 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
break
}
b = appendStructHead(ctx, b)
- iter := mapiterinit(code.Type, uptr)
- ctx.KeepRefs = append(ctx.KeepRefs, iter)
- store(ctxptr, code.ElemIdx, 0)
- store(ctxptr, code.Length, uintptr(mlen))
- store(ctxptr, code.MapIter, uintptr(iter))
- if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
+ unorderedMap := (ctx.Option.Flag & encoder.UnorderedMapOption) != 0
+ mapCtx := encoder.NewMapContext(mlen, unorderedMap)
+ mapiterinit(code.Type, uptr, &mapCtx.Iter)
+ store(ctxptr, code.Idx, uintptr(unsafe.Pointer(mapCtx)))
+ ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx))
+ if unorderedMap {
b = appendMapKeyIndent(ctx, code.Next, b)
} else {
- mapCtx := encoder.NewMapContext(mlen)
- mapCtx.Pos = append(mapCtx.Pos, len(b))
- ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx))
- store(ctxptr, code.End.MapPos, uintptr(unsafe.Pointer(mapCtx)))
+ mapCtx.Start = len(b)
+ mapCtx.First = len(b)
}
- key := mapiterkey(iter)
+ key := mapiterkey(&mapCtx.Iter)
store(ctxptr, code.Next.Idx, uintptr(key))
code = code.Next
case encoder.OpMapKey:
- idx := load(ctxptr, code.ElemIdx)
- length := load(ctxptr, code.Length)
+ mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
+ idx := mapCtx.Idx
idx++
if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
- if idx < length {
+ if idx < mapCtx.Len {
b = appendMapKeyIndent(ctx, code, b)
- store(ctxptr, code.ElemIdx, idx)
- ptr := load(ctxptr, code.MapIter)
- iter := ptrToUnsafePtr(ptr)
- key := mapiterkey(iter)
+ mapCtx.Idx = int(idx)
+ key := mapiterkey(&mapCtx.Iter)
store(ctxptr, code.Next.Idx, uintptr(key))
code = code.Next
} else {
b = appendObjectEnd(ctx, code, b)
+ encoder.ReleaseMapContext(mapCtx)
code = code.End.Next
}
} else {
- ptr := load(ctxptr, code.End.MapPos)
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(ptr))
- mapCtx.Pos = append(mapCtx.Pos, len(b))
- if idx < length {
- ptr := load(ctxptr, code.MapIter)
- iter := ptrToUnsafePtr(ptr)
- store(ctxptr, code.ElemIdx, idx)
- key := mapiterkey(iter)
+ mapCtx.Slice.Items[mapCtx.Idx].Value = b[mapCtx.Start:len(b)]
+ if idx < mapCtx.Len {
+ mapCtx.Idx = int(idx)
+ mapCtx.Start = len(b)
+ key := mapiterkey(&mapCtx.Iter)
store(ctxptr, code.Next.Idx, uintptr(key))
code = code.Next
} else {
@@ -452,46 +449,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
}
}
case encoder.OpMapValue:
+ mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
b = appendColon(ctx, b)
} else {
- ptr := load(ctxptr, code.End.MapPos)
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(ptr))
- mapCtx.Pos = append(mapCtx.Pos, len(b))
+ mapCtx.Slice.Items[mapCtx.Idx].Key = b[mapCtx.Start:len(b)]
+ mapCtx.Start = len(b)
}
- ptr := load(ctxptr, code.MapIter)
- iter := ptrToUnsafePtr(ptr)
- value := mapitervalue(iter)
+ value := mapitervalue(&mapCtx.Iter)
store(ctxptr, code.Next.Idx, uintptr(value))
- mapiternext(iter)
+ mapiternext(&mapCtx.Iter)
code = code.Next
case encoder.OpMapEnd:
// this operation only used by sorted map.
- length := int(load(ctxptr, code.Length))
- ptr := load(ctxptr, code.MapPos)
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(ptr))
- pos := mapCtx.Pos
- for i := 0; i < length; i++ {
- startKey := pos[i*2]
- startValue := pos[i*2+1]
- var endValue int
- if i+1 < length {
- endValue = pos[i*2+2]
- } else {
- endValue = len(b)
- }
- mapCtx.Slice.Items = append(mapCtx.Slice.Items, encoder.MapItem{
- Key: b[startKey:startValue],
- Value: b[startValue:endValue],
- })
- }
+ mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
sort.Sort(mapCtx.Slice)
buf := mapCtx.Buf
for _, item := range mapCtx.Slice.Items {
buf = appendMapKeyValue(ctx, code, buf, item.Key, item.Value)
}
buf = appendMapEnd(ctx, code, buf)
- b = b[:pos[0]]
+ b = b[:mapCtx.First]
b = append(b, buf...)
mapCtx.Buf = buf
encoder.ReleaseMapContext(mapCtx)
@@ -731,14 +709,15 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
if code.Flags&encoder.AnonymousHeadFlags == 0 {
b = appendStructHead(ctx, b)
}
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
+ p += uintptr(code.Offset)
+ u64 := ptrToUint64(p, code.NumBitSize)
v := u64 & ((1 << code.NumBitSize) - 1)
if v == 0 {
code = code.NextField
} else {
b = appendStructKey(ctx, code, b)
b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
+ b = appendInt(ctx, b, p, code)
b = append(b, '"')
b = appendComma(ctx, b)
code = code.Next
@@ -2979,9 +2958,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
b = appendStructHead(ctx, b)
}
b = appendStructKey(ctx, code, b)
+ p += uintptr(code.Offset)
if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalJSON {
- p = ptrToPtr(p + uintptr(code.Offset))
+ p = ptrToPtr(p)
}
}
if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
@@ -3020,9 +3000,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
if code.Flags&encoder.AnonymousHeadFlags == 0 {
b = appendStructHead(ctx, b)
}
+ p += uintptr(code.Offset)
if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON {
- p = ptrToPtr(p + uintptr(code.Offset))
+ p = ptrToPtr(p)
}
}
iface := ptrToInterface(code, p)
@@ -3140,9 +3121,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
b = appendStructHead(ctx, b)
}
b = appendStructKey(ctx, code, b)
+ p += uintptr(code.Offset)
if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalText {
- p = ptrToPtr(p + uintptr(code.Offset))
+ p = ptrToPtr(p)
}
}
if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
@@ -3181,9 +3163,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
if code.Flags&encoder.AnonymousHeadFlags == 0 {
b = appendStructHead(ctx, b)
}
+ p += uintptr(code.Offset)
if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText {
- p = ptrToPtr(p + uintptr(code.Offset))
+ p = ptrToPtr(p)
}
}
if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/debug_vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/debug_vm.go
index a68bbf6bfc..dd4cd489e0 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/debug_vm.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/debug_vm.go
@@ -16,16 +16,17 @@ func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet)
defer func() {
if err := recover(); err != nil {
- fmt.Println("=============[DEBUG]===============")
- fmt.Println("* [TYPE]")
- fmt.Println(codeSet.Type)
- fmt.Printf("\n")
- fmt.Println("* [ALL OPCODE]")
- fmt.Println(code.Dump())
- fmt.Printf("\n")
- fmt.Println("* [CONTEXT]")
- fmt.Printf("%+v\n", ctx)
- fmt.Println("===================================")
+ w := ctx.Option.DebugOut
+ fmt.Fprintln(w, "=============[DEBUG]===============")
+ fmt.Fprintln(w, "* [TYPE]")
+ fmt.Fprintln(w, codeSet.Type)
+ fmt.Fprintf(w, "\n")
+ fmt.Fprintln(w, "* [ALL OPCODE]")
+ fmt.Fprintln(w, code.Dump())
+ fmt.Fprintf(w, "\n")
+ fmt.Fprintln(w, "* [CONTEXT]")
+ fmt.Fprintf(w, "%+v\n", ctx)
+ fmt.Fprintln(w, "===================================")
panic(err)
}
}()
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/util.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/util.go
index 60e4a8ed56..2395abec97 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/util.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/util.go
@@ -189,7 +189,7 @@ func appendNullComma(ctx *encoder.RuntimeContext, b []byte) []byte {
}
func appendColon(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, ':', ' ')
+ return append(b[:len(b)-2], ':', ' ')
}
func appendMapKeyValue(ctx *encoder.RuntimeContext, code *encoder.Opcode, b, key, value []byte) []byte {
@@ -229,8 +229,9 @@ func appendEmptyObject(_ *encoder.RuntimeContext, b []byte) []byte {
func appendObjectEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
last := len(b) - 1
- b[last] = '\n'
- b = appendIndent(ctx, b, code.Indent-1)
+ // replace comma to newline
+ b[last-1] = '\n'
+ b = appendIndent(ctx, b[:last], code.Indent)
return append(b, '}', ',', '\n')
}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/vm.go
index 691ffc6cef..3b4e22e5d4 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/vm.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/vm.go
@@ -3,6 +3,7 @@ package vm_color_indent
import (
"math"
+ "reflect"
"sort"
"unsafe"
@@ -194,12 +195,15 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
typ = iface.typ
}
if ifacePtr == nil {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
+ isDirectedNil := typ != nil && typ.Kind() == reflect.Struct && !runtime.IfaceIndir(typ)
+ if !isDirectedNil {
+ b = appendNullComma(ctx, b)
+ code = code.Next
+ break
+ }
}
ctx.KeepRefs = append(ctx.KeepRefs, up)
- ifaceCodeSet, err := encoder.CompileToGetCodeSet(uintptr(unsafe.Pointer(typ)))
+ ifaceCodeSet, err := encoder.CompileToGetCodeSet(ctx, uintptr(unsafe.Pointer(typ)))
if err != nil {
return nil, err
}
@@ -218,8 +222,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
oldOffset := ptrOffset
ptrOffset += totalLength * uintptrSize
oldBaseIndent := ctx.BaseIndent
- indentDiffFromTop := c.Indent - 1
- ctx.BaseIndent += code.Indent - indentDiffFromTop
+ ctx.BaseIndent += code.Indent
newLen := offsetNum + totalLength + nextTotalLength
if curlen < newLen {
@@ -403,48 +406,42 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
break
}
b = appendStructHead(ctx, b)
- iter := mapiterinit(code.Type, uptr)
- ctx.KeepRefs = append(ctx.KeepRefs, iter)
- store(ctxptr, code.ElemIdx, 0)
- store(ctxptr, code.Length, uintptr(mlen))
- store(ctxptr, code.MapIter, uintptr(iter))
- if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
+ unorderedMap := (ctx.Option.Flag & encoder.UnorderedMapOption) != 0
+ mapCtx := encoder.NewMapContext(mlen, unorderedMap)
+ mapiterinit(code.Type, uptr, &mapCtx.Iter)
+ store(ctxptr, code.Idx, uintptr(unsafe.Pointer(mapCtx)))
+ ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx))
+ if unorderedMap {
b = appendMapKeyIndent(ctx, code.Next, b)
} else {
- mapCtx := encoder.NewMapContext(mlen)
- mapCtx.Pos = append(mapCtx.Pos, len(b))
- ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx))
- store(ctxptr, code.End.MapPos, uintptr(unsafe.Pointer(mapCtx)))
+ mapCtx.Start = len(b)
+ mapCtx.First = len(b)
}
- key := mapiterkey(iter)
+ key := mapiterkey(&mapCtx.Iter)
store(ctxptr, code.Next.Idx, uintptr(key))
code = code.Next
case encoder.OpMapKey:
- idx := load(ctxptr, code.ElemIdx)
- length := load(ctxptr, code.Length)
+ mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
+ idx := mapCtx.Idx
idx++
if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
- if idx < length {
+ if idx < mapCtx.Len {
b = appendMapKeyIndent(ctx, code, b)
- store(ctxptr, code.ElemIdx, idx)
- ptr := load(ctxptr, code.MapIter)
- iter := ptrToUnsafePtr(ptr)
- key := mapiterkey(iter)
+ mapCtx.Idx = int(idx)
+ key := mapiterkey(&mapCtx.Iter)
store(ctxptr, code.Next.Idx, uintptr(key))
code = code.Next
} else {
b = appendObjectEnd(ctx, code, b)
+ encoder.ReleaseMapContext(mapCtx)
code = code.End.Next
}
} else {
- ptr := load(ctxptr, code.End.MapPos)
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(ptr))
- mapCtx.Pos = append(mapCtx.Pos, len(b))
- if idx < length {
- ptr := load(ctxptr, code.MapIter)
- iter := ptrToUnsafePtr(ptr)
- store(ctxptr, code.ElemIdx, idx)
- key := mapiterkey(iter)
+ mapCtx.Slice.Items[mapCtx.Idx].Value = b[mapCtx.Start:len(b)]
+ if idx < mapCtx.Len {
+ mapCtx.Idx = int(idx)
+ mapCtx.Start = len(b)
+ key := mapiterkey(&mapCtx.Iter)
store(ctxptr, code.Next.Idx, uintptr(key))
code = code.Next
} else {
@@ -452,46 +449,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
}
}
case encoder.OpMapValue:
+ mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
b = appendColon(ctx, b)
} else {
- ptr := load(ctxptr, code.End.MapPos)
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(ptr))
- mapCtx.Pos = append(mapCtx.Pos, len(b))
+ mapCtx.Slice.Items[mapCtx.Idx].Key = b[mapCtx.Start:len(b)]
+ mapCtx.Start = len(b)
}
- ptr := load(ctxptr, code.MapIter)
- iter := ptrToUnsafePtr(ptr)
- value := mapitervalue(iter)
+ value := mapitervalue(&mapCtx.Iter)
store(ctxptr, code.Next.Idx, uintptr(value))
- mapiternext(iter)
+ mapiternext(&mapCtx.Iter)
code = code.Next
case encoder.OpMapEnd:
// this operation only used by sorted map.
- length := int(load(ctxptr, code.Length))
- ptr := load(ctxptr, code.MapPos)
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(ptr))
- pos := mapCtx.Pos
- for i := 0; i < length; i++ {
- startKey := pos[i*2]
- startValue := pos[i*2+1]
- var endValue int
- if i+1 < length {
- endValue = pos[i*2+2]
- } else {
- endValue = len(b)
- }
- mapCtx.Slice.Items = append(mapCtx.Slice.Items, encoder.MapItem{
- Key: b[startKey:startValue],
- Value: b[startValue:endValue],
- })
- }
+ mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
sort.Sort(mapCtx.Slice)
buf := mapCtx.Buf
for _, item := range mapCtx.Slice.Items {
buf = appendMapKeyValue(ctx, code, buf, item.Key, item.Value)
}
buf = appendMapEnd(ctx, code, buf)
- b = b[:pos[0]]
+ b = b[:mapCtx.First]
b = append(b, buf...)
mapCtx.Buf = buf
encoder.ReleaseMapContext(mapCtx)
@@ -731,14 +709,15 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
if code.Flags&encoder.AnonymousHeadFlags == 0 {
b = appendStructHead(ctx, b)
}
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
+ p += uintptr(code.Offset)
+ u64 := ptrToUint64(p, code.NumBitSize)
v := u64 & ((1 << code.NumBitSize) - 1)
if v == 0 {
code = code.NextField
} else {
b = appendStructKey(ctx, code, b)
b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
+ b = appendInt(ctx, b, p, code)
b = append(b, '"')
b = appendComma(ctx, b)
code = code.Next
@@ -2979,9 +2958,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
b = appendStructHead(ctx, b)
}
b = appendStructKey(ctx, code, b)
+ p += uintptr(code.Offset)
if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalJSON {
- p = ptrToPtr(p + uintptr(code.Offset))
+ p = ptrToPtr(p)
}
}
if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
@@ -3020,9 +3000,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
if code.Flags&encoder.AnonymousHeadFlags == 0 {
b = appendStructHead(ctx, b)
}
+ p += uintptr(code.Offset)
if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON {
- p = ptrToPtr(p + uintptr(code.Offset))
+ p = ptrToPtr(p)
}
}
iface := ptrToInterface(code, p)
@@ -3140,9 +3121,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
b = appendStructHead(ctx, b)
}
b = appendStructKey(ctx, code, b)
+ p += uintptr(code.Offset)
if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalText {
- p = ptrToPtr(p + uintptr(code.Offset))
+ p = ptrToPtr(p)
}
}
if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
@@ -3181,9 +3163,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
if code.Flags&encoder.AnonymousHeadFlags == 0 {
b = appendStructHead(ctx, b)
}
+ p += uintptr(code.Offset)
if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText {
- p = ptrToPtr(p + uintptr(code.Offset))
+ p = ptrToPtr(p)
}
}
if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/debug_vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/debug_vm.go
index 4cfd17ab21..99395388c1 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/debug_vm.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/debug_vm.go
@@ -16,16 +16,17 @@ func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet)
defer func() {
if err := recover(); err != nil {
- fmt.Println("=============[DEBUG]===============")
- fmt.Println("* [TYPE]")
- fmt.Println(codeSet.Type)
- fmt.Printf("\n")
- fmt.Println("* [ALL OPCODE]")
- fmt.Println(code.Dump())
- fmt.Printf("\n")
- fmt.Println("* [CONTEXT]")
- fmt.Printf("%+v\n", ctx)
- fmt.Println("===================================")
+ w := ctx.Option.DebugOut
+ fmt.Fprintln(w, "=============[DEBUG]===============")
+ fmt.Fprintln(w, "* [TYPE]")
+ fmt.Fprintln(w, codeSet.Type)
+ fmt.Fprintf(w, "\n")
+ fmt.Fprintln(w, "* [ALL OPCODE]")
+ fmt.Fprintln(w, code.Dump())
+ fmt.Fprintf(w, "\n")
+ fmt.Fprintln(w, "* [CONTEXT]")
+ fmt.Fprintf(w, "%+v\n", ctx)
+ fmt.Fprintln(w, "===================================")
panic(err)
}
}()
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go
index fca8f18555..6cb745e393 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go
@@ -133,7 +133,7 @@ func appendNullComma(_ *encoder.RuntimeContext, b []byte) []byte {
}
func appendColon(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, ':', ' ')
+ return append(b[:len(b)-2], ':', ' ')
}
func appendMapKeyValue(ctx *encoder.RuntimeContext, code *encoder.Opcode, b, key, value []byte) []byte {
@@ -173,8 +173,9 @@ func appendEmptyObject(_ *encoder.RuntimeContext, b []byte) []byte {
func appendObjectEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
last := len(b) - 1
- b[last] = '\n'
- b = appendIndent(ctx, b, code.Indent-1)
+ // replace comma to newline
+ b[last-1] = '\n'
+ b = appendIndent(ctx, b[:last], code.Indent)
return append(b, '}', ',', '\n')
}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go
index fcc3b32985..836c5c8a85 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go
@@ -3,6 +3,7 @@ package vm_indent
import (
"math"
+ "reflect"
"sort"
"unsafe"
@@ -194,12 +195,15 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
typ = iface.typ
}
if ifacePtr == nil {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
+ isDirectedNil := typ != nil && typ.Kind() == reflect.Struct && !runtime.IfaceIndir(typ)
+ if !isDirectedNil {
+ b = appendNullComma(ctx, b)
+ code = code.Next
+ break
+ }
}
ctx.KeepRefs = append(ctx.KeepRefs, up)
- ifaceCodeSet, err := encoder.CompileToGetCodeSet(uintptr(unsafe.Pointer(typ)))
+ ifaceCodeSet, err := encoder.CompileToGetCodeSet(ctx, uintptr(unsafe.Pointer(typ)))
if err != nil {
return nil, err
}
@@ -218,8 +222,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
oldOffset := ptrOffset
ptrOffset += totalLength * uintptrSize
oldBaseIndent := ctx.BaseIndent
- indentDiffFromTop := c.Indent - 1
- ctx.BaseIndent += code.Indent - indentDiffFromTop
+ ctx.BaseIndent += code.Indent
newLen := offsetNum + totalLength + nextTotalLength
if curlen < newLen {
@@ -403,48 +406,42 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
break
}
b = appendStructHead(ctx, b)
- iter := mapiterinit(code.Type, uptr)
- ctx.KeepRefs = append(ctx.KeepRefs, iter)
- store(ctxptr, code.ElemIdx, 0)
- store(ctxptr, code.Length, uintptr(mlen))
- store(ctxptr, code.MapIter, uintptr(iter))
- if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
+ unorderedMap := (ctx.Option.Flag & encoder.UnorderedMapOption) != 0
+ mapCtx := encoder.NewMapContext(mlen, unorderedMap)
+ mapiterinit(code.Type, uptr, &mapCtx.Iter)
+ store(ctxptr, code.Idx, uintptr(unsafe.Pointer(mapCtx)))
+ ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx))
+ if unorderedMap {
b = appendMapKeyIndent(ctx, code.Next, b)
} else {
- mapCtx := encoder.NewMapContext(mlen)
- mapCtx.Pos = append(mapCtx.Pos, len(b))
- ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx))
- store(ctxptr, code.End.MapPos, uintptr(unsafe.Pointer(mapCtx)))
+ mapCtx.Start = len(b)
+ mapCtx.First = len(b)
}
- key := mapiterkey(iter)
+ key := mapiterkey(&mapCtx.Iter)
store(ctxptr, code.Next.Idx, uintptr(key))
code = code.Next
case encoder.OpMapKey:
- idx := load(ctxptr, code.ElemIdx)
- length := load(ctxptr, code.Length)
+ mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
+ idx := mapCtx.Idx
idx++
if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
- if idx < length {
+ if idx < mapCtx.Len {
b = appendMapKeyIndent(ctx, code, b)
- store(ctxptr, code.ElemIdx, idx)
- ptr := load(ctxptr, code.MapIter)
- iter := ptrToUnsafePtr(ptr)
- key := mapiterkey(iter)
+ mapCtx.Idx = int(idx)
+ key := mapiterkey(&mapCtx.Iter)
store(ctxptr, code.Next.Idx, uintptr(key))
code = code.Next
} else {
b = appendObjectEnd(ctx, code, b)
+ encoder.ReleaseMapContext(mapCtx)
code = code.End.Next
}
} else {
- ptr := load(ctxptr, code.End.MapPos)
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(ptr))
- mapCtx.Pos = append(mapCtx.Pos, len(b))
- if idx < length {
- ptr := load(ctxptr, code.MapIter)
- iter := ptrToUnsafePtr(ptr)
- store(ctxptr, code.ElemIdx, idx)
- key := mapiterkey(iter)
+ mapCtx.Slice.Items[mapCtx.Idx].Value = b[mapCtx.Start:len(b)]
+ if idx < mapCtx.Len {
+ mapCtx.Idx = int(idx)
+ mapCtx.Start = len(b)
+ key := mapiterkey(&mapCtx.Iter)
store(ctxptr, code.Next.Idx, uintptr(key))
code = code.Next
} else {
@@ -452,46 +449,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
}
}
case encoder.OpMapValue:
+ mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
b = appendColon(ctx, b)
} else {
- ptr := load(ctxptr, code.End.MapPos)
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(ptr))
- mapCtx.Pos = append(mapCtx.Pos, len(b))
+ mapCtx.Slice.Items[mapCtx.Idx].Key = b[mapCtx.Start:len(b)]
+ mapCtx.Start = len(b)
}
- ptr := load(ctxptr, code.MapIter)
- iter := ptrToUnsafePtr(ptr)
- value := mapitervalue(iter)
+ value := mapitervalue(&mapCtx.Iter)
store(ctxptr, code.Next.Idx, uintptr(value))
- mapiternext(iter)
+ mapiternext(&mapCtx.Iter)
code = code.Next
case encoder.OpMapEnd:
// this operation only used by sorted map.
- length := int(load(ctxptr, code.Length))
- ptr := load(ctxptr, code.MapPos)
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(ptr))
- pos := mapCtx.Pos
- for i := 0; i < length; i++ {
- startKey := pos[i*2]
- startValue := pos[i*2+1]
- var endValue int
- if i+1 < length {
- endValue = pos[i*2+2]
- } else {
- endValue = len(b)
- }
- mapCtx.Slice.Items = append(mapCtx.Slice.Items, encoder.MapItem{
- Key: b[startKey:startValue],
- Value: b[startValue:endValue],
- })
- }
+ mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
sort.Sort(mapCtx.Slice)
buf := mapCtx.Buf
for _, item := range mapCtx.Slice.Items {
buf = appendMapKeyValue(ctx, code, buf, item.Key, item.Value)
}
buf = appendMapEnd(ctx, code, buf)
- b = b[:pos[0]]
+ b = b[:mapCtx.First]
b = append(b, buf...)
mapCtx.Buf = buf
encoder.ReleaseMapContext(mapCtx)
@@ -731,14 +709,15 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
if code.Flags&encoder.AnonymousHeadFlags == 0 {
b = appendStructHead(ctx, b)
}
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
+ p += uintptr(code.Offset)
+ u64 := ptrToUint64(p, code.NumBitSize)
v := u64 & ((1 << code.NumBitSize) - 1)
if v == 0 {
code = code.NextField
} else {
b = appendStructKey(ctx, code, b)
b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
+ b = appendInt(ctx, b, p, code)
b = append(b, '"')
b = appendComma(ctx, b)
code = code.Next
@@ -2979,9 +2958,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
b = appendStructHead(ctx, b)
}
b = appendStructKey(ctx, code, b)
+ p += uintptr(code.Offset)
if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalJSON {
- p = ptrToPtr(p + uintptr(code.Offset))
+ p = ptrToPtr(p)
}
}
if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
@@ -3020,9 +3000,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
if code.Flags&encoder.AnonymousHeadFlags == 0 {
b = appendStructHead(ctx, b)
}
+ p += uintptr(code.Offset)
if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON {
- p = ptrToPtr(p + uintptr(code.Offset))
+ p = ptrToPtr(p)
}
}
iface := ptrToInterface(code, p)
@@ -3140,9 +3121,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
b = appendStructHead(ctx, b)
}
b = appendStructKey(ctx, code, b)
+ p += uintptr(code.Offset)
if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalText {
- p = ptrToPtr(p + uintptr(code.Offset))
+ p = ptrToPtr(p)
}
}
if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
@@ -3181,9 +3163,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]b
if code.Flags&encoder.AnonymousHeadFlags == 0 {
b = appendStructHead(ctx, b)
}
+ p += uintptr(code.Offset)
if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText {
- p = ptrToPtr(p + uintptr(code.Offset))
+ p = ptrToPtr(p)
}
}
if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
diff --git a/vendor/github.com/goccy/go-json/internal/errors/error.go b/vendor/github.com/goccy/go-json/internal/errors/error.go
index d58e39f4e1..9207d0ff25 100644
--- a/vendor/github.com/goccy/go-json/internal/errors/error.go
+++ b/vendor/github.com/goccy/go-json/internal/errors/error.go
@@ -162,3 +162,22 @@ func ErrInvalidBeginningOfValue(c byte, cursor int64) *SyntaxError {
Offset: cursor,
}
}
+
+type PathError struct {
+ msg string
+}
+
+func (e *PathError) Error() string {
+ return fmt.Sprintf("json: invalid path format: %s", e.msg)
+}
+
+func ErrInvalidPath(msg string, args ...interface{}) *PathError {
+ if len(args) != 0 {
+ return &PathError{msg: fmt.Sprintf(msg, args...)}
+ }
+ return &PathError{msg: msg}
+}
+
+func ErrEmptyPath() *PathError {
+ return &PathError{msg: "path is empty"}
+}
diff --git a/vendor/github.com/goccy/go-json/internal/runtime/struct_field.go b/vendor/github.com/goccy/go-json/internal/runtime/struct_field.go
index c321180a35..baab0c5978 100644
--- a/vendor/github.com/goccy/go-json/internal/runtime/struct_field.go
+++ b/vendor/github.com/goccy/go-json/internal/runtime/struct_field.go
@@ -13,7 +13,11 @@ func getTag(field reflect.StructField) string {
func IsIgnoredStructField(field reflect.StructField) bool {
if field.PkgPath != "" {
if field.Anonymous {
- if !(field.Type.Kind() == reflect.Ptr && field.Type.Elem().Kind() == reflect.Struct) && field.Type.Kind() != reflect.Struct {
+ t := field.Type
+ if t.Kind() == reflect.Ptr {
+ t = t.Elem()
+ }
+ if t.Kind() != reflect.Struct {
return true
}
} else {
diff --git a/vendor/github.com/goccy/go-json/json.go b/vendor/github.com/goccy/go-json/json.go
index 5c9448d8c1..413cb20bf3 100644
--- a/vendor/github.com/goccy/go-json/json.go
+++ b/vendor/github.com/goccy/go-json/json.go
@@ -364,3 +364,8 @@ func Valid(data []byte) bool {
}
return decoder.InputOffset() >= int64(len(data))
}
+
+func init() {
+ encoder.Marshal = Marshal
+ encoder.Unmarshal = Unmarshal
+}
diff --git a/vendor/github.com/goccy/go-json/option.go b/vendor/github.com/goccy/go-json/option.go
index ad6509183a..378031a080 100644
--- a/vendor/github.com/goccy/go-json/option.go
+++ b/vendor/github.com/goccy/go-json/option.go
@@ -1,6 +1,8 @@
package json
import (
+ "io"
+
"github.com/goccy/go-json/internal/decoder"
"github.com/goccy/go-json/internal/encoder"
)
@@ -15,6 +17,23 @@ func UnorderedMap() EncodeOptionFunc {
}
}
+// DisableHTMLEscape disables escaping of HTML characters ( '&', '<', '>' ) when encoding string.
+func DisableHTMLEscape() EncodeOptionFunc {
+ return func(opt *EncodeOption) {
+ opt.Flag &= ^encoder.HTMLEscapeOption
+ }
+}
+
+// DisableNormalizeUTF8
+// By default, when encoding string, UTF8 characters in the range of 0x80 - 0xFF are processed by applying \ufffd for invalid code and escaping for \u2028 and \u2029.
+// This option disables this behaviour. You can expect faster speeds by applying this option, but be careful.
+// encoding/json implements here: https://github.com/golang/go/blob/6178d25fc0b28724b1b5aec2b1b74fc06d9294c7/src/encoding/json/encode.go#L1067-L1093.
+func DisableNormalizeUTF8() EncodeOptionFunc {
+ return func(opt *EncodeOption) {
+ opt.Flag &= ^encoder.NormalizeUTF8Option
+ }
+}
+
// Debug outputs debug information when panic occurs during encoding.
func Debug() EncodeOptionFunc {
return func(opt *EncodeOption) {
@@ -22,6 +41,20 @@ func Debug() EncodeOptionFunc {
}
}
+// DebugWith sets the destination to write debug messages.
+func DebugWith(w io.Writer) EncodeOptionFunc {
+ return func(opt *EncodeOption) {
+ opt.DebugOut = w
+ }
+}
+
+// DebugDOT sets the destination to write opcodes graph.
+func DebugDOT(w io.WriteCloser) EncodeOptionFunc {
+ return func(opt *EncodeOption) {
+ opt.DebugDOTOut = w
+ }
+}
+
// Colorize add an identifier for coloring to the string of the encoded result.
func Colorize(scheme *ColorScheme) EncodeOptionFunc {
return func(opt *EncodeOption) {
diff --git a/vendor/github.com/goccy/go-json/path.go b/vendor/github.com/goccy/go-json/path.go
new file mode 100644
index 0000000000..38abce78f3
--- /dev/null
+++ b/vendor/github.com/goccy/go-json/path.go
@@ -0,0 +1,84 @@
+package json
+
+import (
+ "reflect"
+
+ "github.com/goccy/go-json/internal/decoder"
+)
+
+// CreatePath creates JSON Path.
+//
+// JSON Path rule
+// $ : root object or element. The JSON Path format must start with this operator, which refers to the outermost level of the JSON-formatted string.
+// . : child operator. You can identify child values using dot-notation.
+// .. : recursive descent.
+// [] : subscript operator. If the JSON object is an array, you can use brackets to specify the array index.
+// [*] : all objects/elements for array.
+//
+// Reserved words must be properly escaped when included in Path.
+//
+// Escape Rule
+// single quote style escape: e.g.) `$['a.b'].c`
+// double quote style escape: e.g.) `$."a.b".c`
+func CreatePath(p string) (*Path, error) {
+ path, err := decoder.PathString(p).Build()
+ if err != nil {
+ return nil, err
+ }
+ return &Path{path: path}, nil
+}
+
+// Path represents JSON Path.
+type Path struct {
+ path *decoder.Path
+}
+
+// RootSelectorOnly whether only the root selector ($) is used.
+func (p *Path) RootSelectorOnly() bool {
+ return p.path.RootSelectorOnly
+}
+
+// UsedSingleQuotePathSelector whether single quote-based escaping was done when building the JSON Path.
+func (p *Path) UsedSingleQuotePathSelector() bool {
+ return p.path.SingleQuotePathSelector
+}
+
+// UsedSingleQuotePathSelector whether double quote-based escaping was done when building the JSON Path.
+func (p *Path) UsedDoubleQuotePathSelector() bool {
+ return p.path.DoubleQuotePathSelector
+}
+
+// Extract extracts a specific JSON string.
+func (p *Path) Extract(data []byte, optFuncs ...DecodeOptionFunc) ([][]byte, error) {
+ return extractFromPath(p, data, optFuncs...)
+}
+
+// PathString returns original JSON Path string.
+func (p *Path) PathString() string {
+ return p.path.String()
+}
+
+// Unmarshal extract and decode the value of the part corresponding to JSON Path from the input data.
+func (p *Path) Unmarshal(data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error {
+ contents, err := extractFromPath(p, data, optFuncs...)
+ if err != nil {
+ return err
+ }
+ results := make([]interface{}, 0, len(contents))
+ for _, content := range contents {
+ var result interface{}
+ if err := Unmarshal(content, &result); err != nil {
+ return err
+ }
+ results = append(results, result)
+ }
+ if err := decoder.AssignValue(reflect.ValueOf(results), reflect.ValueOf(v)); err != nil {
+ return err
+ }
+ return nil
+}
+
+// Get extract and substitute the value of the part corresponding to JSON Path from the input value.
+func (p *Path) Get(src, dst interface{}) error {
+ return p.path.Get(reflect.ValueOf(src), reflect.ValueOf(dst))
+}
diff --git a/vendor/github.com/goccy/go-json/query.go b/vendor/github.com/goccy/go-json/query.go
new file mode 100644
index 0000000000..4b11cf20df
--- /dev/null
+++ b/vendor/github.com/goccy/go-json/query.go
@@ -0,0 +1,47 @@
+package json
+
+import (
+ "github.com/goccy/go-json/internal/encoder"
+)
+
+type (
+ // FieldQuery you can dynamically filter the fields in the structure by creating a FieldQuery,
+ // adding it to context.Context using SetFieldQueryToContext and then passing it to MarshalContext.
+ // This is a type-safe operation, so it is faster than filtering using map[string]interface{}.
+ FieldQuery = encoder.FieldQuery
+ FieldQueryString = encoder.FieldQueryString
+)
+
+var (
+ // FieldQueryFromContext get current FieldQuery from context.Context.
+ FieldQueryFromContext = encoder.FieldQueryFromContext
+ // SetFieldQueryToContext set current FieldQuery to context.Context.
+ SetFieldQueryToContext = encoder.SetFieldQueryToContext
+)
+
+// BuildFieldQuery builds FieldQuery by fieldName or sub field query.
+// First, specify the field name that you want to keep in structure type.
+// If the field you want to keep is a structure type, by creating a sub field query using BuildSubFieldQuery,
+// you can select the fields you want to keep in the structure.
+// This description can be written recursively.
+func BuildFieldQuery(fields ...FieldQueryString) (*FieldQuery, error) {
+ query, err := Marshal(fields)
+ if err != nil {
+ return nil, err
+ }
+ return FieldQueryString(query).Build()
+}
+
+// BuildSubFieldQuery builds sub field query.
+func BuildSubFieldQuery(name string) *SubFieldQuery {
+ return &SubFieldQuery{name: name}
+}
+
+type SubFieldQuery struct {
+ name string
+}
+
+func (q *SubFieldQuery) Fields(fields ...FieldQueryString) FieldQueryString {
+ query, _ := Marshal(map[string][]FieldQueryString{q.name: fields})
+ return FieldQueryString(query)
+}
diff --git a/vendor/github.com/lestrrat-go/blackmagic/blackmagic.go b/vendor/github.com/lestrrat-go/blackmagic/blackmagic.go
index c97eefd994..8d1d468543 100644
--- a/vendor/github.com/lestrrat-go/blackmagic/blackmagic.go
+++ b/vendor/github.com/lestrrat-go/blackmagic/blackmagic.go
@@ -1,9 +1,8 @@
package blackmagic
import (
+ "fmt"
"reflect"
-
- "github.com/pkg/errors"
)
// AssignIfCompatible is a convenience function to safely
@@ -23,12 +22,12 @@ func AssignIfCompatible(dst, src interface{}) error {
case reflect.Slice:
isSlice = true
default:
- return errors.Errorf("argument t to AssignIfCompatible must be a pointer or a slice: %T", src)
+ return fmt.Errorf("argument t to AssignIfCompatible must be a pointer or a slice: %T", src)
}
rv := reflect.ValueOf(dst)
if rv.Kind() != reflect.Ptr {
- return errors.Errorf(`argument to AssignIfCompatible() must be a pointer: %T`, dst)
+ return fmt.Errorf(`argument to AssignIfCompatible() must be a pointer: %T`, dst)
}
actualDst := rv.Elem()
@@ -43,11 +42,11 @@ func AssignIfCompatible(dst, src interface{}) error {
}
}
if !result.Type().AssignableTo(actualDst.Type()) {
- return errors.Errorf(`argument to AssignIfCompatible() must be compatible with %T (was %T)`, orv.Interface(), dst)
+ return fmt.Errorf(`argument to AssignIfCompatible() must be compatible with %T (was %T)`, orv.Interface(), dst)
}
if !actualDst.CanSet() {
- return errors.Errorf(`argument to AssignIfCompatible() must be settable`)
+ return fmt.Errorf(`argument to AssignIfCompatible() must be settable`)
}
actualDst.Set(result)
diff --git a/vendor/github.com/lestrrat-go/httpcc/httpcc.go b/vendor/github.com/lestrrat-go/httpcc/httpcc.go
index 454615094e..14679f9b1c 100644
--- a/vendor/github.com/lestrrat-go/httpcc/httpcc.go
+++ b/vendor/github.com/lestrrat-go/httpcc/httpcc.go
@@ -2,11 +2,10 @@ package httpcc
import (
"bufio"
+ "fmt"
"strconv"
"strings"
"unicode/utf8"
-
- "github.com/pkg/errors"
)
const (
@@ -103,28 +102,28 @@ func parseDirective(s string, ccd directiveValidator) (*TokenPair, error) {
switch ccd.Validate(pair.Name) {
case TokenOnly:
if v[0] == '"' {
- return nil, errors.Errorf(`invalid value for %s (quoted string not allowed)`, pair.Name)
+ return nil, fmt.Errorf(`invalid value for %s (quoted string not allowed)`, pair.Name)
}
case QuotedStringOnly: // quoted-string only
if v[0] != '"' {
- return nil, errors.Errorf(`invalid value for %s (bare token not allowed)`, pair.Name)
+ return nil, fmt.Errorf(`invalid value for %s (bare token not allowed)`, pair.Name)
}
tmp, err := strconv.Unquote(v)
if err != nil {
- return nil, errors.Errorf(`malformed quoted string in token`)
+ return nil, fmt.Errorf(`malformed quoted string in token`)
}
v = tmp
case AnyTokenValue:
if v[0] == '"' {
tmp, err := strconv.Unquote(v)
if err != nil {
- return nil, errors.Errorf(`malformed quoted string in token`)
+ return nil, fmt.Errorf(`malformed quoted string in token`)
}
v = tmp
}
case NoArgument:
if len(v) > 0 {
- return nil, errors.Errorf(`received argument to directive %s`, pair.Name)
+ return nil, fmt.Errorf(`received argument to directive %s`, pair.Name)
}
}
@@ -148,7 +147,7 @@ func parseDirectives(s string, p func(string) (*TokenPair, error)) ([]*TokenPair
for scanner.Scan() {
tok, err := p(scanner.Text())
if err != nil {
- return nil, errors.Wrapf(err, `failed to parse token #%d`, len(tokens)+1)
+ return nil, fmt.Errorf(`failed to parse token #%d: %w`, len(tokens)+1, err)
}
tokens = append(tokens, tok)
}
@@ -220,7 +219,7 @@ func ParseRequest(v string) (*RequestDirective, error) {
var dir RequestDirective
tokens, err := ParseRequestDirectives(v)
if err != nil {
- return nil, errors.Wrap(err, `failed to parse tokens`)
+ return nil, fmt.Errorf(`failed to parse tokens: %w`, err)
}
for _, token := range tokens {
@@ -229,19 +228,19 @@ func ParseRequest(v string) (*RequestDirective, error) {
case MaxAge:
iv, err := strconv.ParseUint(token.Value, 10, 64)
if err != nil {
- return nil, errors.Wrap(err, `failed to parse max-age`)
+ return nil, fmt.Errorf(`failed to parse max-age: %w`, err)
}
dir.maxAge = &iv
case MaxStale:
iv, err := strconv.ParseUint(token.Value, 10, 64)
if err != nil {
- return nil, errors.Wrap(err, `failed to parse max-stale`)
+ return nil, fmt.Errorf(`failed to parse max-stale: %w`, err)
}
dir.maxStale = &iv
case MinFresh:
iv, err := strconv.ParseUint(token.Value, 10, 64)
if err != nil {
- return nil, errors.Wrap(err, `failed to parse min-fresh`)
+ return nil, fmt.Errorf(`failed to parse min-fresh: %w`, err)
}
dir.minFresh = &iv
case NoCache:
@@ -263,7 +262,7 @@ func ParseRequest(v string) (*RequestDirective, error) {
func ParseResponse(v string) (*ResponseDirective, error) {
tokens, err := ParseResponseDirectives(v)
if err != nil {
- return nil, errors.Wrap(err, `failed to parse tokens`)
+ return nil, fmt.Errorf(`failed to parse tokens: %w`, err)
}
var dir ResponseDirective
@@ -274,7 +273,7 @@ func ParseResponse(v string) (*ResponseDirective, error) {
case MaxAge:
iv, err := strconv.ParseUint(token.Value, 10, 64)
if err != nil {
- return nil, errors.Wrap(err, `failed to parse max-age`)
+ return nil, fmt.Errorf(`failed to parse max-age: %w`, err)
}
dir.maxAge = &iv
case NoCache:
@@ -300,7 +299,7 @@ func ParseResponse(v string) (*ResponseDirective, error) {
case SMaxAge:
iv, err := strconv.ParseUint(token.Value, 10, 64)
if err != nil {
- return nil, errors.Wrap(err, `failed to parse s-maxage`)
+ return nil, fmt.Errorf(`failed to parse s-maxage: %w`, err)
}
dir.sMaxAge = &iv
default:
diff --git a/vendor/github.com/lestrrat-go/iter/arrayiter/arrayiter.go b/vendor/github.com/lestrrat-go/iter/arrayiter/arrayiter.go
index 435cfa78f5..b531e769e0 100644
--- a/vendor/github.com/lestrrat-go/iter/arrayiter/arrayiter.go
+++ b/vendor/github.com/lestrrat-go/iter/arrayiter/arrayiter.go
@@ -2,10 +2,9 @@ package arrayiter
import (
"context"
+ "fmt"
"reflect"
"sync"
-
- "github.com/pkg/errors"
)
func Iterate(ctx context.Context, a interface{}) (Iterator, error) {
@@ -14,7 +13,7 @@ func Iterate(ctx context.Context, a interface{}) (Iterator, error) {
switch arv.Kind() {
case reflect.Array, reflect.Slice:
default:
- return nil, errors.Errorf(`argument must be an array/slice (%s)`, arv.Type())
+ return nil, fmt.Errorf(`argument must be an array/slice (%s)`, arv.Type())
}
ch := make(chan *Pair)
@@ -119,7 +118,7 @@ func Walk(ctx context.Context, s Source, v Visitor) error {
for i := s.Iterate(ctx); i.Next(ctx); {
pair := i.Pair()
if err := v.Visit(pair.Index, pair.Value); err != nil {
- return errors.Wrapf(err, `failed to visit index %d`, pair.Index)
+ return fmt.Errorf(`failed to visit index %d: %w`, pair.Index, err)
}
}
return nil
@@ -131,13 +130,13 @@ func AsArray(ctx context.Context, s interface{}, v interface{}) error {
case reflect.Array, reflect.Slice:
x, err := Iterate(ctx, s)
if err != nil {
- return errors.Wrap(err, `failed to iterate over array/slice type`)
+ return fmt.Errorf(`failed to iterate over array/slice type: %w`, err)
}
iter = x
default:
ssrc, ok := s.(Source)
if !ok {
- return errors.Errorf(`cannot iterate over %T: not a arrayiter.Source type`, s)
+ return fmt.Errorf(`cannot iterate over %T: not a arrayiter.Source type`, s)
}
iter = ssrc.Iterate(ctx)
}
@@ -146,14 +145,14 @@ func AsArray(ctx context.Context, s interface{}, v interface{}) error {
// dst MUST be a pointer to a array type
if kind := dst.Kind(); kind != reflect.Ptr {
- return errors.Errorf(`dst must be a pointer to a array (%s)`, dst.Type())
+ return fmt.Errorf(`dst must be a pointer to a array (%s)`, dst.Type())
}
dst = dst.Elem()
switch dst.Kind() {
case reflect.Array, reflect.Slice:
default:
- return errors.Errorf(`dst must be a pointer to an array or slice (%s)`, dst.Type())
+ return fmt.Errorf(`dst must be a pointer to an array or slice (%s)`, dst.Type())
}
var pairs []*Pair
@@ -165,7 +164,7 @@ func AsArray(ctx context.Context, s interface{}, v interface{}) error {
switch dst.Kind() {
case reflect.Array:
if len(pairs) < dst.Len() {
- return errors.Errorf(`dst array does not have enough space for elements (%d, want %d)`, dst.Len(), len(pairs))
+ return fmt.Errorf(`dst array does not have enough space for elements (%d, want %d)`, dst.Len(), len(pairs))
}
case reflect.Slice:
if dst.IsNil() {
@@ -175,7 +174,7 @@ func AsArray(ctx context.Context, s interface{}, v interface{}) error {
// dst must be assignable
if !dst.CanSet() {
- return errors.New(`dst is not writeable`)
+ return fmt.Errorf(`dst is not writeable`)
}
elemtyp := dst.Type().Elem()
@@ -183,7 +182,7 @@ func AsArray(ctx context.Context, s interface{}, v interface{}) error {
rvvalue := reflect.ValueOf(pair.Value)
if !rvvalue.Type().AssignableTo(elemtyp) {
- return errors.Errorf(`cannot assign key of type %s to map key of type %s`, rvvalue.Type(), elemtyp)
+ return fmt.Errorf(`cannot assign key of type %s to map key of type %s`, rvvalue.Type(), elemtyp)
}
dst.Index(pair.Index).Set(rvvalue)
diff --git a/vendor/github.com/lestrrat-go/iter/mapiter/mapiter.go b/vendor/github.com/lestrrat-go/iter/mapiter/mapiter.go
index 331a978f5f..ec332855eb 100644
--- a/vendor/github.com/lestrrat-go/iter/mapiter/mapiter.go
+++ b/vendor/github.com/lestrrat-go/iter/mapiter/mapiter.go
@@ -2,10 +2,9 @@ package mapiter
import (
"context"
+ "fmt"
"reflect"
"sync"
-
- "github.com/pkg/errors"
)
// Iterate creates an iterator from arbitrary map types. This is not
@@ -17,7 +16,7 @@ func Iterate(ctx context.Context, m interface{}) (Iterator, error) {
mrv := reflect.ValueOf(m)
if mrv.Kind() != reflect.Map {
- return nil, errors.Errorf(`argument must be a map (%s)`, mrv.Type())
+ return nil, fmt.Errorf(`argument must be a map (%s)`, mrv.Type())
}
ch := make(chan *Pair)
@@ -121,7 +120,7 @@ func Walk(ctx context.Context, s Source, v Visitor) error {
for i := s.Iterate(ctx); i.Next(ctx); {
pair := i.Pair()
if err := v.Visit(pair.Key, pair.Value); err != nil {
- return errors.Wrapf(err, `failed to visit key %s`, pair.Key)
+ return fmt.Errorf(`failed to visit key %s: %w`, pair.Key, err)
}
}
return nil
@@ -134,13 +133,13 @@ func AsMap(ctx context.Context, s interface{}, v interface{}) error {
case reflect.Map:
x, err := Iterate(ctx, s)
if err != nil {
- return errors.Wrap(err, `failed to iterate over map type`)
+ return fmt.Errorf(`failed to iterate over map type: %w`, err)
}
iter = x
default:
ssrc, ok := s.(Source)
if !ok {
- return errors.Errorf(`cannot iterate over %T: not a mapiter.Source type`, s)
+ return fmt.Errorf(`cannot iterate over %T: not a mapiter.Source type`, s)
}
iter = ssrc.Iterate(ctx)
}
@@ -149,12 +148,12 @@ func AsMap(ctx context.Context, s interface{}, v interface{}) error {
// dst MUST be a pointer to a map type
if kind := dst.Kind(); kind != reflect.Ptr {
- return errors.Errorf(`dst must be a pointer to a map (%s)`, dst.Type())
+ return fmt.Errorf(`dst must be a pointer to a map (%s)`, dst.Type())
}
dst = dst.Elem()
if dst.Kind() != reflect.Map {
- return errors.Errorf(`dst must be a pointer to a map (%s)`, dst.Type())
+ return fmt.Errorf(`dst must be a pointer to a map (%s)`, dst.Type())
}
if dst.IsNil() {
@@ -163,7 +162,7 @@ func AsMap(ctx context.Context, s interface{}, v interface{}) error {
// dst must be assignable
if !dst.CanSet() {
- return errors.New(`dst is not writeable`)
+ return fmt.Errorf(`dst is not writeable`)
}
keytyp := dst.Type().Key()
@@ -176,7 +175,7 @@ func AsMap(ctx context.Context, s interface{}, v interface{}) error {
rvvalue := reflect.ValueOf(pair.Value)
if !rvkey.Type().AssignableTo(keytyp) {
- return errors.Errorf(`cannot assign key of type %s to map key of type %s`, rvkey.Type(), keytyp)
+ return fmt.Errorf(`cannot assign key of type %s to map key of type %s`, rvkey.Type(), keytyp)
}
switch rvvalue.Kind() {
@@ -185,7 +184,7 @@ func AsMap(ctx context.Context, s interface{}, v interface{}) error {
rvvalue = reflect.New(valtyp).Elem()
default:
if !rvvalue.Type().AssignableTo(valtyp) {
- return errors.Errorf(`cannot assign value of type %s to map value of type %s`, rvvalue.Type(), valtyp)
+ return fmt.Errorf(`cannot assign value of type %s to map value of type %s`, rvvalue.Type(), valtyp)
}
}
diff --git a/vendor/github.com/lestrrat-go/jwx/.golangci.yml b/vendor/github.com/lestrrat-go/jwx/.golangci.yml
index b5afb667ab..f2b0845290 100644
--- a/vendor/github.com/lestrrat-go/jwx/.golangci.yml
+++ b/vendor/github.com/lestrrat-go/jwx/.golangci.yml
@@ -28,11 +28,14 @@ linters:
- gofumpt
- golint #deprecated
- gomnd
+ - gomoddirectives # I think it's broken
- gosec
- govet
- interfacer # deprecated
- ifshort
+ - ireturn # No, I _LIKE_ returning interfaces
- lll
+ - maintidx # Do this in code review
- maligned # deprecated
- makezero
- nakedret
@@ -42,7 +45,8 @@ linters:
- scopelint # deprecated
- tagliatelle
- testpackage
- - thelper
+ - thelper # Tests are fine
+ - varnamelen # Short names are ok
- wrapcheck
- wsl
@@ -63,9 +67,15 @@ issues:
- path: internal/codegen/codegen.go
linters:
- errcheck
+ - path: internal/jwxtest/jwxtest.go
+ linters:
+ - errcheck
+ - errchkjson
+ - forcetypeassert
- path: /*_test.go
linters:
- errcheck
+ - errchkjson
- forcetypeassert
- path: /*_example_test.go
linters:
diff --git a/vendor/github.com/lestrrat-go/jwx/Changes b/vendor/github.com/lestrrat-go/jwx/Changes
index c924318a41..428b16f65e 100644
--- a/vendor/github.com/lestrrat-go/jwx/Changes
+++ b/vendor/github.com/lestrrat-go/jwx/Changes
@@ -1,6 +1,130 @@
Changes
=======
+v1.2.26 - 14 Jun 2023
+[Security]
+ * Potential Padding Oracle Attack Vulnerability and Timing Attack Vulnerability
+ for JWE AES-CBC encrypted payloads affecting all v2 releases up to v2.0.10,
+ all v1 releases up to v1.2.25, and all v0 releases up to v0.9.2 have been reported by
+ @shogo82148.
+
+ Please note that v0 versions will NOT receive fixes.
+ This release fixes these vulnerabilities for the v1 series.
+
+[Miscellaneous]
+ * JWE tests now only run algorithms that are supported by the underlying
+ `jose` tool
+
+v1.2.25 23 May 2022
+[Bug Fixes][Security]
+ * [jwe] An old bug from at least 7 years ago existed in handling AES-CBC unpadding,
+ where the unpad operation might remove more bytes than necessary (#744)
+ This affects all jwx code that is available before v2.0.2 and v1.2.25.
+
+v1.2.24 05 May 2022
+[Security]
+ * Upgrade golang.org/x/crypto (#724)
+
+v1.2.23 13 Apr 2022
+[Bug fixes]
+ * [jwk] jwk.AutoRefresh had a race condition when `Configure()` was
+ called concurrently (#686)
+ (It has been patched correctly, but we may come back to revisit
+ the design choices in the near future)
+
+v1.2.22 08 Apr 2022
+[Bug fixes]
+ * [jws] jws.Verify was ignoring the `b64` header when it was present
+ in the protected headers (#681). Now the following should work:
+
+ jws.Sign(..., jws.WithDetachedPayload(payload))
+ // previously payload had to be base64 encoded
+ jws.Verify(..., jws.WithDetachedPayload(payload))
+
+ (note: v2 branch was not affected)
+
+v1.2.21 30 Mar 2022
+[Bug fixes]
+ * [jwk] RSA keys without p and q can now be parsed.
+
+v1.2.20 03 Mar 2022
+[Miscellaneous]
+ * Dependency on golang.org/x/crypto has been upgraded to
+ v0.0.0-20220214200702-86341886e292 to address
+ https://nvd.nist.gov/vuln/detail/CVE-2020-14040 (#598)
+
+v1.2.19 22 Feb 2022
+[New Feature]
+ * [jwk] jwk.Parse (and (jwk.AutoRefresh).Configure) can accept a new
+ option `jwk.WithIgnoreParseError(bool)`, which allows users to ignore
+ errors during parsing of each key contained in the JWKS, allowing
+ you to "skip" invalid keys.
+
+ This option should not be used lightly, as it hides the presence of
+ possibly faulty keys. However, this can be an escape hatch if you are
+ faced with a faulty JWKS that you do not control.
+
+v1.2.18 23 Jan 2022
+[Bug fixes]
+ * [jwe] When presented with jwk.Key with a key ID, the jwe encryption
+ code path did not assign this key ID to the resulting data structure.
+ This has been fixed, and now the key ID is properly applied to the
+ `kid` field.
+ * [jws] Use for `crypto.Signer`s were implemented for signing, but verification was
+ never properly implemented. This has been fixed.
+
+[Miscellaneous]
+ * [jws] Because of fixes to code path that deals with `crypto.Signer`s, we are
+ now able to fully integrate with Cloud services, such as Google's Cloud KMS
+ and AWS KMS, that provide key management and signing payloads
+
+ An implementation for these are available at https://github.com/jwx-go/crypto-signer.
+
+ Suppot `crypto.Signer` in JWE encryption has not been implemented.
+
+v1.2.17 12 Jan 2022
+[Miscellaneous]
+ * Re-release v1.2.16 as v1.2.17 because of an error in the release process.
+ The code is exactly the same as what v1.2.16 intended to release.
+ v1.2.16 has been retracted in go.mod.
+
+v1.2.16 12 Jan 2022
+
+ THIS VERSION HAS BEEN RETRACTED. PLEASE USE v1.2.17
+
+[Bug Fixes]
+ * Peviously, `jws.Sign()` could not create a signed payload with
+ detached and unencoded payload, even when the documentation said it could.
+ Now you may use the `jws.Sign()` in the following way to create
+ a JWS message with detached, unencoded state:
+
+ hdrs := jws.NewHeaders()
+ hdrs.Set("b64", false)
+ hdrs.Set("crit", "b64")
+ jws.Sign(nil, alg, key, jws.WithDetachedPayload(payload), jws.WithHeaders(hdrs))
+
+ Notice the use of `nil` for the first parameter, and the use of
+ `jws.WithDetachedPayload()`.
+
+ We realize this is not exactly a clean API, but this is currently the
+ only way to implement this in a backward-compatible fashion. Most likely
+ this will change in a future major version.
+[Miscellaneous]
+ * `jws.WithDetachedPayload()` is now of type `jws.SignVerifyOption`, which
+ satisfies both `jws.SignOption` and `jws.VerifyOption`
+
+
+v1.2.15 07 Jan 2022
+[New Features]
+ * `(jwk.AutoRefresh).Remove()` has been implemented.
+[Bug Fixes]
+ * ES256K is now included in the list of JWS inferred algorithms, if it's
+ enabled via -tags jwx_es256k
+[Miscellaneous]
+ * `jwt.Parse` has been improved for efficiency and has more tests to
+ cover corner cases.
+ * Documentation fixes
+
v1.2.14 22 Dec 2021
[New Features]
* `jwk.Fetch()` and `(*jwk.AutoRefresh).Configure()` can now take `jwk.Whitelist`
diff --git a/vendor/github.com/lestrrat-go/jwx/Makefile b/vendor/github.com/lestrrat-go/jwx/Makefile
index 2bbfac31bb..6b50544673 100644
--- a/vendor/github.com/lestrrat-go/jwx/Makefile
+++ b/vendor/github.com/lestrrat-go/jwx/Makefile
@@ -77,10 +77,5 @@ imports:
goimports -w ./
tidy:
- $(MAKE) tidy-cmd
- $(MAKE) -f $(PWD)/Makefile -C examples tidy-cmd
- $(MAKE) -f $(PWD)/Makefile -C bench/performance tidy-cmd
- $(MAKE) -f $(PWD)/Makefile -C cmd/jwx tidy-cmd
+ ./scripts/tidy.sh
-tidy-cmd:
- go mod tidy
diff --git a/vendor/github.com/lestrrat-go/jwx/README.md b/vendor/github.com/lestrrat-go/jwx/README.md
index bb9c453ca9..89ce8d85db 100644
--- a/vendor/github.com/lestrrat-go/jwx/README.md
+++ b/vendor/github.com/lestrrat-go/jwx/README.md
@@ -2,6 +2,8 @@
Various libraries implementing various JWx technologies. Please click on the package names in the table below to find the synopsis/description for each package.
+If you are using this module in your product or your company, please add your product and/or company name in the [Wiki](https://github.com/lestrrat-go/jwx/wiki/Users)! It really helps keeping up our motivation.
+
| Package name | Notes |
|-----------------------------------------------------------|-------------------------------------------------|
| [jwt](https://github.com/lestrrat-go/jwx/tree/main/jwt) | [RFC 7519](https://tools.ietf.org/html/rfc7519) |
@@ -39,11 +41,13 @@ so why should you use this library?
From a purely functional perspective, the only major difference is this:
Whereas most other projects only deal with what they seem necessary to handle
-JWTs, this module handles the entire spectrum of JWS, JWE, JWK, and JWT.
+JWTs, this module handles the **_entire_** spectrum of JWS, JWE, JWK, and JWT.
That is, if you need to not only parse JWTs, but also to control JWKs, or
if you need to handle payloads that are NOT JWTs, you should probably consider
-using this module.
+using this module. You should also note that JWT is built _on top_ of those
+other technologies. You simply cannot have a complete JWT package without
+implementing the entirety of JWS/JWS/JWK, which this library does.
Next, from an implementation perspective, this module differs significantly
from others in that it tries very hard to expose only the APIs, and not the
@@ -107,7 +111,7 @@ For either bug reports or feature requests, failing tests are even better.
Please make sure to include tests that excercise the changes you made.
-If you are editing auto-generated files (those files with the `_gen.go` prefix, please make sure that you do the following:
+If you are editing auto-generated files (those files with the `_gen.go` suffix, please make sure that you do the following:
1. Edit the generator, not the generated files (e.g. internal/cmd/genreadfile/main.go)
2. Run `make generate` (or `go generate`) to generate the new code
@@ -117,9 +121,14 @@ If you are editing auto-generated files (those files with the `_gen.go` prefix,
Please try [discussions](https://github.com/lestrrat-go/jwx/discussions) first.
+# Related Modules
+
+* [github.com/jwx-go/crypto-signer/gcp](https://github.com/jwx-go/crypto-signer/tree/main/gcp) - GCP KMS wrapper that implements [`crypto.Signer`](https://pkg.go.dev/crypto#Signer)
+* [github.com/jwx-go/crypto-signer/aws](https://github.com/jwx-go/crypto-signer/tree/main/aws) - AWS KMS wrapper that implements [`crypto.Signer`](https://pkg.go.dev/crypto#Signer)
+
# Credits
-* Work on this library was generously sponsored by HDE Inc (https://www.hde.co.jp)
+* Initial work on this library was generously sponsored by HDE Inc (https://www.hde.co.jp)
* Lots of code, especially JWE was taken from go-jose library (https://github.com/square/go-jose)
* Lots of individual contributors have helped this project over the years. Thank each and everyone of you very much.
diff --git a/vendor/github.com/lestrrat-go/jwx/internal/ecutil/ecutil.go b/vendor/github.com/lestrrat-go/jwx/internal/ecutil/ecutil.go
index 1d79aeb37e..1286669133 100644
--- a/vendor/github.com/lestrrat-go/jwx/internal/ecutil/ecutil.go
+++ b/vendor/github.com/lestrrat-go/jwx/internal/ecutil/ecutil.go
@@ -61,6 +61,7 @@ var ecpointBufferPool = sync.Pool{
}
func getCrvFixedBuffer(size int) []byte {
+ //nolint:forcetypeassert
buf := *(ecpointBufferPool.Get().(*[]byte))
if size > ec521BufferSize && cap(buf) < size {
buf = append(buf, make([]byte, size-cap(buf))...)
diff --git a/vendor/github.com/lestrrat-go/jwx/internal/iter/mapiter.go b/vendor/github.com/lestrrat-go/jwx/internal/iter/mapiter.go
index 184d3f0c13..f7ddc11895 100644
--- a/vendor/github.com/lestrrat-go/jwx/internal/iter/mapiter.go
+++ b/vendor/github.com/lestrrat-go/jwx/internal/iter/mapiter.go
@@ -22,6 +22,7 @@ func (fn MapVisitorFunc) Visit(s string, v interface{}) error {
func WalkMap(ctx context.Context, src mapiter.Source, visitor MapVisitor) error {
return mapiter.Walk(ctx, src, mapiter.VisitorFunc(func(k, v interface{}) error {
+ //nolint:forcetypeassert
return visitor.Visit(k.(string), v)
}))
}
diff --git a/vendor/github.com/lestrrat-go/jwx/internal/json/stdlib.go b/vendor/github.com/lestrrat-go/jwx/internal/json/stdlib.go
index 0d0c5ce3d8..62b1a5ff51 100644
--- a/vendor/github.com/lestrrat-go/jwx/internal/json/stdlib.go
+++ b/vendor/github.com/lestrrat-go/jwx/internal/json/stdlib.go
@@ -1,3 +1,4 @@
+//go:build !jwx_goccy
// +build !jwx_goccy
package json
diff --git a/vendor/github.com/lestrrat-go/jwx/internal/keyconv/keyconv.go b/vendor/github.com/lestrrat-go/jwx/internal/keyconv/keyconv.go
index 50ff3c83be..62b31de161 100644
--- a/vendor/github.com/lestrrat-go/jwx/internal/keyconv/keyconv.go
+++ b/vendor/github.com/lestrrat-go/jwx/internal/keyconv/keyconv.go
@@ -18,7 +18,7 @@ func RSAPrivateKey(dst, src interface{}) error {
if jwkKey, ok := src.(jwk.Key); ok {
var raw rsa.PrivateKey
if err := jwkKey.Raw(&raw); err != nil {
- return errors.Wrapf(err, `failed to produce rsa.PrvateKey from %T`, src)
+ return errors.Wrapf(err, `failed to produce rsa.PrivateKey from %T`, src)
}
src = &raw
}
@@ -67,7 +67,7 @@ func ECDSAPrivateKey(dst, src interface{}) error {
if jwkKey, ok := src.(jwk.Key); ok {
var raw ecdsa.PrivateKey
if err := jwkKey.Raw(&raw); err != nil {
- return errors.Wrapf(err, `failed to produce ecdsa.PrvateKey from %T`, src)
+ return errors.Wrapf(err, `failed to produce ecdsa.PrivateKey from %T`, src)
}
src = &raw
}
diff --git a/vendor/github.com/lestrrat-go/jwx/internal/pool/pool.go b/vendor/github.com/lestrrat-go/jwx/internal/pool/pool.go
index 09a4af8b2e..fae560b7c5 100644
--- a/vendor/github.com/lestrrat-go/jwx/internal/pool/pool.go
+++ b/vendor/github.com/lestrrat-go/jwx/internal/pool/pool.go
@@ -15,6 +15,7 @@ func allocBytesBuffer() interface{} {
}
func GetBytesBuffer() *bytes.Buffer {
+ //nolint:forcetypeassert
return bytesBufferPool.Get().(*bytes.Buffer)
}
@@ -32,6 +33,7 @@ func allocBigInt() interface{} {
}
func GetBigInt() *big.Int {
+ //nolint:forcetypeassert
return bigIntPool.Get().(*big.Int)
}
@@ -48,6 +50,7 @@ func allocKeyToErrorMap() interface{} {
}
func GetKeyToErrorMap() map[string]error {
+ //nolint:forcetypeassert
return keyToErrorMapPool.Get().(map[string]error)
}
diff --git a/vendor/github.com/lestrrat-go/jwx/jwa/elliptic_gen.go b/vendor/github.com/lestrrat-go/jwx/jwa/elliptic_gen.go
index acc045ccb0..8b26ffbb7d 100644
--- a/vendor/github.com/lestrrat-go/jwx/jwa/elliptic_gen.go
+++ b/vendor/github.com/lestrrat-go/jwx/jwa/elliptic_gen.go
@@ -10,7 +10,7 @@ import (
"github.com/pkg/errors"
)
-// EllipticCurveAlgorithm represents the algorithms used for EC keys
+// EllipticCurveAlgorithm represents the algorithms used for EC keys
type EllipticCurveAlgorithm string
// Supported values for EllipticCurveAlgorithm
diff --git a/vendor/github.com/lestrrat-go/jwx/jwe/encrypt.go b/vendor/github.com/lestrrat-go/jwx/jwe/encrypt.go
index 0b1b40bf4d..230b5aba9e 100644
--- a/vendor/github.com/lestrrat-go/jwx/jwe/encrypt.go
+++ b/vendor/github.com/lestrrat-go/jwx/jwe/encrypt.go
@@ -16,6 +16,7 @@ var encryptCtxPool = sync.Pool{
}
func getEncryptCtx() *encryptCtx {
+ //nolint:forcetypeassert
return encryptCtxPool.Get().(*encryptCtx)
}
diff --git a/vendor/github.com/lestrrat-go/jwx/jwe/headers.go b/vendor/github.com/lestrrat-go/jwx/jwe/headers.go
index 7d8efd634c..eacbfda011 100644
--- a/vendor/github.com/lestrrat-go/jwx/jwe/headers.go
+++ b/vendor/github.com/lestrrat-go/jwx/jwe/headers.go
@@ -71,8 +71,10 @@ func (h *stdHeaders) Clone(ctx context.Context) (Headers, error) {
func (h *stdHeaders) Copy(ctx context.Context, dst Headers) error {
for _, pair := range h.makePairs() {
- if err := dst.Set(pair.Key.(string), pair.Value); err != nil {
- return errors.Wrapf(err, `failed to set header`)
+ //nolint:forcetypeassert
+ key := pair.Key.(string)
+ if err := dst.Set(key, pair.Value); err != nil {
+ return errors.Wrapf(err, `failed to set header %q`, key)
}
}
return nil
diff --git a/vendor/github.com/lestrrat-go/jwx/jwe/internal/aescbc/aescbc.go b/vendor/github.com/lestrrat-go/jwx/jwe/internal/aescbc/aescbc.go
index f08f2cbec7..1d8a468145 100644
--- a/vendor/github.com/lestrrat-go/jwx/jwe/internal/aescbc/aescbc.go
+++ b/vendor/github.com/lestrrat-go/jwx/jwe/internal/aescbc/aescbc.go
@@ -32,26 +32,56 @@ func pad(buf []byte, n int) []byte {
return newbuf
}
-func unpad(buf []byte, n int) ([]byte, error) {
- lbuf := len(buf)
- rem := lbuf % n
- if rem != 0 {
- return nil, errors.Errorf("input buffer must be multiple of block size %d", n)
+// ref. https://github.com/golang/go/blob/c3db64c0f45e8f2d75c5b59401e0fc925701b6f4/src/crypto/tls/conn.go#L279-L324
+//
+// extractPadding returns, in constant time, the length of the padding to remove
+// from the end of payload. It also returns a byte which is equal to 255 if the
+// padding was valid and 0 otherwise. See RFC 2246, Section 6.2.3.2.
+func extractPadding(payload []byte) (toRemove int, good byte) {
+ if len(payload) < 1 {
+ return 0, 0
}
- count := 0
- last := buf[lbuf-1]
- for i := lbuf - 1; i >= 0; i-- {
- if buf[i] != last {
- break
- }
- count++
+ paddingLen := payload[len(payload)-1]
+ t := uint(len(payload)) - uint(paddingLen)
+ // if len(payload) > paddingLen then the MSB of t is zero
+ good = byte(int32(^t) >> 31)
+
+ // The maximum possible padding length plus the actual length field
+ toCheck := 256
+ // The length of the padded data is public, so we can use an if here
+ if toCheck > len(payload) {
+ toCheck = len(payload)
}
- if count != int(last) {
- return nil, errors.New("invalid padding")
+
+ for i := 1; i <= toCheck; i++ {
+ t := uint(paddingLen) - uint(i)
+ // if i <= paddingLen then the MSB of t is zero
+ mask := byte(int32(^t) >> 31)
+ b := payload[len(payload)-i]
+ good &^= mask&paddingLen ^ mask&b
}
- return buf[:lbuf-int(last)], nil
+ // We AND together the bits of good and replicate the result across
+ // all the bits.
+ good &= good << 4
+ good &= good << 2
+ good &= good << 1
+ good = uint8(int8(good) >> 7)
+
+ // Zero the padding length on error. This ensures any unchecked bytes
+ // are included in the MAC. Otherwise, an attacker that could
+ // distinguish MAC failures from padding failures could mount an attack
+ // similar to POODLE in SSL 3.0: given a good ciphertext that uses a
+ // full block's worth of padding, replace the final block with another
+ // block. If the MAC check passed but the padding check failed, the
+ // last byte of that block decrypted to the block size.
+ //
+ // See also macAndPaddingGood logic below.
+ paddingLen &= good
+
+ toRemove = int(paddingLen)
+ return
}
type Hmac struct {
@@ -196,10 +226,13 @@ func (c Hmac) Open(dst, nonce, ciphertext, data []byte) ([]byte, error) {
buf := make([]byte, tagOffset)
cbc.CryptBlocks(buf, ciphertext)
- plaintext, err := unpad(buf, c.blockCipher.BlockSize())
- if err != nil {
- return nil, errors.Wrap(err, `failed to generate plaintext from decrypted blocks`)
+ toRemove, good := extractPadding(buf)
+ cmp := subtle.ConstantTimeCompare(expectedTag, tag) & int(good)
+ if cmp != 1 {
+ return nil, errors.New("invalid ciphertext")
}
+
+ plaintext := buf[:len(buf)-toRemove]
ret := ensureSize(dst, len(plaintext))
out := ret[len(dst):]
copy(out, plaintext)
diff --git a/vendor/github.com/lestrrat-go/jwx/jwe/internal/cipher/cipher.go b/vendor/github.com/lestrrat-go/jwx/jwe/internal/cipher/cipher.go
index 586feff891..4581f648bf 100644
--- a/vendor/github.com/lestrrat-go/jwx/jwe/internal/cipher/cipher.go
+++ b/vendor/github.com/lestrrat-go/jwx/jwe/internal/cipher/cipher.go
@@ -96,10 +96,8 @@ func (c AesContentCipher) Encrypt(cek, plaintext, aad []byte) (iv, ciphertext, t
switch e := e.(type) {
case error:
err = e
- case string:
- err = errors.New(e)
default:
- err = fmt.Errorf("%s", e)
+ err = errors.Errorf("%s", e)
}
err = errors.Wrap(err, "failed to encrypt")
}
@@ -142,10 +140,8 @@ func (c AesContentCipher) Decrypt(cek, iv, ciphertxt, tag, aad []byte) (plaintex
switch e := e.(type) {
... 2037 lines suppressed ...